Mammoth update to the Python code generator scripts that live in

src/mesa/glapi.  Basically, the scripts that did simple things (like
gl_offsets.py) were simple, and the scripts that did more complicated things
(like glX_proto_send.py) were getting progressively more and more out of
control.  So, I re-write the foundation classes on which everything is based.

One problem with the existing code is that the division between the GL API
database representation and the way the output code is generated was either
blury or nonexistant.  The new code somewhat follows the
Model-View-Controller pattern, minus the Controller.  There is a distinct
set of classes that model the API data, and there is a distinct set of
classes that generate code from that data.

One big change is in the class that represents GL functions (was glFunction,
is now gl_function).  There used to be an instance of this calls for each
function and for each alias to that function.  For example, there was an
instance for PointParameterivSGIS, PointParameterivEXT, PointParameterivARB,
and PointParameteriv.  In the new code, there is one instance.  Each
instance has a list of entrypoint names for the function. In the next
revision, this will allow a couple useful things.  The script will be able
to verify that the parameters, return type, and GLX protocol for a function
and all it's aliases match.

It will also allow aliases to be represented in the XML more compactly.
Instead of repeating all the information, an alias can be listed as:

     <function name="PointParameterivARB" alias="PointParameterivEXT"/>

Because the data representation was changed, the order that the alias
functions are processed by the scripts also changed.  This accounts for at
least 2,700 of the ~3,600 lines of diffs in the generated code.

Most of the remaining ~900 lines of diffs are the result of bugs *fixed* by
the new scripts.  The old scripts also generated code with some bugs in it.
These bugs were discovered while the new code was being written.

These changes were discussed on the mesa3d-dev mailing list back at the end
of May:

http://marc.theaimsgroup.com/?t=111714569000004&r=1&w=2

Xorg bug: 3197, 3208

21 files changed, 5498 insertions, 5114 deletions

diff --git a/src/mesa/glapi/Makefile b/src/mesa/glapi/Makefile
index 96fdacb3430..d2998d893ed 100644
--- a/src/mesa/glapi/Makefile
+++ b/src/mesa/glapi/Makefile
@@ -13,26 +13,14 @@ OUTPUTS = glprocs.h glapitemp.h glapioffsets.h glapitable.h \
 	../../glx/x11/indirect_size.h \
 	../../glx/x11/indirect_size.c
 
-COMMON = gl_XML.pyo license.pyo gl_API.xml
-COMMON_GLX = $(COMMON) glX_XML.pyo
+COMMON = gl_XML.py license.py gl_API.xml typeexpr.py
+COMMON_GLX = $(COMMON) glX_XML.py glX_proto_common.py
 
 PYTHON2 = python
 PYTHON_FLAGS = -t -O -O
 
 all: $(OUTPUTS)
 
-gl_XML.pyo: gl_XML.py
-	rm -f gl_XML.pyo > /dev/null
-	$(PYTHON2) $(PYTHON_FLAGS) gl_XML.py
-
-glX_XML.pyo: glX_XML.py $(COMMON)
-	rm -f glX_XML.pyo > /dev/null
-	$(PYTHON2) $(PYTHON_FLAGS) glX_XML.py
-
-license.pyo: license.py
-	rm -f license.pyo > /dev/null
-	$(PYTHON2) $(PYTHON_FLAGS) license.py
-
 glprocs.h: $(COMMON) gl_procs.py
 	$(PYTHON2) $(PYTHON_FLAGS) gl_procs.py > glprocs.h
 
diff --git a/src/mesa/glapi/glX_XML.py b/src/mesa/glapi/glX_XML.py
index 53f89b31bd5..e0f07e576e4 100644
--- a/src/mesa/glapi/glX_XML.py
+++ b/src/mesa/glapi/glX_XML.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/env python
 
 # (C) Copyright IBM Corporation 2004, 2005
 # All Rights Reserved.
@@ -30,437 +30,319 @@ import license
 import sys, getopt, string
 
 
-class glXItemFactory(gl_XML.glItemFactory):
-	"""Factory to create GLX protocol oriented objects derived from glItem."""
+class glx_item_factory(gl_XML.gl_item_factory):
+	"""Factory to create GLX protocol oriented objects derived from gl_item."""
     
-	def create(self, context, name, attrs):
+	def create_item(self, name, element, context):
 		if name == "function":
-			return glXFunction(context, name, attrs)
+			return glx_function(element, context)
 		elif name == "enum":
-			return glXEnum(context, name, attrs)
-		elif name == "param":
-			return glXParameter(context, name, attrs)
+			return glx_enum(element, context)
+		elif name == "api":
+			return glx_api(self)
 		else:
-			return gl_XML.glItemFactory.create(self, context, name, attrs)
+			return gl_XML.gl_item_factory.create_item(self, name, element, context)
 
-class glXEnumFunction:
-	def __init__(self, name, context):
-		self.name = name
-		self.context = context
-		self.mode = 0
-		self.sig = None
 
-		# "enums" is a set of lists.  The element in the set is the
-		# value of the enum.  The list is the list of names for that
-		# value.  For example, [0x8126] = {"POINT_SIZE_MIN",
-		# "POINT_SIZE_MIN_ARB", "POINT_SIZE_MIN_EXT",
-		# "POINT_SIZE_MIN_SGIS"}.
-
-		self.enums = {}
-
-		# "count" is indexed by count values.  Each element of count
-		# is a list of index to "enums" that have that number of
-		# associated data elements.  For example, [4] = 
-		# {GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION,
-		# GL_AMBIENT_AND_DIFFUSE} (the enum names are used here,
-		# but the actual hexadecimal values would be in the array).
-
-		self.count = {}
-
-
-	def append(self, count, value, name):
-		if self.enums.has_key( value ):
-			self.enums[value].append(name)
-		else:
-			if not self.count.has_key(count):
-				self.count[count] = []
-
-			self.enums[value] = []
-			self.enums[value].append(name)
-			self.count[count].append(value)
-
-
-	def signature( self ):
-		if self.sig == None:
-			self.sig = ""
-			for i in self.count:
-				self.count[i].sort()
-				for e in self.count[i]:
-					self.sig += "%04x,%u," % (e, i)
-	
-		return self.sig
-
-
-	def set_mode( self, mode ):
-		"""Mark an enum-function as a 'set' function."""
-
-		self.mode = mode
-
-
-	def is_set( self ):
-		return self.mode
-
-
-	def PrintUsingTable(self):
-		"""Emit the body of the __gl*_size function using a pair
-		of look-up tables and a mask.  The mask is calculated such
-		that (e & mask) is unique for all the valid values of e for
-		this function.  The result of (e & mask) is used as an index
-		into the first look-up table.  If it matches e, then the
-		same entry of the second table is returned.  Otherwise zero
-		is returned.
+class glx_enum(gl_XML.gl_enum):
+	def __init__(self, element, context):
+		gl_XML.gl_enum.__init__(self, element, context)
 		
-		It seems like this should cause better code to be generated.
-		However, on x86 at least, the resulting .o file is about 20%
-		larger then the switch-statment version.  I am leaving this
-		code in because the results may be different on other
-		platforms (e.g., PowerPC or x86-64)."""
-
-		return 0
-		count = 0
-		for a in self.enums:
-			count += 1
-
-		if self.count.has_key(-1):
-			return 0
-
-		# Determine if there is some mask M, such that M = (2^N) - 1,
-		# that will generate unique values for all of the enums.
+		self.functions = {}
+
+		child = element.children
+		while child:
+			if child.type == "element" and child.name == "size":
+				n = child.nsProp( "name", None )
+				c = child.nsProp( "count", None )
+				m = child.nsProp( "mode", None )
+				
+				if not c:
+					c = self.default_count
+
+				if m == "get":
+					mode = 0
+				else:
+					mode = 1
 
-		mask = 0
-		for i in [1, 2, 3, 4, 5, 6, 7, 8]:
-			mask = (1 << i) - 1
+				if not self.functions.has_key(n):
+					self.functions[ n ] = [c, mode]
 
-			fail = 0;
-			for a in self.enums:
-				for b in self.enums:
-					if a != b:
-						if (a & mask) == (b & mask):
-							fail = 1;
+			child = child.next
 
-			if not fail:
-				break;
-			else:
-				mask = 0
+		return
 
-		if (mask != 0) and (mask < (2 * count)):
-			masked_enums = {}
-			masked_count = {}
 
-			for i in range(0, mask + 1):
-				masked_enums[i] = "0";
-				masked_count[i] = 0;
+class glx_function(gl_XML.gl_function):
+	def __init__(self, element, context):
+		self.glx_rop = 0
+		self.glx_sop = 0
+		self.glx_vendorpriv = 0
 
-			for c in self.count:
-				for e in self.count[c]:
-					i = e & mask
-					masked_enums[i] = '0x%04x /* %s */' % (e, self.enums[e][0])
-					masked_count[i] = c
+		# If this is set to true, it means that GLdouble parameters should be
+		# written to the GLX protocol packet in the order they appear in the
+		# prototype.  This is different from the "classic" ordering.  In the
+		# classic ordering GLdoubles are written to the protocol packet first,
+		# followed by non-doubles.  NV_vertex_program was the first extension
+		# to break with this tradition.
 
+		self.glx_doubles_in_order = 0
 
-			print '    static const GLushort a[%u] = {' % (mask + 1)
-			for e in masked_enums:
-				print '        %s, ' % (masked_enums[e])
-			print '    };'
+		self.vectorequiv = None
+		self.output = None
+		self.can_be_large = 0
+		self.reply_always_array = 0
+		self.dimensions_in_reply = 0
+		self.img_reset = None
 
-			print '    static const GLubyte b[%u] = {' % (mask + 1)
-			for c in masked_count:
-				print '        %u, ' % (masked_count[c])
-			print '    };'
+		self.server_handcode = 0
+		self.client_handcode = 0
+		self.ignore = 0
 
-			print '    const unsigned idx = (e & 0x%02xU);' % (mask)
-			print ''
-			print '    return (e == a[idx]) ? (GLint) b[idx] : 0;'
-			return 1;
-		else:
-			return 0;
+		self.count_parameter_list = []
+		self.counter_list = []
+		self.parameters_by_name = {}
+		self.offsets_calculated = 0
 
-	def PrintUsingSwitch(self, name):
-		"""Emit the body of the __gl*_size function using a 
-		switch-statement."""
+		gl_XML.gl_function.__init__(self, element, context)
+		return
 
-		print '    switch( e ) {'
 
-		for c in self.count:
-			for e in self.count[c]:
-				first = 1
+	def process_element(self, element):
+		gl_XML.gl_function.process_element(self, element)
 
-				# There may be multiple enums with the same
-				# value.  This happens has extensions are
-				# promoted from vendor-specific or EXT to
-				# ARB and to the core.  Emit the first one as
-				# a case label, and emit the others as
-				# commented-out case labels.
+		self.vectorequiv = element.nsProp( "vectorequiv", None )
 
-				for j in self.enums[e]:
-					if first:
-						print '        case %s:' % (j)
-						first = 0
-					else:
-						print '/*      case %s:*/' % (j)
-					
-			if c == -1:
-				print '            return __gl%s_variable_size( e );' % (name)
-			else:
-				print '            return %u;' % (c)
-					
-		print '        default: return 0;'
-		print '    }'
 
+		if element.nsProp( "name", None ) == self.name:
+			for param in self.parameters:
+				self.parameters_by_name[ param.name ] = param
+				
+				if len(param.count_parameter_list):
+					self.count_parameter_list.extend( param.count_parameter_list )
+				
+				if param.counter and param.counter not in self.counter_list:
+					self.counter_list.append(param.counter)
 
-	def Print(self, name):
-		print 'INTERNAL PURE FASTCALL GLint'
-		print '__gl%s_size( GLenum e )' % (name)
-		print '{'
 
-		if not self.PrintUsingTable():
-			self.PrintUsingSwitch(name)
+		child = element.children
+		while child:
+			if child.type == "element":
+				if child.name == "glx":
+					rop = child.nsProp( 'rop', None )
+					sop = child.nsProp( 'sop', None )
+					vop = child.nsProp( 'vendorpriv', None )
 
-		print '}'
-		print ''
+					if rop:
+						self.glx_rop = int(rop)
+					else:
+						self.glx_rop = 0
 
+					if sop:
+						self.glx_sop = int(sop)
+					else:
+						self.glx_sop = 0
 
+					if vop:
+						self.glx_vendorpriv = int(vop)
+					else:
+						self.glx_vendorpriv = 0
+
+					self.img_reset = child.nsProp( 'img_reset', None )
+
+					# The 'handcode' attribute can be one of 'true',
+					# 'false', 'client', or 'server'.
+
+					handcode = child.nsProp( 'handcode', None )
+					if handcode == "false":
+						self.server_handcode = 0
+						self.client_handcode = 0
+					elif handcode == "true":
+						self.server_handcode = 1
+						self.client_handcode = 1
+					elif handcode == "client":
+						self.server_handcode = 0
+						self.client_handcode = 1
+					elif handcode == "server":
+						self.server_handcode = 1
+						self.client_handcode = 0
+					else:
+						raise RuntimeError('Invalid handcode mode "%s" in function "%s".' % (handcode, self.name))
 
-class glXEnum(gl_XML.glEnum):
-	def __init__(self, context, name, attrs):
-		gl_XML.glEnum.__init__(self, context, name, attrs)
+					self.ignore               = gl_XML.is_attr_true( child, 'ignore' )
+					self.can_be_large         = gl_XML.is_attr_true( child, 'large' )
+					self.glx_doubles_in_order = gl_XML.is_attr_true( child, 'doubles_in_order' )
+					self.reply_always_array   = gl_XML.is_attr_true( child, 'always_array' )
+					self.dimensions_in_reply  = gl_XML.is_attr_true( child, 'dimensions_in_reply' )
 
+			child = child.next
 
-	def startElementNS(self, name, qname, attrs):
-		[uri, true_name] = name
-		if true_name == "size":
-			[temp_n, c, mode] = self.process_attributes(attrs)
 
-			if temp_n == "Get":
-				names = ["GetIntegerv", "GetBooleanv", "GetFloatv", "GetDoublev" ]
-			else:
-				names = [ temp_n ]
+		# Do some validation of the GLX protocol information.  As
+		# new tests are discovered, they should be added here.
 
-			for n in names:
-				if not self.context.glx_enum_functions.has_key( n ):
-					f = self.context.createEnumFunction( n )
-					f.set_mode( mode )
-					self.context.glx_enum_functions[ f.name ] = f
+		for param in self.parameters:
+			if param.is_output and self.glx_rop != 0:
+				raise RuntimeError("Render / RenderLarge commands cannot have outputs (%s)." % (self.name))
 
-				self.context.glx_enum_functions[ n ].append( c, self.value, self.name )
-		else:
-			gl_XML.glEnum.startElementNS(self, name, qname, attrs)
 		return
 
 
-class glXParameter(gl_XML.glParameter):
-	def __init__(self, context, name, attrs):
-		self.order = 1;
-		gl_XML.glParameter.__init__(self, context, name, attrs);
-
-
-class glXParameterIterator:
-	"""Class to iterate over a list of glXParameters.
-
-	Objects of this class are returned by the parameterIterator method of
-	the glXFunction class.  They are used to iterate over the list of
-	parameters to the function."""
-
-	def __init__(self, data, skip_output, max_order):
-		self.data = data
-		self.index = 0
-		self.order = 0
-		self.skip_output = skip_output
-		self.max_order = max_order
-
-	def __iter__(self):
-		return self
-
-	def next(self):
-		if len( self.data ) == 0:
-			raise StopIteration
-
-		while 1:
-			if self.index == len( self.data ):
-				if self.order == self.max_order:
-					raise StopIteration
-				else:
-					self.order += 1
-					self.index = 0
-
-			i = self.index
-			self.index += 1
-
-			if self.data[i].order == self.order and not (self.data[i].is_output and self.skip_output):
-				return self.data[i]
+	def has_variable_size_request(self):
+		"""Determine if the GLX request packet is variable sized.
 
+		The GLX request packet is variable sized in several common
+		situations.
+		
+		1. The function has a non-output parameter that is counted
+		   by another parameter (e.g., the 'textures' parameter of
+		   glDeleteTextures).
+		   
+		2. The function has a non-output parameter whose count is
+		   determined by another parameter that is an enum (e.g., the
+		   'params' parameter of glLightfv).
+		   
+		3. The function has a non-output parameter that is an
+		   image.
+
+		4. The function must be hand-coded on the server.
+		"""
+
+		if self.glx_rop == 0:
+			return 0
 
-class glXFunction(gl_XML.glFunction):
-	glx_rop = 0
-	glx_sop = 0
-	glx_vendorpriv = 0
+		if self.server_handcode or self.images:
+			return 1
 
-	# If this is set to true, it means that GLdouble parameters should be
-	# written to the GLX protocol packet in the order they appear in the
-	# prototype.  This is different from the "classic" ordering.  In the
-	# classic ordering GLdoubles are written to the protocol packet first,
-	# followed by non-doubles.  NV_vertex_program was the first extension
-	# to break with this tradition.
+		for param in self.parameters:
+			if not param.is_output:
+				if param.counter or len(param.count_parameter_list):
+					return 1
 
-	glx_doubles_in_order = 0
+		return 0
 
-	vectorequiv = None
-	can_be_large = 0
 
-	def __init__(self, context, name, attrs):
-		self.vectorequiv = attrs.get((None, 'vectorequiv'), None)
-		self.counter = None
-		self.output = None
-		self.can_be_large = 0
-		self.reply_always_array = 0
-		self.dimensions_in_reply = 0
-		self.img_reset = None
+	def variable_length_parameter(self):
+		for param in self.parameters:
+			if not param.is_output:
+				if param.counter or len(param.count_parameter_list):
+					return param
+				
+		return None
 
-		self.server_handcode = 0
-		self.client_handcode = 0
-		self.ignore = 0
 
-		gl_XML.glFunction.__init__(self, context, name, attrs)
-		return
+	def calculate_offsets(self):
+		if not self.offsets_calculated:
+			# Calculate the offset of the first function parameter
+			# in the GLX command packet.  This byte offset is
+			# measured from the end of the Render / RenderLarge
+			# header.  The offset for all non-pixel commends is
+			# zero.  The offset for pixel commands depends on the
+			# number of dimensions of the pixel data.
 
+			if len(self.images) and not self.images[0].is_output:
+				[dim, junk, junk, junk, junk] = self.images[0].get_dimensions()
 
-	def parameterIterator(self, skip_output, max_order):
-		return glXParameterIterator(self.fn_parameters, skip_output, max_order)
+				# The base size is the size of the pixel pack info
+				# header used by images with the specified number
+				# of dimensions.
 
-		
-	def startElementNS(self, name, qname, attrs):
-		"""Process elements within a function that are specific to GLX."""
-
-		[uri, true_name] = name
-		if true_name == "glx":
-			self.glx_rop = int(attrs.get((None, 'rop'), "0"))
-			self.glx_sop = int(attrs.get((None, 'sop'), "0"))
-			self.glx_vendorpriv = int(attrs.get((None, 'vendorpriv'), "0"))
-			self.img_reset = attrs.get((None, 'img_reset'), None)
-
-			# The 'handcode' attribute can be one of 'true',
-			# 'false', 'client', or 'server'.
-
-			handcode = attrs.get((None, 'handcode'), "false")
-			if handcode == "false":
-				self.server_handcode = 0
-				self.client_handcode = 0
-			elif handcode == "true":
-				self.server_handcode = 1
-				self.client_handcode = 1
-			elif handcode == "client":
-				self.server_handcode = 0
-				self.client_handcode = 1
-			elif handcode == "server":
-				self.server_handcode = 1
-				self.client_handcode = 0
+				if dim <=  2:
+					offset = 20
+				elif dim <= 4:
+					offset = 36
+				else:
+					raise RuntimeError('Invalid number of dimensions %u for parameter "%s" in function "%s".' % (dim, self.image.name, self.name))
 			else:
-				raise RuntimeError('Invalid handcode mode "%s" in function "%s".' % (handcode, self.name))
-
-			self.ignore               = gl_XML.is_attr_true( attrs, 'ignore' )
-			self.can_be_large         = gl_XML.is_attr_true( attrs, 'large' )
-			self.glx_doubles_in_order = gl_XML.is_attr_true( attrs, 'doubles_in_order' )
-			self.reply_always_array   = gl_XML.is_attr_true( attrs, 'always_array' )
-			self.dimensions_in_reply  = gl_XML.is_attr_true( attrs, 'dimensions_in_reply' )
-		else:
-			gl_XML.glFunction.startElementNS(self, name, qname, attrs)
-
-
-	def endElementNS(self, name, qname):
-		[uri, true_name] = name
-		if true_name == "function":
-			# Mark any function that does not have GLX protocol
-			# defined as "ignore".  This prevents bad things from
-			# happening when people add new functions to the GL
-			# API XML without adding any GLX section.
-			#
-			# This will also mark functions that don't have a
-			# dispatch offset at ignored.
-
-			if (self.fn_offset == -1 and not self.fn_alias) or not (self.client_handcode or self.server_handcode or self.glx_rop or self.glx_sop or self.glx_vendorpriv or self.vectorequiv or self.fn_alias):
-				#if not self.ignore:
-				#	if self.fn_offset == -1:
-				#		print '/* %s ignored becuase no offset assigned. */' % (self.name)
-				#	else:
-				#		print '/* %s ignored becuase no GLX opcode assigned. */' % (self.name)
+				offset = 0
 
-				self.ignore = 1
+			for param in self.parameterIterateGlxSend():
+				if param.img_null_flag:
+					offset += 4
 
-		return gl_XML.glFunction.endElementNS(self, name, qname)
-
-
-	def append(self, tag_name, p):
-		gl_XML.glFunction.append(self, tag_name, p)
-
-		if p.is_variable_length_array():
-			p.order = 2;
-		elif not self.glx_doubles_in_order and p.p_type.size == 8:
-			p.order = 0;
+				if param.name != self.img_reset:
+					param.offset = offset
+					if not param.is_variable_length():
+						offset += param.size()
+					
+				if self.pad_after( param ):
+					offset += 4
 
-		if p.is_counter:
-			self.counter = p.name
-			
-		if p.is_output:
-			self.output = p
 
+			self.offsets_calculated = 1
 		return
 
 
-	def variable_length_parameter(self):
-		if len(self.variable_length_parameters):
-			return self.variable_length_parameters[0]
+	def offset_of(self, param_name):
+		self.calculate_offsets()
+		return self.parameters_by_name[ param_name ].offset
 
-		return None
 
+	def parameterIterateGlxSend(self, include_variable_parameters = 1):
+		"""Create an iterator for parameters in GLX request order."""
 
-	def output_parameter(self):
-		for param in self.fn_parameters:
-			if param.is_output:
-				return param
+		# The parameter lists are usually quite short, so it's easier
+		# (i.e., less code) to just generate a new list with the
+		# required elements than it is to create a new iterator class.
+		
+		temp = [ [],  [], [] ]
+		for param in self.parameters:
+			if param.is_output: continue
+
+			if param.is_variable_length():
+				temp[2].append( param )
+			elif not self.glx_doubles_in_order and param.is_64_bit():
+				temp[0].append( param )
+			else:
+				temp[1].append( param )
 
-		return None
+		parameters = temp[0]
+		parameters.extend( temp[1] )
+		if include_variable_parameters:
+			parameters.extend( temp[2] )
+		return parameters.__iter__()
 
 
-	def offset_of_first_parameter(self):
-		"""Get the offset of the first parameter in the command.
+	def parameterIterateCounters(self):
+		temp = []
+		for name in self.counter_list:
+			temp.append( self.parameters_by_name[ name ] )
 
-		Gets the offset of the first function parameter in the GLX
-		command packet.  This byte offset is measured from the end
-		of the Render / RenderLarge header.  The offset for all non-
-		pixel commends is zero.  The offset for pixel commands depends
-		on the number of dimensions of the pixel data."""
+		return temp.__iter__()
 
-		if self.image and not self.image.is_output:
-			[dim, junk, junk, junk, junk] = self.dimensions()
 
-			# The base size is the size of the pixel pack info
-			# header used by images with the specified number
-			# of dimensions.
+	def parameterIterateOutputs(self):
+		temp = []
+		for p in self.parameters:
+			if p.is_output:
+				temp.append( p )
 
-			if dim <=  2:
-				return 20
-			elif dim <= 4:
-				return 36
-			else:
-				raise RuntimeError('Invalid number of dimensions %u for parameter "%s" in function "%s".' % (dim, self.image.name, self.name))
-		else:
-			return 0
+		return temp
 
 
 	def command_fixed_length(self):
 		"""Return the length, in bytes as an integer, of the
 		fixed-size portion of the command."""
 
-		size = self.offset_of_first_parameter()
+		if len(self.parameters) == 0:
+			return 0
+		
+		self.calculate_offsets()
 
-		for p in gl_XML.glFunction.parameterIterator(self):
-			if not p.is_output and p.name != self.img_reset:
-				size += p.size()
-				if self.pad_after(p):
+		size = 0
+		for param in self.parameterIterateGlxSend(0):
+			if param.name != self.img_reset:
+				if size == 0:
+					size = param.offset + param.size()
+				else:
+					size += param.size()
+
+				if self.pad_after( param ):
 					size += 4
 
-		if self.image and (self.image.img_null_flag or self.image.is_output):
-			size += 4
+		for param in self.images:
+			if param.img_null_flag or param.is_output:
+				size += 4
 
 		return size
 
@@ -470,9 +352,15 @@ class glXFunction(gl_XML.glFunction):
 		portion of the command."""
 
 		size_string = ""
-		for p in gl_XML.glFunction.parameterIterator(self):
-			if (not p.is_output) and (p.size() == 0):
-				size_string = size_string + " + __GLX_PAD(%s)" % (p.size_string())
+		for p in self.parameterIterateGlxSend():
+			if (not p.is_output) and (p.is_variable_length() or p.is_image()):
+				# FIXME Replace the 1 in the size_string call
+				# FIXME w/0 to eliminate some un-needed parnes
+				# FIXME This would already be done, but it
+				# FIXME adds some extra diffs to the generated
+				# FIXME code.
+
+				size_string = size_string + " + __GLX_PAD(%s)" % (p.size_string(1))
 
 		return size_string
 
@@ -506,9 +394,15 @@ class glXFunction(gl_XML.glFunction):
 		else:
 			return self.opcode_value()
 
+
 	def opcode_value(self):
 		"""Get the unique protocol opcode for the glXFunction"""
 
+		if (self.glx_rop == 0) and self.vectorequiv:
+			equiv = self.context.functions_by_name[ self.vectorequiv ]
+			self.glx_rop = equiv.glx_rop
+
+
 		if self.glx_rop != 0:
 			return self.glx_rop
 		elif self.glx_sop != 0:
@@ -518,6 +412,7 @@ class glXFunction(gl_XML.glFunction):
 		else:
 			return -1
 	
+
 	def opcode_rop_basename(self):
 		"""Return either the name to be used for GLX protocol enum.
 		
@@ -530,9 +425,16 @@ class glXFunction(gl_XML.glFunction):
 		else:
 			return self.vectorequiv
 
+
 	def opcode_name(self):
 		"""Get the unique protocol enum name for the glXFunction"""
 
+		if (self.glx_rop == 0) and self.vectorequiv:
+			equiv = self.context.functions_by_name[ self.vectorequiv ]
+			self.glx_rop = equiv.glx_rop
+			self.glx_doubles_in_order = equiv.glx_doubles_in_order
+
+
 		if self.glx_rop != 0:
 			return "X_GLrop_%s" % (self.opcode_rop_basename())
 		elif self.glx_sop != 0:
@@ -562,154 +464,66 @@ class glXFunction(gl_XML.glFunction):
 			return self.opcode_name()
 
 
-	def return_string(self):
-		if self.fn_return_type != 'void':
-			return "return retval;"
-		else:
-			return "return;"
-
-
 	def needs_reply(self):
-		return self.fn_return_type != 'void' or self.output != None
+		try:
+			x = self._needs_reply
+		except Exception, e:
+			x = 0
+			if self.return_type != 'void':
+				x = 1
 
+			for param in self.parameters:
+				if param.is_output:
+					x = 1
+					break
 
-	def dimensions(self):
-		"""Determine the dimensions of an image.
-		
-		Returns a tuple representing the number of dimensions and the
-		string name of each of the dimensions of an image,  If the
-		function is not a pixel function, the number of dimensions
-		will be zero."""
-
-		if not self.image:
-			return [0, "0", "0", "0", "0"]
-		else:
-			dim = 1
-			w = self.image.width
-
-			if self.image.height:
-				dim = 2
-				h = self.image.height
-			else:
-				h = "1"
-
-			if self.image.depth:
-				dim = 3
-				d = self.image.depth
-			else:
-				d = "1"
-			
-			if self.image.extent:
-				dim = 4
-				e = self.image.extent
-			else:
-				e = "1"
+			self._needs_reply = x
 
-			return [dim, w, h, d, e]
+		return x
 
 
 	def pad_after(self, p):
 		"""Returns the name of the field inserted after the
 		specified field to pad out the command header."""
 
-		if self.image and self.image.img_pad_dimensions:
-			if not self.image.height:
-				if p.name == self.image.width:
-					return "height"
-				elif p.name == self.image.img_xoff:
-					return "yoffset"
-			elif not self.image.extent:
-				if p.name == self.image.depth:
-					# Should this be "size4d"?
-					return "extent"
-				elif p.name == self.image.img_zoff:
-					return "woffset"
+		for image in self.images:
+			if image.img_pad_dimensions:
+				if not image.height:
+					if p.name == image.width:
+						return "height"
+					elif p.name == image.img_xoff:
+						return "yoffset"
+				elif not image.extent:
+					if p.name == image.depth:
+						# Should this be "size4d"?
+						return "extent"
+					elif p.name == image.img_zoff:
+						return "woffset"
+
 		return None
 
 
-class glXFunctionIterator(gl_XML.glFunctionIterator):
+class glx_function_iterator:
 	"""Class to iterate over a list of glXFunctions"""
 
 	def __init__(self, context):
-		self.context = context
-		self.keys = context.functions.keys()
-		self.keys.sort()
-
-		for self.index in range(0, len(self.keys)):
-			if self.keys[ self.index ] >= 0: break
-
+		self.iterator = context.functionIterateByOffset()
 		return
 
 
-	def next(self):
-		if self.index == len(self.keys):
-			raise StopIteration
+	def __iter__(self):
+		return self
 
-		f = self.context.functions[ self.keys[ self.index ] ]
-		self.index += 1
 
-		if f.ignore:
+	def next(self):
+		f = self.iterator.next()
+		if f.ignore or not (f.glx_rop or f.glx_sop or f.glx_vendorpriv or f.vectorequiv or f.client_handcode):
 			return self.next()
 		else:
 			return f
 
 
-class GlxProto(gl_XML.FilterGLAPISpecBase):
-	name = "glX_proto_send.py (from Mesa)"
-
-	def __init__(self):
-		gl_XML.FilterGLAPISpecBase.__init__(self)
-		self.factory = glXItemFactory()
-		self.glx_enum_functions = {}
-
-
-	def endElementNS(self, name, qname):
-		[uri, true_name] = name
-		if true_name == 'OpenGLAPI':
-			# Once all the parsing is done, we have to go back and
-			# fix-up some cross references between different
-			# functions.
-
-			for k in self.functions:
-				f = self.functions[k]
-				if f.vectorequiv != None:
-					equiv = self.find_function(f.vectorequiv)
-					if equiv != None:
-						f.glx_doubles_in_order = equiv.glx_doubles_in_order
-						f.glx_rop = equiv.glx_rop
-					else:
-						raise RuntimeError("Could not find the vector equiv. function %s for %s!" % (f.name, f.vectorequiv))
-		else:
-			gl_XML.FilterGLAPISpecBase.endElementNS(self, name, qname)
-		return
-
-
-	def createEnumFunction(self, n):
-		return glXEnumFunction(n, self)
-
-
-	def functionIterator(self):
-		return glXFunctionIterator(self)
-
-	
-	def size_call(self, func):
-		"""Create C code to calculate 'compsize'.
-
-		Creates code to calculate 'compsize'.  If the function does
-		not need 'compsize' to be calculated, None will be
-		returned."""
-
-		if not func.image and not func.count_parameter_list:
-			return None
-
-		if not func.image:
-			parameters = string.join( func.count_parameter_list, "," )
-			compsize = "__gl%s_size(%s)" % (func.name, parameters)
-		else:
-			[dim, w, h, d, junk] = func.dimensions()
-
-			compsize = '__glImageSize(%s, %s, %s, %s, %s, %s)' % (w, h, d, func.image.img_format, func.image.img_type, func.image.img_target)
-			if not func.image.img_send_null:
-				compsize = '(%s != NULL) ? %s : 0' % (func.image.name, compsize)
+class glx_api(gl_XML.gl_api):
+	def functionIterateGlx(self):
+		return glx_function_iterator(self)
 
-		return compsize
diff --git a/src/mesa/glapi/glX_doc.py b/src/mesa/glapi/glX_doc.py
index fa2d812974c..e9fbbe6f169 100644
--- a/src/mesa/glapi/glX_doc.py
+++ b/src/mesa/glapi/glX_doc.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/env python
 
 # (C) Copyright IBM Corporation 2004, 2005
 # All Rights Reserved.
@@ -25,28 +25,22 @@
 # Authors:
 #    Ian Romanick <[email protected]>
 
-import gl_XML
-import glX_XML
-import license
+import gl_XML, glX_XML, glX_proto_common, license
 import sys, getopt
 
 
-class glXDocItemFactory(glX_XML.glXItemFactory):
+class glx_doc_item_factory(glX_proto_common.glx_proto_item_factory):
 	"""Factory to create GLX protocol documentation oriented objects derived from glItem."""
     
-	def create(self, context, name, attrs):
-		if name == "param":
-			return glXDocParameter(context, name, attrs)
+	def create_item(self, name, element, context):
+		if name == "parameter":
+			return glx_doc_parameter(element, context)
 		else:
-			return glX_XML.glXItemFactory.create(self, context, name, attrs)
+			return glX_proto_common.glx_proto_item_factory.create_item(self, name, element, context)
 
-class glXDocParameter(gl_XML.glParameter):
-	def __init__(self, context, name, attrs):
-		self.order = 1;
-		gl_XML.glParameter.__init__(self, context, name, attrs);
 
-
-	def packet_type(self):
+class glx_doc_parameter(gl_XML.gl_parameter):
+	def packet_type(self, type_dict):
 		"""Get the type string for the packet header
 		
 		GLX protocol documentation uses type names like CARD32,
@@ -57,13 +51,15 @@ class glXDocParameter(gl_XML.glParameter):
 		if self.is_array():
 			list_of = "LISTof"
 
-		if self.p_type.glx_name == "":
+		t_name = self.get_base_type_string()
+		if not type_dict.has_key( t_name ):
 			type_name = "CARD8"
 		else:
-			type_name = self.p_type.glx_name
+			type_name = type_dict[ t_name ]
 
 		return "%s%s" % (list_of, type_name)
 
+
 	def packet_size(self):
 		p = None
 		s = self.size()
@@ -89,16 +85,16 @@ class glXDocParameter(gl_XML.glParameter):
 
 			return [str(s), p]
 
-class PrintGlxProtoText(glX_XML.GlxProto):
+class PrintGlxProtoText(gl_XML.gl_print_base):
 	def __init__(self):
-		glX_XML.GlxProto.__init__(self)
-		self.factory = glXDocItemFactory()
-		self.last_category = ""
+		gl_XML.gl_print_base.__init__(self)
 		self.license = ""
 
+
 	def printHeader(self):
 		return
 
+
 	def body_size(self, f):
 		# At some point, refactor this function and
 		# glXFunction::command_payload_length.
@@ -107,7 +103,7 @@ class PrintGlxProtoText(glX_XML.GlxProto):
 		size_str = ""
 		pad_str = ""
 		plus = ""
-		for p in f.parameterIterator(1, 2):
+		for p in f.parameterIterateGlxSend():
 			[s, pad] = p.packet_size()
 			try: 
 				size += int(s)
@@ -120,6 +116,7 @@ class PrintGlxProtoText(glX_XML.GlxProto):
 
 		return [size, size_str, pad_str]
 
+
 	def print_render_header(self, f):
 		[size, size_str, pad_str] = self.body_size(f)
 		size += 4;
@@ -162,6 +159,7 @@ class PrintGlxProtoText(glX_XML.GlxProto):
 
 		return
 		
+
 	def print_reply(self, f):
 		print '          =>'
 		print '            1        1               reply'
@@ -176,33 +174,39 @@ class PrintGlxProtoText(glX_XML.GlxProto):
 			print '            4        m               reply length, m = (n == 1 ? 0 : n)'
 
 
+		output = None
+		for x in f.parameterIterateOutputs():
+			output = x
+			break
+
+
 		unused = 24
-		if f.fn_return_type != 'void':
-			print '            4        %-15s return value' % (f.fn_return_type)
+		if f.return_type != 'void':
+			print '            4        %-15s return value' % (f.return_type)
 			unused -= 4
-		elif f.output != None:
+		elif output != None:
 			print '            4                        unused'
 			unused -= 4
 
-		if f.output != None:
+		if output != None:
 			print '            4        CARD32          n'
 			unused -= 4
 
-		if f.output != None:
+		if output != None:
 			if not f.reply_always_array:
 				print ''
 				print '            if (n = 1) this follows:'
 				print ''
-				print '            4        CARD32          %s' % (f.output.name)
+				print '            4        CARD32          %s' % (output.name)
 				print '            %-2u                       unused' % (unused - 4)
 				print ''
 				print '            otherwise this follows:'
 				print ''
 
 			print '            %-2u                       unused' % (unused)
-			p = f.output
-			[s, pad] = p.packet_size()
-			print '            %-8s %-15s %s' % (s, p.packet_type(), p.name)
+
+			[s, pad] = output.packet_size()
+			print '            %-8s %-15s %s' % (s, output.packet_type( self.type_map ), output.name)
 			if pad != None:
 				try:
 					bytes = int(s)
@@ -215,9 +219,9 @@ class PrintGlxProtoText(glX_XML.GlxProto):
 
 
 	def print_body(self, f):
-		for p in f.parameterIterator(1, 2):
+		for p in f.parameterIterateGlxSend():
 			[s, pad] = p.packet_size()
-			print '            %-8s %-15s %s' % (s, p.packet_type(), p.name)
+			print '            %-8s %-15s %s' % (s, p.packet_type( self.type_map ), p.name)
 			if pad != None:
 				try:
 					bytes = int(s)
@@ -226,26 +230,35 @@ class PrintGlxProtoText(glX_XML.GlxProto):
 				except Exception,e:
 					print '            %-8s %-15s unused, %s=pad(%s)' % (pad, "", pad, s)
 
-	def printFunction(self, f):
+	def printBody(self, api):
+		self.type_map = {}
+		for t in api.typeIterate():
+			self.type_map[ "GL" + t.name ] = t.glx_name
+
+
 		# At some point this should be expanded to support pixel
 		# functions, but I'm not going to lose any sleep over it now.
 
-		if f.client_handcode or f.server_handcode or f.vectorequiv or f.image:
-			return
+		for f in api.functionIterateByOffset():
+			if f.client_handcode or f.server_handcode or f.vectorequiv or len(f.get_images()):
+				continue
 
-		print '        %s' % (f.name)
 
-		if f.glx_rop != 0:
-			self.print_render_header(f)
-		else:
-			self.print_single_header(f)
-		
-		self.print_body(f)
+			if f.glx_rop:
+				print '        %s' % (f.name)
+				self.print_render_header(f)
+			elif f.glx_sop or f.glx_vendorpriv:
+				print '        %s' % (f.name)
+				self.print_single_header(f)
+			else:
+				continue
 
-		if f.needs_reply():
-			self.print_reply(f)
+			self.print_body(f)
 
-		print ''
+			if f.needs_reply():
+				self.print_reply(f)
+
+			print ''
 		return
 
 
@@ -261,5 +274,7 @@ if __name__ == '__main__':
 		if arg == "-f":
 			file_name = val
 
-	dh = PrintGlxProtoText()
-	gl_XML.parse_GL_API( dh, file_name )
+	api = gl_XML.parse_GL_API( file_name, glx_doc_item_factory() )
+
+	printer = PrintGlxProtoText()
+	printer.Print( api )
diff --git a/src/mesa/glapi/glX_proto_common.py b/src/mesa/glapi/glX_proto_common.py
new file mode 100644
index 00000000000..74489635710
--- /dev/null
+++ b/src/mesa/glapi/glX_proto_common.py
@@ -0,0 +1,95 @@
+#!/usr/bin/env python
+
+# (C) Copyright IBM Corporation 2004, 2005
+# All Rights Reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# on the rights to use, copy, modify, merge, publish, distribute, sub
+# license, and/or sell copies of the Software, and to permit persons to whom
+# the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice (including the next
+# paragraph) shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+# IBM AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+# Authors:
+#    Ian Romanick <[email protected]>
+
+import gl_XML, glX_XML
+import string
+
+
+class glx_proto_item_factory(glX_XML.glx_item_factory):
+	"""Factory to create GLX protocol oriented objects derived from gl_item."""
+    
+	def create_item(self, name, element, context):
+		if name == "type":
+			return glx_proto_type(element, context)
+		else:
+			return glX_XML.glx_item_factory.create_item(self, name, element, context)
+
+
+class glx_proto_type(gl_XML.gl_type):
+	def __init__(self, element, context):
+		gl_XML.gl_type.__init__(self, element, context)
+
+		self.glx_name = element.nsProp( "glx_name", None )
+		return
+
+
+class glx_print_proto(gl_XML.gl_print_base):
+	def size_call(self, func):
+		"""Create C code to calculate 'compsize'.
+
+		Creates code to calculate 'compsize'.  If the function does
+		not need 'compsize' to be calculated, None will be
+		returned."""
+	
+		compsize = None
+
+		for param in func.parameterIterator():
+			if not param.is_output:
+				if param.is_image():
+					[dim, w, h, d, junk] = param.get_dimensions()
+
+					compsize = '__glImageSize(%s, %s, %s, %s, %s, %s)' % (w, h, d, param.img_format, param.img_type, param.img_target)
+					if not param.img_send_null:
+						compsize = '(%s != NULL) ? %s : 0' % (param.name, compsize)
+
+					return compsize
+
+				elif len(param.count_parameter_list):
+					parameters = string.join( param.count_parameter_list, "," )
+					compsize = "__gl%s_size(%s)" % (func.name, parameters)
+
+					return compsize
+
+		return None
+
+
+	def emit_packet_size_calculation(self, f, bias):
+		# compsize is only used in the command size calculation if
+		# the function has a non-output parameter that has a non-empty
+		# counter_parameter_list.
+
+		compsize = self.size_call(f)
+		if compsize:
+			print '    const GLuint compsize = %s;' % (compsize)
+
+		if bias:
+			print '    const GLuint cmdlen = %s - %u;' % (f.command_length(), bias)
+		else:
+			print '    const GLuint cmdlen = %s;' % (f.command_length())
+
+		#print ''
+		return compsize
diff --git a/src/mesa/glapi/glX_proto_send.py b/src/mesa/glapi/glX_proto_send.py
index 94c096e686d..6a4d1dfc0d4 100644
--- a/src/mesa/glapi/glX_proto_send.py
+++ b/src/mesa/glapi/glX_proto_send.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/env python
 
 # (C) Copyright IBM Corporation 2004, 2005
 # All Rights Reserved.
@@ -25,10 +25,8 @@
 # Authors:
 #    Ian Romanick <[email protected]>
 
-import gl_XML
-import glX_XML
-import license
-import sys, getopt, copy
+import gl_XML, glX_XML, glX_proto_common, license
+import sys, getopt, copy, string
 
 def hash_pixel_function(func):
 	"""Generate a 'unique' key for a pixel function.  The key is based on
@@ -36,26 +34,34 @@ def hash_pixel_function(func):
 	padding that might be added for the original function and the 'NULL
 	image' flag."""
 
-	[dim, junk, junk, junk, junk] = func.dimensions()
 
-	d = (dim + 1) & ~1
-	h = "%uD%uD_" % (d - 1, d)
+	h = ""
+	hash_pre = ""
+	hash_suf = ""
+	for param in func.parameterIterateGlxSend():
+		if param.is_image():
+			[dim, junk, junk, junk, junk] = param.get_dimensions()
 
-	for p in func.parameterIterator(1, 1):
-		h = "%s%u" % (h, p.size())
+			d = (dim + 1) & ~1
+			hash_pre = "%uD%uD_" % (d - 1, d)
 
-		if func.pad_after(p):
+			if param.img_null_flag:
+				hash_suf = "_NF"
+
+		h += "%u" % (param.size())
+
+		if func.pad_after(param):
 			h += "4"
 
-	if func.image.img_null_flag:
-		h += "_NF"
 
 	n = func.name.replace("%uD" % (dim), "")
 	n = "__glx_%s_%uD%uD" % (n, d - 1, d)
+
+	h = hash_pre + h + hash_suf
 	return [h, n]
 
 
-class glXPixelFunctionUtility(glX_XML.glXFunction):
+class glx_pixel_function_stub(glX_XML.glx_function):
 	"""Dummy class used to generate pixel "utility" functions that are
 	shared by multiple dimension image functions.  For example, these
 	objects are used to generate shared functions used to send GLX
@@ -68,46 +74,71 @@ class glXPixelFunctionUtility(glX_XML.glXFunction):
 		# parameters.
 
 		self.name = name
-		self.image = copy.copy(func.image)
-		self.fn_parameters = []
-		for p in gl_XML.glFunction.parameterIterator(func):
-			self.fn_parameters.append(p)
+		self.images = []
+		self.parameters = []
+		self.parameters_by_name = {}
+		for _p in func.parameterIterator():
+			p = copy.copy(_p)
+			self.parameters.append(p)
+			self.parameters_by_name[ p.name ] = p
+
+
+			if p.is_image():
+				self.images.append(p)
+				p.height = "height"
+
+				if p.img_yoff == None:
+					p.img_yoff = "yoffset"
+
+				if p.depth:
+					if p.extent == None:
+						p.extent = "extent"
+
+					if p.img_woff == None:
+						p.img_woff = "woffset"
+
 
 			pad_name = func.pad_after(p)
 			if pad_name:
 				pad = copy.copy(p)
 				pad.name = pad_name
-				self.fn_parameters.append(pad)
+				self.parameters.append(pad)
+				self.parameters_by_name[ pad.name ] = pad
 				
 
-		if self.image.height == None:
-			self.image.height = "height"
+		self.return_type = func.return_type
 
-		if self.image.img_yoff == None:
-			self.image.img_yoff = "yoffset"
+		self.glx_rop = ~0
+		self.glx_sop = 0
+		self.glx_vendorpriv = 0
 
-		if func.image.depth:
-			if self.image.extent == None:
-				self.image.extent = "extent"
+		self.glx_doubles_in_order = func.glx_doubles_in_order
 
-			if self.image.img_woff == None:
-				self.image.img_woff = "woffset"
+		self.vectorequiv = None
+		self.output = None
+		self.can_be_large = func.can_be_large
+		self.reply_always_array = func.reply_always_array
+		self.dimensions_in_reply = func.dimensions_in_reply
+		self.img_reset = None
 
+		self.server_handcode = 0
+		self.client_handcode = 0
+		self.ignore = 0
 
-		self.set_return_type( func.fn_return_type )
-		self.glx_rop = ~0
-		self.can_be_large = func.can_be_large
 		self.count_parameter_list = func.count_parameter_list
-		self.counter = func.counter
-		self.img_reset = None
+		self.counter_list = func.counter_list
+		self.offsets_calculated = 0
 		return
 
 
-class PrintGlxProtoStubs(glX_XML.GlxProto):
+class PrintGlxProtoStubs(glX_proto_common.glx_print_proto):
 	def __init__(self):
-		glX_XML.GlxProto.__init__(self)
-		self.last_category = ""
+		glX_proto_common.glx_print_proto.__init__(self)
+		self.name = "glX_proto_send.py (from Mesa)"
 		self.license = license.bsd_license_template % ( "(C) Copyright IBM Corporation 2004, 2005", "IBM")
+
+
+		self.last_category = ""
 		self.generic_sizes = [3, 4, 6, 8, 12, 16, 24, 32]
 		self.pixel_stubs = {}
 		self.debug = 0
@@ -125,7 +156,7 @@ class PrintGlxProtoStubs(glX_XML.GlxProto):
 		print '#include <X11/XCB/xcb.h>'
 		print '#include <X11/XCB/glx.h>'
 		print '#endif /* USE_XCB */'
-		
+
 		print ''
 		print '#define __GLX_PAD(n) (((n) + 3) & ~3)'
 		print ''
@@ -262,18 +293,76 @@ const GLuint __glXDefaultPixelStore[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
 			self.print_generic_function(size)
 		return
 
-	def printFunction(self, f):
-		if f.client_handcode: return
 
-		if f.glx_rop != 0 or f.vectorequiv != None:
-			if f.image:
-				self.printPixelFunction(f)
+	def printBody(self, api):
+
+		self.pixel_stubs = {}
+		generated_stubs = []
+
+		for func in api.functionIterateGlx():
+			if func.client_handcode: continue
+
+			# If the function is a pixel function with a certain
+			# GLX protocol signature, create a fake stub function
+			# for it.  For example, create a single stub function
+			# that is used to implement both glTexImage1D and
+			# glTexImage2D.
+
+			if func.glx_rop != 0:
+				do_it = 0
+				for image in func.get_images():
+					if image.img_pad_dimensions:
+						do_it = 1
+						break
+			
+
+				if do_it:
+					[h, n] = hash_pixel_function(func)
+
+
+					self.pixel_stubs[ func.name ] = n
+					if h not in generated_stubs:
+						generated_stubs.append(h)
+
+						fake_func = glx_pixel_function_stub( func, n )
+						self.printFunction( fake_func )
+
+
+			self.printFunction( func )
+
+		return
+
+
+	def printFunction(self, func):
+		if func.glx_rop == ~0:
+			print 'static %s' % (func.return_type)
+			print '%s( unsigned opcode, unsigned dim, %s )' % (func.name, func.get_parameter_string())
+		else:
+			print '#define %s %d' % (func.opcode_name(), func.opcode_value())
+
+			print '%s' % (func.return_type)
+			print '__indirect_gl%s(%s)' % (func.name, func.get_parameter_string())
+
+
+		print '{'
+
+
+		if func.glx_rop != 0 or func.vectorequiv != None:
+			if len(func.images):
+				self.printPixelFunction(func)
 			else:
-				self.printRenderFunction(f)
-		elif f.glx_sop != 0 or f.glx_vendorpriv != 0:
-			self.printSingleFunction(f)
+				self.printRenderFunction(func)
+		elif func.glx_sop != 0 or func.glx_vendorpriv != 0:
+			self.printSingleFunction(func)
+			pass
 		else:
-			print "/* Missing GLX protocol for %s. */" % (f.name)
+			print "/* Missing GLX protocol for %s. */" % (func.name)
+
+		print '}'
+		print ''
+
+		return
+
 
 	def print_generic_function(self, n):
 		size = (n + 3) & ~3
@@ -289,59 +378,91 @@ generic_%u_byte( GLint rop, const void * ptr )
     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 }
 """ % (n, size + 4, size)
+		return
 
 
-	def common_emit_one_arg(self, p, offset, pc, indent, adjust):
-		t = p.p_type
+	def common_emit_one_arg(self, p, pc, indent, adjust, extra_offset):
 		if p.is_array():
 			src_ptr = p.name
 		else:
 			src_ptr = "&" + p.name
 
-		print '%s    (void) memcpy((void *)(%s + %u), (void *)(%s), %s);' \
-			% (indent, pc, offset + adjust, src_ptr, p.size_string() )
+		if not extra_offset:
+			print '%s    (void) memcpy((void *)(%s + %u), (void *)(%s), %s);' \
+			    % (indent, pc, p.offset + adjust, src_ptr, p.size_string() )
+		else:
+			print '%s    (void) memcpy((void *)(%s + %u + %s), (void *)(%s), %s);' \
+			    % (indent, pc, p.offset + adjust, extra_offset, src_ptr, p.size_string() )
 
 	def common_emit_args(self, f, pc, indent, adjust, skip_vla):
-		offset = 0
-
-		if skip_vla:
-			r = 1
-		else:
-			r = 2
+		extra_offset = None
 
-		for p in f.parameterIterator(1, r):
+		for p in f.parameterIterateGlxSend( not skip_vla ):
 			if p.name != f.img_reset:
-				self.common_emit_one_arg(p, offset, pc, indent, adjust)
-				offset += p.size()
+				self.common_emit_one_arg(p, pc, indent, adjust, extra_offset)
+				
+				if p.is_variable_length():
+					temp = p.size_string()
+					if extra_offset:
+						extra_offset += " + %s" % (temp)
+					else:
+						extra_offset = temp
 
-		return offset
+		return
 
 
-	def pixel_emit_args(self, f, pc, indent, adjust, dim, large):
+	def pixel_emit_args(self, f, pc, indent, large):
 		"""Emit the arguments for a pixel function.  This differs from
 		common_emit_args in that pixel functions may require padding
 		be inserted (i.e., for the missing width field for
 		TexImage1D), and they may also require a 'NULL image' flag
 		be inserted before the image data."""
 
-		offset = 0
-		for p in f.parameterIterator(1, 1):
-			self.common_emit_one_arg(p, offset, pc, indent, adjust)
-			offset += p.size()
+		if large:
+			adjust = 8
+		else:
+			adjust = 4
+
+		for param in f.parameterIterateGlxSend():
+			if not param.is_image():
+				self.common_emit_one_arg(param, pc, indent, adjust, None)
 
-			if f.pad_after(p):
-				print '%s    (void) memcpy((void *)(%s + %u), zero, 4);' % (indent, pc, offset + adjust)
-				offset += 4
+				if f.pad_after(param):
+					print '%s    (void) memcpy((void *)(%s + %u), zero, 4);' % (indent, pc, (param.offset + param.size()) + adjust)
 
-		if f.image.img_null_flag:
-			if large:
-				print '%s    (void) memcpy((void *)(%s + %u), zero, 4);' % (indent, pc, offset + adjust)
 			else:
-				print '%s    (void) memcpy((void *)(%s + %u), (void *)((%s == NULL) ? one : zero), 4);' % (indent, pc, offset + adjust, f.image.name)
+				[dim, width, height, depth, extent] = param.get_dimensions()
+				if f.glx_rop == ~0:
+					dim_str = "dim"
+				else:
+					dim_str = str(dim)
+
+				if param.img_null_flag:
+					if large:
+						print '%s    (void) memcpy((void *)(%s + %u), zero, 4);' % (indent, pc, (param.offset - 4) + adjust)
+					else:
+						print '%s    (void) memcpy((void *)(%s + %u), (void *)((%s == NULL) ? one : zero), 4);' % (indent, pc, (param.offset - 4) + adjust, param.name)
+
 
-			offset += 4
+				pixHeaderPtr = "%s + %u" % (pc, adjust)
+				pcPtr = "%s + %u" % (pc, param.offset + adjust)
 
-		return offset
+				if not large:
+					if param.img_send_null:
+						condition = '(compsize > 0) && (%s != NULL)' % (param.name)
+					else:
+						condition = 'compsize > 0'
+
+					print '%s    if (%s) {' % (indent, condition)
+					print '%s        (*gc->fillImage)(gc, %s, %s, %s, %s, %s, %s, %s, %s, %s);' % (indent, dim_str, width, height, depth, param.img_format, param.img_type, param.name, pcPtr, pixHeaderPtr)
+					print '%s    }' % (indent)
+					print '%s    else {' % (indent)
+					print '%s        (void) memcpy( %s, default_pixel_store_%uD, default_pixel_store_%uD_size );' % (indent, pixHeaderPtr, dim, dim)
+					print '%s    }' % (indent)
+				else:
+					print '%s    __glXSendLargeImage(gc, compsize, %s, %s, %s, %s, %s, %s, %s, %s, %s);' % (indent, dim_str, width, height, depth, param.img_format, param.img_type, param.name, pcPtr, pixHeaderPtr)
+
+		return
 
 
 	def large_emit_begin(self, indent, f, op_name = None):
@@ -356,26 +477,27 @@ generic_%u_byte( GLint rop, const void * ptr )
 		return
 
 
-	def common_func_print_just_header(self, f):
-		print '#define %s %d' % (f.opcode_name(), f.opcode_value())
-
-		print '%s' % (f.fn_return_type)
-		print '__indirect_gl%s(%s)' % (f.name, f.get_parameter_string())
-		print '{'
-
-
 	def common_func_print_just_start(self, f):
 		print '    __GLXcontext * const gc = __glXGetCurrentContext();'
-		
+
 		# The only reason that single and vendor private commands need
 		# a variable called 'dpy' is becuase they use the SyncHandle
 		# macro.  For whatever brain-dead reason, that macro is hard-
 		# coded to use a variable called 'dpy' instead of taking a
 		# parameter.
 
+		# FIXME Simplify the logic related to skip_condition and
+		# FIXME condition_list in this function.  Basically, remove
+		# FIXME skip_condition, and just append the "dpy != NULL" type
+		# FIXME condition to condition_list from the start.  The only
+		# FIXME reason it's done in this confusing way now is to
+		# FIXME minimize the diffs in the generated code.
+
 		if not f.glx_rop:
-			if f.image and f.image.is_output:
-				print '    const __GLXattribute * const state = gc->client_state_private;'
+			for p in f.parameterIterateOutputs():
+				if p.is_image():
+					print '    const __GLXattribute * const state = gc->client_state_private;'
+					break
 
 			print '    Display * const dpy = gc->currentDpy;'
 			skip_condition = "dpy != NULL"
@@ -385,41 +507,37 @@ generic_%u_byte( GLint rop, const void * ptr )
 			skip_condition = None
 
 
-		if f.fn_return_type != 'void':
-			print '    %s retval = (%s) 0;' % (f.fn_return_type, f.fn_return_type)
+		if f.return_type != 'void':
+			print '    %s retval = (%s) 0;' % (f.return_type, f.return_type)
 
-		if not f.output_parameter():
-			compsize = self.size_call( f )
-			if compsize:
-				print '    const GLuint compsize = %s;' % (compsize)
 
-		print '    const GLuint cmdlen = %s;' % (f.command_length())
-
-		if f.counter:
-			if skip_condition:
-				skip_condition = "(%s >= 0) && (%s)" % (f.counter, skip_condition)
-			else:
-				skip_condition = "%s >= 0" % (f.counter)
+		self.emit_packet_size_calculation(f, 0)
 
+		condition_list = []
+		for p in f.parameterIterateCounters():
+			condition_list.append( "%s >= 0" % (p.name) )
 
 		if skip_condition:
+			condition_list.append( skip_condition )
+
+		if len( condition_list ) > 0:
+			if len( condition_list ) > 1:
+				skip_condition = "(%s)" % (string.join( condition_list, ") && (" ))
+			else:
+				skip_condition = "%s" % (condition_list.pop(0))
+
 			print '    if (__builtin_expect(%s, 1)) {' % (skip_condition)
 			return 1
 		else:
 			return 0
 
 
-	def common_func_print_header(self, f):
-		self.common_func_print_just_header(f)
-		return self.common_func_print_just_start(f)
-
-
-
 	def printSingleFunction(self, f):
-		self.common_func_print_header(f)
-		
+		self.common_func_print_just_start(f)
+
 		if self.debug:
 			print '        printf( "Enter %%s...\\n", "gl%s" );' % (f.name)
+
 		if f.glx_vendorpriv == 0:
 
 			# XCB specific:
@@ -429,44 +547,52 @@ generic_%u_byte( GLint rop, const void * ptr )
 			print '        XCBConnection *c = XCBConnectionOfDisplay(dpy);'
 			print '        (void) __glXFlushRenderBuffer(gc, gc->pc);'
 			xcb_name = 'XCBGlx%s' % f.name
+
 			iparams=[]
-			for p in f.fn_parameters:
-				if p.is_output == 0:
+			extra_iparams = []
+			output = None
+			for p in f.parameterIterator():
+				if p.is_output:
+					output = p
+
+					if p.is_image():
+						if p.img_format != "GL_COLOR_INDEX" or p.img_type != "GL_BITMAP":
+							extra_iparams.append("state->storePack.swapEndian")
+						else:
+							extra_iparams.append("0")
+					
+						# Hardcode this in.  lsb_first param (apparently always GL_FALSE)
+						# also present in GetPolygonStipple, but taken care of above.
+						if xcb_name == "XCBGlxReadPixels": 
+							extra_iparams.append("0")
+				else:
 					iparams.append(p.name)
 
-			if f.image and f.image.is_output:
-				if f.image.img_format != "GL_COLOR_INDEX" or f.image.img_type != "GL_BITMAP":
-					iparams.append("state->storePack.swapEndian")
-				else:
-					iparams.append("0")
-					
-				# Hardcode this in.  lsb_first param (apparently always GL_FALSE)
-				# also present in GetPolygonStipple, but taken care of above.
-				if xcb_name == "XCBGlxReadPixels": iparams.append("0")
-			    
-			xcb_request = '%s(%s)' % (xcb_name, ", ".join(["c", "gc->currentContextTag"] + iparams))
+
+			xcb_request = '%s(%s)' % (xcb_name, ", ".join(["c", "gc->currentContextTag"] + iparams + extra_iparams))
 
 			if f.needs_reply():
 				print '        %sRep *reply = %sReply(c, %s, NULL);' % (xcb_name, xcb_name, xcb_request)
-				if f.output and f.reply_always_array:
-					print '        %s = (%s *)%sData(reply);' % (f.output.name, f.output.p_type.name, xcb_name)
-				elif f.output and not f.reply_always_array:
-					if not f.image and not f.name == "GenQueriesARB":
+				if output and f.reply_always_array:
+					print '        %s = (%s)%sData(reply);' % (output.name, output.type_string(), xcb_name)
+				elif output and not f.reply_always_array:
+					if not output.is_image():
 						print '        if (%sDataLength(reply) == 0)' % (xcb_name)
-						print '            (void)memcpy(%s, &reply->datum, sizeof(reply->datum));' % (f.output.name)
+						print '            (void)memcpy(%s, &reply->datum, sizeof(reply->datum));' % (output.name)
 						print '        else'
-					print '        (void)memcpy(%s, %sData(reply), %sDataLength(reply) * sizeof(%s));' % (f.output.name, xcb_name, xcb_name, f.output.p_type.name)
+					print '        (void)memcpy(%s, %sData(reply), %sDataLength(reply) * sizeof(%s));' % (output.name, xcb_name, xcb_name, output.get_base_type_string())
 
 
-				if f.fn_return_type != 'void':
+				if f.return_type != 'void':
 					print '        retval = reply->ret_val;'
 				print '        free(reply);'
 			else:
 				print '        ' + xcb_request + ';'
 			print '#else'
 			# End of XCB specific.
-		
-		if f.fn_parameters != []:
+
+
+		if f.parameters != []:
 			pc_decl = "GLubyte const * pc ="
 		else:
 			pc_decl = "(void)"
@@ -477,190 +603,108 @@ generic_%u_byte( GLint rop, const void * ptr )
 			print '        %s __glXSetupSingleRequest(gc, %s, cmdlen);' % (pc_decl, f.opcode_name())
 
 		self.common_emit_args(f, "pc", "    ", 0, 0)
-		if f.image and f.image.is_output:
-			o = f.command_fixed_length() - 4
-			print '        *(int32_t *)(pc + %u) = 0;' % (o)
-			if f.image.img_format != "GL_COLOR_INDEX" or f.image.img_type != "GL_BITMAP":
-				print '        * (int8_t *)(pc + %u) = state->storePack.swapEndian;' % (o)
 
+		images = f.get_images()
+
+		for img in images:
+			if img.is_output:
+				o = f.command_fixed_length() - 4
+				print '        *(int32_t *)(pc + %u) = 0;' % (o)
+				if img.img_format != "GL_COLOR_INDEX" or img.img_type != "GL_BITMAP":
+					print '        * (int8_t *)(pc + %u) = state->storePack.swapEndian;' % (o)
+		
 				if f.img_reset:
 					print '        * (int8_t *)(pc + %u) = %s;' % (o + 1, f.img_reset)
 
 
+		return_name = ''
 		if f.needs_reply():
-			if f.image and f.image.is_output:
-				[dim, w, h, d, junk] = f.dimensions()
-				if f.dimensions_in_reply:
-					print "        __glXReadPixelReply(dpy, gc, %u, 0, 0, 0, %s, %s, %s, GL_TRUE);" % (dim, f.image.img_format, f.image.img_type, f.image.name)
-				else:
-					print "        __glXReadPixelReply(dpy, gc, %u, %s, %s, %s, %s, %s, %s, GL_FALSE);" % (dim, w, h, d, f.image.img_format, f.image.img_type, f.image.name)
+			if f.return_type != 'void':
+				return_name = " retval"
+				return_str = " retval = (%s)" % (f.return_type)
 			else:
-				if f.output != None:
-					if f.output.p_type.size == 0:
-						output_size = 1
+				return_str = " (void)"
+
+			got_reply = 0
+
+			for p in f.parameterIterateOutputs():
+				if p.is_image():
+					[dim, w, h, d, junk] = p.get_dimensions()
+					if f.dimensions_in_reply:
+						print "        __glXReadPixelReply(dpy, gc, %u, 0, 0, 0, %s, %s, %s, GL_TRUE);" % (dim, p.img_format, p.img_type, p.name)
 					else:
-						output_size = f.output.p_type.size
+						print "        __glXReadPixelReply(dpy, gc, %u, %s, %s, %s, %s, %s, %s, GL_FALSE);" % (dim, w, h, d, p.img_format, p.img_type, p.name)
 
-					output_str = f.output.name
+					got_reply = 1
 				else:
-					output_size = 0
-					output_str = "NULL"
+					if f.reply_always_array:
+						aa = "GL_TRUE"
+					else:
+						aa = "GL_FALSE"
 
-				if f.fn_return_type != 'void':
-					return_str = " retval = (%s)" % (f.fn_return_type)
-				else:
-					return_str = " (void)"
+					# gl_parameter.size() returns the size
+					# of the entire data item.  If the
+					# item is a fixed-size array, this is
+					# the size of the whole array.  This
+					# is not what __glXReadReply wants. It
+					# wants the size of a single data
+					# element in the reply packet.
+					# Dividing by the array size (1 for
+					# non-arrays) gives us this.
 
-				if f.reply_always_array:
-					aa = "GL_TRUE"
-				else:
-					aa = "GL_FALSE"
+					s = p.size() / p.get_element_count()
+					print "       %s __glXReadReply(dpy, %s, %s, %s);" % (return_str, s, p.name, aa)
+					got_reply = 1
+
+
+			# If a reply wasn't read to fill an output parameter,
+			# read a NULL reply to get the return value.
+
+			if not got_reply:
+				print "       %s __glXReadReply(dpy, 0, NULL, GL_FALSE);" % (return_str)
 
-				print "       %s __glXReadReply(dpy, %s, %s, %s);" % (return_str, output_size, output_str, aa)
 
 		elif self.debug:
 			# Only emit the extra glFinish call for functions
 			# that don't already require a reply from the server.
 			print '        __indirect_glFinish();'
 
-		print '        UnlockDisplay(dpy); SyncHandle();'
-		
-		if f.glx_vendorpriv == 0:
-			print '#endif /* USE_XCB */'
-			
 		if self.debug:
 			print '        printf( "Exit %%s.\\n", "gl%s" );' % (f.name)
-		print '    }'
-		print '    %s' % f.return_string()
-		print '}'
-		print ''
-		return
-
-
-	def printPixelFunction(self, f):
-		"""This function could use some major refactoring. :("""
-
-		# There is a code-space optimization that we can do here.
-		# Functions that are marked img_pad_dimensions have a version
-		# with an odd number of dimensions and an even number of
-		# dimensions.  TexSubImage1D and TexSubImage2D are examples.
-		# We can emit a single function that does both, and have the
-		# real functions call the utility function with the correct
-		# parameters.
-		#
-		# The only quirk to this is that utility funcitons will be
-		# generated for 3D and 4D functions, but 4D (e.g.,
-		# GL_SGIS_texture4D) isn't typically supported.  This is
-		# probably not an issue.  However, it would be possible to
-		# look at the total set of functions and determine if there
-		# is another function that would actually use the utility
-		# function.  If not, then fallback to the normal way of
-		# generating code.
-
-		if f.image.img_pad_dimensions:
-			# Determine the hash key and the name for the utility
-			# function that is used to implement the real
-			# function.
-
-			[h, n] = hash_pixel_function(f)
-
-			
-			# If the utility function is not yet known, generate
-			# it.
-
-			if not self.pixel_stubs.has_key(h):
-				self.pixel_stubs[h] = n
-				pixel_func = glXPixelFunctionUtility(f, n)
 
-				print 'static void'
-				print '%s( unsigned opcode, unsigned dim, %s )' % (n, pixel_func.get_parameter_string())
-				print '{'
-
-				if self.common_func_print_just_start(pixel_func):
-					indent = "    "
-					trailer = "    }"
-				else:
-					indent = ""
-					trailer = None
-
-
-				if pixel_func.can_be_large:
-					print '%s    if (cmdlen <= gc->maxSmallRenderCommandSize) {' % (indent)
-					print '%s        if ( (gc->pc + cmdlen) > gc->bufEnd ) {' % (indent)
-					print '%s            (void) __glXFlushRenderBuffer(gc, gc->pc);' % (indent)
-					print '%s        }' % (indent)
-					indent += "    "
-
-				[dim, width, height, depth, extent] = pixel_func.dimensions()
-				adjust = pixel_func.offset_of_first_parameter() + 4
-
-				print '%s    emit_header(gc->pc, opcode, cmdlen);' % (indent)
-
-				offset = self.pixel_emit_args(pixel_func, "gc->pc", indent, adjust, dim, 0)
-
-				s = pixel_func.command_fixed_length()
-
-				pixHeaderPtr = "gc->pc + 4"
-				pcPtr = "gc->pc + %u" % (s + 4)
-
-				if pixel_func.image.img_send_null:
-					condition = '(compsize > 0) && (%s != NULL)' % (pixel_func.image.name)
-				else:
-					condition = 'compsize > 0'
-
-				print '%s    if (%s) {' % (indent, condition)
-				print '%s        (*gc->fillImage)(gc, dim, %s, %s, %s, %s, %s, %s, %s, %s);' % (indent, width, height, depth, pixel_func.image.img_format, pixel_func.image.img_type, pixel_func.image.name, pcPtr, pixHeaderPtr)
-				print '%s    }' % (indent)
-				print '%s    else {' % (indent)
-				print '%s        (void) memcpy( %s, default_pixel_store_%uD, default_pixel_store_%uD_size );' % (indent, pixHeaderPtr, dim, dim)
-				print '%s    }' % (indent)
-
-				print '%s    gc->pc += cmdlen;' % (indent)
-				print '%s    if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }' % (indent)
-
-				if f.can_be_large:
-					adjust += 4
-
-					print '%s}' % (indent)
-					print '%selse {' % (indent)
-
-					self.large_emit_begin(indent, pixel_func, "opcode")
-					offset = self.pixel_emit_args(pixel_func, "pc", indent, adjust, dim, 1)
-
-					pixHeaderPtr = "pc + 8"
-					pcPtr = "pc + %u" % (s + 8)
-
-					print '%s    __glXSendLargeImage(gc, compsize, dim, %s, %s, %s, %s, %s, %s, %s, %s);' % (indent, width, height, depth, f.image.img_format, f.image.img_type, f.image.name, pcPtr, pixHeaderPtr)
-
-					print '%s}' % (indent)
-
-				if trailer: print trailer
-				print '}'
-				print ''
 
+		print '        UnlockDisplay(dpy); SyncHandle();'
 
+		if f.glx_vendorpriv == 0:
+			print '#endif /* USE_XCB */'
 
-			# Generate the real function as a call to the
-			# utility function.
+		print '    }'
+		print '    return%s;' % (return_name)
+		return
 
-			self.common_func_print_just_header(f)
 
-			[dim, junk, junk, junk, junk] = f.dimensions()
+	def printPixelFunction(self, f):
+		if self.pixel_stubs.has_key( f.name ):
+			# Normally gl_function::get_parameter_string could be
+			# used.  However, this call needs to have the missing
+			# dimensions (e.g., a fake height value for
+			# glTexImage1D) added in.
 
 			p_string = ""
-			for p in gl_XML.glFunction.parameterIterator(f):
-				p_string += ", " + p.name
+			for param in f.parameterIterateGlxSend():
+				p_string += ", " + param.name
+
+				if param.is_image():
+					[dim, junk, junk, junk, junk] = param.get_dimensions()
 
-				if f.pad_after(p):
+				if f.pad_after(param):
 					p_string += ", 1"
 
-			print '    %s(%s, %u%s );' % (n, f.opcode_name(), dim, p_string)
-			print '}'
-			print ''
+			print '    %s(%s, %u%s );' % (self.pixel_stubs[f.name] , f.opcode_name(), dim, p_string)
 			return
 
 
-		if self.common_func_print_header(f):
+		if self.common_func_print_just_start(f):
 			indent = "    "
 			trailer = "    }"
 		else:
@@ -675,52 +719,27 @@ generic_%u_byte( GLint rop, const void * ptr )
 			print '%s        }' % (indent)
 			indent += "    "
 
-		[dim, width, height, depth, extent] = f.dimensions()
-		adjust = f.offset_of_first_parameter() + 4
-
-		print '%s    emit_header(gc->pc, %s, cmdlen);' % (indent, f.opcode_real_name())
-
-		offset = self.pixel_emit_args(f, "gc->pc", indent, adjust, dim, 0)
-
-		s = f.command_fixed_length()
-
-		pixHeaderPtr = "gc->pc + 4"
-		pcPtr = "gc->pc + %u" % (s + 4)
-
-		if f.image.img_send_null:
-			condition = '(compsize > 0) && (%s != NULL)' % (f.image.name)
+		if f.glx_rop == ~0:
+			opcode = "opcode"
 		else:
-			condition = 'compsize > 0'
+			opcode = f.opcode_real_name()
 
-		print '%s    if (%s) {' % (indent, condition)
-		print '%s        (*gc->fillImage)(gc, %u, %s, %s, %s, %s, %s, %s, %s, %s);' % (indent, dim, width, height, depth, f.image.img_format, f.image.img_type, f.image.name, pcPtr, pixHeaderPtr)
-		print '%s    }' % (indent)
-		print '%s    else {' % (indent)
-		print '%s        (void) memcpy( %s, default_pixel_store_%uD, default_pixel_store_%uD_size );' % (indent, pixHeaderPtr, dim, dim)
-		print '%s    }' % (indent)
+		print '%s    emit_header(gc->pc, %s, cmdlen);' % (indent, opcode)
 
+		self.pixel_emit_args( f, "gc->pc", indent, 0 )
 		print '%s    gc->pc += cmdlen;' % (indent)
 		print '%s    if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }' % (indent)
 
 		if f.can_be_large:
-			adjust += 4
-
 			print '%s}' % (indent)
 			print '%selse {' % (indent)
 
-			self.large_emit_begin(indent, f)
-			offset = self.pixel_emit_args(f, "pc", indent, adjust, dim, 1)
-
-			pixHeaderPtr = "pc + 8"
-			pcPtr = "pc + %u" % (s + 8)
-
-			print '%s    __glXSendLargeImage(gc, compsize, %u, %s, %s, %s, %s, %s, %s, %s, %s);' % (indent, dim, width, height, depth, f.image.img_format, f.image.img_type, f.image.name, pcPtr, pixHeaderPtr)
+			self.large_emit_begin(indent, f, opcode)
+			self.pixel_emit_args( f, "pc", indent, 1 )
 
 			print '%s}' % (indent)
 
 		if trailer: print trailer
-		print '}'
-		print ''
 		return
 
 
@@ -731,19 +750,16 @@ generic_%u_byte( GLint rop, const void * ptr )
 		# regular.  Since they are so regular and there are so many
 		# of them, special case them with generic functions.  On
 		# x86, this saves about 26KB in the libGL.so binary.
-		
-		if f.variable_length_parameter() == None and len(f.fn_parameters) == 1:
-			p = f.fn_parameters[0]
-			if p.is_pointer:
+
+		if f.variable_length_parameter() == None and len(f.parameters) == 1:
+			p = f.parameters[0]
+			if p.is_pointer():
 				cmdlen = f.command_fixed_length()
 				if cmdlen in self.generic_sizes:
-					self.common_func_print_just_header(f)
 					print '    generic_%u_byte( %s, %s );' % (cmdlen, f.opcode_real_name(), p.name)
-					print '}'
-					print ''
 					return
 
-		if self.common_func_print_header(f):
+		if self.common_func_print_just_start(f):
 			indent = "    "
 			trailer = "    }"
 		else:
@@ -771,10 +787,10 @@ generic_%u_byte( GLint rop, const void * ptr )
 			print '%selse {' % (indent)
 
 			self.large_emit_begin(indent, f)
-			offset = self.common_emit_args(f, "pc", indent, 8, 1)
+			self.common_emit_args(f, "pc", indent, 8, 1)
 
 			p = f.variable_length_parameter()
-			print '%s    __glXSendLargeCommand(gc, pc, %u, %s, %s);' % (indent, offset + 8, p.name, p.size_string())
+			print '%s    __glXSendLargeCommand(gc, pc, %u, %s, %s);' % (indent, p.offset + 8, p.name, p.size_string())
 			print '%s}' % (indent)
 
 		if self.debug:
@@ -782,18 +798,18 @@ generic_%u_byte( GLint rop, const void * ptr )
 			print '%s    printf( "Exit %%s.\\n", "gl%s" );' % (indent, f.name)
 
 		if trailer: print trailer
-		print '}'
-		print ''
 		return
 
 
-class PrintGlxProtoInit_c(glX_XML.GlxProto):
+class PrintGlxProtoInit_c(gl_XML.gl_print_base):
 	def __init__(self):
-		glX_XML.GlxProto.__init__(self)
-		self.last_category = ""
+		gl_XML.gl_print_base.__init__(self)
+
+		self.name = "glX_proto_send.py (from Mesa)"
 		self.license = license.bsd_license_template % ( \
 """Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
 (C) Copyright IBM Corporation 2004""", "PRECISION INSIGHT, IBM")
+		return
 
 
 	def printRealHeader(self):
@@ -848,26 +864,107 @@ __GLapi * __glXNewIndirectAPI( void )
     return glAPI;
 }
 """
+		return
 
-	def printFunction(self, f):
-		if f.category != self.last_category:
-			self.last_category = f.category
-			print ''
-			print '    /* %s */' % (self.last_category)
-			print ''
-			
-		print '    glAPI->%s = __indirect_gl%s;' % (f.name, f.name)
 
+	def printCategory(self, category_group, show_num):
+		cat_keys = category_group.keys()
+		cat_keys.sort()
+		for cat_num in cat_keys:
+			first = 1
+			for offset in category_group[ cat_num ]:
+				[cat_name, func_name] = category_group[ cat_num ][ offset ]
+
+				if first:
+					print ''
+					if show_num:
+						print '    /* % 3u. %s */' % (cat_num, cat_name)
+					else:
+						print '    /* %s */' % (cat_name)
+					print ''
+					first = 0
+
+				print '    glAPI->%s = __indirect_gl%s;' % (func_name, func_name)
+		
+
+	def printBody(self, api):
+		core_categories = {}
+		arb_categories = {}
+		other_categories = {}
+		next_unnum = 1000
+
+		for func in api.functionIterateGlx():
+			[cat, num] = api.get_category_for_name( func.name )
+
+			# There are three groups of "categories" that we
+			# care about here.  We want to separate the core GL
+			# version categories from extensions.  We also want to
+			# separate the ARB extensions from the non-ARB
+			# extensions.
+			#
+			# This is done by first trying to convert the category
+			# name to a floating point number.  All core GL
+			# versions are of the form "N.M" where both N and M
+			# are integers.  If the cast to float fails, an
+			# exception will be thrown.  Once down that path, 
+			# we can look at the start of the extension string.
+			# If it begins with "GL_ARB_", it's an ARB extension.
+			#
+			# Once the categories are separated, the are ordered
+			# by number.  The un-numbered non-ARB extensions
+			# (e.g., GL_INGR_blend_func_separate) are assigned
+			# arbitrary numbers starting at 1000.
+			#
+			# FIXME In order to maintain repeatability, the
+			# FIXME unnumbered extensions should be put in their
+			# FIXME own dictionary and ordered by name (since they
+			# FIXME have no number).
+
+			try:
+				num = float(cat)
+				if not core_categories.has_key( num ):
+					core_categories[ num ] = {}
+
+				core_categories[ num ][ func.offset ] = [cat, func.name]
+
+			except Exception, e:
+				if not num:
+					num = next_unnum
+					next_unnum += 1
+				else:
+					num = int(num)
+
+				if cat.startswith( "GL_ARB_" ):
+					if not arb_categories.has_key( num ):
+						arb_categories[ num ] = {}
+
+					arb_categories[ num ][ func.offset ] = [cat, func.name]
+				else:
+					if not other_categories.has_key( num ):
+						other_categories[ num ] = {}
 
-class PrintGlxProtoInit_h(glX_XML.GlxProto):
+					other_categories[ num ][ func.offset ] = [cat, func.name]
+
+		self.printCategory( core_categories,  0 )
+		self.printCategory( arb_categories,   1 )
+		self.printCategory( other_categories, 1 )
+		return
+
+
+class PrintGlxProtoInit_h(gl_XML.gl_print_base):
 	def __init__(self):
-		glX_XML.GlxProto.__init__(self)
-		self.last_category = ""
+		gl_XML.gl_print_base.__init__(self)
+
+		self.name = "glX_proto_send.py (from Mesa)"
 		self.license = license.bsd_license_template % ( \
 """Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
 (C) Copyright IBM Corporation 2004""", "PRECISION INSIGHT, IBM")
 		self.header_tag = "_INDIRECT_H_"
 
+		self.last_category = ""
+		return
+
+
 	def printRealHeader(self):
 		print """/**
  * \\file
@@ -900,8 +997,9 @@ extern HIDDEN NOINLINE FASTCALL GLubyte * __glXSetupVendorRequest(
 """
 
 
-	def printFunction(self, f):
-		print 'extern HIDDEN %s __indirect_gl%s(%s);' % (f.fn_return_type, f.name, f.get_parameter_string())
+	def printBody(self, api):
+		for func in api.functionIterateGlx():
+			print 'extern HIDDEN %s __indirect_gl%s(%s);' % (func.return_type, func.name, func.get_parameter_string())
 
 
 def show_usage():
@@ -930,14 +1028,16 @@ if __name__ == '__main__':
 			debug = 1
 
 	if mode == "proto":
-		dh = PrintGlxProtoStubs()
+		printer = PrintGlxProtoStubs()
 	elif mode == "init_c":
-		dh = PrintGlxProtoInit_c()
+		printer = PrintGlxProtoInit_c()
 	elif mode == "init_h":
-		dh = PrintGlxProtoInit_h()
+		printer = PrintGlxProtoInit_h()
 	else:
 		show_usage()
 
 
-	dh.debug = debug
-	gl_XML.parse_GL_API( dh, file_name )
+	printer.debug = debug
+	api = gl_XML.parse_GL_API( file_name, glX_XML.glx_item_factory() )
+
+	printer.Print( api )
diff --git a/src/mesa/glapi/glX_proto_size.py b/src/mesa/glapi/glX_proto_size.py
index a1c0497ae74..b097fed0ebb 100644
--- a/src/mesa/glapi/glX_proto_size.py
+++ b/src/mesa/glapi/glX_proto_size.py
@@ -25,104 +25,262 @@
 # Authors:
 #    Ian Romanick <[email protected]>
 
-import gl_XML
-import glX_XML
+import gl_XML, glX_XML
 import license
-import sys, getopt, copy
+import sys, getopt, copy, string
 
 
-class SizeStubFunctionIterator(glX_XML.glXFunctionIterator):
-	"""Iterate over functions that need "size" information.
+class glx_enum_function:
+	def __init__(self, func_name, enum_dict):
+		self.name = func_name
+		self.mode = 1
+		self.sig = None
 
-	Iterate over the functions that have variable sized data.  First the
-	"set"-type functions are iterated followed by the "get"-type
-	functions.
-	"""
+		# "enums" is a set of lists.  The element in the set is the
+		# value of the enum.  The list is the list of names for that
+		# value.  For example, [0x8126] = {"POINT_SIZE_MIN",
+		# "POINT_SIZE_MIN_ARB", "POINT_SIZE_MIN_EXT",
+		# "POINT_SIZE_MIN_SGIS"}.
 
-	def __init__(self, context):
-		self.data = []
-		self.index = 0
+		self.enums = {}
 
-		set_functions = []
-		get_functions = []
-		extra_data = []
+		# "count" is indexed by count values.  Each element of count
+		# is a list of index to "enums" that have that number of
+		# associated data elements.  For example, [4] = 
+		# {GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION,
+		# GL_AMBIENT_AND_DIFFUSE} (the enum names are used here,
+		# but the actual hexadecimal values would be in the array).
+
+		self.count = {}
 
-		for f in gl_XML.glFunctionIterator(context):
-			if context.glx_enum_functions.has_key(f.name):
-				ef = context.glx_enum_functions[f.name]
-				if ef.is_set():
-					set_functions.append(f)
-				else:
-					get_functions.append(f)
 
+		# Fill self.count and self.enums using the dictionary of enums
+		# that was passed in.
+
+		mode_set = 0
+		for enum_name in enum_dict:
+			e = enum_dict[ enum_name ]
+		
+			if e.functions.has_key( func_name ):
+				[count, mode] = e.functions[ func_name ]
 
-		if (context.which_functions & PrintGlxSizeStubs_c.do_set) != 0:
-			self.data += set_functions
-		elif context.get_alias_set:
-			extra_data = set_functions
+				if mode_set and mode != self.mode:
+					raise RuntimeError("Not all enums for %s have the same mode." % (func_name))
 
-		if (context.which_functions & PrintGlxSizeStubs_c.do_get) != 0:
-			self.data += get_functions
+				self.mode = mode
 
+				if self.enums.has_key( e.value ):
+					if e.name not in self.enums[ e.value ]:
+						self.enums[ e.value ].append( e )
+				else:
+					if not self.count.has_key( count ):
+						self.count[ count ] = []
 
-		for f in extra_data + self.data:
-			sig = context.glx_enum_functions[f.name].signature()
+					self.enums[ e.value ] = [ e ]
+					self.count[ count ].append( e.value )
 
-			if not context.glx_enum_sigs.has_key(sig):
-				context.glx_enum_sigs[sig] = f.name;
 
 		return
 
 
-	def next(self):
-		if self.index == len(self.data):
-			raise StopIteration
+	def signature( self ):
+		if self.sig == None:
+			self.sig = ""
+			for i in self.count:
+				if i == None:
+					raise RuntimeError("i is None.  WTF?")
+
+				self.count[i].sort()
+				for e in self.count[i]:
+					self.sig += "%04x,%u," % (e, i)
+	
+		return self.sig
+
+
+	def is_set( self ):
+		return self.mode
+
+
+	def PrintUsingTable(self):
+		"""Emit the body of the __gl*_size function using a pair
+		of look-up tables and a mask.  The mask is calculated such
+		that (e & mask) is unique for all the valid values of e for
+		this function.  The result of (e & mask) is used as an index
+		into the first look-up table.  If it matches e, then the
+		same entry of the second table is returned.  Otherwise zero
+		is returned.
+		
+		It seems like this should cause better code to be generated.
+		However, on x86 at least, the resulting .o file is about 20%
+		larger then the switch-statment version.  I am leaving this
+		code in because the results may be different on other
+		platforms (e.g., PowerPC or x86-64)."""
+
+		return 0
+		count = 0
+		for a in self.enums:
+			count += 1
+
+		if self.count.has_key(-1):
+			return 0
+
+		# Determine if there is some mask M, such that M = (2^N) - 1,
+		# that will generate unique values for all of the enums.
+
+		mask = 0
+		for i in [1, 2, 3, 4, 5, 6, 7, 8]:
+			mask = (1 << i) - 1
+
+			fail = 0;
+			for a in self.enums:
+				for b in self.enums:
+					if a != b:
+						if (a & mask) == (b & mask):
+							fail = 1;
+
+			if not fail:
+				break;
+			else:
+				mask = 0
+
+		if (mask != 0) and (mask < (2 * count)):
+			masked_enums = {}
+			masked_count = {}
+
+			for i in range(0, mask + 1):
+				masked_enums[i] = "0";
+				masked_count[i] = 0;
+
+			for c in self.count:
+				for e in self.count[c]:
+					i = e & mask
+					enum_obj = self.enums[e][0]
+					masked_enums[i] = '0x%04x /* %s */' % (e, enum_obj.name )
+					masked_count[i] = c
+
+
+			print '    static const GLushort a[%u] = {' % (mask + 1)
+			for e in masked_enums:
+				print '        %s, ' % (masked_enums[e])
+			print '    };'
 
-		f = self.data[ self.index ]
-		self.index += 1
+			print '    static const GLubyte b[%u] = {' % (mask + 1)
+			for c in masked_count:
+				print '        %u, ' % (masked_count[c])
+			print '    };'
 
-		return f
+			print '    const unsigned idx = (e & 0x%02xU);' % (mask)
+			print ''
+			print '    return (e == a[idx]) ? (GLint) b[idx] : 0;'
+			return 1;
+		else:
+			return 0;
+
+
+	def PrintUsingSwitch(self, name):
+		"""Emit the body of the __gl*_size function using a 
+		switch-statement."""
+
+		print '    switch( e ) {'
+
+		for c in self.count:
+			for e in self.count[c]:
+				first = 1
+
+				# There may be multiple enums with the same
+				# value.  This happens has extensions are
+				# promoted from vendor-specific or EXT to
+				# ARB and to the core.  Emit the first one as
+				# a case label, and emit the others as
+				# commented-out case labels.
+
+				list = {}
+				for enum_obj in self.enums[e]:
+					list[ enum_obj.priority() ] = enum_obj.name
+
+				keys = list.keys()
+				keys.sort()
+				for k in keys:
+					j = list[k]
+					if first:
+						print '        case GL_%s:' % (j)
+						first = 0
+					else:
+						print '/*      case GL_%s:*/' % (j)
+					
+			if c == -1:
+				print '            return __gl%s_variable_size( e );' % (name)
+			else:
+				print '            return %u;' % (c)
+					
+		print '        default: return 0;'
+		print '    }'
+
+
+	def Print(self, name):
+		print 'INTERNAL PURE FASTCALL GLint'
+		print '__gl%s_size( GLenum e )' % (name)
+		print '{'
+
+		if not self.PrintUsingTable():
+			self.PrintUsingSwitch(name)
+
+		print '}'
+		print ''
+
+
+class glx_server_enum_function(glx_enum_function):
+	def __init__(self, func, enum_dict):
+		glx_enum_function.__init__(self, func.name, enum_dict)
+		
+		self.function = func
+		return
 
 
-class glXServerEnumFunction(glX_XML.glXEnumFunction):
 	def signature( self ):
 		if self.sig == None:
-			sig = glX_XML.glXEnumFunction.signature(self)
+			sig = glx_enum_function.signature(self)
 
-			f = self.context.find_function( self.name )
-			p = f.variable_length_parameter()
-
-			try:
-				sig += "%u" % (p.p_type.size)
-			except Exception,e:
-				print '%s' % (self.name)
-				raise e
+			p = self.function.variable_length_parameter()
+			if p:
+				sig += "%u" % (p.size())
 
 			self.sig = sig
 
 		return self.sig;
 
 
-	def Print(self, name):
-		f = self.context.find_function( self.name )
-		self.context.common_func_print_just_header( f )
+	def Print(self, name, printer):
+		f = self.function
+		printer.common_func_print_just_header( f )
 
 		fixup = []
-		o = 0
-		for p in f.parameterIterator(1, 1):
-			if f.count_parameter_list.count(p.name) or p.name == f.counter:
-				self.context.common_emit_one_arg(p, o, "pc", "    ", 0)
-				fixup.append(p.name)
+		
+		foo = {}
+		for param_name in f.count_parameter_list:
+			o = f.offset_of( param_name )
+			foo[o] = param_name
+
+		for param_name in f.counter_list:
+			o = f.offset_of( param_name )
+			foo[o] = param_name
+
+		keys = foo.keys()
+		keys.sort()
+		for o in keys:
+			p = f.parameters_by_name[ foo[o] ]
+
+			printer.common_emit_one_arg(p, "pc", "    ", 0)
+			fixup.append( p.name )
 
-			o += p.size()
 
 		print '    GLsizei compsize;'
 		print ''
 
-		self.context.common_emit_fixups(fixup)
+		printer.common_emit_fixups(fixup)
 
 		print ''
-		print '    compsize = %s;' % (context.size_call(context, f))
+		print '    compsize = __gl%s_size(%s);' % (f.name, string.join(f.count_parameter_list, ","))
 		p = f.variable_length_parameter()
 		print '    return __GLX_PAD(%s);' % (p.size_string())
 
@@ -130,34 +288,26 @@ class glXServerEnumFunction(glX_XML.glXEnumFunction):
 		print ''
 
 
-class PrintGlxSizeStubs_common(glX_XML.GlxProto):
+class PrintGlxSizeStubs_common(gl_XML.gl_print_base):
 	do_get = (1 << 0)
 	do_set = (1 << 1)
-	do_get_alias_set = (1 << 2)
 
 	def __init__(self, which_functions):
-		glX_XML.GlxProto.__init__(self)
-		self.license = license.bsd_license_template % ( "(C) Copyright IBM Corporation 2004", "IBM")
-		self.aliases = []
-		self.glx_enum_sigs = {}
-		self.name = "glX_proto_size.py (from Mesa)"
-		self.which_functions = which_functions
-
-		if (((which_functions & PrintGlxSizeStubs_common.do_set) != 0) and ((which_functions & PrintGlxSizeStubs_common.do_get) != 0)) or ((which_functions & PrintGlxSizeStubs_common.do_get_alias_set) != 0):
-			self.get_alias_set = 1
-		else:
-			self.get_alias_set = 0
+		gl_XML.gl_print_base.__init__(self)
 
+		self.name = "glX_proto_size.py (from Mesa)"
+		self.license = license.bsd_license_template % ( "(C) Copyright IBM Corporation 2004", "IBM")
 
-	def functionIterator(self):
-		return SizeStubFunctionIterator(self)
+		self.emit_set = ((which_functions & PrintGlxSizeStubs_common.do_set) != 0)
+		self.emit_get = ((which_functions & PrintGlxSizeStubs_common.do_get) != 0)
+		return
 
 
 class PrintGlxSizeStubs_c(PrintGlxSizeStubs_common):
 	def printRealHeader(self):
 		print ''
 		print '#include <GL/gl.h>'
-		if self.which_functions & self.do_get:
+		if self.emit_get:
 			print '#include "indirect_size_get.h"'
 		
 		print '#include "indirect_size.h"'
@@ -186,20 +336,26 @@ class PrintGlxSizeStubs_c(PrintGlxSizeStubs_common):
 		print ''
 
 
-	def printRealFooter(self):
-		for a in self.aliases:
-			print a
+	def printBody(self, api):
+		enum_sigs = {}
+		aliases = []
+
+		for func in api.functionIterateGlx():
+			ef = glx_enum_function( func.name, api.enums_by_name )
+			if len(ef.enums) == 0:
+				continue
 
+			if (ef.is_set() and self.emit_set) or (not ef.is_set() and self.emit_get):
+				sig = ef.signature()
+				if enum_sigs.has_key( sig ):
+					aliases.append( [func.name, enum_sigs[ sig ]] )
+				else:
+					enum_sigs[ sig ] = func.name
+					ef.Print( func.name )
 
-	def printFunction(self, f):
-		ef = self.glx_enum_functions[f.name]
-		n = self.glx_enum_sigs[ ef.signature() ];
 
-		if n != f.name:
-			a = 'ALIAS( %s, %s )' % (f.name, n)
-			self.aliases.append(a)
-		else:
-			ef.Print( f.name )
+		for [alias_name, real_name] in aliases:
+			print 'ALIAS( %s, %s )' % (alias_name, real_name)
 
 
 				
@@ -221,12 +377,17 @@ class PrintGlxSizeStubs_h(PrintGlxSizeStubs_common):
 		print ''
 
 
-	def printFunction(self, f):
-		ef = self.glx_enum_functions[f.name]
-		print 'extern INTERNAL PURE FASTCALL GLint __gl%s_size(GLenum);' % (f.name)
+	def printBody(self, api):
+		for func in api.functionIterateGlx():
+			ef = glx_enum_function( func.name, api.enums_by_name )
+			if len(ef.enums) == 0:
+				continue
+
+			if (ef.is_set() and self.emit_set) or (not ef.is_set() and self.emit_get):
+				print 'extern INTERNAL PURE FASTCALL GLint __gl%s_size(GLenum);' % (func.name)
 
 
-class PrintGlxReqSize_common(glX_XML.GlxProto):
+class PrintGlxReqSize_common(gl_XML.gl_print_base):
 	"""Common base class for PrintGlxSizeReq_h and PrintGlxSizeReq_h.
 
 	The main purpose of this common base class is to provide the infrastructure
@@ -234,33 +395,10 @@ class PrintGlxReqSize_common(glX_XML.GlxProto):
 	"""
 
 	def __init__(self):
-		glX_XML.GlxProto.__init__(self)
+		gl_XML.gl_print_base.__init__(self)
+
 		self.name = "glX_proto_size.py (from Mesa)"
 		self.license = license.bsd_license_template % ( "(C) Copyright IBM Corporation 2005", "IBM")
-		self.aliases = []
-		self.glx_enum_sigs = {}
-		self.size_functions = []
-
-
-	def endElementNS(self, name, qname):
-		[uri, true_name] = name
-		if true_name == "function":
-			f = self.current_object
-			if f.glx_rop and not f.ignore and f.fn_alias == None and f.vectorequiv == None:
-
-				if self.glx_enum_functions.has_key(f.name) or f.image or f.server_handcode:
-					self.size_functions.append( f )
-				else:
-					for p in f.parameterIterator(1,2):
-						if p.counter and not p.is_output:
-							self.size_functions.append( f )
-							break
-
-		glX_XML.GlxProto.endElementNS(self, name, qname)
-
-
-	def functionIterator(self):
-		return self.size_functions
 
 
 class PrintGlxReqSize_h(PrintGlxReqSize_common):
@@ -276,8 +414,10 @@ class PrintGlxReqSize_h(PrintGlxReqSize_common):
 		print ''
 
 
-	def printFunction(self, f):
-		print 'extern PURE HIDDEN int __glX%sReqSize(const GLbyte *pc, Bool swap);' % (f.name)
+	def printBody(self, api):
+		for func in api.functionIterateGlx():
+			if not func.ignore and func.has_variable_size_request():
+				print 'extern PURE HIDDEN int __glX%sReqSize(const GLbyte *pc, Bool swap);' % (func.name)
 
 
 class PrintGlxReqSize_c(PrintGlxReqSize_common):
@@ -286,10 +426,6 @@ class PrintGlxReqSize_c(PrintGlxReqSize_common):
 		self.counter_sigs = {}
 
 
-	def createEnumFunction(self, n):
-		return glXServerEnumFunction(n, self)
-
-
 	def printRealHeader(self):
 		print ''
 		print '#include <GL/gl.h>'
@@ -317,38 +453,58 @@ class PrintGlxReqSize_c(PrintGlxReqSize_common):
 		print ''
 
 
-	def printRealFooter(self):
-		for a in self.aliases:
-			print a
+	def printBody(self, api):
+		aliases = []
+		enum_functions = {}
+		enum_sigs = {}
 
+		for func in api.functionIterateGlx():
+			if not func.has_variable_size_request(): continue
 
-	def printFunction(self, f):
-		# Even though server-handcode fuctions are on "the list",
-		# and prototypes are generated for them, there isn't enough
-		# information to generate a size function.  If there was
-		# enough information, they probably wouldn't need to be
-		# handcoded in the first place!
+			ef = glx_server_enum_function( func, api.enums_by_name )
+			if len(ef.enums) == 0: continue
 
-		if f.server_handcode: return
+			sig = ef.signature()
 
-		if self.glx_enum_functions.has_key(f.name):
-			ef = self.glx_enum_functions[f.name]
+			if not enum_functions.has_key(func.name):
+				enum_functions[ func.name ] = sig
 
-			sig = ef.signature();
-			if self.glx_enum_sigs.has_key(sig):
-				n = self.glx_enum_sigs[sig];
-				a = 'ALIAS( %s, %s )' % (f.name, n)
-				self.aliases.append(a)
-			else:
-				ef.Print( f.name )
-				self.glx_enum_sigs[sig] = f.name;
-		elif f.image:
-			self.printPixelFunction(f)
-		else:
-			for p in f.parameterIterator(1,2):
-				if p.counter and not p.is_output:
-					self.printCountedFunction(f)
-					break
+			if not enum_sigs.has_key( sig ):
+				enum_sigs[ sig ] = ef
+			
+
+
+		for func in api.functionIterateGlx():
+			# Even though server-handcode fuctions are on "the
+			# list", and prototypes are generated for them, there
+			# isn't enough information to generate a size
+			# function.  If there was enough information, they
+			# probably wouldn't need to be handcoded in the first
+			# place!
+
+			if func.server_handcode: continue
+			if not func.has_variable_size_request(): continue
+
+			if enum_functions.has_key(func.name):
+				sig = enum_functions[func.name]
+				ef = enum_sigs[ sig ]
+
+				if ef.name != func.name:
+					aliases.append( [func.name, ef.name] )
+				else:
+					ef.Print( func.name, self )
+
+			elif func.images:
+				self.printPixelFunction(func)
+			elif func.has_variable_size_request():
+				a = self.printCountedFunction(func)
+				if a: aliases.append(a)
+
+
+		for [alias_name, real_name] in aliases:
+			print 'ALIAS( %s, %s )' % (alias_name, real_name)
+
+		return
 
 
 	def common_emit_fixups(self, fixup):
@@ -363,9 +519,10 @@ class PrintGlxReqSize_c(PrintGlxReqSize_common):
 		return
 
 
-	def common_emit_one_arg(self, p, offset, pc, indent, adjust):
-		dst = '%s %s' % (p.p_type_string, p.name)
-		src = '(%s *)' % (p.p_type_string)
+	def common_emit_one_arg(self, p, pc, indent, adjust):
+		offset = p.offset
+		dst = p.string()
+		src = '(%s *)' % (p.type_string())
 		print '%s%-18s = *%11s(%s + %u);' % (indent, dst, src, pc, offset + adjust);
 		return
 
@@ -379,10 +536,9 @@ class PrintGlxReqSize_c(PrintGlxReqSize_common):
 	def printPixelFunction(self, f):
 		self.common_func_print_just_header(f)
 		
+		f.offset_of( f.parameters[0].name )
 		[dim, w, h, d, junk] = f.dimensions()
 
-		offset = f.offset_of_first_parameter()
-
 		print '    GLint row_length   = *  (GLint *)(pc +  4);'
 
 		if dim < 3:
@@ -398,19 +554,18 @@ class PrintGlxReqSize_c(PrintGlxReqSize_common):
 			print '    GLint skip_images  = *  (GLint *)(pc + 20);'
 			print '    GLint alignment    = *  (GLint *)(pc + 32);'
 
-		for p in f.parameterIterator(1, 2):
-			if p.name in [w, h, d, f.image.img_format, f.image.img_type, f.image.img_target]:
-				self.common_emit_one_arg(p, offset, "pc", "    ", 0 )
+		img = f.images[0]
+		for p in f.parameterIterateGlxSend():
+			if p.name in [w, h, d, img.img_format, img.img_type, img.img_target]:
+				self.common_emit_one_arg( p, "pc", "    ", 0 )
 				fixup.append( p.name )
 
-			offset += p.size()
-
 		print ''
 
 		self.common_emit_fixups(fixup)
 
 		print ''
-		print '    return __glXImageSize(%s, %s, %s, %s, %s, %s,' % (f.image.img_format, f.image.img_type, f.image.img_target, w, h, d )
+		print '    return __glXImageSize(%s, %s, %s, %s, %s, %s,' % (img.img_format, img.img_type, img.img_target, w, h, d )
 		print '                          image_height, row_length, skip_images,'
 		print '                          skip_rows, alignment);'
 		print '}'
@@ -433,38 +588,34 @@ class PrintGlxReqSize_c(PrintGlxReqSize_common):
 		# that is being done, calculate a unique signature for this
 		# function.
 
-		for p in f.parameterIterator(1,2):
+		for p in f.parameterIterateGlxSend():
 			if p.is_counter:
-				param_offsets[ p.name ] = offset
 				fixup.append( p.name )
-				params.append( [p, offset] )
+				params.append( p )
 			elif p.counter:
-				s = p.p_type.size
+				s = p.size()
 				if s == 0: s = 1
 
-				sig += "(%u,%u)" % (param_offsets[p.counter], s)
+				sig += "(%u,%u)" % (f.offset_of(p.counter), s)
 				size += '%s%s' % (plus, p.size_string())
 				plus = ' + '
 
 
-			offset += p.size()
-
-
 		# If the calculated signature matches a function that has
 		# already be emitted, don't emit this function.  Instead, add
 		# it to the list of function aliases.
 
 		if self.counter_sigs.has_key(sig):
 			n = self.counter_sigs[sig];
-			a = 'ALIAS( %s, %s )' % (f.name, n)
-			self.aliases.append(a)
+			alias = [f.name, n]
 		else:
+			alias = None
 			self.counter_sigs[sig] = f.name
 
 			self.common_func_print_just_header(f)
 
-			for [p, offset] in params:
-				self.common_emit_one_arg(p, offset, "pc", "    ", 0 )
+			for p in params:
+				self.common_emit_one_arg(p, "pc", "    ", 0 )
 
 
 			print ''
@@ -475,7 +626,7 @@ class PrintGlxReqSize_c(PrintGlxReqSize_common):
 			print '}'
 			print ''
 
-		return
+		return alias
 
 
 def show_usage():
@@ -494,7 +645,7 @@ if __name__ == '__main__':
 	file_name = "gl_API.xml"
 
 	try:
-		(args, trail) = getopt.getopt(sys.argv[1:], "f:m:h:", ["only-get", "only-set", "get-alias-set", "header-tag"])
+		(args, trail) = getopt.getopt(sys.argv[1:], "f:m:h:", ["only-get", "only-set", "header-tag"])
 	except Exception,e:
 		show_usage()
 
@@ -511,22 +662,23 @@ if __name__ == '__main__':
 			which_functions = PrintGlxSizeStubs_common.do_get
 		elif arg == "--only-set":
 			which_functions = PrintGlxSizeStubs_common.do_set
-		elif arg == "--get-alias-set":
-			which_functions |= PrintGlxSizeStubs_common.do_get_alias_set
 		elif (arg == '-h') or (arg == "--header-tag"):
 			header_tag = val
 
 	if mode == "size_c":
-		dh = PrintGlxSizeStubs_c( which_functions )
+		printer = PrintGlxSizeStubs_c( which_functions )
 	elif mode == "size_h":
-		dh = PrintGlxSizeStubs_h( which_functions )
+		printer = PrintGlxSizeStubs_h( which_functions )
 		if header_tag:
-			dh.header_tag = header_tag
+			printer.header_tag = header_tag
 	elif mode == "reqsize_c":
-		dh = PrintGlxReqSize_c()
+		printer = PrintGlxReqSize_c()
 	elif mode == "reqsize_h":
-		dh = PrintGlxReqSize_h()
+		printer = PrintGlxReqSize_h()
 	else:
 		show_usage()
 
-	gl_XML.parse_GL_API( dh, file_name )
+	api = gl_XML.parse_GL_API( file_name, glX_XML.glx_item_factory() )
+
+
+	printer.Print( api )
diff --git a/src/mesa/glapi/gl_API.dtd b/src/mesa/glapi/gl_API.dtd
index 4adfaaceb7e..ded487bc922 100644
--- a/src/mesa/glapi/gl_API.dtd
+++ b/src/mesa/glapi/gl_API.dtd
@@ -1,4 +1,4 @@
-<!ELEMENT OpenGLAPI (category+)>
+<!ELEMENT OpenGLAPI (category?, xi:include?, OpenGLAPI?)+>
 <!ELEMENT category (type*, enum*, function*)*>
 <!ELEMENT type EMPTY>
 <!ELEMENT enum (size*)>
@@ -8,10 +8,24 @@
 <!ELEMENT return EMPTY>
 <!ELEMENT glx EMPTY>
 
+<!ELEMENT xi:include (xi:fallback)?>
+<!ATTLIST xi:include
+          xmlns:xi  CDATA #FIXED "http://www.w3.org/2001/XInclude"
+          href       CDATA #REQUIRED
+          parse      (xml|text) "xml"
+          encoding   CDATA #IMPLIED>
+<!ELEMENT xi:fallback ANY>
+<!ATTLIST xi:fallback
+          xmlns:xi   CDATA #FIXED "http://www.w3.org/2001/XInclude">
+
+
 <!ATTLIST category name                NMTOKEN #REQUIRED
-                   number              NMTOKEN #IMPLIED>
+                   number              NMTOKEN #IMPLIED
+		   window_system       NMTOKEN #IMPLIED>
 <!ATTLIST type     name                NMTOKEN #REQUIRED
                    size                NMTOKEN #REQUIRED
+		   float               (true | false) "false"
+		   unsigned            (true | false) "false"
                    glx_name            NMTOKEN #IMPLIED>
 <!ATTLIST enum     name                NMTOKEN #REQUIRED
                    count               CDATA   #IMPLIED
diff --git a/src/mesa/glapi/gl_API.xml b/src/mesa/glapi/gl_API.xml
index 19f204c3172..49eb6d17e20 100644
--- a/src/mesa/glapi/gl_API.xml
+++ b/src/mesa/glapi/gl_API.xml
@@ -1078,26 +1078,26 @@
     <enum name="SCISSOR_BIT"                              value="0x00080000"/>
     <enum name="ALL_ATTRIB_BITS"                          value="0x000FFFFF"/>
 
-    <type name="double"  size="8"  glx_name="FLOAT64"/>
-    <type name="clampd"  size="8"  glx_name="FLOAT64"/>
+    <type name="double"  size="8"  float="true"    glx_name="FLOAT64"/>
+    <type name="clampd"  size="8"  float="true"    glx_name="FLOAT64"/>
 
-    <type name="float"   size="4"  glx_name="FLOAT32"/>
-    <type name="clampf"  size="4"  glx_name="FLOAT32"/>
+    <type name="float"   size="4"  float="true"    glx_name="FLOAT32"/>
+    <type name="clampf"  size="4"  float="true"    glx_name="FLOAT32"/>
 
-    <type name="int"     size="4"  glx_name="CARD32"/>
-    <type name="uint"    size="4"  glx_name="CARD32"/>
-    <type name="sizei"   size="4"  glx_name="CARD32"/>
-    <type name="enum"    size="4"  glx_name="ENUM"/>
-    <type name="bitfield" size="4" glx_name="CARD32"/>
+    <type name="int"     size="4"                  glx_name="CARD32"/>
+    <type name="uint"    size="4"  unsigned="true" glx_name="CARD32"/>
+    <type name="sizei"   size="4"  unsigned="true" glx_name="CARD32"/>
+    <type name="enum"    size="4"  unsigned="true" glx_name="ENUM"/>
+    <type name="bitfield" size="4" unsigned="true" glx_name="CARD32"/>
 
-    <type name="short"   size="2"  glx_name="CARD16"/>
-    <type name="ushort"  size="2"  glx_name="CARD16"/>
+    <type name="short"   size="2"                  glx_name="CARD16"/>
+    <type name="ushort"  size="2"  unsigned="true" glx_name="CARD16"/>
 
-    <type name="byte"    size="1"  glx_name="CARD8"/>
-    <type name="ubyte"   size="1"  glx_name="CARD8"/>
-    <type name="boolean" size="1"  glx_name="CARD8"/>
+    <type name="byte"    size="1"                  glx_name="CARD8"/>
+    <type name="ubyte"   size="1"  unsigned="true" glx_name="CARD8"/>
+    <type name="boolean" size="1"  unsigned="true" glx_name="CARD8"/>
     
-    <type name="void"    size="0"/>
+    <type name="void"    size="1"/>
 
     <function name="NewList" offset="0">
         <param name="list" type="GLuint"/>
@@ -4909,8 +4909,8 @@
     <enum name="SRC1_ALPHA"                               value="0x8589"/>
     <enum name="SRC2_ALPHA"                               value="0x858A"/>
 
-    <type name="intptr"   size="4"  glx_name="CARD32"/>
-    <type name="sizeiptr" size="4"  glx_name="CARD32"/>
+    <type name="intptr"   size="4"                  glx_name="CARD32"/>
+    <type name="sizeiptr" size="4"  unsigned="true" glx_name="CARD32"/>
 
     <function name="BindBuffer" alias="BindBufferARB">
         <param name="target" type="GLenum"/>
@@ -6622,8 +6622,8 @@
     <enum name="DYNAMIC_READ_ARB"                         value="0x88E9"/>
     <enum name="DYNAMIC_COPY_ARB"                         value="0x88EA"/>
 
-    <type name="intptrARB" size="4"/>
-    <type name="sizeiptrARB" size="4"/>
+    <type name="intptrARB"                   size="4"/>
+    <type name="sizeiptrARB" unsigned="true" size="4"/>
 
     <function name="BindBufferARB" offset="688">
         <param name="target" type="GLenum"/>
@@ -11378,158 +11378,7 @@
     <enum name="MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB" count="1" value="0x8B4C"/>
 </category>
 
-<category name="GL_EXT_framebuffer_object" number="310">
-    <enum name="FRAMEBUFFER_EXT" value="0x8D40"/>
-    <enum name="RENDERBUFFER_EXT" value="0x8D41"/>
-    <enum name="STENCIL_INDEX_EXT" value="0x8D45"/>
-    <enum name="STENCIL_INDEX1_EXT" value="0x8D46"/>
-    <enum name="STENCIL_INDEX4_EXT" value="0x8D47"/>
-    <enum name="STENCIL_INDEX8_EXT" value="0x8D48"/>
-    <enum name="STENCIL_INDEX16_EXT" value="0x8D49"/>
-    <enum name="RENDERBUFFER_WIDTH_EXT" value="0x8D42"/>
-    <enum name="RENDERBUFFER_HEIGHT_EXT" value="0x8D43"/>
-    <enum name="RENDERBUFFER_INTERNAL_FORMAT_EXT" value="0x8D44"/>
-    <enum name="FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT" value="0x8CD0"/>
-    <enum name="FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT" value="0x8CD1"/>
-    <enum name="FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT" value="0x8CD2"/>
-    <enum name="FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT" value="0x8CD3"/>
-    <enum name="FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT" value="0x8CD4"/>
-    <enum name="COLOR_ATTACHMENT0_EXT" value="0x8CE0"/>
-    <enum name="COLOR_ATTACHMENT1_EXT" value="0x8CE1"/>
-    <enum name="COLOR_ATTACHMENT2_EXT" value="0x8CE2"/>
-    <enum name="COLOR_ATTACHMENT3_EXT" value="0x8CE3"/>
-    <enum name="COLOR_ATTACHMENT4_EXT" value="0x8CE4"/>
-    <enum name="COLOR_ATTACHMENT5_EXT" value="0x8CE5"/>
-    <enum name="COLOR_ATTACHMENT6_EXT" value="0x8CE6"/>
-    <enum name="COLOR_ATTACHMENT7_EXT" value="0x8CE7"/>
-    <enum name="COLOR_ATTACHMENT8_EXT" value="0x8CE8"/>
-    <enum name="COLOR_ATTACHMENT9_EXT" value="0x8CE9"/>
-    <enum name="COLOR_ATTACHMENT10_EXT" value="0x8CEA"/>
-    <enum name="COLOR_ATTACHMENT11_EXT" value="0x8CEB"/>
-    <enum name="COLOR_ATTACHMENT12_EXT" value="0x8CEC"/>
-    <enum name="COLOR_ATTACHMENT13_EXT" value="0x8CED"/>
-    <enum name="COLOR_ATTACHMENT14_EXT" value="0x8CEE"/>
-    <enum name="COLOR_ATTACHMENT15_EXT" value="0x8CEF"/>
-    <enum name="DEPTH_ATTACHMENT_EXT" value="0x8D00"/>
-    <enum name="STENCIL_ATTACHMENT_EXT" value="0x8D20"/>
-    <enum name="FRAMEBUFFER_COMPLETE_EXT" value="0x8CD5"/>
-    <enum name="FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT" value="0x8CD6"/>
-    <enum name="FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT" value="0x8CD7"/>
-    <enum name="FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT" value="0x8CD8"/>
-    <enum name="FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT" value="0x8CD9"/>
-    <enum name="FRAMEBUFFER_INCOMPLETE_FORMATS_EXT" value="0x8CDA"/>
-    <enum name="FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT" value="0x8CDB"/>
-    <enum name="FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT" value="0x8CDC"/>
-    <enum name="FRAMEBUFFER_UNSUPPORTED_EXT" value="0x8CDD"/>
-    <enum name="FRAMEBUFFER_STATUS_ERROR_EXT" value="0x8CDE"/>
-    <enum name="FRAMEBUFFER_BINDING_EXT" value="0x8CA6"/>
-    <enum name="RENDERBUFFER_BINDING_EXT" value="0x8CA7"/>
-    <enum name="MAX_COLOR_ATTACHMENTS_EXT" value="0x8CDF"/>
-    <enum name="MAX_RENDERBUFFER_SIZE_EXT" value="0x84E8"/>
-    <enum name="INVALID_FRAMEBUFFER_OPERATION_EXT" value="0x0506"/>
-
-    <function name="IsRenderbufferEXT" offset="796">
-      <param name="renderbuffer" type="GLuint"/>
-      <return type="GLboolean"/>
-    </function>
-
-    <function name="BindRenderbufferEXT" offset="797">
-      <param name="target" type="GLenum"/>
-      <param name="renderbuffer" type="GLuint"/>
-    </function>
-
-    <function name="DeleteRenderbuffersEXT" offset="798">
-      <param name="n" type="GLsizei"/>
-      <param name="renderbuffers" type="const GLuint *"/>
-    </function>
-
-    <function name="GenRenderbuffersEXT" offset="799">
-      <param name="n" type="GLsizei"/>
-      <param name="renderbuffers" type="GLuint *"/>
-    </function>
-
-    <function name="RenderbufferStorageEXT" offset="800">
-      <param name="target" type="GLenum"/>
-      <param name="internalformat" type="GLenum"/>
-      <param name="width" type="GLsizei"/>
-      <param name="height" type="GLsizei"/>
-    </function>
-
-    <function name="GetRenderbufferParameterivEXT" offset="801">
-      <param name="target" type="GLenum"/>
-      <param name="pname" type="GLenum"/>
-      <param name="params" type="GLint *"/>
-    </function>
-
-    <function name="IsFramebufferEXT" offset="802">
-      <param name="framebuffer" type="GLuint"/>
-      <return type="GLboolean"/>
-    </function>
-
-    <function name="BindFramebufferEXT" offset="803">
-      <param name="target" type="GLenum"/>
-      <param name="framebuffer" type="GLuint"/>
-    </function>
-
-    <function name="DeleteFramebuffersEXT" offset="804">
-      <param name="n" type="GLsizei"/>
-      <param name="framebuffers" type="const GLuint *"/>
-    </function>
-
-    <function name="GenFramebuffersEXT" offset="805">
-      <param name="n" type="GLsizei"/>
-      <param name="framebuffers" type="GLuint *"/>
-    </function>
-
-    <function name="CheckFramebufferStatusEXT" offset="806">
-      <param name="target" type="GLenum"/>
-      <return type="GLenum"/>
-    </function>
-
-    <function name="FramebufferTexture1DEXT" offset="807">
-      <param name="target" type="GLenum"/>
-      <param name="attachment" type="GLenum"/>
-      <param name="textarget" type="GLenum"/>
-      <param name="texture" type="GLuint"/>
-      <param name="level" type="GLint"/>
-    </function>
-
-    <function name="FramebufferTexture2DEXT" offset="808">
-      <param name="target" type="GLenum"/>
-      <param name="attachment" type="GLenum"/>
-      <param name="textarget" type="GLenum"/>
-      <param name="texture" type="GLuint"/>
-      <param name="level" type="GLint"/>
-    </function>
-
-    <function name="FramebufferTexture3DEXT" offset="809">
-      <param name="target" type="GLenum"/>
-      <param name="attachment" type="GLenum"/>
-      <param name="textarget" type="GLenum"/>
-      <param name="texture" type="GLuint"/>
-      <param name="level" type="GLint"/>
-      <param name="zoffset" type="GLint"/>
-    </function>
-
-    <function name="FramebufferRenderbufferEXT" offset="810">
-      <param name="target" type="GLenum"/>
-      <param name="attachment" type="GLenum"/>
-      <param name="renderbuffertarget" type="GLenum"/>
-      <param name="renderbuffer" type="GLuint"/>
-    </function>
-
-    <function name="GetFramebufferAttachmentParameterivEXT" offset="811">
-      <param name="target" type="GLenum"/>
-      <param name="attachment" type="GLenum"/>
-      <param name="pname" type="GLenum"/>
-      <param name="params" type="GLint *"/>
-    </function>
-
-    <function name="GenerateMipmapEXT" offset="812">
-      <param name="target" type="GLenum"/>
-    </function>
-</category>
-
+<xi:include href="EXT_framebuffer_object.xml" xmlns:xi="http://www.w3.org/2001/XInclude"/>
 
 <!-- Extension number 307 is a GLX extension. -->
 <!-- Extension number 308 is a GLX extension. -->
diff --git a/src/mesa/glapi/gl_SPARC_asm.py b/src/mesa/glapi/gl_SPARC_asm.py
index 76a545d90c9..9be4849010d 100644
--- a/src/mesa/glapi/gl_SPARC_asm.py
+++ b/src/mesa/glapi/gl_SPARC_asm.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/env python
 
 # (C) Copyright IBM Corporation 2004
 # All Rights Reserved.
@@ -25,15 +25,13 @@
 # Authors:
 #    Ian Romanick <[email protected]>
 
-import gl_XML
-import license
+import gl_XML, license
 import sys, getopt
 
-class PrintGenericStubs(gl_XML.FilterGLAPISpecBase):
-	name = "gl_SPARC_asm.py (from Mesa)"
-
+class PrintGenericStubs(gl_XML.gl_print_base):
 	def __init__(self):
-		gl_XML.FilterGLAPISpecBase.__init__(self)
+		gl_XML.gl_print_base.__init__(self)
+		self.name = "gl_SPARC_asm.py (from Mesa)"
 		self.license = license.bsd_license_template % ( \
 """Copyright (C) 1999-2003  Brian Paul   All Rights Reserved.
 (C) Copyright IBM Corporation 2004""", "BRIAN PAUL, IBM")
@@ -68,6 +66,8 @@ class PrintGenericStubs(gl_XML.FilterGLAPISpecBase):
 		print '\tnop'
 		print '#endif'
 		print ''
+		print '#define GL_STUB_ALIAS(fn,alias) GLOBL_FN(fn) ; fn = alias'
+		print ''
 		print '.text'
 		print '.align 32'
 		print 'GLOBL_FN(__glapi_sparc_icache_flush)'
@@ -79,21 +79,31 @@ class PrintGenericStubs(gl_XML.FilterGLAPISpecBase):
 		print '.data'
 		print '.align 64'
 		print ''
+		return
+
+
+	def printBody(self, api):
 		print 'GLOBL_FN(_mesa_sparc_glapi_begin)'
 		print '_mesa_sparc_glapi_begin:'
 		print ''
-		return
 
-	def printRealFooter(self):
+		for f in api.functionIterateByOffset():
+			print '\tGL_STUB(gl%s, _gloffset_%s)' % (f.name, f.name)
+
 		print ''
 		print 'GLOBL_FN(_mesa_sparc_glapi_end)'
 		print '_mesa_sparc_glapi_end:'
-		return
+		print ''
+
+
+		for f in api.functionIterateByOffset():
+			for n in f.entry_points:
+				if n != f.name:
+					print '\tGL_STUB_ALIAS(gl%s, gl%s)' % (n, f.name)
 
-	def printFunction(self, f):
-		print '\tGL_STUB(gl%s, _gloffset_%s)' % (f.name, f.real_name)
 		return
 
+
 def show_usage():
 	print "Usage: %s [-f input_file_name] [-m output_mode]" % sys.argv[0]
 	sys.exit(1)
@@ -114,9 +124,11 @@ if __name__ == '__main__':
 			file_name = val
 
 	if mode == "generic":
-		dh = PrintGenericStubs()
+		printer = PrintGenericStubs()
 	else:
 		print "ERROR: Invalid mode \"%s\" specified." % mode
 		show_usage()
 
-	gl_XML.parse_GL_API( dh, file_name )
+	api = gl_XML.parse_GL_API( file_name )
+
+	printer.Print( api )
diff --git a/src/mesa/glapi/gl_XML.py b/src/mesa/glapi/gl_XML.py
index ac936d15651..e4de4cacdd6 100644
--- a/src/mesa/glapi/gl_XML.py
+++ b/src/mesa/glapi/gl_XML.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/env python
 
 # (C) Copyright IBM Corporation 2004, 2005
 # All Rights Reserved.
@@ -25,14 +25,27 @@
 # Authors:
 #    Ian Romanick <[email protected]>
 
-from xml.sax import saxutils
-from xml.sax import make_parser
-from xml.sax.handler import feature_namespaces
+import libxml2
+import re, sys, string
+import typeexpr
 
-import re
-import sys
 
-def is_attr_true( attrs, name ):
+def parse_GL_API( file_name, factory = None ):
+	doc = libxml2.readFile( file_name, None, libxml2.XML_PARSE_XINCLUDE + libxml2.XML_PARSE_NOBLANKS + libxml2.XML_PARSE_DTDVALID + libxml2.XML_PARSE_DTDATTR + libxml2.XML_PARSE_DTDLOAD + libxml2.XML_PARSE_NOENT )
+	ret = doc.xincludeProcess()
+
+	if not factory:
+		factory = gl_item_factory()
+
+	api = factory.create_item( "api", None, None )
+	api.process_element( doc )
+
+	doc.freeDoc()
+
+	return api
+
+
+def is_attr_true( element, name ):
 	"""Read a name value from an element's attributes.
 	
 	The value read from the attribute list must be either 'true' or
@@ -40,7 +53,7 @@ def is_attr_true( attrs, name ):
 	value is 'true', non-zero will be returned.  An exception will be
 	raised for any other value."""
 
-	value = attrs.get((None, name), "false")
+	value = element.nsProp( name, None )
 	if value == "true":
 		return 1
 	elif value == "false":
@@ -49,713 +62,758 @@ def is_attr_true( attrs, name ):
 		raise RuntimeError('Invalid value "%s" for boolean "%s".' % (value, name))
 
 
-def parse_GL_API( handler, file_name ):
-	"""Boiler-plate code to create an XML parser and use it.
+class gl_print_base:
+	"""Base class of all API pretty-printers.
 
-	Creates an XML parser and uses that parser with the application
-	supplied SAX callback, which should be derived from
-	FilterGLAPISpecBase.
+	In the model-view-controller pattern, this is the view.  Any derived
+	class will want to over-ride the printBody, printRealHader, and
+	printRealFooter methods.  Some derived classes may want to over-ride
+	printHeader and printFooter, or even Print (though this is unlikely).
 	"""
 
-	parser = make_parser()
-	parser.setFeature(feature_namespaces, 1)
-	parser.setContentHandler( handler )
+	def __init__(self):
+		# Name of the script that is generating the output file.
+		# Every derived class should set this to the name of its
+		# source file.
 
-	handler.printHeader()
+		self.name = "a"
 
-	if not file_name or file_name == "-":
-		parser.parse( sys.stdin )
-	else:
-		parser.parse( file_name )
 
-	handler.printFooter()
-	return
-	
+		# License on the *generated* source file.  This may differ
+		# from the license on the script that is generating the file.
+		# Every derived class should set this to some reasonable
+		# value.
+		#
+		# See license.py for an example of a reasonable value.
 
-class glItem:
-	"""Generic class on which all other API entity types are based."""
+		self.license = "The license for this file is unspecified."
 
-	def __init__(self, tag_name, name, context):
-		self.name = name
-		self.category = context.get_category_define()
-		self.context = context
-		self.tag_name = tag_name
 		
-		context.append(tag_name, self)
-		return
-	
-	def startElementNS(self, name, qname, attrs):
-		"""Generic startElement handler.
+		# The header_tag is the name of the C preprocessor define
+		# used to prevent multiple inclusion.  Typically only
+		# generated C header files need this to be set.  Setting it
+		# causes code to be generated automatically in printHeader
+		# and printFooter.
+
+		self.header_tag = None
+
 		
-		The startElement handler is called for all elements except
-		the one that starts the object.  For a foo element, the
-		XML "<foo><bar/></foo>" would cause the startElement handler
-		to be called once, but the endElement handler would be called
-		twice."""
+		# List of file-private defines that must be undefined at the
+		# end of the file.  This can be used in header files to define
+		# names for use in the file, then undefine them at the end of
+		# the header file.
+
+		self.undef_list = []
 		return
 
-	def endElementNS(self, name, qname):
-		"""Generic endElement handler.
 
-		Generic endElement handler.    Returns 1 if the tag containing
-		the object is complete.  Otherwise 0 is returned.  All
-		derived class endElement handlers should call this method.  If
-		the name of the ending tag is the same as the tag that
-		started this object, the object is assumed to be complete.
-		
-		This fails if a tag can contain another tag with the same
-		name.  The XML "<foo><foo/><bar/></foo>" would fail.  The
-		object would end before the bar tag was processed.
-		
-		The endElement handler is called for every end element
-		associated with an object, even the element that started the
-		object.  See the description of startElement an example."""
+	def Print(self, api):
+		self.printHeader()
+		self.printBody(api)
+		self.printFooter()
+		return
 
-		if name == (None, self.tag_name):
-			return 1
-		else:
-			return 0
 
-	def get_category_define(self):
-		return self.category
+	def printHeader(self):
+		"""Print the header associated with all files and call the printRealHeader method."""
+
+		print '/* DO NOT EDIT - This file generated automatically by %s script */' \
+			% (self.name)
+		print ''
+		print '/*'
+		print ' * ' + self.license.replace('\n', '\n * ')
+		print ' */'
+		print ''
+		if self.header_tag:
+		    print '#if !defined( %s )' % (self.header_tag)
+		    print '#  define %s' % (self.header_tag)
+		    print ''
+		self.printRealHeader();
+		return
+
+
+	def printFooter(self):
+		"""Print the header associated with all files and call the printRealFooter method."""
+
+		self.printRealFooter()
+
+		if self.undef_list:
+			print ''
+			for u in self.undef_list:
+				print "#  undef %s" % (u)
+
+		if self.header_tag:
+			print ''
+			print '#endif /* !defined( %s ) */' % (self.header_tag)
+
+
+	def printRealHeader(self):
+		"""Print the "real" header for the created file.
+
+		In the base class, this function is empty.  All derived
+		classes should over-ride this function."""
+		return
+
+
+	def printRealFooter(self):
+		"""Print the "real" footer for the created file.
+
+		In the base class, this function is empty.  All derived
+		classes should over-ride this function."""
+		return
+
+
+	def printPure(self):
+		"""Conditionally define `PURE' function attribute.
+
+		Conditionally defines a preprocessor macro `PURE' that wraps
+		GCC's `pure' function attribute.  The conditional code can be
+		easilly adapted to other compilers that support a similar
+		feature.
+
+		The name is also added to the file's undef_list.
+		"""
+		self.undef_list.append("PURE")
+		print """#  if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
+#    define PURE __attribute__((pure))
+#  else
+#    define PURE
+#  endif"""
+		return
+
+
+	def printFastcall(self):
+		"""Conditionally define `FASTCALL' function attribute.
+
+		Conditionally defines a preprocessor macro `FASTCALL' that
+		wraps GCC's `fastcall' function attribute.  The conditional
+		code can be easilly adapted to other compilers that support a
+		similar feature.
+
+		The name is also added to the file's undef_list.
+		"""
+
+		self.undef_list.append("FASTCALL")
+		print """#  if defined(__i386__) && defined(__GNUC__)
+#    define FASTCALL __attribute__((fastcall))
+#  else
+#    define FASTCALL
+#  endif"""
+		return
+
+
+	def printVisibility(self, S, s):
+		"""Conditionally define visibility function attribute.
 
+		Conditionally defines a preprocessor macro name S that wraps
+		GCC's visibility function attribute.  The visibility used is
+		the parameter s.  The conditional code can be easilly adapted
+		to other compilers that support a similar feature.
 
-class glEnum( glItem ):
-	"""Subclass of glItem for representing GL enumerants.
+		The name is also added to the file's undef_list.
+		"""
+
+		self.undef_list.append(S)
+		print """#  if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)
+#    define %s  __attribute__((visibility("%s")))
+#  else
+#    define %s
+#  endif""" % (S, s, S)
+		return
+
+
+	def printNoinline(self):
+		"""Conditionally define `NOINLINE' function attribute.
+
+		Conditionally defines a preprocessor macro `NOINLINE' that
+		wraps GCC's `noinline' function attribute.  The conditional
+		code can be easilly adapted to other compilers that support a
+		similar feature.
+
+		The name is also added to the file's undef_list.
+		"""
+
+		self.undef_list.append("NOINLINE")
+		print """#  if defined(__GNUC__)
+#    define NOINLINE __attribute__((noinline))
+#  else
+#    define NOINLINE
+#  endif"""
+		return
+
+
+	def printHaveAlias(self):
+		"""Conditionally define `HAVE_ALIAS'.
+
+		Conditionally defines a preprocessor macro `HAVE_ALIAS'.  The
+		existance of this macro can be used to determine whether or
+		not GCC's alias function attribute can be used.
+
+		The name is also added to the file's undef_list.
+		"""
+
+		self.undef_list.append("HAVE_ALIAS")
+		print """#  if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
+#    define HAVE_ALIAS
+#  endif"""
+		return
+
+
+def real_function_name(element):
+	name = element.nsProp( "name", None )
+	alias = element.nsProp( "alias", None )
 	
-	This class is not complete, and is not really used yet."""
+	if alias:
+		return alias
+	else:
+		return name
 
-	def __init__(self, context, name, attrs):
-		self.value = int(attrs.get((None, 'value'), "0x0000"), 0)
 
-		enum_name = "GL_" + attrs.get((None, 'name'), None)
-		glItem.__init__(self, name, enum_name, context)
+class gl_item:
+	def __init__(self, element, context):
+		self.context = context
 
-		temp = attrs.get((None, 'count'), None)
-		self.default_count = 0
-		if temp == "?":
-			self.default_count = -1
-		elif temp:
-			try:
-				c = int(temp)
-			except Exception,e:
-				raise RuntimeError('Invalid count value "%s" for enum "%s" in function "%s" when an integer was expected.' % (temp, self.name, n))
+		self.name = element.nsProp( "name", None )
+
+		c = element.parent.nsProp( "name", None )
+		if re.compile("[1-9][0-9]*[.][0-9]+").match(c):
+			self.category = "GL_VERSION_" + c.replace(".", "_")
+		else:
+			self.category = c
 
-			self.default_count = c
 		return
 
 
-	def process_attributes(self, attrs):
-		name = attrs.get((None, 'name'), None)
+class gl_type( gl_item ):
+	def __init__(self, element, context):
+		gl_item.__init__(self, element, context)
+		self.size = int( element.nsProp( "size", None ), 0 )
+
+		te = typeexpr.type_expression( None )
+		tn = typeexpr.type_node()
+		tn.size = int( element.nsProp( "size", None ), 0 )
+		tn.integer = not is_attr_true( element, "float" )
+		tn.unsigned = is_attr_true( element, "unsigned" )
+		tn.name = "GL" + self.name
+		te.set_base_type_node( tn )
 
-		temp = attrs.get((None, 'count'), None)
-		if temp == None:
-			c = self.default_count
+		self.type_expr = te
+		return
+	
+
+	def get_type_expression(self):
+		return self.type_expr
+
+
+class gl_enum( gl_item ):
+	def __init__(self, element, context):
+		gl_item.__init__(self, element, context)
+		self.value = int( element.nsProp( "value", None ), 0 )
+
+		temp = element.nsProp( "count", None )
+		if not temp or temp == "?":
+			self.default_count = -1
 		else:
 			try:
 				c = int(temp)
 			except Exception,e:
 				raise RuntimeError('Invalid count value "%s" for enum "%s" in function "%s" when an integer was expected.' % (temp, self.name, n))
 
-		mode_str = attrs.get((None, 'mode'), "set")
-		if mode_str == "set":
-			mode = 1
-		elif mode_str == "get":
-			mode = 0
-		else:
-			raise RuntimeError("Invalid mode '%s' for function '%s' in enum '%s'." % (mode_str, self.context.name, self.name))
+			self.default_count = c
+
+		return
 
-		return [name, c, mode]
 
+	def priority(self):
+		"""Calculate a 'priority' for this enum name.
+		
+		When an enum is looked up by number, there may be many
+		possible names, but only one is the 'prefered' name.  The
+		priority is used to select which name is the 'best'.
+
+		Highest precedence is given to core GL name.  ARB extension
+		names have the next highest, followed by EXT extension names.
+		Vendor extension names are the lowest.
+		"""
 
-class glType( glItem ):
-	"""Subclass of glItem for representing GL types."""
+		if self.name.endswith( "_BIT" ):
+			bias = 1
+		else:
+			bias = 0
+
+		if self.category.startswith( "GL_VERSION_" ):
+			priority = 0
+		elif self.category.startswith( "GL_ARB_" ):
+			priority = 2
+		elif self.category.startswith( "GL_EXT_" ):
+			priority = 4
+		else:
+			priority = 6
 
-	def __init__(self, context, name, attrs):
-		self.size = int(attrs.get((None, 'size'), "0"))
-		self.glx_name = attrs.get((None, 'glx_name'), "")
+		return priority + bias
 
-		type_name = "GL" + attrs.get((None, 'name'), None)
-		glItem.__init__(self, name, type_name, context)
 
 
-class glParameter( glItem ):
-	"""Parameter of a glFunction."""
-	p_type = None
-	p_type_string = ""
-	p_count = 0
-	counter = None
-	is_output = 0
-	is_counter = 0
-	is_pointer = 0
+class gl_parameter:
+	def __init__(self, element, context):
+		self.name = element.nsProp( "name", None )
 
-	def __init__(self, context, name, attrs):
-		p_name = attrs.get((None, 'name'), None)
-		self.p_type_string = attrs.get((None, 'type'), None)
+		ts = element.nsProp( "type", None )
+		self.type_expr = typeexpr.type_expression( ts, context )
 
-		temp = attrs.get((None, 'variable_param'), None)
+		temp = element.nsProp( "variable_param", None )
 		if temp:
 			self.count_parameter_list = temp.split( ' ' )
 		else:
 			self.count_parameter_list = []
 
-		self.p_type = context.context.find_type(self.p_type_string)
-		if self.p_type == None:
-			raise RuntimeError("Unknown type '%s' in function '%s'." % (self.p_type_string, context.name))
-
-
 		# The count tag can be either a numeric string or the name of
 		# a variable.  If it is the name of a variable, the int(c)
 		# statement will throw an exception, and the except block will
 		# take over.
 
-		c = attrs.get((None, 'count'), "0")
+		c = element.nsProp( "count", None )
 		try: 
-			self.p_count = int(c)
+			count = int(c)
+			self.count = count
 			self.counter = None
 		except Exception,e:
-			self.p_count = 0
+			count = 1
+			self.count = 0
 			self.counter = c
+		
+		self.count_scale = int(element.nsProp( "count_scale", None ))
 
-		self.count_scale = int(attrs.get((None, 'count_scale'), "1"))
+		elements = (count * self.count_scale)
+		if elements == 1:
+			elements = 0
 
-		self.is_counter = is_attr_true( attrs, 'counter' )
-		self.is_output  = is_attr_true( attrs, 'output' )
+		#if ts == "GLdouble":
+		#	print '/* stack size -> %s = %u (before)*/' % (self.name, self.type_expr.get_stack_size())
+		#	print '/* # elements = %u */' % (elements)
+		self.type_expr.set_elements( elements )
+		#if ts == "GLdouble":
+		#	print '/* stack size -> %s = %u (after) */' % (self.name, self.type_expr.get_stack_size())
 
+		self.is_counter = is_attr_true( element, 'counter' )
+		self.is_output  = is_attr_true( element, 'output' )
 
-		# Pixel data has special parameters.
 
-		self.width      = attrs.get((None, 'img_width'),  None)
-		self.height     = attrs.get((None, 'img_height'), None)
-		self.depth      = attrs.get((None, 'img_depth'),  None)
-		self.extent     = attrs.get((None, 'img_extent'), None)
+		# Pixel data has special parameters.
 
-		self.img_xoff   = attrs.get((None, 'img_xoff'),   None)
-		self.img_yoff   = attrs.get((None, 'img_yoff'),   None)
-		self.img_zoff   = attrs.get((None, 'img_zoff'),   None)
-		self.img_woff   = attrs.get((None, 'img_woff'),   None)
+		self.width      = element.nsProp('img_width',  None)
+		self.height     = element.nsProp('img_height', None)
+		self.depth      = element.nsProp('img_depth',  None)
+		self.extent     = element.nsProp('img_extent', None)
 
-		self.img_format = attrs.get((None, 'img_format'), None)
-		self.img_type   = attrs.get((None, 'img_type'),   None)
-		self.img_target = attrs.get((None, 'img_target'), None)
+		self.img_xoff   = element.nsProp('img_xoff',   None)
+		self.img_yoff   = element.nsProp('img_yoff',   None)
+		self.img_zoff   = element.nsProp('img_zoff',   None)
+		self.img_woff   = element.nsProp('img_woff',   None)
 
-		self.img_pad_dimensions = is_attr_true( attrs, 'img_pad_dimensions' )
-		self.img_null_flag      = is_attr_true( attrs, 'img_null_flag' )
-		self.img_send_null      = is_attr_true( attrs, 'img_send_null' )
+		self.img_format = element.nsProp('img_format', None)
+		self.img_type   = element.nsProp('img_type',   None)
+		self.img_target = element.nsProp('img_target', None)
 
-		if self.p_count > 0 or self.counter or self.count_parameter_list:
-			has_count = 1
-		else:
-			has_count = 0
+		self.img_pad_dimensions = is_attr_true( element, 'img_pad_dimensions' )
+		self.img_null_flag      = is_attr_true( element, 'img_null_flag' )
+		self.img_send_null      = is_attr_true( element, 'img_send_null' )
 
+		return
 
-		# If there is a * anywhere in the parameter's type, then it
-		# is a pointer.
 
-		if re.compile("[*]").search(self.p_type_string):
-			# We could do some other validation here.  For
-			# example, an output parameter should not be const,
-			# but every non-output parameter should.
+	def compatible(self, other):
+		return 1
 
-			self.is_pointer = 1;
-		else:
-			# If a parameter is not a pointer, then there cannot
-			# be an associated count (either fixed size or
-			# variable) and the parameter cannot be an output.
 
-			if has_count or self.is_output:
-				raise RuntimeError("Non-pointer type has count or is output.")
-			self.is_pointer = 0;
+	def is_array(self):
+		return self.is_pointer()
 
-		glItem.__init__(self, name, p_name, context)
-		return
 
+	def is_pointer(self):
+		return self.type_expr.is_pointer()
 
-	def is_variable_length_array(self):
-		"""Determine if a parameter is a variable length array.
-		
-		A parameter is considered to be a variable length array if
-		its size depends on the value of another parameter that is
-		an enumerant.  The params parameter to glTexEnviv is an
-		example of a variable length array parameter.  Arrays whose
-		size depends on a count variable, such as the lists parameter
-		to glCallLists, are not variable length arrays in this
-		sense."""
 
-		return self.count_parameter_list or self.counter or self.width
+	def is_image(self):
+		if self.width:
+			return 1
+		else:
+			return 0
 
 
-	def is_array(self):
-		return self.is_pointer
+	def is_variable_length(self):
+		return len(self.count_parameter_list) or self.counter
 
 
-	def count_string(self):
-		"""Return a string representing the number of items
-		
-		Returns a string representing the number of items in a
-		parameter.  For scalar types this will always be "1".  For
-		vector types, it will depend on whether or not it is a
-		fixed length vector (like the parameter of glVertex3fv),
-		a counted length (like the vector parameter of
-		glDeleteTextures), or a general variable length vector."""
-
-		if self.is_array():
-			if self.count_parameter_list:
-				return "compsize"
-			elif self.counter != None:
-				return self.counter
-			else:
-				return str(self.p_count)
+	def is_64_bit(self):
+		count = self.type_expr.get_element_count()
+		if count:
+			if (self.size() / count) == 8:
+				return 1
 		else:
-			return "1"
+			if self.size() == 8:
+				return 1
 
+		return 0
 
-	def size(self):
-		if self.count_parameter_list or self.counter or self.width or self.is_output:
-			return 0
-		elif self.p_count == 0:
-			return self.p_type.size
-		else:
-			return self.p_type.size * self.p_count * self.count_scale
 
-	def size_string(self):
-		s = self.size()
-		if s == 0:
-			a_prod = "compsize"
-			b_prod = self.p_type.size
-
-			# Handle functions like glCompressedTexImage2D that
-			# have a counted 'void *' parameter.
-
-			if b_prod == 0:	b_prod = 1
-
-			if not self.count_parameter_list and self.counter != None:
-				if self.count_scale > 1:
-					a_prod = '(%s * %u)' % (self.counter, self.count_scale)
-				else:
-					a_prod = self.counter
-			elif self.count_parameter_list and self.counter == None:
-				pass
-			elif self.count_parameter_list and self.counter != None:
-				if self.count_scale > 1:
-					b_prod = '(%s * %u)' % (self.counter, self.count_scale)
-				else:
-					b_prod = self.counter
-			elif self.width:
-				return "compsize"
-			else:
-				raise RuntimeError("Parameter '%s' to function '%s' has size 0." % (self.name, self.context.name))
+	def string(self):
+		return self.type_expr.original_string + " " + self.name
 
-			return "(%s * %s)" % (a_prod, b_prod)
-		else:
-			return str(s)
 
+	def type_string(self):
+		return self.type_expr.original_string
 
-class glParameterIterator:
-	"""Class to iterate over a list of glParameters.
-	
-	Objects of this class are returned by the parameterIterator method of
-	the glFunction class.  They are used to iterate over the list of
-	parameters to the function."""
-
-	def __init__(self, data):
-		self.data = data
-		self.index = 0
-
-	def __iter__(self):
-		return self
-
-	def next(self):
-		if self.index == len( self.data ):
-			raise StopIteration
-		i = self.index
-		self.index += 1
-		return self.data[i]
-
-
-class glFunction( glItem ):
-	def __init__(self, context, name, attrs):
-		self.fn_alias = attrs.get((None, 'alias'), None)
-		self.fn_parameters = []
-		self.image = None
-		self.count_parameter_list = []
-		self.fn_return_type = "void"
-
-		temp = attrs.get((None, 'offset'), None)
-		if temp == None or temp == "?":
-			self.fn_offset = -1
-		else:
-			self.fn_offset = int(temp)
 
-		fn_name = attrs.get((None, 'name'), None)
-		if self.fn_alias != None:
-			self.real_name = self.fn_alias
-		else:
-			self.real_name = fn_name
+	def get_base_type_string(self):
+		return self.type_expr.get_base_name()
 
-		self.parameters_by_name = {}
-		self.variable_length_parameters = []
 
-		glItem.__init__(self, name, fn_name, context)
-		return
+	def get_dimensions(self):
+		if not self.width:
+			return [ 0, "0", "0", "0", "0" ]
 
+		dim = 1
+		w = self.width
+		h = "1"
+		d = "1"
+		e = "1"
 
-	def parameterIterator(self):
-		return glParameterIterator(self.fn_parameters)
+		if self.height:
+			dim = 2
+			h = self.height
 
+		if self.depth:
+			dim = 3
+			d = self.depth
 
-	def startElementNS(self, name, qname, attrs):
-		[uri, true_name] = name
-		if true_name == "param":
-			try:
-				self.context.factory.create(self, true_name, attrs)
-			except RuntimeError:
-				print "Error with parameter '%s' in function '%s'." \
-					% (attrs.get((None, 'name'),'(unknown)'), self.name)
-				raise
-		elif true_name == "return":
-			self.set_return_type(attrs.get((None, 'type'), None))
+		if self.extent:
+			dim = 4
+			e = self.extent
 
+		return [ dim, w, h, d, e ]
 
-	def endElementNS(self, name, qname):
-		"""Handle the end of a <function> element.
 
-		At the end of a <function> element, there is some semantic
-		checking that can be done.  This prevents some possible
-		exceptions from being thrown elsewhere in the code.
-		"""
-
-		[uri, true_name] = name
-		if true_name == "function":
-			for p in self.variable_length_parameters:
-				if p.counter:
-					counter = self.parameters_by_name[ p.counter ]
-					if not self.parameters_by_name.has_key( p.counter ):
-						raise RuntimeError("Parameter '%s' of function '%s' has counter '%s', but function has no such parameter." % (p.name, self.name, p.counter))
-					elif not self.parameters_by_name[ p.counter ].is_counter:
-						raise RuntimeError("Parameter '%s' of function '%s' has counter '%s', but '%s' is not marked as a counter." % (p.name, self.name, p.counter, p.counter))
+	def get_stack_size(self):
+		return self.type_expr.get_stack_size()
 
-					for n in p.count_parameter_list:
-						if not self.parameters_by_name.has_key( n ):
-							raise RuntimeError("Parameter '%s' of function '%s' has size parameter '%s', but function has no such parameter." % (p.name, self.name, n))
 
-			return 1
-		else:
+	def size(self):
+		if self.is_image():
 			return 0
+		else:
+			return self.type_expr.get_element_size()
 
 
-	def append(self, tag_name, p):
-		if tag_name != "param":
-			raise RuntimeError("Trying to append '%s' to parameter list of function '%s'." % (tag_name, self.name))
-
-		if p.width:
-			self.image = p
+	def get_element_count(self):
+		c = self.type_expr.get_element_count()
+		if c == 0:
+			return 1
 
-		self.fn_parameters.append(p)
-		if p.count_parameter_list != []:
-			self.count_parameter_list.extend( p.count_parameter_list )
+		return c
 
-		if p.is_variable_length_array():
-			self.variable_length_parameters.append(p)
 
-		self.parameters_by_name[ p.name ] = p
+	def size_string(self, use_parens = 1):
+		s = self.size()
+		if self.counter or self.count_parameter_list:
+			list = [ "compsize" ]
 
+			if self.counter and self.count_parameter_list:
+				list.append( self.counter )
+			elif self.counter:
+				list = [ self.counter ]
 
-	def set_return_type(self, t):
-		self.fn_return_type = t
+			if s > 1:
+				list.append( str(s) )
 
+			if len(list) > 1 and use_parens :
+				return "(%s)" % (string.join(list, " * "))
+			else:
+				return string.join(list, " * ")
 
-	def get_parameter_string(self):
-		arg_string = ""
-		comma = ""
-		for p in glFunction.parameterIterator(self):
-			arg_string = arg_string + comma + p.p_type_string + " " + p.name
-			comma = ", "
-
-		if arg_string == "":
-			arg_string = "void"
-
-		return arg_string
-
-
-class glItemFactory:
-	"""Factory to create objects derived from glItem."""
-    
-	def create(self, context, name, attrs):
-		if name == "function":
-			return glFunction(context, name, attrs)
-		elif name == "type":
-			return glType(context, name, attrs)
-		elif name == "enum":
-			return glEnum(context, name, attrs)
-		elif name == "param":
-			return glParameter(context, name, attrs)
+		elif self.is_image():
+			return "compsize"
 		else:
-			return None
+			return str(s)
 
 
-class glFunctionIterator:
-	"""Class to iterate over a list of glFunctions
+	def format_string(self):
+		if self.type_expr.original_string == "GLenum":
+			return "0x%x"
+		else:
+			return self.type_expr.format_string()
 
-	Objects of this classare returned by
-	FilterGLAPISpecBase::functionIterator.  This default version
-	iterates over the functions in order of dispatch table offset.  All
-	of the "true" functions are iterated first, followed by the alias
-	functions."""
 
-	def __init__(self, context):
-		self.context = context
-		self.keys = context.functions.keys()
-		self.keys.sort()
 
-		self.prevk = -1
-		self.direction = 1
+class gl_function( gl_item ):
+	def __init__(self, element, context):
+		self.context = context
+		self.name = None
 
-		for self.index in range(0, len(self.keys)):
-			if self.keys[ self.index ] >= 0: break
+		self.entry_points = []
+		self.return_type = "void"
+		self.parameters = []
+		self.offset = -1
+		self.uninitialized = 1
+		self.images = []
 
-		if self.index == len(self.keys):
-			self.direction = -1
-			self.index -= 1
+		self.process_element( element )
 
-		self.split = self.index - 1
 		return
 
+	
+	def process_element(self, element):
+		name = element.nsProp( "name", None )
+		alias = element.nsProp( "alias", None )
 
-	def __iter__(self):
-		return self
+		self.entry_points.append( name )
+		if alias:
+			true_name = alias
+		else:
+			true_name = name
+
+			# Only try to set the offset when a non-alias
+			# entry-point is being processes.
+
+			offset = element.nsProp( "offset", None )
+			if offset:
+				try:
+					o = int( offset )
+					self.offset = o
+				except Exception, e:
+					self.offset = -1
+
+
+		if not self.name:
+			self.name = true_name
+		elif self.name != true_name:
+			raise RuntimeError("Function true name redefined.  Was %s, now %s." % (self.name, true_name))
+
+
+		# There are two possible cases.  The first time an entry-point
+		# with data is seen, self.uninitialzied will be 1.  On that
+		# pass, we just fill in the data.  The next time an
+		# entry-point with data is seen, self.uninitialized will be 0.
+		# On that pass we have to make that the new values match the
+		# valuse from the previous entry-point.
+
+		child = element.children
+		if self.uninitialized:
+			while child:
+				if child.type == "element":
+					if child.name == "return":
+						self.return_type = child.nsProp( "type", None )
+					elif child.name == "param":
+						param = self.context.factory.create_item( "parameter", child, self.context)
+						self.parameters.append( param )
+
+				child = child.next
+		else:
+			parameters = []
+			while child:
+				if child.type == "element":
+					if child.name == "return":
+						return_type = child.nsProp( "type", None )
+						if self.return_type != return_type:
+							raise RuntimeError( "Return type changed in %s.  Was %s, now %s." % (name, self.return_type, return_type))
+					elif child.name == "param":
+						param = self.context.factory.create_item( "parameter", child, self.context)
+						parameters.append( param )
+
+				child = child.next
+
+			if len(parameters) != len(self.parameters):
+				raise RuntimeError( "Parameter count mismatch in %s.  Was %d, now %d." % (name, len(self.parameters), len(parameters)))
+
+			for j in range(0, len(parameters)):
+				p1 = parameters[j]
+				p2 = self.parameters[j]
+				if not p1.compatible( p2 ):
+					raise RuntimeError( 'Parameter type mismatch in %s.  "%s" was "%s", now "%s".' % (name, p2.name, p2.type_expr.original_string, p1.type_expr.original_string))
+
+
+			# This is done becuase we may hit an alias before we
+			# hit the "real" entry.  The aliases may not have all
+			# of the parameter information (e.g., counter,
+			# variable_param, etc. fields) required to generate
+			# GLX code.
+
+			if true_name == name:
+				self.parameters = parameters
+
+				for param in self.parameters:
+					if param.is_image():
+						self.images.append( param )
+
+		if true_name == name:
+			for param in self.parameters:
+				if param.is_image():
+					self.images.append( param )
+
+		if element.children:
+			self.uninitialized = 0
 
+		return
 
-	def next(self):
-		if self.index < 0:
-			raise StopIteration
 
-		k = self.keys[ self.index ]
+	def get_images(self):
+		"""Return potentially empty list of input images."""
+		return self.images
 
-		#if self.context.functions[k].fn_alias == None:
-		#	if k != self.prevk + 1:
-		#		print 'Missing offset %d' % (prevk)
-		#	self.prevk = int(k)
 
-		self.index += self.direction
+	def parameterIterator(self):
+		return self.parameters.__iter__();
 
-		if self.index == len(self.keys):
-			self.index = self.split
-			self.direction = -1
 
-		return self.context.functions[k]
+	def get_parameter_string(self):
+		list = []
+		for p in self.parameters:
+			list.append( p.string() )
 
+		if len(list) == 0:
+			return "void"
+		else:
+			return string.join(list, ", ")
+
+
+class gl_item_factory:
+	"""Factory to create objects derived from gl_item."""
+
+	def create_item(self, item_name, element, context):
+		if item_name == "function":
+			return gl_function(element, context)
+		if item_name == "type":
+			return gl_type(element, context)
+		elif item_name == "enum":
+			return gl_enum(element, context)
+		elif item_name == "parameter":
+			return gl_parameter(element, context)
+		elif item_name == "api":
+			return gl_api(self)
+		else:
+			return None
 
-class FilterGLAPISpecBase(saxutils.XMLFilterBase):
-	name = "a"
-	license = "The license for this file is unspecified."
-	next_alias = -2
-	current_object = None
 
-	def __init__(self):
-		saxutils.XMLFilterBase.__init__(self)
-		self.functions = {}
-		self.types = {}
+class gl_api:
+	def __init__(self, factory):
 		self.functions_by_name = {}
-		self.factory = glItemFactory()
-		self.header_tag = None
-		self.undef_list = []
-		self.current_category = ""
-
+		self.enums_by_name = {}
+		self.types_by_name = {}
+		self.category_dict = {}
 
-	def find_type(self,type_name):
-		for t in self.types:
-			if re.compile(t).search(type_name):
-				return self.types[t]
-		print "Unable to find base type matching \"%s\"." % (type_name)
-		return None
+		self.factory = factory
 
-
-	def find_function(self,function_name):
-		return self.functions_by_name[function_name]
-
-
-	def functionIterator(self):
-		return glFunctionIterator(self)
-
-
-	def printFunctions(self):
-		for f in self.functionIterator():
-			self.printFunction(f)
+		typeexpr.create_initial_types()
 		return
 
 
-	def printHeader(self):
-		"""Print the header associated with all files and call the printRealHeader method."""
+	def process_element(self, doc):
+		element = doc.children
+		while element.type != "element" or element.name != "OpenGLAPI":
+			element = element.next
 
-		print '/* DO NOT EDIT - This file generated automatically by %s script */' \
-			% (self.name)
-		print ''
-		print '/*'
-		print ' * ' + self.license.replace('\n', '\n * ')
-		print ' */'
-		print ''
-		if self.header_tag:
-		    print '#if !defined( %s )' % (self.header_tag)
-		    print '#  define %s' % (self.header_tag)
-		    print ''
-		self.printRealHeader();
+		if element:
+			self.process_OpenGLAPI(element)
 		return
 
 
-	def printFooter(self):
-		"""Print the header associated with all files and call the printRealFooter method."""
-
-		self.printFunctions()
-		self.printRealFooter()
-		if self.header_tag:
-			if self.undef_list:
-				print ''
-				for u in self.undef_list:
-					print "#  undef %s" % (u)
-			print ''
-			print '#endif /* !defined( %s ) */' % (self.header_tag)
-
+	def process_OpenGLAPI(self, element):
+		child = element.children
+		while child:
+			if child.type == "element":
+				if child.name == "category":
+					self.process_category( child )
+				elif child.name == "OpenGLAPI":
+					self.process_OpenGLAPI( child )
 
-	def get_category_define(self):
-		"""Convert the category name to the #define that would be found in glext.h"""
+			child = child.next
 
-		if re.compile("[1-9][0-9]*[.][0-9]+").match(self.current_category):
-			s = self.current_category
-			return "GL_VERSION_" + s.replace(".", "_")
-		else:
-			return self.current_category
+		return
 
 
-	def append(self, object_type, obj):
-		if object_type == "function":
-			# If the function is not an alias and has a negative
-			# offset, then we do not need to track it.  These are
-			# functions that don't have an assigned offset
+	def process_category(self, cat):
+		cat_name = cat.nsProp( "name", None )
+		cat_number = cat.nsProp( "number", None )
 
-			if not self.functions_by_name.has_key(obj.name):
-				self.functions_by_name[obj.name] = obj
+		child = cat.children
+		while child:
+			if child.type == "element":
+				if child.name == "function":
+					func_name = real_function_name( child )
 
-				if obj.fn_offset >= 0 or obj.fn_alias != None:
-					if obj.fn_offset >= 0:
-						index = obj.fn_offset
+					if self.functions_by_name.has_key( func_name ):
+						func = self.functions_by_name[ func_name ]
+						func.process_element( child )
 					else:
-						index = self.next_alias
-						self.next_alias -= 1
+						func = self.factory.create_item( "function", child, self )
+						self.functions_by_name[ func_name ] = func
 
-					self.functions[index] = obj
-			else:
-				# We should do some checking here to make
-				# sure the functions are an identical match.
-				pass
+					if func_name == child.nsProp("name", None):
+						self.category_dict[ func.name ] = [cat_name, cat_number]
 
-		elif object_type == "type":
-			self.types[obj.name] = obj
+				elif child.name == "enum":
+					enum = self.factory.create_item( "enum", child, self )
+					self.enums_by_name[ enum.name ] = enum
+				elif child.name == "type":
+					t = self.factory.create_item( "type", child, self )
+					self.types_by_name[ "GL" + t.name ] = t
 
-		return
 
+			child = child.next
 
-	def startElementNS(self, name, qname, attrs):
-		"""Start a new element in the XML stream.
-		
-		Starts a new element.  There are three types of elements that
-		are specially handled by this function.  When a "category"
-		element is encountered, the name of the category is saved.
-		If an element is encountered and no API object is
-		in-progress, a new object is created using the API factory.
-		Any future elements, until that API object is closed, are
-		passed to the current objects startElement method.
-	
-		This paradigm was chosen becuase it allows subclasses of the
-		basic API types (i.e., glFunction, glEnum, etc.) to handle
-		additional XML data, GLX protocol information,  that the base
-		classes do not know about."""
-
-		[uri, true_name] = name
-		if uri is None:
-			if self.current_object != None:
-				self.current_object.startElementNS(name, qname, attrs)
-			elif true_name == "category":
-				self.current_category = attrs.get((None, 'name'), "")
-			elif true_name == "include":
-				self.next_include = attrs.get((None, 'name'), "")
-			else:
-				self.current_object = self.factory.create(self, true_name, attrs)
 		return
 
 
-	def endElementNS(self, name, qname):
-		if self.current_object != None:
-			if self.current_object.endElementNS(name, qname):
-				self.current_object = None
-		elif name == "include":
-			parser = make_parser()
-			parser.setFeature(feature_namespaces, 1)
-			parser.setContentHandler(self)
+	def functionIterateByOffset(self):
+		max_offset = -1
+		for func in self.functions_by_name.itervalues():
+			if func.offset > max_offset:
+				max_offset = func.offset
 
-			f = open(self.next_include)
-			parser.parse(f)
 
-		return
+		temp = [None for i in range(0, max_offset + 1)]
+		for func in self.functions_by_name.itervalues():
+			if func.offset != -1:
+				temp[ func.offset ] = func
 
 
-	def printPure(self):
-		self.undef_list.append("PURE")
-		print """#  if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)
-#    define PURE __attribute__((pure))
-#  else
-#    define PURE
-#  endif"""
+		list = []
+		for i in range(0, max_offset + 1):
+			if temp[i]:
+				list.append(temp[i])
 
-	def printFastcall(self):
-		self.undef_list.append("FASTCALL")
-		print """#  if defined(__i386__) && defined(__GNUC__)
-#    define FASTCALL __attribute__((fastcall))
-#  else
-#    define FASTCALL
-#  endif"""
+		return list.__iter__();
 
-	def printVisibility(self, S, s):
-		self.undef_list.append(S)
-		print """#  if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)
-#    define %s  __attribute__((visibility("%s")))
-#  else
-#    define %s
-#  endif""" % (S, s, S)
 
-	def printNoinline(self):
-		self.undef_list.append("NOINLINE")
-		print """#  if defined(__GNUC__)
-#    define NOINLINE __attribute__((noinline))
-#  else
-#    define NOINLINE
-#  endif"""
+	def functionIterateAll(self):
+		return self.functions_by_name.itervalues()
 
-	def printHaveAlias(self):
-		self.undef_list.append("HAVE_ALIAS")
-		print """#  if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
-#    define HAVE_ALIAS
-#  endif"""
 
-	def printFunction(self,offset):
-		"""Print a single function.
+	def enumIterateByName(self):
+		keys = self.enums_by_name.keys()
+		keys.sort()
+		
+		list = []
+		for enum in keys:
+			list.append( self.enums_by_name[ enum ] )
 
-		In the base class, this function is empty.  All derived
-		classes should over-ride this function."""
-		return
-    
+		return list.__iter__()
 
-	def printRealHeader(self):
-		"""Print the "real" header for the created file.
 
-		In the base class, this function is empty.  All derived
-		classes should over-ride this function."""
-		return
+	def get_category_for_name( self, name ):
+		if self.category_dict.has_key(name):
+			return self.category_dict[name]
+		else:
+			return ["<unknown category>", None]
 
 
-	def printRealFooter(self):
-		"""Print the "real" footer for the created file.
+	def typeIterate(self):
+		return self.types_by_name.itervalues()
 
-		In the base class, this function is empty.  All derived
-		classes should over-ride this function."""
-		return
+
+	def find_type( self, type_name ):
+		if type_name in self.types_by_name:
+			return self.types_by_name[ type_name ].type_expr
+		else:
+			print "Unable to find base type matching \"%s\"." % (type_name)
+			return None
diff --git a/src/mesa/glapi/gl_apitemp.py b/src/mesa/glapi/gl_apitemp.py
index 6f30a16d994..32fca646c15 100644
--- a/src/mesa/glapi/gl_apitemp.py
+++ b/src/mesa/glapi/gl_apitemp.py
@@ -1,6 +1,6 @@
-#!/usr/bin/python2
+#!/usr/bin/env python
 
-# (C) Copyright IBM Corporation 2004
+# (C) Copyright IBM Corporation 2004, 2005
 # All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
@@ -29,54 +29,57 @@ import gl_XML
 import license
 import sys, getopt
 
-class PrintGlOffsets(gl_XML.FilterGLAPISpecBase):
-	name = "gl_apitemp.py (from Mesa)"
-
+class PrintGlOffsets(gl_XML.gl_print_base):
 	def __init__(self):
-		gl_XML.FilterGLAPISpecBase.__init__(self)
+		gl_XML.gl_print_base.__init__(self)
+
+		self.name = "gl_apitemp.py (from Mesa)"
 		self.license = license.bsd_license_template % ( \
 """Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
 (C) Copyright IBM Corporation 2004""", "BRIAN PAUL, IBM")
 
-	def printFunction(self, f):
+		self.undef_list.append( "KEYWORD1" )
+		self.undef_list.append( "KEYWORD2" )
+		self.undef_list.append( "NAME" )
+		self.undef_list.append( "DISPATCH" )
+		self.undef_list.append( "RETURN_DISPATCH" )
+		self.undef_list.append( "DISPATCH_TABLE_NAME" )
+		self.undef_list.append( "UNUSED_TABLE_NAME" )
+		self.undef_list.append( "TABLE_ENTRY" )
+
+
+	def printFunction(self, f, name):
 		p_string = ""
 		o_string = ""
 		t_string = ""
 		comma = ""
 
 		for p in f.parameterIterator():
-			cast = ""
-
-			if p.is_pointer:
-				t = "%p"
+			if p.is_pointer():
 				cast = "(const void *) "
-			elif p.p_type_string == 'GLenum':
-				t = "0x%x"
-			elif p.p_type_string in ['GLfloat', 'GLdouble', 'GLclampf', 'GLclampd']:
-				t = "%f"
 			else:
-				t = "%d"
+				cast = ""
 
-			t_string = t_string + comma + t
+			t_string = t_string + comma + p.format_string()
 			p_string = p_string + comma + p.name
 			o_string = o_string + comma + cast + p.name
 			comma = ", "
 
 
-		if f.fn_return_type != 'void':
+		if f.return_type != 'void':
 			dispatch = "RETURN_DISPATCH"
 		else:
 			dispatch = "DISPATCH"
 
 		print 'KEYWORD1 %s KEYWORD2 NAME(%s)(%s)' \
-			% (f.fn_return_type, f.name, f.get_parameter_string())
+			% (f.return_type, name, f.get_parameter_string())
 		print '{'
 		if p_string == "":
 			print '   %s(%s, (), (F, "gl%s();\\n"));' \
-				% (dispatch, f.real_name, f.name)
+				% (dispatch, f.name, name)
 		else:
 			print '   %s(%s, (%s), (F, "gl%s(%s);\\n", %s));' \
-				% (dispatch, f.real_name, p_string, f.name, t_string, o_string)
+				% (dispatch, f.name, p_string, name, t_string, o_string)
 		print '}'
 		print ''
 		return
@@ -130,7 +133,7 @@ class PrintGlOffsets(gl_XML.FilterGLAPISpecBase):
 
     
 
-	def printInitDispatch(self):
+	def printInitDispatch(self, api):
 		print """
 #endif /* defined( NAME ) */
 
@@ -145,9 +148,7 @@ class PrintGlOffsets(gl_XML.FilterGLAPISpecBase):
 #endif
 
 static _glapi_proc DISPATCH_TABLE_NAME[] = {"""
-		for f in self.functionIterator():
-			if f.fn_offset < 0: continue
-
+		for f in api.functionIterateByOffset():
 			print '   TABLE_ENTRY(%s),' % (f.name)
 
 		print '   /* A whole bunch of no-op functions.  These might be called'
@@ -162,7 +163,8 @@ static _glapi_proc DISPATCH_TABLE_NAME[] = {"""
 		print ''
 		return
 
-	def printAliasedTable(self):
+
+	def printAliasedTable(self, api):
 		print """
 /*
  * This is just used to silence compiler warnings.
@@ -171,30 +173,27 @@ static _glapi_proc DISPATCH_TABLE_NAME[] = {"""
 #ifdef UNUSED_TABLE_NAME
 static _glapi_proc UNUSED_TABLE_NAME[] = {"""
 
-		for f in self.functionIterator():
-			if f.fn_offset < 0:
-				print '   TABLE_ENTRY(%s),' % (f.name)
+		for f in api.functionIterateByOffset():
+			for n in f.entry_points:
+				if n != f.name:
+					print '   TABLE_ENTRY(%s),' % (n)
 
 		print '};'
 		print '#endif /*UNUSED_TABLE_NAME*/'
 		print ''
 		return
 
-	def printRealFooter(self):
-		self.printInitDispatch()
-		self.printAliasedTable()
-		print"""
-#undef KEYWORD1
-#undef KEYWORD2
-#undef NAME
-#undef DISPATCH
-#undef RETURN_DISPATCH
-#undef DISPATCH_TABLE_NAME
-#undef UNUSED_TABLE_NAME
-#undef TABLE_ENTRY
-"""
+
+	def printBody(self, api):
+		for func in api.functionIterateByOffset():
+			for n in func.entry_points:
+				self.printFunction( func, n )
+
+		self.printInitDispatch(api)
+		self.printAliasedTable(api)
 		return
 
+
 def show_usage():
 	print "Usage: %s [-f input_file_name]" % sys.argv[0]
 	sys.exit(1)
@@ -211,5 +210,7 @@ if __name__ == '__main__':
 		if arg == "-f":
 			file_name = val
 
-	dh = PrintGlOffsets()
-	gl_XML.parse_GL_API( dh, file_name )
+	api = gl_XML.parse_GL_API( file_name )
+
+	printer = PrintGlOffsets()
+	printer.Print(api)
diff --git a/src/mesa/glapi/gl_enums.py b/src/mesa/glapi/gl_enums.py
index 8520d9e33ea..33d621dcd6f 100644
--- a/src/mesa/glapi/gl_enums.py
+++ b/src/mesa/glapi/gl_enums.py
@@ -30,10 +30,10 @@ import license
 import gl_XML
 import sys, getopt
 
-class PrintGlEnums(gl_XML.FilterGLAPISpecBase):
+class PrintGlEnums(gl_XML.gl_print_base):
 
 	def __init__(self):
-		gl_XML.FilterGLAPISpecBase.__init__(self)
+		gl_XML.gl_print_base.__init__(self)
 
 		self.name = "gl_enums.py (from Mesa)"
 		self.license = license.bsd_license_template % ( \
@@ -53,7 +53,7 @@ class PrintGlEnums(gl_XML.FilterGLAPISpecBase):
 		print ''
 		return
 
-	def printBody(self):
+	def print_code(self):
 		print """
 #define Elements(x) sizeof(x)/sizeof(*x)
 
@@ -124,7 +124,10 @@ int _mesa_lookup_enum_by_name( const char *symbol )
 """
 		return
 
-	def printFunctions(self):
+
+	def printBody(self, api):
+		self.process_enums( api )
+
 		keys = self.enum_table.keys()
 		keys.sort()
 
@@ -175,50 +178,21 @@ int _mesa_lookup_enum_by_name( const char *symbol )
 		print '};'
 
 
-		self.printBody();
+		self.print_code()
 		return
 
 
-	def append(self, object_type, obj):
-		if object_type == "enum":
+	def process_enums(self, api):
+		self.enum_table = {}
+		
+		for obj in api.enumIterateByName():
 			if obj.value not in self.enum_table:
 				self.enum_table[ obj.value ] = []
 
 
-			# Prevent duplicate names in the enum table.
-
-			found_it = 0
-			for [n, junk] in self.enum_table[ obj.value ]:
-				if n == obj.name:
-					found_it = 1
-					break
-
-			if not found_it:
-
-				# Calculate a "priority" for this enum name.
-				# When we lookup an enum by number, there may
-				# be many possible names, but only one can be
-				# returned.  The priority is used by this
-				# script to select which name is the "best".
-				#
-				# Highest precedence is given to "core" name.
-				# ARB extension names have the next highest,
-				# followed by EXT extension names.  Vendor
-				# extension names are the lowest.
-
-				if obj.category.startswith( "GL_VERSION_" ):
-					priority = 0
-				elif obj.category.startswith( "GL_ARB_" ):
-					priority = 1
-				elif obj.category.startswith( "GL_EXT_" ):
-					priority = 2
-				else:
-					priority = 3
-
-				self.enum_table[ obj.value ].append( [obj.name, priority] )
-
-		else:
-			gl_XML.FilterGLAPISpecBase.append(self, object_type, obj)
+			name = "GL_" + obj.name
+			priority = obj.priority()
+			self.enum_table[ obj.value ].append( [name, priority] )
 
 
 def show_usage():
@@ -237,5 +211,7 @@ if __name__ == '__main__':
 		if arg == "-f":
 			file_name = val
 
-	dh = PrintGlEnums()
-	gl_XML.parse_GL_API( dh, file_name )
+	api = gl_XML.parse_GL_API( file_name )
+
+	printer = PrintGlEnums()
+	printer.Print( api )
diff --git a/src/mesa/glapi/gl_offsets.py b/src/mesa/glapi/gl_offsets.py
index f47eaa26b30..dfd7fda9d77 100644
--- a/src/mesa/glapi/gl_offsets.py
+++ b/src/mesa/glapi/gl_offsets.py
@@ -1,6 +1,6 @@
-#!/usr/bin/python2
+#!/usr/bin/env python
 
-# (C) Copyright IBM Corporation 2004
+# (C) Copyright IBM Corporation 2004, 2005
 # All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
@@ -29,19 +29,20 @@ import gl_XML
 import license
 import sys, getopt
 
-class PrintGlOffsets(gl_XML.FilterGLAPISpecBase):
-	name = "gl_offsets.py (from Mesa)"
-
+class PrintGlOffsets(gl_XML.gl_print_base):
 	def __init__(self):
-		gl_XML.FilterGLAPISpecBase.__init__(self)
+		gl_XML.gl_print_base.__init__(self)
+
+		self.name = "gl_offsets.py (from Mesa)"
 		self.header_tag = '_GLAPI_OFFSETS_H_'
 		self.license = license.bsd_license_template % ( \
 """Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
 (C) Copyright IBM Corporation 2004""", "BRIAN PAUL, IBM")
+		return
 
-	def printFunction(self, f):
-		if f.fn_offset < 0: return
-		print '#define _gloffset_%s %d' % (f.name, f.fn_offset)
+	def printBody(self, api):
+		for f in api.functionIterateByOffset():
+			print '#define _gloffset_%s %d' % (f.name, f.offset)
 
 
 def show_usage():
@@ -60,5 +61,7 @@ if __name__ == '__main__':
 		if arg == "-f":
 			file_name = val
 
-	dh = PrintGlOffsets()
-	gl_XML.parse_GL_API( dh, file_name )
+	api = gl_XML.parse_GL_API( file_name )
+
+	printer = PrintGlOffsets()
+	printer.Print( api )
diff --git a/src/mesa/glapi/gl_procs.py b/src/mesa/glapi/gl_procs.py
index 75bb844a335..1ad683de5c7 100644
--- a/src/mesa/glapi/gl_procs.py
+++ b/src/mesa/glapi/gl_procs.py
@@ -1,6 +1,6 @@
-#!/usr/bin/python2
+#!/usr/bin/env python
 
-# (C) Copyright IBM Corporation 2004
+# (C) Copyright IBM Corporation 2004, 2005
 # All Rights Reserved.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a
@@ -29,12 +29,12 @@ import license
 import gl_XML
 import sys, getopt
 
-class PrintGlProcs(gl_XML.FilterGLAPISpecBase):
-	name = "gl_procs.py (from Mesa)"
-
+class PrintGlProcs(gl_XML.gl_print_base):
 	def __init__(self, long_strings):
+		gl_XML.gl_print_base.__init__(self)
+
 		self.long_strings = long_strings
-		gl_XML.FilterGLAPISpecBase.__init__(self)
+		self.name = "gl_procs.py (from Mesa)"
 		self.license = license.bsd_license_template % ( \
 """Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
 (C) Copyright IBM Corporation 2004""", "BRIAN PAUL, IBM")
@@ -66,29 +66,43 @@ class PrintGlProcs(gl_XML.FilterGLAPISpecBase):
 		print '#undef NAME_FUNC_OFFSET'
 		return
 
-	def printFunctionString(self, f):
+	def printFunctionString(self, name):
 		if self.long_strings:
-			print '    "gl%s\\0"' % (f.name)
+			print '    "gl%s\\0"' % (name)
 		else:
 			print "    'g','l',",
-			for c in f.name:
+			for c in name:
 				print "'%s'," % (c),
 			
 			print "'\\0',"
 
-	def printFunctionOffset(self, f, offset_of_name):
-		print '    NAME_FUNC_OFFSET( % 5u, gl%s, _gloffset_%s ),' % (offset_of_name, f.name, f.real_name)
-
 
-	def printFunctions(self):
+	def printBody(self, api):
 		print ''
 		if self.long_strings:
 			print 'static const char gl_string_table[] ='
 		else:
 			print 'static const char gl_string_table[] = {'
 
-		for f in self.functionIterator():
-			self.printFunctionString(f)
+		base_offset = 0
+		table = []
+		for func in api.functionIterateByOffset():
+			self.printFunctionString( func.name )
+			table.append((base_offset, func.name, func.name))
+
+			# The length of the function's name, plus 2 for "gl",
+			# plus 1 for the NUL.
+
+			base_offset += len(func.name) + 3
+
+
+		for func in api.functionIterateByOffset():
+			for n in func.entry_points:
+				if n != func.name:
+					self.printFunctionString( n )
+					table.append((base_offset, n, func.name))
+					base_offset += len(n) + 3
+
 
 		if self.long_strings:
 			print '    ;'
@@ -98,15 +112,8 @@ class PrintGlProcs(gl_XML.FilterGLAPISpecBase):
 		print ''
 		print 'static const glprocs_table_t static_functions[] = {'
 
-		base_offset = 0
-
-		for f in self.functionIterator():
-			self.printFunctionOffset(f, base_offset)
-
-			# The length of the function's name, plus 2 for "gl",
-			# plus 1 for the NUL.
-
-			base_offset += len(f.name) + 3
+		for (offset, disp_name, real_name) in table:
+			print '    NAME_FUNC_OFFSET( % 5u, gl%s, _gloffset_%s ),' % (offset, disp_name, real_name)
 
 		print '    NAME_FUNC_OFFSET( -1, NULL, 0 )'
 		print '};'
@@ -142,5 +149,7 @@ if __name__ == '__main__':
 			else:
 				show_usage()
 
-	dh = PrintGlProcs( long_string )
-	gl_XML.parse_GL_API( dh, file_name )
+	api = gl_XML.parse_GL_API( file_name )
+
+	printer = PrintGlProcs( long_string )
+	printer.Print( api )
diff --git a/src/mesa/glapi/gl_table.py b/src/mesa/glapi/gl_table.py
index 7585efa947c..a3b49438b70 100644
--- a/src/mesa/glapi/gl_table.py
+++ b/src/mesa/glapi/gl_table.py
@@ -29,23 +29,23 @@ import gl_XML
 import license
 import sys, getopt
 
-class PrintGlTable(gl_XML.FilterGLAPISpecBase):
+class PrintGlTable(gl_XML.gl_print_base):
 	def __init__(self):
-		gl_XML.FilterGLAPISpecBase.__init__(self)
+		gl_XML.gl_print_base.__init__(self)
 
 		self.header_tag = '_GLAPI_TABLE_H_'
 		self.name = "gl_table.py (from Mesa)"
 		self.license = license.bsd_license_template % ( \
 """Copyright (C) 1999-2003  Brian Paul   All Rights Reserved.
 (C) Copyright IBM Corporation 2004""", "BRIAN PAUL, IBM")
+		return
 
 
-	def printFunction(self, f):
-		if f.fn_offset < 0: return
+	def printBody(self, api):
+		for f in api.functionIterateByOffset():
+			arg_string = f.get_parameter_string()
+			print '   %s (GLAPIENTRYP %s)(%s); /* %d */' % (f.return_type, f.name, arg_string, f.offset)
 
-		arg_string = f.get_parameter_string()
-		print '   %s (GLAPIENTRYP %s)(%s); /* %d */' % \
-			(f.fn_return_type, f.name, arg_string, f.fn_offset)
 
 	def printRealHeader(self):
 		print '#ifndef GLAPIENTRYP'
@@ -56,6 +56,7 @@ class PrintGlTable(gl_XML.FilterGLAPISpecBase):
 		print '{'
 		return
 
+
 	def printRealFooter(self):
 		print '};'
 		return
@@ -77,5 +78,7 @@ if __name__ == '__main__':
 		if arg == "-f":
 			file_name = val
 
-	dh = PrintGlTable()
-	gl_XML.parse_GL_API( dh, file_name )
+	api = gl_XML.parse_GL_API( file_name )
+
+	printer = PrintGlTable()
+	printer.Print( api )
diff --git a/src/mesa/glapi/gl_x86_asm.py b/src/mesa/glapi/gl_x86_asm.py
index 85a5c2be050..caaa9e83e53 100644
--- a/src/mesa/glapi/gl_x86_asm.py
+++ b/src/mesa/glapi/gl_x86_asm.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python2
+#!/usr/bin/env python
 
 # (C) Copyright IBM Corporation 2004, 2005
 # All Rights Reserved.
@@ -25,32 +25,29 @@
 # Authors:
 #    Ian Romanick <[email protected]>
 
-import gl_XML
-import license
+import gl_XML, license
 import sys, getopt
 
-class PrintGenericStubs(gl_XML.FilterGLAPISpecBase):
-	name = "gl_x86_asm.py (from Mesa)"
+class PrintGenericStubs(gl_XML.gl_print_base):
 
 	def __init__(self):
-		gl_XML.FilterGLAPISpecBase.__init__(self)
+		gl_XML.gl_print_base.__init__(self)
+
+		self.name = "gl_x86_asm.py (from Mesa)"
 		self.license = license.bsd_license_template % ( \
 """Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.
 (C) Copyright IBM Corporation 2004, 2005""", "BRIAN PAUL, IBM")
+		return
 
 
 	def get_stack_size(self, f):
 		size = 0
 		for p in f.parameterIterator():
-			t = p.p_type
-
-			if p.is_array() or t.size != 8:
-				size += 4
-			else:
-				size += 8
+			size += p.get_stack_size()
 
 		return size
 
+
 	def printRealHeader(self):
 		print '#include "assyntax.h"'
 		print '#include "glapioffsets.h"'
@@ -183,6 +180,7 @@ class PrintGenericStubs(gl_XML.FilterGLAPISpecBase):
 		print ''
 		return
 
+
 	def printRealFooter(self):
 		print ''
 		print '\t\tGLOBL\tGLNAME(gl_dispatch_functions_end)'
@@ -206,16 +204,24 @@ class PrintGenericStubs(gl_XML.FilterGLAPISpecBase):
 		print '#endif  /* __WIN32__ */'
 		return
 
-	def printFunction(self, f):
-		stack = self.get_stack_size(f)
 
-		alt = "%s@%u" % (f.name, stack)
-		if f.fn_alias == None:
-			print '\tGL_STUB(%s, _gloffset_%s, %s)' % (f.name, f.real_name, alt)
-		else:
-			alias_alt = "%s@%u" % (f.real_name, stack)
-			print '\tGL_STUB_ALIAS(%s, _gloffset_%s, %s, %s, %s)' % \
-			    (f.name, f.real_name, alt, f.real_name, alias_alt)
+	def printBody(self, api):
+		for f in api.functionIterateByOffset():
+			stack = self.get_stack_size(f)
+
+			alt = "%s@%u" % (f.name, stack)
+			print '\tGL_STUB(%s, _gloffset_%s, %s)' % (f.name, f.name, alt)
+
+		for f in api.functionIterateByOffset():
+			stack = self.get_stack_size(f)
+
+			alt = "%s@%u" % (f.name, stack)
+
+			for n in f.entry_points:
+				if n != f.name:
+					alt2 = "%s@%u" % (n, stack)
+					print '\tGL_STUB_ALIAS(%s, _gloffset_%s, %s, %s, %s)' % (n, f.name, alt2, f.name, alt)
+
 		return
 
 def show_usage():
@@ -238,9 +244,11 @@ if __name__ == '__main__':
 			file_name = val
 
 	if mode == "generic":
-		dh = PrintGenericStubs()
+		printer = PrintGenericStubs()
 	else:
 		print "ERROR: Invalid mode \"%s\" specified." % mode
 		show_usage()
 
-	gl_XML.parse_GL_API( dh, file_name )
+	api = gl_XML.parse_GL_API( file_name )
+
+	printer.Print( api )
diff --git a/src/mesa/glapi/glapitemp.h b/src/mesa/glapi/glapitemp.h
index fd68cb8a554..7cc0cdd7399 100644
--- a/src/mesa/glapi/glapitemp.h
+++ b/src/mesa/glapi/glapitemp.h
@@ -1605,11 +1605,21 @@ KEYWORD1 void KEYWORD2 NAME(ArrayElement)(GLint i)
    DISPATCH(ArrayElement, (i), (F, "glArrayElement(%d);\n", i));
 }
 
+KEYWORD1 void KEYWORD2 NAME(ArrayElementEXT)(GLint i)
+{
+   DISPATCH(ArrayElement, (i), (F, "glArrayElementEXT(%d);\n", i));
+}
+
 KEYWORD1 void KEYWORD2 NAME(BindTexture)(GLenum target, GLuint texture)
 {
    DISPATCH(BindTexture, (target, texture), (F, "glBindTexture(0x%x, %d);\n", target, texture));
 }
 
+KEYWORD1 void KEYWORD2 NAME(BindTextureEXT)(GLenum target, GLuint texture)
+{
+   DISPATCH(BindTexture, (target, texture), (F, "glBindTextureEXT(0x%x, %d);\n", target, texture));
+}
+
 KEYWORD1 void KEYWORD2 NAME(ColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
 {
    DISPATCH(ColorPointer, (size, type, stride, pointer), (F, "glColorPointer(%d, 0x%x, %d, %p);\n", size, type, stride, (const void *) pointer));
@@ -1625,6 +1635,11 @@ KEYWORD1 void KEYWORD2 NAME(DrawArrays)(GLenum mode, GLint first, GLsizei count)
    DISPATCH(DrawArrays, (mode, first, count), (F, "glDrawArrays(0x%x, %d, %d);\n", mode, first, count));
 }
 
+KEYWORD1 void KEYWORD2 NAME(DrawArraysEXT)(GLenum mode, GLint first, GLsizei count)
+{
+   DISPATCH(DrawArrays, (mode, first, count), (F, "glDrawArraysEXT(0x%x, %d, %d);\n", mode, first, count));
+}
+
 KEYWORD1 void KEYWORD2 NAME(DrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices)
 {
    DISPATCH(DrawElements, (mode, count, type, indices), (F, "glDrawElements(0x%x, %d, 0x%x, %p);\n", mode, count, type, (const void *) indices));
@@ -1690,26 +1705,51 @@ KEYWORD1 void KEYWORD2 NAME(CopyTexImage1D)(GLenum target, GLint level, GLenum i
    DISPATCH(CopyTexImage1D, (target, level, internalformat, x, y, width, border), (F, "glCopyTexImage1D(0x%x, %d, 0x%x, %d, %d, %d, %d);\n", target, level, internalformat, x, y, width, border));
 }
 
+KEYWORD1 void KEYWORD2 NAME(CopyTexImage1DEXT)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
+{
+   DISPATCH(CopyTexImage1D, (target, level, internalformat, x, y, width, border), (F, "glCopyTexImage1DEXT(0x%x, %d, 0x%x, %d, %d, %d, %d);\n", target, level, internalformat, x, y, width, border));
+}
+
 KEYWORD1 void KEYWORD2 NAME(CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
    DISPATCH(CopyTexImage2D, (target, level, internalformat, x, y, width, height, border), (F, "glCopyTexImage2D(0x%x, %d, 0x%x, %d, %d, %d, %d, %d);\n", target, level, internalformat, x, y, width, height, border));
 }
 
+KEYWORD1 void KEYWORD2 NAME(CopyTexImage2DEXT)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+{
+   DISPATCH(CopyTexImage2D, (target, level, internalformat, x, y, width, height, border), (F, "glCopyTexImage2DEXT(0x%x, %d, 0x%x, %d, %d, %d, %d, %d);\n", target, level, internalformat, x, y, width, height, border));
+}
+
 KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
    DISPATCH(CopyTexSubImage1D, (target, level, xoffset, x, y, width), (F, "glCopyTexSubImage1D(0x%x, %d, %d, %d, %d, %d);\n", target, level, xoffset, x, y, width));
 }
 
+KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage1DEXT)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
+{
+   DISPATCH(CopyTexSubImage1D, (target, level, xoffset, x, y, width), (F, "glCopyTexSubImage1DEXT(0x%x, %d, %d, %d, %d, %d);\n", target, level, xoffset, x, y, width));
+}
+
 KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
    DISPATCH(CopyTexSubImage2D, (target, level, xoffset, yoffset, x, y, width, height), (F, "glCopyTexSubImage2D(0x%x, %d, %d, %d, %d, %d, %d, %d);\n", target, level, xoffset, yoffset, x, y, width, height));
 }
 
+KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage2DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+   DISPATCH(CopyTexSubImage2D, (target, level, xoffset, yoffset, x, y, width, height), (F, "glCopyTexSubImage2DEXT(0x%x, %d, %d, %d, %d, %d, %d, %d);\n", target, level, xoffset, yoffset, x, y, width, height));
+}
+
 KEYWORD1 void KEYWORD2 NAME(DeleteTextures)(GLsizei n, const GLuint * textures)
 {
    DISPATCH(DeleteTextures, (n, textures), (F, "glDeleteTextures(%d, %p);\n", n, (const void *) textures));
 }
 
+KEYWORD1 void KEYWORD2 NAME(DeleteTexturesEXT)(GLsizei n, const GLuint * textures)
+{
+   DISPATCH(DeleteTextures, (n, textures), (F, "glDeleteTexturesEXT(%d, %p);\n", n, (const void *) textures));
+}
+
 KEYWORD1 void KEYWORD2 NAME(GenTextures)(GLsizei n, GLuint * textures)
 {
    DISPATCH(GenTextures, (n, textures), (F, "glGenTextures(%d, %p);\n", n, (const void *) textures));
@@ -1720,6 +1760,11 @@ KEYWORD1 void KEYWORD2 NAME(GetPointerv)(GLenum pname, GLvoid ** params)
    DISPATCH(GetPointerv, (pname, params), (F, "glGetPointerv(0x%x, %p);\n", pname, (const void *) params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(GetPointervEXT)(GLenum pname, GLvoid ** params)
+{
+   DISPATCH(GetPointerv, (pname, params), (F, "glGetPointervEXT(0x%x, %p);\n", pname, (const void *) params));
+}
+
 KEYWORD1 GLboolean KEYWORD2 NAME(IsTexture)(GLuint texture)
 {
    RETURN_DISPATCH(IsTexture, (texture), (F, "glIsTexture(%d);\n", texture));
@@ -1730,16 +1775,31 @@ KEYWORD1 void KEYWORD2 NAME(PrioritizeTextures)(GLsizei n, const GLuint * textur
    DISPATCH(PrioritizeTextures, (n, textures, priorities), (F, "glPrioritizeTextures(%d, %p, %p);\n", n, (const void *) textures, (const void *) priorities));
 }
 
+KEYWORD1 void KEYWORD2 NAME(PrioritizeTexturesEXT)(GLsizei n, const GLuint * textures, const GLclampf * priorities)
+{
+   DISPATCH(PrioritizeTextures, (n, textures, priorities), (F, "glPrioritizeTexturesEXT(%d, %p, %p);\n", n, (const void *) textures, (const void *) priorities));
+}
+
 KEYWORD1 void KEYWORD2 NAME(TexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)
 {
    DISPATCH(TexSubImage1D, (target, level, xoffset, width, format, type, pixels), (F, "glTexSubImage1D(0x%x, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, xoffset, width, format, type, (const void *) pixels));
 }
 
+KEYWORD1 void KEYWORD2 NAME(TexSubImage1DEXT)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)
+{
+   DISPATCH(TexSubImage1D, (target, level, xoffset, width, format, type, pixels), (F, "glTexSubImage1DEXT(0x%x, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, xoffset, width, format, type, (const void *) pixels));
+}
+
 KEYWORD1 void KEYWORD2 NAME(TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
 {
    DISPATCH(TexSubImage2D, (target, level, xoffset, yoffset, width, height, format, type, pixels), (F, "glTexSubImage2D(0x%x, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, xoffset, yoffset, width, height, format, type, (const void *) pixels));
 }
 
+KEYWORD1 void KEYWORD2 NAME(TexSubImage2DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
+{
+   DISPATCH(TexSubImage2D, (target, level, xoffset, yoffset, width, height, format, type, pixels), (F, "glTexSubImage2DEXT(0x%x, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, xoffset, yoffset, width, height, format, type, (const void *) pixels));
+}
+
 KEYWORD1 void KEYWORD2 NAME(PopClientAttrib)(void)
 {
    DISPATCH(PopClientAttrib, (), (F, "glPopClientAttrib();\n"));
@@ -1755,36 +1815,76 @@ KEYWORD1 void KEYWORD2 NAME(BlendColor)(GLclampf red, GLclampf green, GLclampf b
    DISPATCH(BlendColor, (red, green, blue, alpha), (F, "glBlendColor(%f, %f, %f, %f);\n", red, green, blue, alpha));
 }
 
+KEYWORD1 void KEYWORD2 NAME(BlendColorEXT)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+{
+   DISPATCH(BlendColor, (red, green, blue, alpha), (F, "glBlendColorEXT(%f, %f, %f, %f);\n", red, green, blue, alpha));
+}
+
 KEYWORD1 void KEYWORD2 NAME(BlendEquation)(GLenum mode)
 {
    DISPATCH(BlendEquation, (mode), (F, "glBlendEquation(0x%x);\n", mode));
 }
 
+KEYWORD1 void KEYWORD2 NAME(BlendEquationEXT)(GLenum mode)
+{
+   DISPATCH(BlendEquation, (mode), (F, "glBlendEquationEXT(0x%x);\n", mode));
+}
+
 KEYWORD1 void KEYWORD2 NAME(DrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices)
 {
    DISPATCH(DrawRangeElements, (mode, start, end, count, type, indices), (F, "glDrawRangeElements(0x%x, %d, %d, %d, 0x%x, %p);\n", mode, start, end, count, type, (const void *) indices));
 }
 
+KEYWORD1 void KEYWORD2 NAME(DrawRangeElementsEXT)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices)
+{
+   DISPATCH(DrawRangeElements, (mode, start, end, count, type, indices), (F, "glDrawRangeElementsEXT(0x%x, %d, %d, %d, 0x%x, %p);\n", mode, start, end, count, type, (const void *) indices));
+}
+
 KEYWORD1 void KEYWORD2 NAME(ColorTable)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)
 {
    DISPATCH(ColorTable, (target, internalformat, width, format, type, table), (F, "glColorTable(0x%x, 0x%x, %d, 0x%x, 0x%x, %p);\n", target, internalformat, width, format, type, (const void *) table));
 }
 
+KEYWORD1 void KEYWORD2 NAME(ColorTableSGI)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)
+{
+   DISPATCH(ColorTable, (target, internalformat, width, format, type, table), (F, "glColorTableSGI(0x%x, 0x%x, %d, 0x%x, 0x%x, %p);\n", target, internalformat, width, format, type, (const void *) table));
+}
+
+KEYWORD1 void KEYWORD2 NAME(ColorTableEXT)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)
+{
+   DISPATCH(ColorTable, (target, internalformat, width, format, type, table), (F, "glColorTableEXT(0x%x, 0x%x, %d, 0x%x, 0x%x, %p);\n", target, internalformat, width, format, type, (const void *) table));
+}
+
 KEYWORD1 void KEYWORD2 NAME(ColorTableParameterfv)(GLenum target, GLenum pname, const GLfloat * params)
 {
    DISPATCH(ColorTableParameterfv, (target, pname, params), (F, "glColorTableParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(ColorTableParameterfvSGI)(GLenum target, GLenum pname, const GLfloat * params)
+{
+   DISPATCH(ColorTableParameterfv, (target, pname, params), (F, "glColorTableParameterfvSGI(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
+}
+
 KEYWORD1 void KEYWORD2 NAME(ColorTableParameteriv)(GLenum target, GLenum pname, const GLint * params)
 {
    DISPATCH(ColorTableParameteriv, (target, pname, params), (F, "glColorTableParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(ColorTableParameterivSGI)(GLenum target, GLenum pname, const GLint * params)
+{
+   DISPATCH(ColorTableParameteriv, (target, pname, params), (F, "glColorTableParameterivSGI(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
+}
+
 KEYWORD1 void KEYWORD2 NAME(CopyColorTable)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
    DISPATCH(CopyColorTable, (target, internalformat, x, y, width), (F, "glCopyColorTable(0x%x, 0x%x, %d, %d, %d);\n", target, internalformat, x, y, width));
 }
 
+KEYWORD1 void KEYWORD2 NAME(CopyColorTableSGI)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
+{
+   DISPATCH(CopyColorTable, (target, internalformat, x, y, width), (F, "glCopyColorTableSGI(0x%x, 0x%x, %d, %d, %d);\n", target, internalformat, x, y, width));
+}
+
 KEYWORD1 void KEYWORD2 NAME(GetColorTable)(GLenum target, GLenum format, GLenum type, GLvoid * table)
 {
    DISPATCH(GetColorTable, (target, format, type, table), (F, "glGetColorTable(0x%x, 0x%x, 0x%x, %p);\n", target, format, type, (const void *) table));
@@ -1805,51 +1905,101 @@ KEYWORD1 void KEYWORD2 NAME(ColorSubTable)(GLenum target, GLsizei start, GLsizei
    DISPATCH(ColorSubTable, (target, start, count, format, type, data), (F, "glColorSubTable(0x%x, %d, %d, 0x%x, 0x%x, %p);\n", target, start, count, format, type, (const void *) data));
 }
 
+KEYWORD1 void KEYWORD2 NAME(ColorSubTableEXT)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data)
+{
+   DISPATCH(ColorSubTable, (target, start, count, format, type, data), (F, "glColorSubTableEXT(0x%x, %d, %d, 0x%x, 0x%x, %p);\n", target, start, count, format, type, (const void *) data));
+}
+
 KEYWORD1 void KEYWORD2 NAME(CopyColorSubTable)(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
    DISPATCH(CopyColorSubTable, (target, start, x, y, width), (F, "glCopyColorSubTable(0x%x, %d, %d, %d, %d);\n", target, start, x, y, width));
 }
 
+KEYWORD1 void KEYWORD2 NAME(CopyColorSubTableEXT)(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
+{
+   DISPATCH(CopyColorSubTable, (target, start, x, y, width), (F, "glCopyColorSubTableEXT(0x%x, %d, %d, %d, %d);\n", target, start, x, y, width));
+}
+
 KEYWORD1 void KEYWORD2 NAME(ConvolutionFilter1D)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image)
 {
    DISPATCH(ConvolutionFilter1D, (target, internalformat, width, format, type, image), (F, "glConvolutionFilter1D(0x%x, 0x%x, %d, 0x%x, 0x%x, %p);\n", target, internalformat, width, format, type, (const void *) image));
 }
 
+KEYWORD1 void KEYWORD2 NAME(ConvolutionFilter1DEXT)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image)
+{
+   DISPATCH(ConvolutionFilter1D, (target, internalformat, width, format, type, image), (F, "glConvolutionFilter1DEXT(0x%x, 0x%x, %d, 0x%x, 0x%x, %p);\n", target, internalformat, width, format, type, (const void *) image));
+}
+
 KEYWORD1 void KEYWORD2 NAME(ConvolutionFilter2D)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)
 {
    DISPATCH(ConvolutionFilter2D, (target, internalformat, width, height, format, type, image), (F, "glConvolutionFilter2D(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p);\n", target, internalformat, width, height, format, type, (const void *) image));
 }
 
+KEYWORD1 void KEYWORD2 NAME(ConvolutionFilter2DEXT)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)
+{
+   DISPATCH(ConvolutionFilter2D, (target, internalformat, width, height, format, type, image), (F, "glConvolutionFilter2DEXT(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p);\n", target, internalformat, width, height, format, type, (const void *) image));
+}
+
 KEYWORD1 void KEYWORD2 NAME(ConvolutionParameterf)(GLenum target, GLenum pname, GLfloat params)
 {
    DISPATCH(ConvolutionParameterf, (target, pname, params), (F, "glConvolutionParameterf(0x%x, 0x%x, %f);\n", target, pname, params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(ConvolutionParameterfEXT)(GLenum target, GLenum pname, GLfloat params)
+{
+   DISPATCH(ConvolutionParameterf, (target, pname, params), (F, "glConvolutionParameterfEXT(0x%x, 0x%x, %f);\n", target, pname, params));
+}
+
 KEYWORD1 void KEYWORD2 NAME(ConvolutionParameterfv)(GLenum target, GLenum pname, const GLfloat * params)
 {
    DISPATCH(ConvolutionParameterfv, (target, pname, params), (F, "glConvolutionParameterfv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(ConvolutionParameterfvEXT)(GLenum target, GLenum pname, const GLfloat * params)
+{
+   DISPATCH(ConvolutionParameterfv, (target, pname, params), (F, "glConvolutionParameterfvEXT(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
+}
+
 KEYWORD1 void KEYWORD2 NAME(ConvolutionParameteri)(GLenum target, GLenum pname, GLint params)
 {
    DISPATCH(ConvolutionParameteri, (target, pname, params), (F, "glConvolutionParameteri(0x%x, 0x%x, %d);\n", target, pname, params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(ConvolutionParameteriEXT)(GLenum target, GLenum pname, GLint params)
+{
+   DISPATCH(ConvolutionParameteri, (target, pname, params), (F, "glConvolutionParameteriEXT(0x%x, 0x%x, %d);\n", target, pname, params));
+}
+
 KEYWORD1 void KEYWORD2 NAME(ConvolutionParameteriv)(GLenum target, GLenum pname, const GLint * params)
 {
    DISPATCH(ConvolutionParameteriv, (target, pname, params), (F, "glConvolutionParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(ConvolutionParameterivEXT)(GLenum target, GLenum pname, const GLint * params)
+{
+   DISPATCH(ConvolutionParameteriv, (target, pname, params), (F, "glConvolutionParameterivEXT(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
+}
+
 KEYWORD1 void KEYWORD2 NAME(CopyConvolutionFilter1D)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
    DISPATCH(CopyConvolutionFilter1D, (target, internalformat, x, y, width), (F, "glCopyConvolutionFilter1D(0x%x, 0x%x, %d, %d, %d);\n", target, internalformat, x, y, width));
 }
 
+KEYWORD1 void KEYWORD2 NAME(CopyConvolutionFilter1DEXT)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
+{
+   DISPATCH(CopyConvolutionFilter1D, (target, internalformat, x, y, width), (F, "glCopyConvolutionFilter1DEXT(0x%x, 0x%x, %d, %d, %d);\n", target, internalformat, x, y, width));
+}
+
 KEYWORD1 void KEYWORD2 NAME(CopyConvolutionFilter2D)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
    DISPATCH(CopyConvolutionFilter2D, (target, internalformat, x, y, width, height), (F, "glCopyConvolutionFilter2D(0x%x, 0x%x, %d, %d, %d, %d);\n", target, internalformat, x, y, width, height));
 }
 
+KEYWORD1 void KEYWORD2 NAME(CopyConvolutionFilter2DEXT)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+   DISPATCH(CopyConvolutionFilter2D, (target, internalformat, x, y, width, height), (F, "glCopyConvolutionFilter2DEXT(0x%x, 0x%x, %d, %d, %d, %d);\n", target, internalformat, x, y, width, height));
+}
+
 KEYWORD1 void KEYWORD2 NAME(GetConvolutionFilter)(GLenum target, GLenum format, GLenum type, GLvoid * image)
 {
    DISPATCH(GetConvolutionFilter, (target, format, type, image), (F, "glGetConvolutionFilter(0x%x, 0x%x, 0x%x, %p);\n", target, format, type, (const void *) image));
@@ -1875,6 +2025,11 @@ KEYWORD1 void KEYWORD2 NAME(SeparableFilter2D)(GLenum target, GLenum internalfor
    DISPATCH(SeparableFilter2D, (target, internalformat, width, height, format, type, row, column), (F, "glSeparableFilter2D(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p, %p);\n", target, internalformat, width, height, format, type, (const void *) row, (const void *) column));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SeparableFilter2DEXT)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column)
+{
+   DISPATCH(SeparableFilter2D, (target, internalformat, width, height, format, type, row, column), (F, "glSeparableFilter2DEXT(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p, %p);\n", target, internalformat, width, height, format, type, (const void *) row, (const void *) column));
+}
+
 KEYWORD1 void KEYWORD2 NAME(GetHistogram)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
 {
    DISPATCH(GetHistogram, (target, reset, format, type, values), (F, "glGetHistogram(0x%x, %d, 0x%x, 0x%x, %p);\n", target, reset, format, type, (const void *) values));
@@ -1910,226 +2065,456 @@ KEYWORD1 void KEYWORD2 NAME(Histogram)(GLenum target, GLsizei width, GLenum inte
    DISPATCH(Histogram, (target, width, internalformat, sink), (F, "glHistogram(0x%x, %d, 0x%x, %d);\n", target, width, internalformat, sink));
 }
 
+KEYWORD1 void KEYWORD2 NAME(HistogramEXT)(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
+{
+   DISPATCH(Histogram, (target, width, internalformat, sink), (F, "glHistogramEXT(0x%x, %d, 0x%x, %d);\n", target, width, internalformat, sink));
+}
+
 KEYWORD1 void KEYWORD2 NAME(Minmax)(GLenum target, GLenum internalformat, GLboolean sink)
 {
    DISPATCH(Minmax, (target, internalformat, sink), (F, "glMinmax(0x%x, 0x%x, %d);\n", target, internalformat, sink));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MinmaxEXT)(GLenum target, GLenum internalformat, GLboolean sink)
+{
+   DISPATCH(Minmax, (target, internalformat, sink), (F, "glMinmaxEXT(0x%x, 0x%x, %d);\n", target, internalformat, sink));
+}
+
 KEYWORD1 void KEYWORD2 NAME(ResetHistogram)(GLenum target)
 {
    DISPATCH(ResetHistogram, (target), (F, "glResetHistogram(0x%x);\n", target));
 }
 
+KEYWORD1 void KEYWORD2 NAME(ResetHistogramEXT)(GLenum target)
+{
+   DISPATCH(ResetHistogram, (target), (F, "glResetHistogramEXT(0x%x);\n", target));
+}
+
 KEYWORD1 void KEYWORD2 NAME(ResetMinmax)(GLenum target)
 {
    DISPATCH(ResetMinmax, (target), (F, "glResetMinmax(0x%x);\n", target));
 }
 
+KEYWORD1 void KEYWORD2 NAME(ResetMinmaxEXT)(GLenum target)
+{
+   DISPATCH(ResetMinmax, (target), (F, "glResetMinmaxEXT(0x%x);\n", target));
+}
+
 KEYWORD1 void KEYWORD2 NAME(TexImage3D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
 {
    DISPATCH(TexImage3D, (target, level, internalformat, width, height, depth, border, format, type, pixels), (F, "glTexImage3D(0x%x, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, internalformat, width, height, depth, border, format, type, (const void *) pixels));
 }
 
+KEYWORD1 void KEYWORD2 NAME(TexImage3DEXT)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
+{
+   DISPATCH(TexImage3D, (target, level, internalformat, width, height, depth, border, format, type, pixels), (F, "glTexImage3DEXT(0x%x, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, internalformat, width, height, depth, border, format, type, (const void *) pixels));
+}
+
 KEYWORD1 void KEYWORD2 NAME(TexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)
 {
    DISPATCH(TexSubImage3D, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels), (F, "glTexSubImage3D(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, (const void *) pixels));
 }
 
+KEYWORD1 void KEYWORD2 NAME(TexSubImage3DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)
+{
+   DISPATCH(TexSubImage3D, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels), (F, "glTexSubImage3DEXT(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, (const void *) pixels));
+}
+
 KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
    DISPATCH(CopyTexSubImage3D, (target, level, xoffset, yoffset, zoffset, x, y, width, height), (F, "glCopyTexSubImage3D(0x%x, %d, %d, %d, %d, %d, %d, %d, %d);\n", target, level, xoffset, yoffset, zoffset, x, y, width, height));
 }
 
+KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage3DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+   DISPATCH(CopyTexSubImage3D, (target, level, xoffset, yoffset, zoffset, x, y, width, height), (F, "glCopyTexSubImage3DEXT(0x%x, %d, %d, %d, %d, %d, %d, %d, %d);\n", target, level, xoffset, yoffset, zoffset, x, y, width, height));
+}
+
+KEYWORD1 void KEYWORD2 NAME(ActiveTexture)(GLenum texture)
+{
+   DISPATCH(ActiveTextureARB, (texture), (F, "glActiveTexture(0x%x);\n", texture));
+}
+
 KEYWORD1 void KEYWORD2 NAME(ActiveTextureARB)(GLenum texture)
 {
    DISPATCH(ActiveTextureARB, (texture), (F, "glActiveTextureARB(0x%x);\n", texture));
 }
 
+KEYWORD1 void KEYWORD2 NAME(ClientActiveTexture)(GLenum texture)
+{
+   DISPATCH(ClientActiveTextureARB, (texture), (F, "glClientActiveTexture(0x%x);\n", texture));
+}
+
 KEYWORD1 void KEYWORD2 NAME(ClientActiveTextureARB)(GLenum texture)
 {
    DISPATCH(ClientActiveTextureARB, (texture), (F, "glClientActiveTextureARB(0x%x);\n", texture));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1d)(GLenum target, GLdouble s)
+{
+   DISPATCH(MultiTexCoord1dARB, (target, s), (F, "glMultiTexCoord1d(0x%x, %f);\n", target, s));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1dARB)(GLenum target, GLdouble s)
 {
    DISPATCH(MultiTexCoord1dARB, (target, s), (F, "glMultiTexCoord1dARB(0x%x, %f);\n", target, s));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1dv)(GLenum target, const GLdouble * v)
+{
+   DISPATCH(MultiTexCoord1dvARB, (target, v), (F, "glMultiTexCoord1dv(0x%x, %p);\n", target, (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1dvARB)(GLenum target, const GLdouble * v)
 {
    DISPATCH(MultiTexCoord1dvARB, (target, v), (F, "glMultiTexCoord1dvARB(0x%x, %p);\n", target, (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1f)(GLenum target, GLfloat s)
+{
+   DISPATCH(MultiTexCoord1fARB, (target, s), (F, "glMultiTexCoord1f(0x%x, %f);\n", target, s));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1fARB)(GLenum target, GLfloat s)
 {
    DISPATCH(MultiTexCoord1fARB, (target, s), (F, "glMultiTexCoord1fARB(0x%x, %f);\n", target, s));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1fv)(GLenum target, const GLfloat * v)
+{
+   DISPATCH(MultiTexCoord1fvARB, (target, v), (F, "glMultiTexCoord1fv(0x%x, %p);\n", target, (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1fvARB)(GLenum target, const GLfloat * v)
 {
    DISPATCH(MultiTexCoord1fvARB, (target, v), (F, "glMultiTexCoord1fvARB(0x%x, %p);\n", target, (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1i)(GLenum target, GLint s)
+{
+   DISPATCH(MultiTexCoord1iARB, (target, s), (F, "glMultiTexCoord1i(0x%x, %d);\n", target, s));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1iARB)(GLenum target, GLint s)
 {
    DISPATCH(MultiTexCoord1iARB, (target, s), (F, "glMultiTexCoord1iARB(0x%x, %d);\n", target, s));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1iv)(GLenum target, const GLint * v)
+{
+   DISPATCH(MultiTexCoord1ivARB, (target, v), (F, "glMultiTexCoord1iv(0x%x, %p);\n", target, (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1ivARB)(GLenum target, const GLint * v)
 {
    DISPATCH(MultiTexCoord1ivARB, (target, v), (F, "glMultiTexCoord1ivARB(0x%x, %p);\n", target, (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1s)(GLenum target, GLshort s)
+{
+   DISPATCH(MultiTexCoord1sARB, (target, s), (F, "glMultiTexCoord1s(0x%x, %d);\n", target, s));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1sARB)(GLenum target, GLshort s)
 {
    DISPATCH(MultiTexCoord1sARB, (target, s), (F, "glMultiTexCoord1sARB(0x%x, %d);\n", target, s));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1sv)(GLenum target, const GLshort * v)
+{
+   DISPATCH(MultiTexCoord1svARB, (target, v), (F, "glMultiTexCoord1sv(0x%x, %p);\n", target, (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1svARB)(GLenum target, const GLshort * v)
 {
    DISPATCH(MultiTexCoord1svARB, (target, v), (F, "glMultiTexCoord1svARB(0x%x, %p);\n", target, (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2d)(GLenum target, GLdouble s, GLdouble t)
+{
+   DISPATCH(MultiTexCoord2dARB, (target, s, t), (F, "glMultiTexCoord2d(0x%x, %f, %f);\n", target, s, t));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2dARB)(GLenum target, GLdouble s, GLdouble t)
 {
    DISPATCH(MultiTexCoord2dARB, (target, s, t), (F, "glMultiTexCoord2dARB(0x%x, %f, %f);\n", target, s, t));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2dv)(GLenum target, const GLdouble * v)
+{
+   DISPATCH(MultiTexCoord2dvARB, (target, v), (F, "glMultiTexCoord2dv(0x%x, %p);\n", target, (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2dvARB)(GLenum target, const GLdouble * v)
 {
    DISPATCH(MultiTexCoord2dvARB, (target, v), (F, "glMultiTexCoord2dvARB(0x%x, %p);\n", target, (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2f)(GLenum target, GLfloat s, GLfloat t)
+{
+   DISPATCH(MultiTexCoord2fARB, (target, s, t), (F, "glMultiTexCoord2f(0x%x, %f, %f);\n", target, s, t));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2fARB)(GLenum target, GLfloat s, GLfloat t)
 {
    DISPATCH(MultiTexCoord2fARB, (target, s, t), (F, "glMultiTexCoord2fARB(0x%x, %f, %f);\n", target, s, t));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2fv)(GLenum target, const GLfloat * v)
+{
+   DISPATCH(MultiTexCoord2fvARB, (target, v), (F, "glMultiTexCoord2fv(0x%x, %p);\n", target, (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2fvARB)(GLenum target, const GLfloat * v)
 {
    DISPATCH(MultiTexCoord2fvARB, (target, v), (F, "glMultiTexCoord2fvARB(0x%x, %p);\n", target, (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2i)(GLenum target, GLint s, GLint t)
+{
+   DISPATCH(MultiTexCoord2iARB, (target, s, t), (F, "glMultiTexCoord2i(0x%x, %d, %d);\n", target, s, t));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2iARB)(GLenum target, GLint s, GLint t)
 {
    DISPATCH(MultiTexCoord2iARB, (target, s, t), (F, "glMultiTexCoord2iARB(0x%x, %d, %d);\n", target, s, t));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2iv)(GLenum target, const GLint * v)
+{
+   DISPATCH(MultiTexCoord2ivARB, (target, v), (F, "glMultiTexCoord2iv(0x%x, %p);\n", target, (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2ivARB)(GLenum target, const GLint * v)
 {
    DISPATCH(MultiTexCoord2ivARB, (target, v), (F, "glMultiTexCoord2ivARB(0x%x, %p);\n", target, (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2s)(GLenum target, GLshort s, GLshort t)
+{
+   DISPATCH(MultiTexCoord2sARB, (target, s, t), (F, "glMultiTexCoord2s(0x%x, %d, %d);\n", target, s, t));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2sARB)(GLenum target, GLshort s, GLshort t)
 {
    DISPATCH(MultiTexCoord2sARB, (target, s, t), (F, "glMultiTexCoord2sARB(0x%x, %d, %d);\n", target, s, t));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2sv)(GLenum target, const GLshort * v)
+{
+   DISPATCH(MultiTexCoord2svARB, (target, v), (F, "glMultiTexCoord2sv(0x%x, %p);\n", target, (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2svARB)(GLenum target, const GLshort * v)
 {
    DISPATCH(MultiTexCoord2svARB, (target, v), (F, "glMultiTexCoord2svARB(0x%x, %p);\n", target, (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3d)(GLenum target, GLdouble s, GLdouble t, GLdouble r)
+{
+   DISPATCH(MultiTexCoord3dARB, (target, s, t, r), (F, "glMultiTexCoord3d(0x%x, %f, %f, %f);\n", target, s, t, r));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3dARB)(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 {
    DISPATCH(MultiTexCoord3dARB, (target, s, t, r), (F, "glMultiTexCoord3dARB(0x%x, %f, %f, %f);\n", target, s, t, r));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3dv)(GLenum target, const GLdouble * v)
+{
+   DISPATCH(MultiTexCoord3dvARB, (target, v), (F, "glMultiTexCoord3dv(0x%x, %p);\n", target, (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3dvARB)(GLenum target, const GLdouble * v)
 {
    DISPATCH(MultiTexCoord3dvARB, (target, v), (F, "glMultiTexCoord3dvARB(0x%x, %p);\n", target, (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3f)(GLenum target, GLfloat s, GLfloat t, GLfloat r)
+{
+   DISPATCH(MultiTexCoord3fARB, (target, s, t, r), (F, "glMultiTexCoord3f(0x%x, %f, %f, %f);\n", target, s, t, r));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3fARB)(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 {
    DISPATCH(MultiTexCoord3fARB, (target, s, t, r), (F, "glMultiTexCoord3fARB(0x%x, %f, %f, %f);\n", target, s, t, r));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3fv)(GLenum target, const GLfloat * v)
+{
+   DISPATCH(MultiTexCoord3fvARB, (target, v), (F, "glMultiTexCoord3fv(0x%x, %p);\n", target, (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3fvARB)(GLenum target, const GLfloat * v)
 {
    DISPATCH(MultiTexCoord3fvARB, (target, v), (F, "glMultiTexCoord3fvARB(0x%x, %p);\n", target, (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3i)(GLenum target, GLint s, GLint t, GLint r)
+{
+   DISPATCH(MultiTexCoord3iARB, (target, s, t, r), (F, "glMultiTexCoord3i(0x%x, %d, %d, %d);\n", target, s, t, r));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3iARB)(GLenum target, GLint s, GLint t, GLint r)
 {
    DISPATCH(MultiTexCoord3iARB, (target, s, t, r), (F, "glMultiTexCoord3iARB(0x%x, %d, %d, %d);\n", target, s, t, r));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3iv)(GLenum target, const GLint * v)
+{
+   DISPATCH(MultiTexCoord3ivARB, (target, v), (F, "glMultiTexCoord3iv(0x%x, %p);\n", target, (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3ivARB)(GLenum target, const GLint * v)
 {
    DISPATCH(MultiTexCoord3ivARB, (target, v), (F, "glMultiTexCoord3ivARB(0x%x, %p);\n", target, (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3s)(GLenum target, GLshort s, GLshort t, GLshort r)
+{
+   DISPATCH(MultiTexCoord3sARB, (target, s, t, r), (F, "glMultiTexCoord3s(0x%x, %d, %d, %d);\n", target, s, t, r));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3sARB)(GLenum target, GLshort s, GLshort t, GLshort r)
 {
    DISPATCH(MultiTexCoord3sARB, (target, s, t, r), (F, "glMultiTexCoord3sARB(0x%x, %d, %d, %d);\n", target, s, t, r));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3sv)(GLenum target, const GLshort * v)
+{
+   DISPATCH(MultiTexCoord3svARB, (target, v), (F, "glMultiTexCoord3sv(0x%x, %p);\n", target, (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3svARB)(GLenum target, const GLshort * v)
 {
    DISPATCH(MultiTexCoord3svARB, (target, v), (F, "glMultiTexCoord3svARB(0x%x, %p);\n", target, (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4d)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
+{
+   DISPATCH(MultiTexCoord4dARB, (target, s, t, r, q), (F, "glMultiTexCoord4d(0x%x, %f, %f, %f, %f);\n", target, s, t, r, q));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4dARB)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
    DISPATCH(MultiTexCoord4dARB, (target, s, t, r, q), (F, "glMultiTexCoord4dARB(0x%x, %f, %f, %f, %f);\n", target, s, t, r, q));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4dv)(GLenum target, const GLdouble * v)
+{
+   DISPATCH(MultiTexCoord4dvARB, (target, v), (F, "glMultiTexCoord4dv(0x%x, %p);\n", target, (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4dvARB)(GLenum target, const GLdouble * v)
 {
    DISPATCH(MultiTexCoord4dvARB, (target, v), (F, "glMultiTexCoord4dvARB(0x%x, %p);\n", target, (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4f)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+{
+   DISPATCH(MultiTexCoord4fARB, (target, s, t, r, q), (F, "glMultiTexCoord4f(0x%x, %f, %f, %f, %f);\n", target, s, t, r, q));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4fARB)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
    DISPATCH(MultiTexCoord4fARB, (target, s, t, r, q), (F, "glMultiTexCoord4fARB(0x%x, %f, %f, %f, %f);\n", target, s, t, r, q));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4fv)(GLenum target, const GLfloat * v)
+{
+   DISPATCH(MultiTexCoord4fvARB, (target, v), (F, "glMultiTexCoord4fv(0x%x, %p);\n", target, (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4fvARB)(GLenum target, const GLfloat * v)
 {
    DISPATCH(MultiTexCoord4fvARB, (target, v), (F, "glMultiTexCoord4fvARB(0x%x, %p);\n", target, (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4i)(GLenum target, GLint s, GLint t, GLint r, GLint q)
+{
+   DISPATCH(MultiTexCoord4iARB, (target, s, t, r, q), (F, "glMultiTexCoord4i(0x%x, %d, %d, %d, %d);\n", target, s, t, r, q));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4iARB)(GLenum target, GLint s, GLint t, GLint r, GLint q)
 {
    DISPATCH(MultiTexCoord4iARB, (target, s, t, r, q), (F, "glMultiTexCoord4iARB(0x%x, %d, %d, %d, %d);\n", target, s, t, r, q));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4iv)(GLenum target, const GLint * v)
+{
+   DISPATCH(MultiTexCoord4ivARB, (target, v), (F, "glMultiTexCoord4iv(0x%x, %p);\n", target, (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4ivARB)(GLenum target, const GLint * v)
 {
    DISPATCH(MultiTexCoord4ivARB, (target, v), (F, "glMultiTexCoord4ivARB(0x%x, %p);\n", target, (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4s)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
+{
+   DISPATCH(MultiTexCoord4sARB, (target, s, t, r, q), (F, "glMultiTexCoord4s(0x%x, %d, %d, %d, %d);\n", target, s, t, r, q));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4sARB)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 {
    DISPATCH(MultiTexCoord4sARB, (target, s, t, r, q), (F, "glMultiTexCoord4sARB(0x%x, %d, %d, %d, %d);\n", target, s, t, r, q));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4sv)(GLenum target, const GLshort * v)
+{
+   DISPATCH(MultiTexCoord4svARB, (target, v), (F, "glMultiTexCoord4sv(0x%x, %p);\n", target, (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4svARB)(GLenum target, const GLshort * v)
 {
    DISPATCH(MultiTexCoord4svARB, (target, v), (F, "glMultiTexCoord4svARB(0x%x, %p);\n", target, (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(LoadTransposeMatrixf)(const GLfloat * m)
+{
+   DISPATCH(LoadTransposeMatrixfARB, (m), (F, "glLoadTransposeMatrixf(%p);\n", (const void *) m));
+}
+
 KEYWORD1 void KEYWORD2 NAME(LoadTransposeMatrixfARB)(const GLfloat * m)
 {
    DISPATCH(LoadTransposeMatrixfARB, (m), (F, "glLoadTransposeMatrixfARB(%p);\n", (const void *) m));
 }
 
+KEYWORD1 void KEYWORD2 NAME(LoadTransposeMatrixd)(const GLdouble * m)
+{
+   DISPATCH(LoadTransposeMatrixdARB, (m), (F, "glLoadTransposeMatrixd(%p);\n", (const void *) m));
+}
+
 KEYWORD1 void KEYWORD2 NAME(LoadTransposeMatrixdARB)(const GLdouble * m)
 {
    DISPATCH(LoadTransposeMatrixdARB, (m), (F, "glLoadTransposeMatrixdARB(%p);\n", (const void *) m));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultTransposeMatrixf)(const GLfloat * m)
+{
+   DISPATCH(MultTransposeMatrixfARB, (m), (F, "glMultTransposeMatrixf(%p);\n", (const void *) m));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultTransposeMatrixfARB)(const GLfloat * m)
 {
    DISPATCH(MultTransposeMatrixfARB, (m), (F, "glMultTransposeMatrixfARB(%p);\n", (const void *) m));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultTransposeMatrixd)(const GLdouble * m)
+{
+   DISPATCH(MultTransposeMatrixdARB, (m), (F, "glMultTransposeMatrixd(%p);\n", (const void *) m));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultTransposeMatrixdARB)(const GLdouble * m)
 {
    DISPATCH(MultTransposeMatrixdARB, (m), (F, "glMultTransposeMatrixdARB(%p);\n", (const void *) m));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SampleCoverage)(GLclampf value, GLboolean invert)
+{
+   DISPATCH(SampleCoverageARB, (value, invert), (F, "glSampleCoverage(%f, %d);\n", value, invert));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SampleCoverageARB)(GLclampf value, GLboolean invert)
 {
    DISPATCH(SampleCoverageARB, (value, invert), (F, "glSampleCoverageARB(%f, %d);\n", value, invert));
@@ -2140,6 +2525,11 @@ KEYWORD1 void KEYWORD2 NAME(DrawBuffersARB)(GLsizei n, const GLenum * bufs)
    DISPATCH(DrawBuffersARB, (n, bufs), (F, "glDrawBuffersARB(%d, %p);\n", n, (const void *) bufs));
 }
 
+KEYWORD1 void KEYWORD2 NAME(DrawBuffersATI)(GLsizei n, const GLenum * bufs)
+{
+   DISPATCH(DrawBuffersARB, (n, bufs), (F, "glDrawBuffersATI(%d, %p);\n", n, (const void *) bufs));
+}
+
 KEYWORD1 void KEYWORD2 NAME(PolygonOffsetEXT)(GLfloat factor, GLfloat bias)
 {
    DISPATCH(PolygonOffsetEXT, (factor, bias), (F, "glPolygonOffsetEXT(%f, %f);\n", factor, bias));
@@ -2305,11 +2695,21 @@ KEYWORD1 void KEYWORD2 NAME(SampleMaskSGIS)(GLclampf value, GLboolean invert)
    DISPATCH(SampleMaskSGIS, (value, invert), (F, "glSampleMaskSGIS(%f, %d);\n", value, invert));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SampleMaskEXT)(GLclampf value, GLboolean invert)
+{
+   DISPATCH(SampleMaskSGIS, (value, invert), (F, "glSampleMaskEXT(%f, %d);\n", value, invert));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SamplePatternSGIS)(GLenum pattern)
 {
    DISPATCH(SamplePatternSGIS, (pattern), (F, "glSamplePatternSGIS(0x%x);\n", pattern));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SamplePatternEXT)(GLenum pattern)
+{
+   DISPATCH(SamplePatternSGIS, (pattern), (F, "glSamplePatternEXT(0x%x);\n", pattern));
+}
+
 KEYWORD1 void KEYWORD2 NAME(ColorPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)
 {
    DISPATCH(ColorPointerEXT, (size, type, stride, count, pointer), (F, "glColorPointerEXT(%d, 0x%x, %d, %d, %p);\n", size, type, stride, count, (const void *) pointer));
@@ -2360,16 +2760,46 @@ KEYWORD1 void KEYWORD2 NAME(SpriteParameterivSGIX)(GLenum pname, const GLint * p
    DISPATCH(SpriteParameterivSGIX, (pname, params), (F, "glSpriteParameterivSGIX(0x%x, %p);\n", pname, (const void *) params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(PointParameterf)(GLenum pname, GLfloat param)
+{
+   DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterf(0x%x, %f);\n", pname, param));
+}
+
+KEYWORD1 void KEYWORD2 NAME(PointParameterfARB)(GLenum pname, GLfloat param)
+{
+   DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterfARB(0x%x, %f);\n", pname, param));
+}
+
 KEYWORD1 void KEYWORD2 NAME(PointParameterfEXT)(GLenum pname, GLfloat param)
 {
    DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterfEXT(0x%x, %f);\n", pname, param));
 }
 
+KEYWORD1 void KEYWORD2 NAME(PointParameterfSGIS)(GLenum pname, GLfloat param)
+{
+   DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterfSGIS(0x%x, %f);\n", pname, param));
+}
+
+KEYWORD1 void KEYWORD2 NAME(PointParameterfv)(GLenum pname, const GLfloat * params)
+{
+   DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfv(0x%x, %p);\n", pname, (const void *) params));
+}
+
+KEYWORD1 void KEYWORD2 NAME(PointParameterfvARB)(GLenum pname, const GLfloat * params)
+{
+   DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfvARB(0x%x, %p);\n", pname, (const void *) params));
+}
+
 KEYWORD1 void KEYWORD2 NAME(PointParameterfvEXT)(GLenum pname, const GLfloat * params)
 {
    DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfvEXT(0x%x, %p);\n", pname, (const void *) params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(PointParameterfvSGIS)(GLenum pname, const GLfloat * params)
+{
+   DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfvSGIS(0x%x, %p);\n", pname, (const void *) params));
+}
+
 KEYWORD1 GLint KEYWORD2 NAME(GetInstrumentsSGIX)(void)
 {
    RETURN_DISPATCH(GetInstrumentsSGIX, (), (F, "glGetInstrumentsSGIX();\n"));
@@ -2635,81 +3065,241 @@ KEYWORD1 void KEYWORD2 NAME(ResizeBuffersMESA)(void)
    DISPATCH(ResizeBuffersMESA, (), (F, "glResizeBuffersMESA();\n"));
 }
 
+KEYWORD1 void KEYWORD2 NAME(WindowPos2d)(GLdouble x, GLdouble y)
+{
+   DISPATCH(WindowPos2dMESA, (x, y), (F, "glWindowPos2d(%f, %f);\n", x, y));
+}
+
+KEYWORD1 void KEYWORD2 NAME(WindowPos2dARB)(GLdouble x, GLdouble y)
+{
+   DISPATCH(WindowPos2dMESA, (x, y), (F, "glWindowPos2dARB(%f, %f);\n", x, y));
+}
+
 KEYWORD1 void KEYWORD2 NAME(WindowPos2dMESA)(GLdouble x, GLdouble y)
 {
    DISPATCH(WindowPos2dMESA, (x, y), (F, "glWindowPos2dMESA(%f, %f);\n", x, y));
 }
 
+KEYWORD1 void KEYWORD2 NAME(WindowPos2dv)(const GLdouble * v)
+{
+   DISPATCH(WindowPos2dvMESA, (v), (F, "glWindowPos2dv(%p);\n", (const void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(WindowPos2dvARB)(const GLdouble * v)
+{
+   DISPATCH(WindowPos2dvMESA, (v), (F, "glWindowPos2dvARB(%p);\n", (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(WindowPos2dvMESA)(const GLdouble * v)
 {
    DISPATCH(WindowPos2dvMESA, (v), (F, "glWindowPos2dvMESA(%p);\n", (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(WindowPos2f)(GLfloat x, GLfloat y)
+{
+   DISPATCH(WindowPos2fMESA, (x, y), (F, "glWindowPos2f(%f, %f);\n", x, y));
+}
+
+KEYWORD1 void KEYWORD2 NAME(WindowPos2fARB)(GLfloat x, GLfloat y)
+{
+   DISPATCH(WindowPos2fMESA, (x, y), (F, "glWindowPos2fARB(%f, %f);\n", x, y));
+}
+
 KEYWORD1 void KEYWORD2 NAME(WindowPos2fMESA)(GLfloat x, GLfloat y)
 {
    DISPATCH(WindowPos2fMESA, (x, y), (F, "glWindowPos2fMESA(%f, %f);\n", x, y));
 }
 
+KEYWORD1 void KEYWORD2 NAME(WindowPos2fv)(const GLfloat * v)
+{
+   DISPATCH(WindowPos2fvMESA, (v), (F, "glWindowPos2fv(%p);\n", (const void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(WindowPos2fvARB)(const GLfloat * v)
+{
+   DISPATCH(WindowPos2fvMESA, (v), (F, "glWindowPos2fvARB(%p);\n", (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(WindowPos2fvMESA)(const GLfloat * v)
 {
    DISPATCH(WindowPos2fvMESA, (v), (F, "glWindowPos2fvMESA(%p);\n", (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(WindowPos2i)(GLint x, GLint y)
+{
+   DISPATCH(WindowPos2iMESA, (x, y), (F, "glWindowPos2i(%d, %d);\n", x, y));
+}
+
+KEYWORD1 void KEYWORD2 NAME(WindowPos2iARB)(GLint x, GLint y)
+{
+   DISPATCH(WindowPos2iMESA, (x, y), (F, "glWindowPos2iARB(%d, %d);\n", x, y));
+}
+
 KEYWORD1 void KEYWORD2 NAME(WindowPos2iMESA)(GLint x, GLint y)
 {
    DISPATCH(WindowPos2iMESA, (x, y), (F, "glWindowPos2iMESA(%d, %d);\n", x, y));
 }
 
+KEYWORD1 void KEYWORD2 NAME(WindowPos2iv)(const GLint * v)
+{
+   DISPATCH(WindowPos2ivMESA, (v), (F, "glWindowPos2iv(%p);\n", (const void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(WindowPos2ivARB)(const GLint * v)
+{
+   DISPATCH(WindowPos2ivMESA, (v), (F, "glWindowPos2ivARB(%p);\n", (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(WindowPos2ivMESA)(const GLint * v)
 {
    DISPATCH(WindowPos2ivMESA, (v), (F, "glWindowPos2ivMESA(%p);\n", (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(WindowPos2s)(GLshort x, GLshort y)
+{
+   DISPATCH(WindowPos2sMESA, (x, y), (F, "glWindowPos2s(%d, %d);\n", x, y));
+}
+
+KEYWORD1 void KEYWORD2 NAME(WindowPos2sARB)(GLshort x, GLshort y)
+{
+   DISPATCH(WindowPos2sMESA, (x, y), (F, "glWindowPos2sARB(%d, %d);\n", x, y));
+}
+
 KEYWORD1 void KEYWORD2 NAME(WindowPos2sMESA)(GLshort x, GLshort y)
 {
    DISPATCH(WindowPos2sMESA, (x, y), (F, "glWindowPos2sMESA(%d, %d);\n", x, y));
 }
 
+KEYWORD1 void KEYWORD2 NAME(WindowPos2sv)(const GLshort * v)
+{
+   DISPATCH(WindowPos2svMESA, (v), (F, "glWindowPos2sv(%p);\n", (const void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(WindowPos2svARB)(const GLshort * v)
+{
+   DISPATCH(WindowPos2svMESA, (v), (F, "glWindowPos2svARB(%p);\n", (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(WindowPos2svMESA)(const GLshort * v)
 {
    DISPATCH(WindowPos2svMESA, (v), (F, "glWindowPos2svMESA(%p);\n", (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(WindowPos3d)(GLdouble x, GLdouble y, GLdouble z)
+{
+   DISPATCH(WindowPos3dMESA, (x, y, z), (F, "glWindowPos3d(%f, %f, %f);\n", x, y, z));
+}
+
+KEYWORD1 void KEYWORD2 NAME(WindowPos3dARB)(GLdouble x, GLdouble y, GLdouble z)
+{
+   DISPATCH(WindowPos3dMESA, (x, y, z), (F, "glWindowPos3dARB(%f, %f, %f);\n", x, y, z));
+}
+
 KEYWORD1 void KEYWORD2 NAME(WindowPos3dMESA)(GLdouble x, GLdouble y, GLdouble z)
 {
    DISPATCH(WindowPos3dMESA, (x, y, z), (F, "glWindowPos3dMESA(%f, %f, %f);\n", x, y, z));
 }
 
+KEYWORD1 void KEYWORD2 NAME(WindowPos3dv)(const GLdouble * v)
+{
+   DISPATCH(WindowPos3dvMESA, (v), (F, "glWindowPos3dv(%p);\n", (const void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(WindowPos3dvARB)(const GLdouble * v)
+{
+   DISPATCH(WindowPos3dvMESA, (v), (F, "glWindowPos3dvARB(%p);\n", (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(WindowPos3dvMESA)(const GLdouble * v)
 {
    DISPATCH(WindowPos3dvMESA, (v), (F, "glWindowPos3dvMESA(%p);\n", (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(WindowPos3f)(GLfloat x, GLfloat y, GLfloat z)
+{
+   DISPATCH(WindowPos3fMESA, (x, y, z), (F, "glWindowPos3f(%f, %f, %f);\n", x, y, z));
+}
+
+KEYWORD1 void KEYWORD2 NAME(WindowPos3fARB)(GLfloat x, GLfloat y, GLfloat z)
+{
+   DISPATCH(WindowPos3fMESA, (x, y, z), (F, "glWindowPos3fARB(%f, %f, %f);\n", x, y, z));
+}
+
 KEYWORD1 void KEYWORD2 NAME(WindowPos3fMESA)(GLfloat x, GLfloat y, GLfloat z)
 {
    DISPATCH(WindowPos3fMESA, (x, y, z), (F, "glWindowPos3fMESA(%f, %f, %f);\n", x, y, z));
 }
 
+KEYWORD1 void KEYWORD2 NAME(WindowPos3fv)(const GLfloat * v)
+{
+   DISPATCH(WindowPos3fvMESA, (v), (F, "glWindowPos3fv(%p);\n", (const void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(WindowPos3fvARB)(const GLfloat * v)
+{
+   DISPATCH(WindowPos3fvMESA, (v), (F, "glWindowPos3fvARB(%p);\n", (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(WindowPos3fvMESA)(const GLfloat * v)
 {
    DISPATCH(WindowPos3fvMESA, (v), (F, "glWindowPos3fvMESA(%p);\n", (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(WindowPos3i)(GLint x, GLint y, GLint z)
+{
+   DISPATCH(WindowPos3iMESA, (x, y, z), (F, "glWindowPos3i(%d, %d, %d);\n", x, y, z));
+}
+
+KEYWORD1 void KEYWORD2 NAME(WindowPos3iARB)(GLint x, GLint y, GLint z)
+{
+   DISPATCH(WindowPos3iMESA, (x, y, z), (F, "glWindowPos3iARB(%d, %d, %d);\n", x, y, z));
+}
+
 KEYWORD1 void KEYWORD2 NAME(WindowPos3iMESA)(GLint x, GLint y, GLint z)
 {
    DISPATCH(WindowPos3iMESA, (x, y, z), (F, "glWindowPos3iMESA(%d, %d, %d);\n", x, y, z));
 }
 
+KEYWORD1 void KEYWORD2 NAME(WindowPos3iv)(const GLint * v)
+{
+   DISPATCH(WindowPos3ivMESA, (v), (F, "glWindowPos3iv(%p);\n", (const void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(WindowPos3ivARB)(const GLint * v)
+{
+   DISPATCH(WindowPos3ivMESA, (v), (F, "glWindowPos3ivARB(%p);\n", (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(WindowPos3ivMESA)(const GLint * v)
 {
    DISPATCH(WindowPos3ivMESA, (v), (F, "glWindowPos3ivMESA(%p);\n", (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(WindowPos3s)(GLshort x, GLshort y, GLshort z)
+{
+   DISPATCH(WindowPos3sMESA, (x, y, z), (F, "glWindowPos3s(%d, %d, %d);\n", x, y, z));
+}
+
+KEYWORD1 void KEYWORD2 NAME(WindowPos3sARB)(GLshort x, GLshort y, GLshort z)
+{
+   DISPATCH(WindowPos3sMESA, (x, y, z), (F, "glWindowPos3sARB(%d, %d, %d);\n", x, y, z));
+}
+
 KEYWORD1 void KEYWORD2 NAME(WindowPos3sMESA)(GLshort x, GLshort y, GLshort z)
 {
    DISPATCH(WindowPos3sMESA, (x, y, z), (F, "glWindowPos3sMESA(%d, %d, %d);\n", x, y, z));
 }
 
+KEYWORD1 void KEYWORD2 NAME(WindowPos3sv)(const GLshort * v)
+{
+   DISPATCH(WindowPos3svMESA, (v), (F, "glWindowPos3sv(%p);\n", (const void *) v));
+}
+
+KEYWORD1 void KEYWORD2 NAME(WindowPos3svARB)(const GLshort * v)
+{
+   DISPATCH(WindowPos3svMESA, (v), (F, "glWindowPos3svARB(%p);\n", (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(WindowPos3svMESA)(const GLshort * v)
 {
    DISPATCH(WindowPos3svMESA, (v), (F, "glWindowPos3svMESA(%p);\n", (const void *) v));
@@ -2755,11 +3345,21 @@ KEYWORD1 void KEYWORD2 NAME(WindowPos4svMESA)(const GLshort * v)
    DISPATCH(WindowPos4svMESA, (v), (F, "glWindowPos4svMESA(%p);\n", (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(BlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
+{
+   DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, "glBlendFuncSeparate(0x%x, 0x%x, 0x%x, 0x%x);\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha));
+}
+
 KEYWORD1 void KEYWORD2 NAME(BlendFuncSeparateEXT)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
    DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, "glBlendFuncSeparateEXT(0x%x, 0x%x, 0x%x, 0x%x);\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha));
 }
 
+KEYWORD1 void KEYWORD2 NAME(BlendFuncSeparateINGR)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
+{
+   DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, "glBlendFuncSeparateINGR(0x%x, 0x%x, 0x%x, 0x%x);\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha));
+}
+
 KEYWORD1 void KEYWORD2 NAME(IndexMaterialEXT)(GLenum face, GLenum mode)
 {
    DISPATCH(IndexMaterialEXT, (face, mode), (F, "glIndexMaterialEXT(0x%x, 0x%x);\n", face, mode));
@@ -2795,26 +3395,51 @@ KEYWORD1 void KEYWORD2 NAME(HintPGI)(GLenum target, GLint mode)
    DISPATCH(HintPGI, (target, mode), (F, "glHintPGI(0x%x, %d);\n", target, mode));
 }
 
+KEYWORD1 void KEYWORD2 NAME(FogCoordf)(GLfloat coord)
+{
+   DISPATCH(FogCoordfEXT, (coord), (F, "glFogCoordf(%f);\n", coord));
+}
+
 KEYWORD1 void KEYWORD2 NAME(FogCoordfEXT)(GLfloat coord)
 {
    DISPATCH(FogCoordfEXT, (coord), (F, "glFogCoordfEXT(%f);\n", coord));
 }
 
+KEYWORD1 void KEYWORD2 NAME(FogCoordfv)(const GLfloat * coord)
+{
+   DISPATCH(FogCoordfvEXT, (coord), (F, "glFogCoordfv(%p);\n", (const void *) coord));
+}
+
 KEYWORD1 void KEYWORD2 NAME(FogCoordfvEXT)(const GLfloat * coord)
 {
    DISPATCH(FogCoordfvEXT, (coord), (F, "glFogCoordfvEXT(%p);\n", (const void *) coord));
 }
 
+KEYWORD1 void KEYWORD2 NAME(FogCoordd)(GLdouble coord)
+{
+   DISPATCH(FogCoorddEXT, (coord), (F, "glFogCoordd(%f);\n", coord));
+}
+
 KEYWORD1 void KEYWORD2 NAME(FogCoorddEXT)(GLdouble coord)
 {
    DISPATCH(FogCoorddEXT, (coord), (F, "glFogCoorddEXT(%f);\n", coord));
 }
 
+KEYWORD1 void KEYWORD2 NAME(FogCoorddv)(const GLdouble * coord)
+{
+   DISPATCH(FogCoorddvEXT, (coord), (F, "glFogCoorddv(%p);\n", (const void *) coord));
+}
+
 KEYWORD1 void KEYWORD2 NAME(FogCoorddvEXT)(const GLdouble * coord)
 {
    DISPATCH(FogCoorddvEXT, (coord), (F, "glFogCoorddvEXT(%p);\n", (const void *) coord));
 }
 
+KEYWORD1 void KEYWORD2 NAME(FogCoordPointer)(GLenum type, GLsizei stride, const GLvoid * pointer)
+{
+   DISPATCH(FogCoordPointerEXT, (type, stride, pointer), (F, "glFogCoordPointer(0x%x, %d, %p);\n", type, stride, (const void *) pointer));
+}
+
 KEYWORD1 void KEYWORD2 NAME(FogCoordPointerEXT)(GLenum type, GLsizei stride, const GLvoid * pointer)
 {
    DISPATCH(FogCoordPointerEXT, (type, stride, pointer), (F, "glFogCoordPointerEXT(0x%x, %d, %p);\n", type, stride, (const void *) pointer));
@@ -2840,121 +3465,241 @@ KEYWORD1 void KEYWORD2 NAME(TbufferMask3DFX)(GLuint mask)
    DISPATCH(TbufferMask3DFX, (mask), (F, "glTbufferMask3DFX(%d);\n", mask));
 }
 
+KEYWORD1 void KEYWORD2 NAME(CompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data)
+{
+   DISPATCH(CompressedTexImage3DARB, (target, level, internalformat, width, height, depth, border, imageSize, data), (F, "glCompressedTexImage3D(0x%x, %d, 0x%x, %d, %d, %d, %d, %d, %p);\n", target, level, internalformat, width, height, depth, border, imageSize, (const void *) data));
+}
+
 KEYWORD1 void KEYWORD2 NAME(CompressedTexImage3DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data)
 {
    DISPATCH(CompressedTexImage3DARB, (target, level, internalformat, width, height, depth, border, imageSize, data), (F, "glCompressedTexImage3DARB(0x%x, %d, 0x%x, %d, %d, %d, %d, %d, %p);\n", target, level, internalformat, width, height, depth, border, imageSize, (const void *) data));
 }
 
+KEYWORD1 void KEYWORD2 NAME(CompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data)
+{
+   DISPATCH(CompressedTexImage2DARB, (target, level, internalformat, width, height, border, imageSize, data), (F, "glCompressedTexImage2D(0x%x, %d, 0x%x, %d, %d, %d, %d, %p);\n", target, level, internalformat, width, height, border, imageSize, (const void *) data));
+}
+
 KEYWORD1 void KEYWORD2 NAME(CompressedTexImage2DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data)
 {
    DISPATCH(CompressedTexImage2DARB, (target, level, internalformat, width, height, border, imageSize, data), (F, "glCompressedTexImage2DARB(0x%x, %d, 0x%x, %d, %d, %d, %d, %p);\n", target, level, internalformat, width, height, border, imageSize, (const void *) data));
 }
 
+KEYWORD1 void KEYWORD2 NAME(CompressedTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data)
+{
+   DISPATCH(CompressedTexImage1DARB, (target, level, internalformat, width, border, imageSize, data), (F, "glCompressedTexImage1D(0x%x, %d, 0x%x, %d, %d, %d, %p);\n", target, level, internalformat, width, border, imageSize, (const void *) data));
+}
+
 KEYWORD1 void KEYWORD2 NAME(CompressedTexImage1DARB)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data)
 {
    DISPATCH(CompressedTexImage1DARB, (target, level, internalformat, width, border, imageSize, data), (F, "glCompressedTexImage1DARB(0x%x, %d, 0x%x, %d, %d, %d, %p);\n", target, level, internalformat, width, border, imageSize, (const void *) data));
 }
 
+KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data)
+{
+   DISPATCH(CompressedTexSubImage3DARB, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data), (F, "glCompressedTexSubImage3D(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, %d, %p);\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, (const void *) data));
+}
+
 KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage3DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data)
 {
    DISPATCH(CompressedTexSubImage3DARB, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data), (F, "glCompressedTexSubImage3DARB(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, %d, %p);\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, (const void *) data));
 }
 
+KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data)
+{
+   DISPATCH(CompressedTexSubImage2DARB, (target, level, xoffset, yoffset, width, height, format, imageSize, data), (F, "glCompressedTexSubImage2D(0x%x, %d, %d, %d, %d, %d, 0x%x, %d, %p);\n", target, level, xoffset, yoffset, width, height, format, imageSize, (const void *) data));
+}
+
 KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage2DARB)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data)
 {
    DISPATCH(CompressedTexSubImage2DARB, (target, level, xoffset, yoffset, width, height, format, imageSize, data), (F, "glCompressedTexSubImage2DARB(0x%x, %d, %d, %d, %d, %d, 0x%x, %d, %p);\n", target, level, xoffset, yoffset, width, height, format, imageSize, (const void *) data));
 }
 
+KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data)
+{
+   DISPATCH(CompressedTexSubImage1DARB, (target, level, xoffset, width, format, imageSize, data), (F, "glCompressedTexSubImage1D(0x%x, %d, %d, %d, 0x%x, %d, %p);\n", target, level, xoffset, width, format, imageSize, (const void *) data));
+}
+
 KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage1DARB)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data)
 {
    DISPATCH(CompressedTexSubImage1DARB, (target, level, xoffset, width, format, imageSize, data), (F, "glCompressedTexSubImage1DARB(0x%x, %d, %d, %d, 0x%x, %d, %p);\n", target, level, xoffset, width, format, imageSize, (const void *) data));
 }
 
+KEYWORD1 void KEYWORD2 NAME(GetCompressedTexImage)(GLenum target, GLint level, GLvoid * img)
+{
+   DISPATCH(GetCompressedTexImageARB, (target, level, img), (F, "glGetCompressedTexImage(0x%x, %d, %p);\n", target, level, (const void *) img));
+}
+
 KEYWORD1 void KEYWORD2 NAME(GetCompressedTexImageARB)(GLenum target, GLint level, GLvoid * img)
 {
    DISPATCH(GetCompressedTexImageARB, (target, level, img), (F, "glGetCompressedTexImageARB(0x%x, %d, %p);\n", target, level, (const void *) img));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3b)(GLbyte red, GLbyte green, GLbyte blue)
+{
+   DISPATCH(SecondaryColor3bEXT, (red, green, blue), (F, "glSecondaryColor3b(%d, %d, %d);\n", red, green, blue));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3bEXT)(GLbyte red, GLbyte green, GLbyte blue)
 {
    DISPATCH(SecondaryColor3bEXT, (red, green, blue), (F, "glSecondaryColor3bEXT(%d, %d, %d);\n", red, green, blue));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3bv)(const GLbyte * v)
+{
+   DISPATCH(SecondaryColor3bvEXT, (v), (F, "glSecondaryColor3bv(%p);\n", (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3bvEXT)(const GLbyte * v)
 {
    DISPATCH(SecondaryColor3bvEXT, (v), (F, "glSecondaryColor3bvEXT(%p);\n", (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3d)(GLdouble red, GLdouble green, GLdouble blue)
+{
+   DISPATCH(SecondaryColor3dEXT, (red, green, blue), (F, "glSecondaryColor3d(%f, %f, %f);\n", red, green, blue));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3dEXT)(GLdouble red, GLdouble green, GLdouble blue)
 {
    DISPATCH(SecondaryColor3dEXT, (red, green, blue), (F, "glSecondaryColor3dEXT(%f, %f, %f);\n", red, green, blue));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3dv)(const GLdouble * v)
+{
+   DISPATCH(SecondaryColor3dvEXT, (v), (F, "glSecondaryColor3dv(%p);\n", (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3dvEXT)(const GLdouble * v)
 {
    DISPATCH(SecondaryColor3dvEXT, (v), (F, "glSecondaryColor3dvEXT(%p);\n", (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3f)(GLfloat red, GLfloat green, GLfloat blue)
+{
+   DISPATCH(SecondaryColor3fEXT, (red, green, blue), (F, "glSecondaryColor3f(%f, %f, %f);\n", red, green, blue));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3fEXT)(GLfloat red, GLfloat green, GLfloat blue)
 {
    DISPATCH(SecondaryColor3fEXT, (red, green, blue), (F, "glSecondaryColor3fEXT(%f, %f, %f);\n", red, green, blue));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3fv)(const GLfloat * v)
+{
+   DISPATCH(SecondaryColor3fvEXT, (v), (F, "glSecondaryColor3fv(%p);\n", (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3fvEXT)(const GLfloat * v)
 {
    DISPATCH(SecondaryColor3fvEXT, (v), (F, "glSecondaryColor3fvEXT(%p);\n", (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3i)(GLint red, GLint green, GLint blue)
+{
+   DISPATCH(SecondaryColor3iEXT, (red, green, blue), (F, "glSecondaryColor3i(%d, %d, %d);\n", red, green, blue));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3iEXT)(GLint red, GLint green, GLint blue)
 {
    DISPATCH(SecondaryColor3iEXT, (red, green, blue), (F, "glSecondaryColor3iEXT(%d, %d, %d);\n", red, green, blue));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3iv)(const GLint * v)
+{
+   DISPATCH(SecondaryColor3ivEXT, (v), (F, "glSecondaryColor3iv(%p);\n", (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3ivEXT)(const GLint * v)
 {
    DISPATCH(SecondaryColor3ivEXT, (v), (F, "glSecondaryColor3ivEXT(%p);\n", (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3s)(GLshort red, GLshort green, GLshort blue)
+{
+   DISPATCH(SecondaryColor3sEXT, (red, green, blue), (F, "glSecondaryColor3s(%d, %d, %d);\n", red, green, blue));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3sEXT)(GLshort red, GLshort green, GLshort blue)
 {
    DISPATCH(SecondaryColor3sEXT, (red, green, blue), (F, "glSecondaryColor3sEXT(%d, %d, %d);\n", red, green, blue));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3sv)(const GLshort * v)
+{
+   DISPATCH(SecondaryColor3svEXT, (v), (F, "glSecondaryColor3sv(%p);\n", (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3svEXT)(const GLshort * v)
 {
    DISPATCH(SecondaryColor3svEXT, (v), (F, "glSecondaryColor3svEXT(%p);\n", (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3ub)(GLubyte red, GLubyte green, GLubyte blue)
+{
+   DISPATCH(SecondaryColor3ubEXT, (red, green, blue), (F, "glSecondaryColor3ub(%d, %d, %d);\n", red, green, blue));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3ubEXT)(GLubyte red, GLubyte green, GLubyte blue)
 {
    DISPATCH(SecondaryColor3ubEXT, (red, green, blue), (F, "glSecondaryColor3ubEXT(%d, %d, %d);\n", red, green, blue));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3ubv)(const GLubyte * v)
+{
+   DISPATCH(SecondaryColor3ubvEXT, (v), (F, "glSecondaryColor3ubv(%p);\n", (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3ubvEXT)(const GLubyte * v)
 {
    DISPATCH(SecondaryColor3ubvEXT, (v), (F, "glSecondaryColor3ubvEXT(%p);\n", (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3ui)(GLuint red, GLuint green, GLuint blue)
+{
+   DISPATCH(SecondaryColor3uiEXT, (red, green, blue), (F, "glSecondaryColor3ui(%d, %d, %d);\n", red, green, blue));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3uiEXT)(GLuint red, GLuint green, GLuint blue)
 {
    DISPATCH(SecondaryColor3uiEXT, (red, green, blue), (F, "glSecondaryColor3uiEXT(%d, %d, %d);\n", red, green, blue));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3uiv)(const GLuint * v)
+{
+   DISPATCH(SecondaryColor3uivEXT, (v), (F, "glSecondaryColor3uiv(%p);\n", (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3uivEXT)(const GLuint * v)
 {
    DISPATCH(SecondaryColor3uivEXT, (v), (F, "glSecondaryColor3uivEXT(%p);\n", (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3us)(GLushort red, GLushort green, GLushort blue)
+{
+   DISPATCH(SecondaryColor3usEXT, (red, green, blue), (F, "glSecondaryColor3us(%d, %d, %d);\n", red, green, blue));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3usEXT)(GLushort red, GLushort green, GLushort blue)
 {
    DISPATCH(SecondaryColor3usEXT, (red, green, blue), (F, "glSecondaryColor3usEXT(%d, %d, %d);\n", red, green, blue));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColor3usv)(const GLushort * v)
+{
+   DISPATCH(SecondaryColor3usvEXT, (v), (F, "glSecondaryColor3usv(%p);\n", (const void *) v));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SecondaryColor3usvEXT)(const GLushort * v)
 {
    DISPATCH(SecondaryColor3usvEXT, (v), (F, "glSecondaryColor3usvEXT(%p);\n", (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(SecondaryColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
+{
+   DISPATCH(SecondaryColorPointerEXT, (size, type, stride, pointer), (F, "glSecondaryColorPointer(%d, 0x%x, %d, %p);\n", size, type, stride, (const void *) pointer));
+}
+
 KEYWORD1 void KEYWORD2 NAME(SecondaryColorPointerEXT)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
 {
    DISPATCH(SecondaryColorPointerEXT, (size, type, stride, pointer), (F, "glSecondaryColorPointerEXT(%d, 0x%x, %d, %p);\n", size, type, stride, (const void *) pointer));
@@ -2965,11 +3710,21 @@ KEYWORD1 GLboolean KEYWORD2 NAME(AreProgramsResidentNV)(GLsizei n, const GLuint
    RETURN_DISPATCH(AreProgramsResidentNV, (n, ids, residences), (F, "glAreProgramsResidentNV(%d, %p, %p);\n", n, (const void *) ids, (const void *) residences));
 }
 
+KEYWORD1 void KEYWORD2 NAME(BindProgramARB)(GLenum target, GLuint id)
+{
+   DISPATCH(BindProgramNV, (target, id), (F, "glBindProgramARB(0x%x, %d);\n", target, id));
+}
+
 KEYWORD1 void KEYWORD2 NAME(BindProgramNV)(GLenum target, GLuint id)
 {
    DISPATCH(BindProgramNV, (target, id), (F, "glBindProgramNV(0x%x, %d);\n", target, id));
 }
 
+KEYWORD1 void KEYWORD2 NAME(DeleteProgramsARB)(GLsizei n, const GLuint * ids)
+{
+   DISPATCH(DeleteProgramsNV, (n, ids), (F, "glDeleteProgramsARB(%d, %p);\n", n, (const void *) ids));
+}
+
 KEYWORD1 void KEYWORD2 NAME(DeleteProgramsNV)(GLsizei n, const GLuint * ids)
 {
    DISPATCH(DeleteProgramsNV, (n, ids), (F, "glDeleteProgramsNV(%d, %p);\n", n, (const void *) ids));
@@ -2980,6 +3735,11 @@ KEYWORD1 void KEYWORD2 NAME(ExecuteProgramNV)(GLenum target, GLuint id, const GL
    DISPATCH(ExecuteProgramNV, (target, id, params), (F, "glExecuteProgramNV(0x%x, %d, %p);\n", target, id, (const void *) params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(GenProgramsARB)(GLsizei n, GLuint * ids)
+{
+   DISPATCH(GenProgramsNV, (n, ids), (F, "glGenProgramsARB(%d, %p);\n", n, (const void *) ids));
+}
+
 KEYWORD1 void KEYWORD2 NAME(GenProgramsNV)(GLsizei n, GLuint * ids)
 {
    DISPATCH(GenProgramsNV, (n, ids), (F, "glGenProgramsNV(%d, %p);\n", n, (const void *) ids));
@@ -3025,11 +3785,21 @@ KEYWORD1 void KEYWORD2 NAME(GetVertexAttribivARB)(GLuint index, GLenum pname, GL
    DISPATCH(GetVertexAttribivARB, (index, pname, params), (F, "glGetVertexAttribivARB(%d, 0x%x, %p);\n", index, pname, (const void *) params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(GetVertexAttribPointervARB)(GLuint index, GLenum pname, GLvoid ** pointer)
+{
+   DISPATCH(GetVertexAttribPointervNV, (index, pname, pointer), (F, "glGetVertexAttribPointervARB(%d, 0x%x, %p);\n", index, pname, (const void *) pointer));
+}
+
 KEYWORD1 void KEYWORD2 NAME(GetVertexAttribPointervNV)(GLuint index, GLenum pname, GLvoid ** pointer)
 {
    DISPATCH(GetVertexAttribPointervNV, (index, pname, pointer), (F, "glGetVertexAttribPointervNV(%d, 0x%x, %p);\n", index, pname, (const void *) pointer));
 }
 
+KEYWORD1 GLboolean KEYWORD2 NAME(IsProgramARB)(GLuint id)
+{
+   RETURN_DISPATCH(IsProgramNV, (id), (F, "glIsProgramARB(%d);\n", id));
+}
+
 KEYWORD1 GLboolean KEYWORD2 NAME(IsProgramNV)(GLuint id)
 {
    RETURN_DISPATCH(IsProgramNV, (id), (F, "glIsProgramNV(%d);\n", id));
@@ -3280,21 +4050,41 @@ KEYWORD1 void KEYWORD2 NAME(VertexAttribs4ubvNV)(GLuint index, GLsizei n, const
    DISPATCH(VertexAttribs4ubvNV, (index, n, v), (F, "glVertexAttribs4ubvNV(%d, %d, %p);\n", index, n, (const void *) v));
 }
 
+KEYWORD1 void KEYWORD2 NAME(PointParameteri)(GLenum pname, GLint params)
+{
+   DISPATCH(PointParameteriNV, (pname, params), (F, "glPointParameteri(0x%x, %d);\n", pname, params));
+}
+
 KEYWORD1 void KEYWORD2 NAME(PointParameteriNV)(GLenum pname, GLint params)
 {
    DISPATCH(PointParameteriNV, (pname, params), (F, "glPointParameteriNV(0x%x, %d);\n", pname, params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(PointParameteriv)(GLenum pname, const GLint * params)
+{
+   DISPATCH(PointParameterivNV, (pname, params), (F, "glPointParameteriv(0x%x, %p);\n", pname, (const void *) params));
+}
+
 KEYWORD1 void KEYWORD2 NAME(PointParameterivNV)(GLenum pname, const GLint * params)
 {
    DISPATCH(PointParameterivNV, (pname, params), (F, "glPointParameterivNV(0x%x, %p);\n", pname, (const void *) params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiDrawArrays)(GLenum mode, GLint * first, GLsizei * count, GLsizei primcount)
+{
+   DISPATCH(MultiDrawArraysEXT, (mode, first, count, primcount), (F, "glMultiDrawArrays(0x%x, %p, %p, %d);\n", mode, (const void *) first, (const void *) count, primcount));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiDrawArraysEXT)(GLenum mode, GLint * first, GLsizei * count, GLsizei primcount)
 {
    DISPATCH(MultiDrawArraysEXT, (mode, first, count, primcount), (F, "glMultiDrawArraysEXT(0x%x, %p, %p, %d);\n", mode, (const void *) first, (const void *) count, primcount));
 }
 
+KEYWORD1 void KEYWORD2 NAME(MultiDrawElements)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount)
+{
+   DISPATCH(MultiDrawElementsEXT, (mode, count, type, indices, primcount), (F, "glMultiDrawElements(0x%x, %p, 0x%x, %p, %d);\n", mode, (const void *) count, type, (const void *) indices, primcount));
+}
+
 KEYWORD1 void KEYWORD2 NAME(MultiDrawElementsEXT)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount)
 {
    DISPATCH(MultiDrawElementsEXT, (mode, count, type, indices, primcount), (F, "glMultiDrawElementsEXT(0x%x, %p, 0x%x, %p, %d);\n", mode, (const void *) count, type, (const void *) indices, primcount));
@@ -3510,56 +4300,111 @@ KEYWORD1 void KEYWORD2 NAME(GetProgramNamedParameterdvNV)(GLuint id, GLsizei len
    DISPATCH(GetProgramNamedParameterdvNV, (id, len, name, params), (F, "glGetProgramNamedParameterdvNV(%d, %d, %p, %p);\n", id, len, (const void *) name, (const void *) params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(BindBuffer)(GLenum target, GLuint buffer)
+{
+   DISPATCH(BindBufferARB, (target, buffer), (F, "glBindBuffer(0x%x, %d);\n", target, buffer));
+}
+
 KEYWORD1 void KEYWORD2 NAME(BindBufferARB)(GLenum target, GLuint buffer)
 {
    DISPATCH(BindBufferARB, (target, buffer), (F, "glBindBufferARB(0x%x, %d);\n", target, buffer));
 }
 
+KEYWORD1 void KEYWORD2 NAME(BufferData)(GLenum target, GLsizeiptrARB size, const GLvoid * data, GLenum usage)
+{
+   DISPATCH(BufferDataARB, (target, size, data, usage), (F, "glBufferData(0x%x, %d, %p, 0x%x);\n", target, size, (const void *) data, usage));
+}
+
 KEYWORD1 void KEYWORD2 NAME(BufferDataARB)(GLenum target, GLsizeiptrARB size, const GLvoid * data, GLenum usage)
 {
    DISPATCH(BufferDataARB, (target, size, data, usage), (F, "glBufferDataARB(0x%x, %d, %p, 0x%x);\n", target, size, (const void *) data, usage));
 }
 
+KEYWORD1 void KEYWORD2 NAME(BufferSubData)(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid * data)
+{
+   DISPATCH(BufferSubDataARB, (target, offset, size, data), (F, "glBufferSubData(0x%x, %d, %d, %p);\n", target, offset, size, (const void *) data));
+}
+
 KEYWORD1 void KEYWORD2 NAME(BufferSubDataARB)(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid * data)
 {
    DISPATCH(BufferSubDataARB, (target, offset, size, data), (F, "glBufferSubDataARB(0x%x, %d, %d, %p);\n", target, offset, size, (const void *) data));
 }
 
+KEYWORD1 void KEYWORD2 NAME(DeleteBuffers)(GLsizei n, const GLuint * buffer)
+{
+   DISPATCH(DeleteBuffersARB, (n, buffer), (F, "glDeleteBuffers(%d, %p);\n", n, (const void *) buffer));
+}
+
 KEYWORD1 void KEYWORD2 NAME(DeleteBuffersARB)(GLsizei n, const GLuint * buffer)
 {
    DISPATCH(DeleteBuffersARB, (n, buffer), (F, "glDeleteBuffersARB(%d, %p);\n", n, (const void *) buffer));
 }
 
+KEYWORD1 void KEYWORD2 NAME(GenBuffers)(GLsizei n, GLuint * buffer)
+{
+   DISPATCH(GenBuffersARB, (n, buffer), (F, "glGenBuffers(%d, %p);\n", n, (const void *) buffer));
+}
+
 KEYWORD1 void KEYWORD2 NAME(GenBuffersARB)(GLsizei n, GLuint * buffer)
 {
    DISPATCH(GenBuffersARB, (n, buffer), (F, "glGenBuffersARB(%d, %p);\n", n, (const void *) buffer));
 }
 
+KEYWORD1 void KEYWORD2 NAME(GetBufferParameteriv)(GLenum target, GLenum pname, GLint * params)
+{
+   DISPATCH(GetBufferParameterivARB, (target, pname, params), (F, "glGetBufferParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
+}
+
 KEYWORD1 void KEYWORD2 NAME(GetBufferParameterivARB)(GLenum target, GLenum pname, GLint * params)
 {
    DISPATCH(GetBufferParameterivARB, (target, pname, params), (F, "glGetBufferParameterivARB(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(GetBufferPointerv)(GLenum target, GLenum pname, GLvoid ** params)
+{
+   DISPATCH(GetBufferPointervARB, (target, pname, params), (F, "glGetBufferPointerv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
+}
+
 KEYWORD1 void KEYWORD2 NAME(GetBufferPointervARB)(GLenum target, GLenum pname, GLvoid ** params)
 {
    DISPATCH(GetBufferPointervARB, (target, pname, params), (F, "glGetBufferPointervARB(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(GetBufferSubData)(GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid * data)
+{
+   DISPATCH(GetBufferSubDataARB, (target, offset, size, data), (F, "glGetBufferSubData(0x%x, %d, %d, %p);\n", target, offset, size, (const void *) data));
+}
+
 KEYWORD1 void KEYWORD2 NAME(GetBufferSubDataARB)(GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid * data)
 {
    DISPATCH(GetBufferSubDataARB, (target, offset, size, data), (F, "glGetBufferSubDataARB(0x%x, %d, %d, %p);\n", target, offset, size, (const void *) data));
 }
 
+KEYWORD1 GLboolean KEYWORD2 NAME(IsBuffer)(GLuint buffer)
+{
+   RETURN_DISPATCH(IsBufferARB, (buffer), (F, "glIsBuffer(%d);\n", buffer));
+}
+
 KEYWORD1 GLboolean KEYWORD2 NAME(IsBufferARB)(GLuint buffer)
 {
    RETURN_DISPATCH(IsBufferARB, (buffer), (F, "glIsBufferARB(%d);\n", buffer));
 }
 
+KEYWORD1 GLvoid * KEYWORD2 NAME(MapBuffer)(GLenum target, GLenum access)
+{
+   RETURN_DISPATCH(MapBufferARB, (target, access), (F, "glMapBuffer(0x%x, 0x%x);\n", target, access));
+}
+
 KEYWORD1 GLvoid * KEYWORD2 NAME(MapBufferARB)(GLenum target, GLenum access)
 {
    RETURN_DISPATCH(MapBufferARB, (target, access), (F, "glMapBufferARB(0x%x, 0x%x);\n", target, access));
 }
 
+KEYWORD1 GLboolean KEYWORD2 NAME(UnmapBuffer)(GLenum target)
+{
+   RETURN_DISPATCH(UnmapBufferARB, (target), (F, "glUnmapBuffer(0x%x);\n", target));
+}
+
 KEYWORD1 GLboolean KEYWORD2 NAME(UnmapBufferARB)(GLenum target)
 {
    RETURN_DISPATCH(UnmapBufferARB, (target), (F, "glUnmapBufferARB(0x%x);\n", target));
@@ -3570,41 +4415,81 @@ KEYWORD1 void KEYWORD2 NAME(DepthBoundsEXT)(GLclampd zmin, GLclampd zmax)
    DISPATCH(DepthBoundsEXT, (zmin, zmax), (F, "glDepthBoundsEXT(%f, %f);\n", zmin, zmax));
 }
 
+KEYWORD1 void KEYWORD2 NAME(GenQueries)(GLsizei n, GLuint * ids)
+{
+   DISPATCH(GenQueriesARB, (n, ids), (F, "glGenQueries(%d, %p);\n", n, (const void *) ids));
+}
+
 KEYWORD1 void KEYWORD2 NAME(GenQueriesARB)(GLsizei n, GLuint * ids)
 {
    DISPATCH(GenQueriesARB, (n, ids), (F, "glGenQueriesARB(%d, %p);\n", n, (const void *) ids));
 }
 
+KEYWORD1 void KEYWORD2 NAME(DeleteQueries)(GLsizei n, const GLuint * ids)
+{
+   DISPATCH(DeleteQueriesARB, (n, ids), (F, "glDeleteQueries(%d, %p);\n", n, (const void *) ids));
+}
+
 KEYWORD1 void KEYWORD2 NAME(DeleteQueriesARB)(GLsizei n, const GLuint * ids)
 {
    DISPATCH(DeleteQueriesARB, (n, ids), (F, "glDeleteQueriesARB(%d, %p);\n", n, (const void *) ids));
 }
 
+KEYWORD1 GLboolean KEYWORD2 NAME(IsQuery)(GLuint id)
+{
+   RETURN_DISPATCH(IsQueryARB, (id), (F, "glIsQuery(%d);\n", id));
+}
+
 KEYWORD1 GLboolean KEYWORD2 NAME(IsQueryARB)(GLuint id)
 {
    RETURN_DISPATCH(IsQueryARB, (id), (F, "glIsQueryARB(%d);\n", id));
 }
 
+KEYWORD1 void KEYWORD2 NAME(BeginQuery)(GLenum target, GLuint id)
+{
+   DISPATCH(BeginQueryARB, (target, id), (F, "glBeginQuery(0x%x, %d);\n", target, id));
+}
+
 KEYWORD1 void KEYWORD2 NAME(BeginQueryARB)(GLenum target, GLuint id)
 {
    DISPATCH(BeginQueryARB, (target, id), (F, "glBeginQueryARB(0x%x, %d);\n", target, id));
 }
 
+KEYWORD1 void KEYWORD2 NAME(EndQuery)(GLenum target)
+{
+   DISPATCH(EndQueryARB, (target), (F, "glEndQuery(0x%x);\n", target));
+}
+
 KEYWORD1 void KEYWORD2 NAME(EndQueryARB)(GLenum target)
 {
    DISPATCH(EndQueryARB, (target), (F, "glEndQueryARB(0x%x);\n", target));
 }
 
+KEYWORD1 void KEYWORD2 NAME(GetQueryiv)(GLenum target, GLenum pname, GLint * params)
+{
+   DISPATCH(GetQueryivARB, (target, pname, params), (F, "glGetQueryiv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
+}
+
 KEYWORD1 void KEYWORD2 NAME(GetQueryivARB)(GLenum target, GLenum pname, GLint * params)
 {
    DISPATCH(GetQueryivARB, (target, pname, params), (F, "glGetQueryivARB(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(GetQueryObjectiv)(GLuint id, GLenum pname, GLint * params)
+{
+   DISPATCH(GetQueryObjectivARB, (id, pname, params), (F, "glGetQueryObjectiv(%d, 0x%x, %p);\n", id, pname, (const void *) params));
+}
+
 KEYWORD1 void KEYWORD2 NAME(GetQueryObjectivARB)(GLuint id, GLenum pname, GLint * params)
 {
    DISPATCH(GetQueryObjectivARB, (id, pname, params), (F, "glGetQueryObjectivARB(%d, 0x%x, %p);\n", id, pname, (const void *) params));
 }
 
+KEYWORD1 void KEYWORD2 NAME(GetQueryObjectuiv)(GLuint id, GLenum pname, GLuint * params)
+{
+   DISPATCH(GetQueryObjectuivARB, (id, pname, params), (F, "glGetQueryObjectuiv(%d, 0x%x, %p);\n", id, pname, (const void *) params));
+}
+
 KEYWORD1 void KEYWORD2 NAME(GetQueryObjectuivARB)(GLuint id, GLenum pname, GLuint * params)
 {
    DISPATCH(GetQueryObjectuivARB, (id, pname, params), (F, "glGetQueryObjectuivARB(%d, 0x%x, %p);\n", id, pname, (const void *) params));
@@ -3625,6 +4510,11 @@ KEYWORD1 void KEYWORD2 NAME(BlendEquationSeparateEXT)(GLenum modeRGB, GLenum mod
    DISPATCH(BlendEquationSeparateEXT, (modeRGB, modeA), (F, "glBlendEquationSeparateEXT(0x%x, 0x%x);\n", modeRGB, modeA));
 }
 
+KEYWORD1 void KEYWORD2 NAME(BlendEquationSeparateATI)(GLenum modeRGB, GLenum modeA)
+{
+   DISPATCH(BlendEquationSeparateEXT, (modeRGB, modeA), (F, "glBlendEquationSeparateATI(0x%x, 0x%x);\n", modeRGB, modeA));
+}
+
 KEYWORD1 void KEYWORD2 NAME(DeleteObjectARB)(GLhandleARB obj)
 {
    DISPATCH(DeleteObjectARB, (obj), (F, "glDeleteObjectARB(%d);\n", obj));
@@ -4150,896 +5040,6 @@ KEYWORD1 void KEYWORD2 NAME(StencilMaskSeparate)(GLenum face, GLuint mask)
    DISPATCH(StencilMaskSeparate, (face, mask), (F, "glStencilMaskSeparate(0x%x, %d);\n", face, mask));
 }
 
-KEYWORD1 void KEYWORD2 NAME(ActiveTexture)(GLenum texture)
-{
-   DISPATCH(ActiveTextureARB, (texture), (F, "glActiveTexture(0x%x);\n", texture));
-}
-
-KEYWORD1 void KEYWORD2 NAME(ClientActiveTexture)(GLenum texture)
-{
-   DISPATCH(ClientActiveTextureARB, (texture), (F, "glClientActiveTexture(0x%x);\n", texture));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1d)(GLenum target, GLdouble s)
-{
-   DISPATCH(MultiTexCoord1dARB, (target, s), (F, "glMultiTexCoord1d(0x%x, %f);\n", target, s));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1dv)(GLenum target, const GLdouble * v)
-{
-   DISPATCH(MultiTexCoord1dvARB, (target, v), (F, "glMultiTexCoord1dv(0x%x, %p);\n", target, (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1f)(GLenum target, GLfloat s)
-{
-   DISPATCH(MultiTexCoord1fARB, (target, s), (F, "glMultiTexCoord1f(0x%x, %f);\n", target, s));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1fv)(GLenum target, const GLfloat * v)
-{
-   DISPATCH(MultiTexCoord1fvARB, (target, v), (F, "glMultiTexCoord1fv(0x%x, %p);\n", target, (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1i)(GLenum target, GLint s)
-{
-   DISPATCH(MultiTexCoord1iARB, (target, s), (F, "glMultiTexCoord1i(0x%x, %d);\n", target, s));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1iv)(GLenum target, const GLint * v)
-{
-   DISPATCH(MultiTexCoord1ivARB, (target, v), (F, "glMultiTexCoord1iv(0x%x, %p);\n", target, (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1s)(GLenum target, GLshort s)
-{
-   DISPATCH(MultiTexCoord1sARB, (target, s), (F, "glMultiTexCoord1s(0x%x, %d);\n", target, s));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord1sv)(GLenum target, const GLshort * v)
-{
-   DISPATCH(MultiTexCoord1svARB, (target, v), (F, "glMultiTexCoord1sv(0x%x, %p);\n", target, (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2d)(GLenum target, GLdouble s, GLdouble t)
-{
-   DISPATCH(MultiTexCoord2dARB, (target, s, t), (F, "glMultiTexCoord2d(0x%x, %f, %f);\n", target, s, t));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2dv)(GLenum target, const GLdouble * v)
-{
-   DISPATCH(MultiTexCoord2dvARB, (target, v), (F, "glMultiTexCoord2dv(0x%x, %p);\n", target, (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2f)(GLenum target, GLfloat s, GLfloat t)
-{
-   DISPATCH(MultiTexCoord2fARB, (target, s, t), (F, "glMultiTexCoord2f(0x%x, %f, %f);\n", target, s, t));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2fv)(GLenum target, const GLfloat * v)
-{
-   DISPATCH(MultiTexCoord2fvARB, (target, v), (F, "glMultiTexCoord2fv(0x%x, %p);\n", target, (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2i)(GLenum target, GLint s, GLint t)
-{
-   DISPATCH(MultiTexCoord2iARB, (target, s, t), (F, "glMultiTexCoord2i(0x%x, %d, %d);\n", target, s, t));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2iv)(GLenum target, const GLint * v)
-{
-   DISPATCH(MultiTexCoord2ivARB, (target, v), (F, "glMultiTexCoord2iv(0x%x, %p);\n", target, (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2s)(GLenum target, GLshort s, GLshort t)
-{
-   DISPATCH(MultiTexCoord2sARB, (target, s, t), (F, "glMultiTexCoord2s(0x%x, %d, %d);\n", target, s, t));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord2sv)(GLenum target, const GLshort * v)
-{
-   DISPATCH(MultiTexCoord2svARB, (target, v), (F, "glMultiTexCoord2sv(0x%x, %p);\n", target, (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3d)(GLenum target, GLdouble s, GLdouble t, GLdouble r)
-{
-   DISPATCH(MultiTexCoord3dARB, (target, s, t, r), (F, "glMultiTexCoord3d(0x%x, %f, %f, %f);\n", target, s, t, r));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3dv)(GLenum target, const GLdouble * v)
-{
-   DISPATCH(MultiTexCoord3dvARB, (target, v), (F, "glMultiTexCoord3dv(0x%x, %p);\n", target, (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3f)(GLenum target, GLfloat s, GLfloat t, GLfloat r)
-{
-   DISPATCH(MultiTexCoord3fARB, (target, s, t, r), (F, "glMultiTexCoord3f(0x%x, %f, %f, %f);\n", target, s, t, r));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3fv)(GLenum target, const GLfloat * v)
-{
-   DISPATCH(MultiTexCoord3fvARB, (target, v), (F, "glMultiTexCoord3fv(0x%x, %p);\n", target, (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3i)(GLenum target, GLint s, GLint t, GLint r)
-{
-   DISPATCH(MultiTexCoord3iARB, (target, s, t, r), (F, "glMultiTexCoord3i(0x%x, %d, %d, %d);\n", target, s, t, r));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3iv)(GLenum target, const GLint * v)
-{
-   DISPATCH(MultiTexCoord3ivARB, (target, v), (F, "glMultiTexCoord3iv(0x%x, %p);\n", target, (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3s)(GLenum target, GLshort s, GLshort t, GLshort r)
-{
-   DISPATCH(MultiTexCoord3sARB, (target, s, t, r), (F, "glMultiTexCoord3s(0x%x, %d, %d, %d);\n", target, s, t, r));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord3sv)(GLenum target, const GLshort * v)
-{
-   DISPATCH(MultiTexCoord3svARB, (target, v), (F, "glMultiTexCoord3sv(0x%x, %p);\n", target, (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4d)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
-{
-   DISPATCH(MultiTexCoord4dARB, (target, s, t, r, q), (F, "glMultiTexCoord4d(0x%x, %f, %f, %f, %f);\n", target, s, t, r, q));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4dv)(GLenum target, const GLdouble * v)
-{
-   DISPATCH(MultiTexCoord4dvARB, (target, v), (F, "glMultiTexCoord4dv(0x%x, %p);\n", target, (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4f)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
-{
-   DISPATCH(MultiTexCoord4fARB, (target, s, t, r, q), (F, "glMultiTexCoord4f(0x%x, %f, %f, %f, %f);\n", target, s, t, r, q));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4fv)(GLenum target, const GLfloat * v)
-{
-   DISPATCH(MultiTexCoord4fvARB, (target, v), (F, "glMultiTexCoord4fv(0x%x, %p);\n", target, (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4i)(GLenum target, GLint s, GLint t, GLint r, GLint q)
-{
-   DISPATCH(MultiTexCoord4iARB, (target, s, t, r, q), (F, "glMultiTexCoord4i(0x%x, %d, %d, %d, %d);\n", target, s, t, r, q));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4iv)(GLenum target, const GLint * v)
-{
-   DISPATCH(MultiTexCoord4ivARB, (target, v), (F, "glMultiTexCoord4iv(0x%x, %p);\n", target, (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4s)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
-{
-   DISPATCH(MultiTexCoord4sARB, (target, s, t, r, q), (F, "glMultiTexCoord4s(0x%x, %d, %d, %d, %d);\n", target, s, t, r, q));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiTexCoord4sv)(GLenum target, const GLshort * v)
-{
-   DISPATCH(MultiTexCoord4svARB, (target, v), (F, "glMultiTexCoord4sv(0x%x, %p);\n", target, (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(LoadTransposeMatrixf)(const GLfloat * m)
-{
-   DISPATCH(LoadTransposeMatrixfARB, (m), (F, "glLoadTransposeMatrixf(%p);\n", (const void *) m));
-}
-
-KEYWORD1 void KEYWORD2 NAME(LoadTransposeMatrixd)(const GLdouble * m)
-{
-   DISPATCH(LoadTransposeMatrixdARB, (m), (F, "glLoadTransposeMatrixd(%p);\n", (const void *) m));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultTransposeMatrixf)(const GLfloat * m)
-{
-   DISPATCH(MultTransposeMatrixfARB, (m), (F, "glMultTransposeMatrixf(%p);\n", (const void *) m));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultTransposeMatrixd)(const GLdouble * m)
-{
-   DISPATCH(MultTransposeMatrixdARB, (m), (F, "glMultTransposeMatrixd(%p);\n", (const void *) m));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SampleCoverage)(GLclampf value, GLboolean invert)
-{
-   DISPATCH(SampleCoverageARB, (value, invert), (F, "glSampleCoverage(%f, %d);\n", value, invert));
-}
-
-KEYWORD1 void KEYWORD2 NAME(CompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data)
-{
-   DISPATCH(CompressedTexImage3DARB, (target, level, internalformat, width, height, depth, border, imageSize, data), (F, "glCompressedTexImage3D(0x%x, %d, 0x%x, %d, %d, %d, %d, %d, %p);\n", target, level, internalformat, width, height, depth, border, imageSize, (const void *) data));
-}
-
-KEYWORD1 void KEYWORD2 NAME(CompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data)
-{
-   DISPATCH(CompressedTexImage2DARB, (target, level, internalformat, width, height, border, imageSize, data), (F, "glCompressedTexImage2D(0x%x, %d, 0x%x, %d, %d, %d, %d, %p);\n", target, level, internalformat, width, height, border, imageSize, (const void *) data));
-}
-
-KEYWORD1 void KEYWORD2 NAME(CompressedTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data)
-{
-   DISPATCH(CompressedTexImage1DARB, (target, level, internalformat, width, border, imageSize, data), (F, "glCompressedTexImage1D(0x%x, %d, 0x%x, %d, %d, %d, %p);\n", target, level, internalformat, width, border, imageSize, (const void *) data));
-}
-
-KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data)
-{
-   DISPATCH(CompressedTexSubImage3DARB, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data), (F, "glCompressedTexSubImage3D(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, %d, %p);\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, (const void *) data));
-}
-
-KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data)
-{
-   DISPATCH(CompressedTexSubImage2DARB, (target, level, xoffset, yoffset, width, height, format, imageSize, data), (F, "glCompressedTexSubImage2D(0x%x, %d, %d, %d, %d, %d, 0x%x, %d, %p);\n", target, level, xoffset, yoffset, width, height, format, imageSize, (const void *) data));
-}
-
-KEYWORD1 void KEYWORD2 NAME(CompressedTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data)
-{
-   DISPATCH(CompressedTexSubImage1DARB, (target, level, xoffset, width, format, imageSize, data), (F, "glCompressedTexSubImage1D(0x%x, %d, %d, %d, 0x%x, %d, %p);\n", target, level, xoffset, width, format, imageSize, (const void *) data));
-}
-
-KEYWORD1 void KEYWORD2 NAME(GetCompressedTexImage)(GLenum target, GLint level, GLvoid * img)
-{
-   DISPATCH(GetCompressedTexImageARB, (target, level, img), (F, "glGetCompressedTexImage(0x%x, %d, %p);\n", target, level, (const void *) img));
-}
-
-KEYWORD1 void KEYWORD2 NAME(BlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-   DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, "glBlendFuncSeparate(0x%x, 0x%x, 0x%x, 0x%x);\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha));
-}
-
-KEYWORD1 void KEYWORD2 NAME(FogCoordf)(GLfloat coord)
-{
-   DISPATCH(FogCoordfEXT, (coord), (F, "glFogCoordf(%f);\n", coord));
-}
-
-KEYWORD1 void KEYWORD2 NAME(FogCoordfv)(const GLfloat * coord)
-{
-   DISPATCH(FogCoordfvEXT, (coord), (F, "glFogCoordfv(%p);\n", (const void *) coord));
-}
-
-KEYWORD1 void KEYWORD2 NAME(FogCoordd)(GLdouble coord)
-{
-   DISPATCH(FogCoorddEXT, (coord), (F, "glFogCoordd(%f);\n", coord));
-}
-
-KEYWORD1 void KEYWORD2 NAME(FogCoorddv)(const GLdouble * coord)
-{
-   DISPATCH(FogCoorddvEXT, (coord), (F, "glFogCoorddv(%p);\n", (const void *) coord));
-}
-
-KEYWORD1 void KEYWORD2 NAME(FogCoordPointer)(GLenum type, GLsizei stride, const GLvoid * pointer)
-{
-   DISPATCH(FogCoordPointerEXT, (type, stride, pointer), (F, "glFogCoordPointer(0x%x, %d, %p);\n", type, stride, (const void *) pointer));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiDrawArrays)(GLenum mode, GLint * first, GLsizei * count, GLsizei primcount)
-{
-   DISPATCH(MultiDrawArraysEXT, (mode, first, count, primcount), (F, "glMultiDrawArrays(0x%x, %p, %p, %d);\n", mode, (const void *) first, (const void *) count, primcount));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MultiDrawElements)(GLenum mode, const GLsizei * count, GLenum type, const GLvoid ** indices, GLsizei primcount)
-{
-   DISPATCH(MultiDrawElementsEXT, (mode, count, type, indices, primcount), (F, "glMultiDrawElements(0x%x, %p, 0x%x, %p, %d);\n", mode, (const void *) count, type, (const void *) indices, primcount));
-}
-
-KEYWORD1 void KEYWORD2 NAME(PointParameterf)(GLenum pname, GLfloat param)
-{
-   DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterf(0x%x, %f);\n", pname, param));
-}
-
-KEYWORD1 void KEYWORD2 NAME(PointParameterfv)(GLenum pname, const GLfloat * params)
-{
-   DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfv(0x%x, %p);\n", pname, (const void *) params));
-}
-
-KEYWORD1 void KEYWORD2 NAME(PointParameteri)(GLenum pname, GLint param)
-{
-   DISPATCH(PointParameteriNV, (pname, param), (F, "glPointParameteri(0x%x, %d);\n", pname, param));
-}
-
-KEYWORD1 void KEYWORD2 NAME(PointParameteriv)(GLenum pname, const GLint * params)
-{
-   DISPATCH(PointParameterivNV, (pname, params), (F, "glPointParameteriv(0x%x, %p);\n", pname, (const void *) params));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SecondaryColor3b)(GLbyte red, GLbyte green, GLbyte blue)
-{
-   DISPATCH(SecondaryColor3bEXT, (red, green, blue), (F, "glSecondaryColor3b(%d, %d, %d);\n", red, green, blue));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SecondaryColor3bv)(const GLbyte * v)
-{
-   DISPATCH(SecondaryColor3bvEXT, (v), (F, "glSecondaryColor3bv(%p);\n", (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SecondaryColor3d)(GLdouble red, GLdouble green, GLdouble blue)
-{
-   DISPATCH(SecondaryColor3dEXT, (red, green, blue), (F, "glSecondaryColor3d(%f, %f, %f);\n", red, green, blue));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SecondaryColor3dv)(const GLdouble * v)
-{
-   DISPATCH(SecondaryColor3dvEXT, (v), (F, "glSecondaryColor3dv(%p);\n", (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SecondaryColor3f)(GLfloat red, GLfloat green, GLfloat blue)
-{
-   DISPATCH(SecondaryColor3fEXT, (red, green, blue), (F, "glSecondaryColor3f(%f, %f, %f);\n", red, green, blue));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SecondaryColor3fv)(const GLfloat * v)
-{
-   DISPATCH(SecondaryColor3fvEXT, (v), (F, "glSecondaryColor3fv(%p);\n", (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SecondaryColor3i)(GLint red, GLint green, GLint blue)
-{
-   DISPATCH(SecondaryColor3iEXT, (red, green, blue), (F, "glSecondaryColor3i(%d, %d, %d);\n", red, green, blue));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SecondaryColor3iv)(const GLint * v)
-{
-   DISPATCH(SecondaryColor3ivEXT, (v), (F, "glSecondaryColor3iv(%p);\n", (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SecondaryColor3s)(GLshort red, GLshort green, GLshort blue)
-{
-   DISPATCH(SecondaryColor3sEXT, (red, green, blue), (F, "glSecondaryColor3s(%d, %d, %d);\n", red, green, blue));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SecondaryColor3sv)(const GLshort * v)
-{
-   DISPATCH(SecondaryColor3svEXT, (v), (F, "glSecondaryColor3sv(%p);\n", (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SecondaryColor3ub)(GLubyte red, GLubyte green, GLubyte blue)
-{
-   DISPATCH(SecondaryColor3ubEXT, (red, green, blue), (F, "glSecondaryColor3ub(%d, %d, %d);\n", red, green, blue));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SecondaryColor3ubv)(const GLubyte * v)
-{
-   DISPATCH(SecondaryColor3ubvEXT, (v), (F, "glSecondaryColor3ubv(%p);\n", (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SecondaryColor3ui)(GLuint red, GLuint green, GLuint blue)
-{
-   DISPATCH(SecondaryColor3uiEXT, (red, green, blue), (F, "glSecondaryColor3ui(%d, %d, %d);\n", red, green, blue));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SecondaryColor3uiv)(const GLuint * v)
-{
-   DISPATCH(SecondaryColor3uivEXT, (v), (F, "glSecondaryColor3uiv(%p);\n", (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SecondaryColor3us)(GLushort red, GLushort green, GLushort blue)
-{
-   DISPATCH(SecondaryColor3usEXT, (red, green, blue), (F, "glSecondaryColor3us(%d, %d, %d);\n", red, green, blue));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SecondaryColor3usv)(const GLushort * v)
-{
-   DISPATCH(SecondaryColor3usvEXT, (v), (F, "glSecondaryColor3usv(%p);\n", (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SecondaryColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
-{
-   DISPATCH(SecondaryColorPointerEXT, (size, type, stride, pointer), (F, "glSecondaryColorPointer(%d, 0x%x, %d, %p);\n", size, type, stride, (const void *) pointer));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos2d)(GLdouble x, GLdouble y)
-{
-   DISPATCH(WindowPos2dMESA, (x, y), (F, "glWindowPos2d(%f, %f);\n", x, y));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos2dv)(const GLdouble * v)
-{
-   DISPATCH(WindowPos2dvMESA, (v), (F, "glWindowPos2dv(%p);\n", (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos2f)(GLfloat x, GLfloat y)
-{
-   DISPATCH(WindowPos2fMESA, (x, y), (F, "glWindowPos2f(%f, %f);\n", x, y));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos2fv)(const GLfloat * v)
-{
-   DISPATCH(WindowPos2fvMESA, (v), (F, "glWindowPos2fv(%p);\n", (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos2i)(GLint x, GLint y)
-{
-   DISPATCH(WindowPos2iMESA, (x, y), (F, "glWindowPos2i(%d, %d);\n", x, y));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos2iv)(const GLint * v)
-{
-   DISPATCH(WindowPos2ivMESA, (v), (F, "glWindowPos2iv(%p);\n", (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos2s)(GLshort x, GLshort y)
-{
-   DISPATCH(WindowPos2sMESA, (x, y), (F, "glWindowPos2s(%d, %d);\n", x, y));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos2sv)(const GLshort * v)
-{
-   DISPATCH(WindowPos2svMESA, (v), (F, "glWindowPos2sv(%p);\n", (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos3d)(GLdouble x, GLdouble y, GLdouble z)
-{
-   DISPATCH(WindowPos3dMESA, (x, y, z), (F, "glWindowPos3d(%f, %f, %f);\n", x, y, z));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos3dv)(const GLdouble * v)
-{
-   DISPATCH(WindowPos3dvMESA, (v), (F, "glWindowPos3dv(%p);\n", (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos3f)(GLfloat x, GLfloat y, GLfloat z)
-{
-   DISPATCH(WindowPos3fMESA, (x, y, z), (F, "glWindowPos3f(%f, %f, %f);\n", x, y, z));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos3fv)(const GLfloat * v)
-{
-   DISPATCH(WindowPos3fvMESA, (v), (F, "glWindowPos3fv(%p);\n", (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos3i)(GLint x, GLint y, GLint z)
-{
-   DISPATCH(WindowPos3iMESA, (x, y, z), (F, "glWindowPos3i(%d, %d, %d);\n", x, y, z));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos3iv)(const GLint * v)
-{
-   DISPATCH(WindowPos3ivMESA, (v), (F, "glWindowPos3iv(%p);\n", (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos3s)(GLshort x, GLshort y, GLshort z)
-{
-   DISPATCH(WindowPos3sMESA, (x, y, z), (F, "glWindowPos3s(%d, %d, %d);\n", x, y, z));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos3sv)(const GLshort * v)
-{
-   DISPATCH(WindowPos3svMESA, (v), (F, "glWindowPos3sv(%p);\n", (const void *) v));
-}
-
-KEYWORD1 void KEYWORD2 NAME(BindBuffer)(GLenum target, GLuint buffer)
-{
-   DISPATCH(BindBufferARB, (target, buffer), (F, "glBindBuffer(0x%x, %d);\n", target, buffer));
-}
-
-KEYWORD1 void KEYWORD2 NAME(BufferData)(GLenum target, GLsizeiptr size, const GLvoid * data, GLenum usage)
-{
-   DISPATCH(BufferDataARB, (target, size, data, usage), (F, "glBufferData(0x%x, %d, %p, 0x%x);\n", target, size, (const void *) data, usage));
-}
-
-KEYWORD1 void KEYWORD2 NAME(BufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data)
-{
-   DISPATCH(BufferSubDataARB, (target, offset, size, data), (F, "glBufferSubData(0x%x, %d, %d, %p);\n", target, offset, size, (const void *) data));
-}
-
-KEYWORD1 void KEYWORD2 NAME(DeleteBuffers)(GLsizei n, const GLuint * buffer)
-{
-   DISPATCH(DeleteBuffersARB, (n, buffer), (F, "glDeleteBuffers(%d, %p);\n", n, (const void *) buffer));
-}
-
-KEYWORD1 void KEYWORD2 NAME(GenBuffers)(GLsizei n, GLuint * buffer)
-{
-   DISPATCH(GenBuffersARB, (n, buffer), (F, "glGenBuffers(%d, %p);\n", n, (const void *) buffer));
-}
-
-KEYWORD1 void KEYWORD2 NAME(GetBufferParameteriv)(GLenum target, GLenum pname, GLint * params)
-{
-   DISPATCH(GetBufferParameterivARB, (target, pname, params), (F, "glGetBufferParameteriv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
-}
-
-KEYWORD1 void KEYWORD2 NAME(GetBufferPointerv)(GLenum target, GLenum pname, GLvoid ** params)
-{
-   DISPATCH(GetBufferPointervARB, (target, pname, params), (F, "glGetBufferPointerv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
-}
-
-KEYWORD1 void KEYWORD2 NAME(GetBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid * data)
-{
-   DISPATCH(GetBufferSubDataARB, (target, offset, size, data), (F, "glGetBufferSubData(0x%x, %d, %d, %p);\n", target, offset, size, (const void *) data));
-}
-
-KEYWORD1 GLboolean KEYWORD2 NAME(IsBuffer)(GLuint buffer)
-{
-   RETURN_DISPATCH(IsBufferARB, (buffer), (F, "glIsBuffer(%d);\n", buffer));
-}
-
-KEYWORD1 GLvoid * KEYWORD2 NAME(MapBuffer)(GLenum target, GLenum access)
-{
-   RETURN_DISPATCH(MapBufferARB, (target, access), (F, "glMapBuffer(0x%x, 0x%x);\n", target, access));
-}
-
-KEYWORD1 GLboolean KEYWORD2 NAME(UnmapBuffer)(GLenum target)
-{
-   RETURN_DISPATCH(UnmapBufferARB, (target), (F, "glUnmapBuffer(0x%x);\n", target));
-}
-
-KEYWORD1 void KEYWORD2 NAME(GenQueries)(GLsizei n, GLuint * ids)
-{
-   DISPATCH(GenQueriesARB, (n, ids), (F, "glGenQueries(%d, %p);\n", n, (const void *) ids));
-}
-
-KEYWORD1 void KEYWORD2 NAME(DeleteQueries)(GLsizei n, const GLuint * ids)
-{
-   DISPATCH(DeleteQueriesARB, (n, ids), (F, "glDeleteQueries(%d, %p);\n", n, (const void *) ids));
-}
-
-KEYWORD1 GLboolean KEYWORD2 NAME(IsQuery)(GLuint id)
-{
-   RETURN_DISPATCH(IsQueryARB, (id), (F, "glIsQuery(%d);\n", id));
-}
-
-KEYWORD1 void KEYWORD2 NAME(BeginQuery)(GLenum target, GLuint id)
-{
-   DISPATCH(BeginQueryARB, (target, id), (F, "glBeginQuery(0x%x, %d);\n", target, id));
-}
-
-KEYWORD1 void KEYWORD2 NAME(EndQuery)(GLenum target)
-{
-   DISPATCH(EndQueryARB, (target), (F, "glEndQuery(0x%x);\n", target));
-}
-
-KEYWORD1 void KEYWORD2 NAME(GetQueryiv)(GLenum target, GLenum pname, GLint * params)
-{
-   DISPATCH(GetQueryivARB, (target, pname, params), (F, "glGetQueryiv(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
-}
-
-KEYWORD1 void KEYWORD2 NAME(GetQueryObjectiv)(GLuint id, GLenum pname, GLint * params)
-{
-   DISPATCH(GetQueryObjectivARB, (id, pname, params), (F, "glGetQueryObjectiv(%d, 0x%x, %p);\n", id, pname, (const void *) params));
-}
-
-KEYWORD1 void KEYWORD2 NAME(GetQueryObjectuiv)(GLuint id, GLenum pname, GLuint * params)
-{
-   DISPATCH(GetQueryObjectuivARB, (id, pname, params), (F, "glGetQueryObjectuiv(%d, 0x%x, %p);\n", id, pname, (const void *) params));
-}
-
-KEYWORD1 void KEYWORD2 NAME(PointParameterfARB)(GLenum pname, GLfloat param)
-{
-   DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterfARB(0x%x, %f);\n", pname, param));
-}
-
-KEYWORD1 void KEYWORD2 NAME(PointParameterfvARB)(GLenum pname, const GLfloat * params)
-{
-   DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfvARB(0x%x, %p);\n", pname, (const void *) params));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos2dARB)(GLdouble x, GLdouble y)
-{
-   DISPATCH(WindowPos2dMESA, (x, y), (F, "glWindowPos2dARB(%f, %f);\n", x, y));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos2fARB)(GLfloat x, GLfloat y)
-{
-   DISPATCH(WindowPos2fMESA, (x, y), (F, "glWindowPos2fARB(%f, %f);\n", x, y));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos2iARB)(GLint x, GLint y)
-{
-   DISPATCH(WindowPos2iMESA, (x, y), (F, "glWindowPos2iARB(%d, %d);\n", x, y));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos2sARB)(GLshort x, GLshort y)
-{
-   DISPATCH(WindowPos2sMESA, (x, y), (F, "glWindowPos2sARB(%d, %d);\n", x, y));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos2dvARB)(const GLdouble * p)
-{
-   DISPATCH(WindowPos2dvMESA, (p), (F, "glWindowPos2dvARB(%p);\n", (const void *) p));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos2fvARB)(const GLfloat * p)
-{
-   DISPATCH(WindowPos2fvMESA, (p), (F, "glWindowPos2fvARB(%p);\n", (const void *) p));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos2ivARB)(const GLint * p)
-{
-   DISPATCH(WindowPos2ivMESA, (p), (F, "glWindowPos2ivARB(%p);\n", (const void *) p));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos2svARB)(const GLshort * p)
-{
-   DISPATCH(WindowPos2svMESA, (p), (F, "glWindowPos2svARB(%p);\n", (const void *) p));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos3dARB)(GLdouble x, GLdouble y, GLdouble z)
-{
-   DISPATCH(WindowPos3dMESA, (x, y, z), (F, "glWindowPos3dARB(%f, %f, %f);\n", x, y, z));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos3fARB)(GLfloat x, GLfloat y, GLfloat z)
-{
-   DISPATCH(WindowPos3fMESA, (x, y, z), (F, "glWindowPos3fARB(%f, %f, %f);\n", x, y, z));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos3iARB)(GLint x, GLint y, GLint z)
-{
-   DISPATCH(WindowPos3iMESA, (x, y, z), (F, "glWindowPos3iARB(%d, %d, %d);\n", x, y, z));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos3sARB)(GLshort x, GLshort y, GLshort z)
-{
-   DISPATCH(WindowPos3sMESA, (x, y, z), (F, "glWindowPos3sARB(%d, %d, %d);\n", x, y, z));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos3dvARB)(const GLdouble * p)
-{
-   DISPATCH(WindowPos3dvMESA, (p), (F, "glWindowPos3dvARB(%p);\n", (const void *) p));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos3fvARB)(const GLfloat * p)
-{
-   DISPATCH(WindowPos3fvMESA, (p), (F, "glWindowPos3fvARB(%p);\n", (const void *) p));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos3ivARB)(const GLint * p)
-{
-   DISPATCH(WindowPos3ivMESA, (p), (F, "glWindowPos3ivARB(%p);\n", (const void *) p));
-}
-
-KEYWORD1 void KEYWORD2 NAME(WindowPos3svARB)(const GLshort * p)
-{
-   DISPATCH(WindowPos3svMESA, (p), (F, "glWindowPos3svARB(%p);\n", (const void *) p));
-}
-
-KEYWORD1 void KEYWORD2 NAME(BindProgramARB)(GLenum target, GLuint program)
-{
-   DISPATCH(BindProgramNV, (target, program), (F, "glBindProgramARB(0x%x, %d);\n", target, program));
-}
-
-KEYWORD1 void KEYWORD2 NAME(DeleteProgramsARB)(GLsizei n, const GLuint * programs)
-{
-   DISPATCH(DeleteProgramsNV, (n, programs), (F, "glDeleteProgramsARB(%d, %p);\n", n, (const void *) programs));
-}
-
-KEYWORD1 void KEYWORD2 NAME(GenProgramsARB)(GLsizei n, GLuint * programs)
-{
-   DISPATCH(GenProgramsNV, (n, programs), (F, "glGenProgramsARB(%d, %p);\n", n, (const void *) programs));
-}
-
-KEYWORD1 GLboolean KEYWORD2 NAME(IsProgramARB)(GLuint program)
-{
-   RETURN_DISPATCH(IsProgramNV, (program), (F, "glIsProgramARB(%d);\n", program));
-}
-
-KEYWORD1 void KEYWORD2 NAME(GetVertexAttribPointervARB)(GLuint index, GLenum pname, GLvoid ** params)
-{
-   DISPATCH(GetVertexAttribPointervNV, (index, pname, params), (F, "glGetVertexAttribPointervARB(%d, 0x%x, %p);\n", index, pname, (const void *) params));
-}
-
-KEYWORD1 void KEYWORD2 NAME(BlendColorEXT)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
-{
-   DISPATCH(BlendColor, (red, green, blue, alpha), (F, "glBlendColorEXT(%f, %f, %f, %f);\n", red, green, blue, alpha));
-}
-
-KEYWORD1 void KEYWORD2 NAME(TexImage3DEXT)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
-{
-   DISPATCH(TexImage3D, (target, level, internalformat, width, height, depth, border, format, type, pixels), (F, "glTexImage3DEXT(0x%x, %d, 0x%x, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, internalformat, width, height, depth, border, format, type, (const void *) pixels));
-}
-
-KEYWORD1 void KEYWORD2 NAME(TexSubImage3DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)
-{
-   DISPATCH(TexSubImage3D, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels), (F, "glTexSubImage3DEXT(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, (const void *) pixels));
-}
-
-KEYWORD1 void KEYWORD2 NAME(TexSubImage1DEXT)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)
-{
-   DISPATCH(TexSubImage1D, (target, level, xoffset, width, format, type, pixels), (F, "glTexSubImage1DEXT(0x%x, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, xoffset, width, format, type, (const void *) pixels));
-}
-
-KEYWORD1 void KEYWORD2 NAME(TexSubImage2DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
-{
-   DISPATCH(TexSubImage2D, (target, level, xoffset, yoffset, width, height, format, type, pixels), (F, "glTexSubImage2DEXT(0x%x, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);\n", target, level, xoffset, yoffset, width, height, format, type, (const void *) pixels));
-}
-
-KEYWORD1 void KEYWORD2 NAME(CopyTexImage1DEXT)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
-{
-   DISPATCH(CopyTexImage1D, (target, level, internalformat, x, y, width, border), (F, "glCopyTexImage1DEXT(0x%x, %d, 0x%x, %d, %d, %d, %d);\n", target, level, internalformat, x, y, width, border));
-}
-
-KEYWORD1 void KEYWORD2 NAME(CopyTexImage2DEXT)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-   DISPATCH(CopyTexImage2D, (target, level, internalformat, x, y, width, height, border), (F, "glCopyTexImage2DEXT(0x%x, %d, 0x%x, %d, %d, %d, %d, %d);\n", target, level, internalformat, x, y, width, height, border));
-}
-
-KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage1DEXT)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
-{
-   DISPATCH(CopyTexSubImage1D, (target, level, xoffset, x, y, width), (F, "glCopyTexSubImage1DEXT(0x%x, %d, %d, %d, %d, %d);\n", target, level, xoffset, x, y, width));
-}
-
-KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage2DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-   DISPATCH(CopyTexSubImage2D, (target, level, xoffset, yoffset, x, y, width, height), (F, "glCopyTexSubImage2DEXT(0x%x, %d, %d, %d, %d, %d, %d, %d);\n", target, level, xoffset, yoffset, x, y, width, height));
-}
-
-KEYWORD1 void KEYWORD2 NAME(CopyTexSubImage3DEXT)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-   DISPATCH(CopyTexSubImage3D, (target, level, xoffset, yoffset, zoffset, x, y, width, height), (F, "glCopyTexSubImage3DEXT(0x%x, %d, %d, %d, %d, %d, %d, %d, %d);\n", target, level, xoffset, yoffset, zoffset, x, y, width, height));
-}
-
-KEYWORD1 void KEYWORD2 NAME(HistogramEXT)(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
-{
-   DISPATCH(Histogram, (target, width, internalformat, sink), (F, "glHistogramEXT(0x%x, %d, 0x%x, %d);\n", target, width, internalformat, sink));
-}
-
-KEYWORD1 void KEYWORD2 NAME(MinmaxEXT)(GLenum target, GLenum internalformat, GLboolean sink)
-{
-   DISPATCH(Minmax, (target, internalformat, sink), (F, "glMinmaxEXT(0x%x, 0x%x, %d);\n", target, internalformat, sink));
-}
-
-KEYWORD1 void KEYWORD2 NAME(ResetHistogramEXT)(GLenum target)
-{
-   DISPATCH(ResetHistogram, (target), (F, "glResetHistogramEXT(0x%x);\n", target));
-}
-
-KEYWORD1 void KEYWORD2 NAME(ResetMinmaxEXT)(GLenum target)
-{
-   DISPATCH(ResetMinmax, (target), (F, "glResetMinmaxEXT(0x%x);\n", target));
-}
-
-KEYWORD1 void KEYWORD2 NAME(ConvolutionFilter1DEXT)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image)
-{
-   DISPATCH(ConvolutionFilter1D, (target, internalformat, width, format, type, image), (F, "glConvolutionFilter1DEXT(0x%x, 0x%x, %d, 0x%x, 0x%x, %p);\n", target, internalformat, width, format, type, (const void *) image));
-}
-
-KEYWORD1 void KEYWORD2 NAME(ConvolutionFilter2DEXT)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)
-{
-   DISPATCH(ConvolutionFilter2D, (target, internalformat, width, height, format, type, image), (F, "glConvolutionFilter2DEXT(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p);\n", target, internalformat, width, height, format, type, (const void *) image));
-}
-
-KEYWORD1 void KEYWORD2 NAME(ConvolutionParameterfEXT)(GLenum target, GLenum pname, GLfloat params)
-{
-   DISPATCH(ConvolutionParameterf, (target, pname, params), (F, "glConvolutionParameterfEXT(0x%x, 0x%x, %f);\n", target, pname, params));
-}
-
-KEYWORD1 void KEYWORD2 NAME(ConvolutionParameterfvEXT)(GLenum target, GLenum pname, const GLfloat * params)
-{
-   DISPATCH(ConvolutionParameterfv, (target, pname, params), (F, "glConvolutionParameterfvEXT(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
-}
-
-KEYWORD1 void KEYWORD2 NAME(ConvolutionParameteriEXT)(GLenum target, GLenum pname, GLint params)
-{
-   DISPATCH(ConvolutionParameteri, (target, pname, params), (F, "glConvolutionParameteriEXT(0x%x, 0x%x, %d);\n", target, pname, params));
-}
-
-KEYWORD1 void KEYWORD2 NAME(ConvolutionParameterivEXT)(GLenum target, GLenum pname, const GLint * params)
-{
-   DISPATCH(ConvolutionParameteriv, (target, pname, params), (F, "glConvolutionParameterivEXT(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
-}
-
-KEYWORD1 void KEYWORD2 NAME(CopyConvolutionFilter1DEXT)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-   DISPATCH(CopyConvolutionFilter1D, (target, internalformat, x, y, width), (F, "glCopyConvolutionFilter1DEXT(0x%x, 0x%x, %d, %d, %d);\n", target, internalformat, x, y, width));
-}
-
-KEYWORD1 void KEYWORD2 NAME(CopyConvolutionFilter2DEXT)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-   DISPATCH(CopyConvolutionFilter2D, (target, internalformat, x, y, width, height), (F, "glCopyConvolutionFilter2DEXT(0x%x, 0x%x, %d, %d, %d, %d);\n", target, internalformat, x, y, width, height));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SeparableFilter2DEXT)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column)
-{
-   DISPATCH(SeparableFilter2D, (target, internalformat, width, height, format, type, row, column), (F, "glSeparableFilter2DEXT(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p, %p);\n", target, internalformat, width, height, format, type, (const void *) row, (const void *) column));
-}
-
-KEYWORD1 void KEYWORD2 NAME(ColorTableSGI)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)
-{
-   DISPATCH(ColorTable, (target, internalformat, width, format, type, table), (F, "glColorTableSGI(0x%x, 0x%x, %d, 0x%x, 0x%x, %p);\n", target, internalformat, width, format, type, (const void *) table));
-}
-
-KEYWORD1 void KEYWORD2 NAME(ColorTableParameterfvSGI)(GLenum target, GLenum pname, const GLfloat * params)
-{
-   DISPATCH(ColorTableParameterfv, (target, pname, params), (F, "glColorTableParameterfvSGI(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
-}
-
-KEYWORD1 void KEYWORD2 NAME(ColorTableParameterivSGI)(GLenum target, GLenum pname, const GLint * params)
-{
-   DISPATCH(ColorTableParameteriv, (target, pname, params), (F, "glColorTableParameterivSGI(0x%x, 0x%x, %p);\n", target, pname, (const void *) params));
-}
-
-KEYWORD1 void KEYWORD2 NAME(CopyColorTableSGI)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
-{
-   DISPATCH(CopyColorTable, (target, internalformat, x, y, width), (F, "glCopyColorTableSGI(0x%x, 0x%x, %d, %d, %d);\n", target, internalformat, x, y, width));
-}
-
-KEYWORD1 void KEYWORD2 NAME(BindTextureEXT)(GLenum target, GLuint texture)
-{
-   DISPATCH(BindTexture, (target, texture), (F, "glBindTextureEXT(0x%x, %d);\n", target, texture));
-}
-
-KEYWORD1 void KEYWORD2 NAME(DeleteTexturesEXT)(GLsizei n, const GLuint * textures)
-{
-   DISPATCH(DeleteTextures, (n, textures), (F, "glDeleteTexturesEXT(%d, %p);\n", n, (const void *) textures));
-}
-
-KEYWORD1 void KEYWORD2 NAME(PrioritizeTexturesEXT)(GLsizei n, const GLuint * textures, const GLclampf * priorities)
-{
-   DISPATCH(PrioritizeTextures, (n, textures, priorities), (F, "glPrioritizeTexturesEXT(%d, %p, %p);\n", n, (const void *) textures, (const void *) priorities));
-}
-
-KEYWORD1 void KEYWORD2 NAME(ArrayElementEXT)(GLint i)
-{
-   DISPATCH(ArrayElement, (i), (F, "glArrayElementEXT(%d);\n", i));
-}
-
-KEYWORD1 void KEYWORD2 NAME(DrawArraysEXT)(GLenum mode, GLint first, GLsizei count)
-{
-   DISPATCH(DrawArrays, (mode, first, count), (F, "glDrawArraysEXT(0x%x, %d, %d);\n", mode, first, count));
-}
-
-KEYWORD1 void KEYWORD2 NAME(GetPointervEXT)(GLenum pname, GLvoid ** params)
-{
-   DISPATCH(GetPointerv, (pname, params), (F, "glGetPointervEXT(0x%x, %p);\n", pname, (const void *) params));
-}
-
-KEYWORD1 void KEYWORD2 NAME(BlendEquationEXT)(GLenum mode)
-{
-   DISPATCH(BlendEquation, (mode), (F, "glBlendEquationEXT(0x%x);\n", mode));
-}
-
-KEYWORD1 void KEYWORD2 NAME(ColorSubTableEXT)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data)
-{
-   DISPATCH(ColorSubTable, (target, start, count, format, type, data), (F, "glColorSubTableEXT(0x%x, %d, %d, 0x%x, 0x%x, %p);\n", target, start, count, format, type, (const void *) data));
-}
-
-KEYWORD1 void KEYWORD2 NAME(CopyColorSubTableEXT)(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
-{
-   DISPATCH(CopyColorSubTable, (target, start, x, y, width), (F, "glCopyColorSubTableEXT(0x%x, %d, %d, %d, %d);\n", target, start, x, y, width));
-}
-
-KEYWORD1 void KEYWORD2 NAME(ColorTableEXT)(GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)
-{
-   DISPATCH(ColorTable, (target, internalFormat, width, format, type, table), (F, "glColorTableEXT(0x%x, 0x%x, %d, 0x%x, 0x%x, %p);\n", target, internalFormat, width, format, type, (const void *) table));
-}
-
-KEYWORD1 void KEYWORD2 NAME(DrawRangeElementsEXT)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices)
-{
-   DISPATCH(DrawRangeElements, (mode, start, end, count, type, indices), (F, "glDrawRangeElementsEXT(0x%x, %d, %d, %d, 0x%x, %p);\n", mode, start, end, count, type, (const void *) indices));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SampleMaskEXT)(GLclampf value, GLboolean invert)
-{
-   DISPATCH(SampleMaskSGIS, (value, invert), (F, "glSampleMaskEXT(%f, %d);\n", value, invert));
-}
-
-KEYWORD1 void KEYWORD2 NAME(SamplePatternEXT)(GLenum pattern)
-{
-   DISPATCH(SamplePatternSGIS, (pattern), (F, "glSamplePatternEXT(0x%x);\n", pattern));
-}
-
-KEYWORD1 void KEYWORD2 NAME(DrawBuffersATI)(GLsizei n, const GLenum * bufs)
-{
-   DISPATCH(DrawBuffersARB, (n, bufs), (F, "glDrawBuffersATI(%d, %p);\n", n, (const void *) bufs));
-}
-
-KEYWORD1 void KEYWORD2 NAME(BlendEquationSeparateATI)(GLenum modeRGB, GLenum modeA)
-{
-   DISPATCH(BlendEquationSeparateEXT, (modeRGB, modeA), (F, "glBlendEquationSeparateATI(0x%x, 0x%x);\n", modeRGB, modeA));
-}
-
-KEYWORD1 void KEYWORD2 NAME(BlendFuncSeparateINGR)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
-{
-   DISPATCH(BlendFuncSeparateEXT, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha), (F, "glBlendFuncSeparateINGR(0x%x, 0x%x, 0x%x, 0x%x);\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha));
-}
-
-KEYWORD1 void KEYWORD2 NAME(PointParameterfSGIS)(GLenum pname, GLfloat param)
-{
-   DISPATCH(PointParameterfEXT, (pname, param), (F, "glPointParameterfSGIS(0x%x, %f);\n", pname, param));
-}
-
-KEYWORD1 void KEYWORD2 NAME(PointParameterfvSGIS)(GLenum pname, const GLfloat * params)
-{
-   DISPATCH(PointParameterfvEXT, (pname, params), (F, "glPointParameterfvSGIS(0x%x, %p);\n", pname, (const void *) params));
-}
-
 
 #endif /* defined( NAME ) */
 
@@ -5983,6 +5983,44 @@ static _glapi_proc DISPATCH_TABLE_NAME[] = {
  */
 #ifdef UNUSED_TABLE_NAME
 static _glapi_proc UNUSED_TABLE_NAME[] = {
+   TABLE_ENTRY(ArrayElementEXT),
+   TABLE_ENTRY(BindTextureEXT),
+   TABLE_ENTRY(DrawArraysEXT),
+   TABLE_ENTRY(CopyTexImage1DEXT),
+   TABLE_ENTRY(CopyTexImage2DEXT),
+   TABLE_ENTRY(CopyTexSubImage1DEXT),
+   TABLE_ENTRY(CopyTexSubImage2DEXT),
+   TABLE_ENTRY(DeleteTexturesEXT),
+   TABLE_ENTRY(GetPointervEXT),
+   TABLE_ENTRY(PrioritizeTexturesEXT),
+   TABLE_ENTRY(TexSubImage1DEXT),
+   TABLE_ENTRY(TexSubImage2DEXT),
+   TABLE_ENTRY(BlendColorEXT),
+   TABLE_ENTRY(BlendEquationEXT),
+   TABLE_ENTRY(DrawRangeElementsEXT),
+   TABLE_ENTRY(ColorTableSGI),
+   TABLE_ENTRY(ColorTableEXT),
+   TABLE_ENTRY(ColorTableParameterfvSGI),
+   TABLE_ENTRY(ColorTableParameterivSGI),
+   TABLE_ENTRY(CopyColorTableSGI),
+   TABLE_ENTRY(ColorSubTableEXT),
+   TABLE_ENTRY(CopyColorSubTableEXT),
+   TABLE_ENTRY(ConvolutionFilter1DEXT),
+   TABLE_ENTRY(ConvolutionFilter2DEXT),
+   TABLE_ENTRY(ConvolutionParameterfEXT),
+   TABLE_ENTRY(ConvolutionParameterfvEXT),
+   TABLE_ENTRY(ConvolutionParameteriEXT),
+   TABLE_ENTRY(ConvolutionParameterivEXT),
+   TABLE_ENTRY(CopyConvolutionFilter1DEXT),
+   TABLE_ENTRY(CopyConvolutionFilter2DEXT),
+   TABLE_ENTRY(SeparableFilter2DEXT),
+   TABLE_ENTRY(HistogramEXT),
+   TABLE_ENTRY(MinmaxEXT),
+   TABLE_ENTRY(ResetHistogramEXT),
+   TABLE_ENTRY(ResetMinmaxEXT),
+   TABLE_ENTRY(TexImage3DEXT),
+   TABLE_ENTRY(TexSubImage3DEXT),
+   TABLE_ENTRY(CopyTexSubImage3DEXT),
    TABLE_ENTRY(ActiveTexture),
    TABLE_ENTRY(ClientActiveTexture),
    TABLE_ENTRY(MultiTexCoord1d),
@@ -6022,6 +6060,54 @@ static _glapi_proc UNUSED_TABLE_NAME[] = {
    TABLE_ENTRY(MultTransposeMatrixf),
    TABLE_ENTRY(MultTransposeMatrixd),
    TABLE_ENTRY(SampleCoverage),
+   TABLE_ENTRY(DrawBuffersATI),
+   TABLE_ENTRY(SampleMaskEXT),
+   TABLE_ENTRY(SamplePatternEXT),
+   TABLE_ENTRY(PointParameterf),
+   TABLE_ENTRY(PointParameterfARB),
+   TABLE_ENTRY(PointParameterfSGIS),
+   TABLE_ENTRY(PointParameterfv),
+   TABLE_ENTRY(PointParameterfvARB),
+   TABLE_ENTRY(PointParameterfvSGIS),
+   TABLE_ENTRY(WindowPos2d),
+   TABLE_ENTRY(WindowPos2dARB),
+   TABLE_ENTRY(WindowPos2dv),
+   TABLE_ENTRY(WindowPos2dvARB),
+   TABLE_ENTRY(WindowPos2f),
+   TABLE_ENTRY(WindowPos2fARB),
+   TABLE_ENTRY(WindowPos2fv),
+   TABLE_ENTRY(WindowPos2fvARB),
+   TABLE_ENTRY(WindowPos2i),
+   TABLE_ENTRY(WindowPos2iARB),
+   TABLE_ENTRY(WindowPos2iv),
+   TABLE_ENTRY(WindowPos2ivARB),
+   TABLE_ENTRY(WindowPos2s),
+   TABLE_ENTRY(WindowPos2sARB),
+   TABLE_ENTRY(WindowPos2sv),
+   TABLE_ENTRY(WindowPos2svARB),
+   TABLE_ENTRY(WindowPos3d),
+   TABLE_ENTRY(WindowPos3dARB),
+   TABLE_ENTRY(WindowPos3dv),
+   TABLE_ENTRY(WindowPos3dvARB),
+   TABLE_ENTRY(WindowPos3f),
+   TABLE_ENTRY(WindowPos3fARB),
+   TABLE_ENTRY(WindowPos3fv),
+   TABLE_ENTRY(WindowPos3fvARB),
+   TABLE_ENTRY(WindowPos3i),
+   TABLE_ENTRY(WindowPos3iARB),
+   TABLE_ENTRY(WindowPos3iv),
+   TABLE_ENTRY(WindowPos3ivARB),
+   TABLE_ENTRY(WindowPos3s),
+   TABLE_ENTRY(WindowPos3sARB),
+   TABLE_ENTRY(WindowPos3sv),
+   TABLE_ENTRY(WindowPos3svARB),
+   TABLE_ENTRY(BlendFuncSeparate),
+   TABLE_ENTRY(BlendFuncSeparateINGR),
+   TABLE_ENTRY(FogCoordf),
+   TABLE_ENTRY(FogCoordfv),
+   TABLE_ENTRY(FogCoordd),
+   TABLE_ENTRY(FogCoorddv),
+   TABLE_ENTRY(FogCoordPointer),
    TABLE_ENTRY(CompressedTexImage3D),
    TABLE_ENTRY(CompressedTexImage2D),
    TABLE_ENTRY(CompressedTexImage1D),
@@ -6029,18 +6115,6 @@ static _glapi_proc UNUSED_TABLE_NAME[] = {
    TABLE_ENTRY(CompressedTexSubImage2D),
    TABLE_ENTRY(CompressedTexSubImage1D),
    TABLE_ENTRY(GetCompressedTexImage),
-   TABLE_ENTRY(BlendFuncSeparate),
-   TABLE_ENTRY(FogCoordf),
-   TABLE_ENTRY(FogCoordfv),
-   TABLE_ENTRY(FogCoordd),
-   TABLE_ENTRY(FogCoorddv),
-   TABLE_ENTRY(FogCoordPointer),
-   TABLE_ENTRY(MultiDrawArrays),
-   TABLE_ENTRY(MultiDrawElements),
-   TABLE_ENTRY(PointParameterf),
-   TABLE_ENTRY(PointParameterfv),
-   TABLE_ENTRY(PointParameteri),
-   TABLE_ENTRY(PointParameteriv),
    TABLE_ENTRY(SecondaryColor3b),
    TABLE_ENTRY(SecondaryColor3bv),
    TABLE_ENTRY(SecondaryColor3d),
@@ -6058,22 +6132,15 @@ static _glapi_proc UNUSED_TABLE_NAME[] = {
    TABLE_ENTRY(SecondaryColor3us),
    TABLE_ENTRY(SecondaryColor3usv),
    TABLE_ENTRY(SecondaryColorPointer),
-   TABLE_ENTRY(WindowPos2d),
-   TABLE_ENTRY(WindowPos2dv),
-   TABLE_ENTRY(WindowPos2f),
-   TABLE_ENTRY(WindowPos2fv),
-   TABLE_ENTRY(WindowPos2i),
-   TABLE_ENTRY(WindowPos2iv),
-   TABLE_ENTRY(WindowPos2s),
-   TABLE_ENTRY(WindowPos2sv),
-   TABLE_ENTRY(WindowPos3d),
-   TABLE_ENTRY(WindowPos3dv),
-   TABLE_ENTRY(WindowPos3f),
-   TABLE_ENTRY(WindowPos3fv),
-   TABLE_ENTRY(WindowPos3i),
-   TABLE_ENTRY(WindowPos3iv),
-   TABLE_ENTRY(WindowPos3s),
-   TABLE_ENTRY(WindowPos3sv),
+   TABLE_ENTRY(BindProgramARB),
+   TABLE_ENTRY(DeleteProgramsARB),
+   TABLE_ENTRY(GenProgramsARB),
+   TABLE_ENTRY(GetVertexAttribPointervARB),
+   TABLE_ENTRY(IsProgramARB),
+   TABLE_ENTRY(PointParameteri),
+   TABLE_ENTRY(PointParameteriv),
+   TABLE_ENTRY(MultiDrawArrays),
+   TABLE_ENTRY(MultiDrawElements),
    TABLE_ENTRY(BindBuffer),
    TABLE_ENTRY(BufferData),
    TABLE_ENTRY(BufferSubData),
@@ -6093,84 +6160,16 @@ static _glapi_proc UNUSED_TABLE_NAME[] = {
    TABLE_ENTRY(GetQueryiv),
    TABLE_ENTRY(GetQueryObjectiv),
    TABLE_ENTRY(GetQueryObjectuiv),
-   TABLE_ENTRY(PointParameterfARB),
-   TABLE_ENTRY(PointParameterfvARB),
-   TABLE_ENTRY(WindowPos2dARB),
-   TABLE_ENTRY(WindowPos2fARB),
-   TABLE_ENTRY(WindowPos2iARB),
-   TABLE_ENTRY(WindowPos2sARB),
-   TABLE_ENTRY(WindowPos2dvARB),
-   TABLE_ENTRY(WindowPos2fvARB),
-   TABLE_ENTRY(WindowPos2ivARB),
-   TABLE_ENTRY(WindowPos2svARB),
-   TABLE_ENTRY(WindowPos3dARB),
-   TABLE_ENTRY(WindowPos3fARB),
-   TABLE_ENTRY(WindowPos3iARB),
-   TABLE_ENTRY(WindowPos3sARB),
-   TABLE_ENTRY(WindowPos3dvARB),
-   TABLE_ENTRY(WindowPos3fvARB),
-   TABLE_ENTRY(WindowPos3ivARB),
-   TABLE_ENTRY(WindowPos3svARB),
-   TABLE_ENTRY(BindProgramARB),
-   TABLE_ENTRY(DeleteProgramsARB),
-   TABLE_ENTRY(GenProgramsARB),
-   TABLE_ENTRY(IsProgramARB),
-   TABLE_ENTRY(GetVertexAttribPointervARB),
-   TABLE_ENTRY(BlendColorEXT),
-   TABLE_ENTRY(TexImage3DEXT),
-   TABLE_ENTRY(TexSubImage3DEXT),
-   TABLE_ENTRY(TexSubImage1DEXT),
-   TABLE_ENTRY(TexSubImage2DEXT),
-   TABLE_ENTRY(CopyTexImage1DEXT),
-   TABLE_ENTRY(CopyTexImage2DEXT),
-   TABLE_ENTRY(CopyTexSubImage1DEXT),
-   TABLE_ENTRY(CopyTexSubImage2DEXT),
-   TABLE_ENTRY(CopyTexSubImage3DEXT),
-   TABLE_ENTRY(HistogramEXT),
-   TABLE_ENTRY(MinmaxEXT),
-   TABLE_ENTRY(ResetHistogramEXT),
-   TABLE_ENTRY(ResetMinmaxEXT),
-   TABLE_ENTRY(ConvolutionFilter1DEXT),
-   TABLE_ENTRY(ConvolutionFilter2DEXT),
-   TABLE_ENTRY(ConvolutionParameterfEXT),
-   TABLE_ENTRY(ConvolutionParameterfvEXT),
-   TABLE_ENTRY(ConvolutionParameteriEXT),
-   TABLE_ENTRY(ConvolutionParameterivEXT),
-   TABLE_ENTRY(CopyConvolutionFilter1DEXT),
-   TABLE_ENTRY(CopyConvolutionFilter2DEXT),
-   TABLE_ENTRY(SeparableFilter2DEXT),
-   TABLE_ENTRY(ColorTableSGI),
-   TABLE_ENTRY(ColorTableParameterfvSGI),
-   TABLE_ENTRY(ColorTableParameterivSGI),
-   TABLE_ENTRY(CopyColorTableSGI),
-   TABLE_ENTRY(BindTextureEXT),
-   TABLE_ENTRY(DeleteTexturesEXT),
-   TABLE_ENTRY(PrioritizeTexturesEXT),
-   TABLE_ENTRY(ArrayElementEXT),
-   TABLE_ENTRY(DrawArraysEXT),
-   TABLE_ENTRY(GetPointervEXT),
-   TABLE_ENTRY(BlendEquationEXT),
-   TABLE_ENTRY(ColorSubTableEXT),
-   TABLE_ENTRY(CopyColorSubTableEXT),
-   TABLE_ENTRY(ColorTableEXT),
-   TABLE_ENTRY(DrawRangeElementsEXT),
-   TABLE_ENTRY(SampleMaskEXT),
-   TABLE_ENTRY(SamplePatternEXT),
-   TABLE_ENTRY(DrawBuffersATI),
    TABLE_ENTRY(BlendEquationSeparateATI),
-   TABLE_ENTRY(BlendFuncSeparateINGR),
-   TABLE_ENTRY(PointParameterfSGIS),
-   TABLE_ENTRY(PointParameterfvSGIS),
 };
 #endif /*UNUSED_TABLE_NAME*/
 
 
-#undef KEYWORD1
-#undef KEYWORD2
-#undef NAME
-#undef DISPATCH
-#undef RETURN_DISPATCH
-#undef DISPATCH_TABLE_NAME
-#undef UNUSED_TABLE_NAME
-#undef TABLE_ENTRY
-
+#  undef KEYWORD1
+#  undef KEYWORD2
+#  undef NAME
+#  undef DISPATCH
+#  undef RETURN_DISPATCH
+#  undef DISPATCH_TABLE_NAME
+#  undef UNUSED_TABLE_NAME
+#  undef TABLE_ENTRY
diff --git a/src/mesa/glapi/glprocs.h b/src/mesa/glapi/glprocs.h
index 37fe22ed411..596a3e4cf9a 100644
--- a/src/mesa/glapi/glprocs.h
+++ b/src/mesa/glapi/glprocs.h
@@ -862,6 +862,44 @@ static const char gl_string_table[] =
     "glStencilFuncSeparate\0"
     "glStencilOpSeparate\0"
     "glStencilMaskSeparate\0"
+    "glArrayElementEXT\0"
+    "glBindTextureEXT\0"
+    "glDrawArraysEXT\0"
+    "glCopyTexImage1DEXT\0"
+    "glCopyTexImage2DEXT\0"
+    "glCopyTexSubImage1DEXT\0"
+    "glCopyTexSubImage2DEXT\0"
+    "glDeleteTexturesEXT\0"
+    "glGetPointervEXT\0"
+    "glPrioritizeTexturesEXT\0"
+    "glTexSubImage1DEXT\0"
+    "glTexSubImage2DEXT\0"
+    "glBlendColorEXT\0"
+    "glBlendEquationEXT\0"
+    "glDrawRangeElementsEXT\0"
+    "glColorTableSGI\0"
+    "glColorTableEXT\0"
+    "glColorTableParameterfvSGI\0"
+    "glColorTableParameterivSGI\0"
+    "glCopyColorTableSGI\0"
+    "glColorSubTableEXT\0"
+    "glCopyColorSubTableEXT\0"
+    "glConvolutionFilter1DEXT\0"
+    "glConvolutionFilter2DEXT\0"
+    "glConvolutionParameterfEXT\0"
+    "glConvolutionParameterfvEXT\0"
+    "glConvolutionParameteriEXT\0"
+    "glConvolutionParameterivEXT\0"
+    "glCopyConvolutionFilter1DEXT\0"
+    "glCopyConvolutionFilter2DEXT\0"
+    "glSeparableFilter2DEXT\0"
+    "glHistogramEXT\0"
+    "glMinmaxEXT\0"
+    "glResetHistogramEXT\0"
+    "glResetMinmaxEXT\0"
+    "glTexImage3DEXT\0"
+    "glTexSubImage3DEXT\0"
+    "glCopyTexSubImage3DEXT\0"
     "glActiveTexture\0"
     "glClientActiveTexture\0"
     "glMultiTexCoord1d\0"
@@ -901,6 +939,54 @@ static const char gl_string_table[] =
     "glMultTransposeMatrixf\0"
     "glMultTransposeMatrixd\0"
     "glSampleCoverage\0"
+    "glDrawBuffersATI\0"
+    "glSampleMaskEXT\0"
+    "glSamplePatternEXT\0"
+    "glPointParameterf\0"
+    "glPointParameterfARB\0"
+    "glPointParameterfSGIS\0"
+    "glPointParameterfv\0"
+    "glPointParameterfvARB\0"
+    "glPointParameterfvSGIS\0"
+    "glWindowPos2d\0"
+    "glWindowPos2dARB\0"
+    "glWindowPos2dv\0"
+    "glWindowPos2dvARB\0"
+    "glWindowPos2f\0"
+    "glWindowPos2fARB\0"
+    "glWindowPos2fv\0"
+    "glWindowPos2fvARB\0"
+    "glWindowPos2i\0"
+    "glWindowPos2iARB\0"
+    "glWindowPos2iv\0"
+    "glWindowPos2ivARB\0"
+    "glWindowPos2s\0"
+    "glWindowPos2sARB\0"
+    "glWindowPos2sv\0"
+    "glWindowPos2svARB\0"
+    "glWindowPos3d\0"
+    "glWindowPos3dARB\0"
+    "glWindowPos3dv\0"
+    "glWindowPos3dvARB\0"
+    "glWindowPos3f\0"
+    "glWindowPos3fARB\0"
+    "glWindowPos3fv\0"
+    "glWindowPos3fvARB\0"
+    "glWindowPos3i\0"
+    "glWindowPos3iARB\0"
+    "glWindowPos3iv\0"
+    "glWindowPos3ivARB\0"
+    "glWindowPos3s\0"
+    "glWindowPos3sARB\0"
+    "glWindowPos3sv\0"
+    "glWindowPos3svARB\0"
+    "glBlendFuncSeparate\0"
+    "glBlendFuncSeparateINGR\0"
+    "glFogCoordf\0"
+    "glFogCoordfv\0"
+    "glFogCoordd\0"
+    "glFogCoorddv\0"
+    "glFogCoordPointer\0"
     "glCompressedTexImage3D\0"
     "glCompressedTexImage2D\0"
     "glCompressedTexImage1D\0"
@@ -908,18 +994,6 @@ static const char gl_string_table[] =
     "glCompressedTexSubImage2D\0"
     "glCompressedTexSubImage1D\0"
     "glGetCompressedTexImage\0"
-    "glBlendFuncSeparate\0"
-    "glFogCoordf\0"
-    "glFogCoordfv\0"
-    "glFogCoordd\0"
-    "glFogCoorddv\0"
-    "glFogCoordPointer\0"
-    "glMultiDrawArrays\0"
-    "glMultiDrawElements\0"
-    "glPointParameterf\0"
-    "glPointParameterfv\0"
-    "glPointParameteri\0"
-    "glPointParameteriv\0"
     "glSecondaryColor3b\0"
     "glSecondaryColor3bv\0"
     "glSecondaryColor3d\0"
@@ -937,22 +1011,15 @@ static const char gl_string_table[] =
     "glSecondaryColor3us\0"
     "glSecondaryColor3usv\0"
     "glSecondaryColorPointer\0"
-    "glWindowPos2d\0"
-    "glWindowPos2dv\0"
-    "glWindowPos2f\0"
-    "glWindowPos2fv\0"
-    "glWindowPos2i\0"
-    "glWindowPos2iv\0"
-    "glWindowPos2s\0"
-    "glWindowPos2sv\0"
-    "glWindowPos3d\0"
-    "glWindowPos3dv\0"
-    "glWindowPos3f\0"
-    "glWindowPos3fv\0"
-    "glWindowPos3i\0"
-    "glWindowPos3iv\0"
-    "glWindowPos3s\0"
-    "glWindowPos3sv\0"
+    "glBindProgramARB\0"
+    "glDeleteProgramsARB\0"
+    "glGenProgramsARB\0"
+    "glGetVertexAttribPointervARB\0"
+    "glIsProgramARB\0"
+    "glPointParameteri\0"
+    "glPointParameteriv\0"
+    "glMultiDrawArrays\0"
+    "glMultiDrawElements\0"
     "glBindBuffer\0"
     "glBufferData\0"
     "glBufferSubData\0"
@@ -972,74 +1039,7 @@ static const char gl_string_table[] =
     "glGetQueryiv\0"
     "glGetQueryObjectiv\0"
     "glGetQueryObjectuiv\0"
-    "glPointParameterfARB\0"
-    "glPointParameterfvARB\0"
-    "glWindowPos2dARB\0"
-    "glWindowPos2fARB\0"
-    "glWindowPos2iARB\0"
-    "glWindowPos2sARB\0"
-    "glWindowPos2dvARB\0"
-    "glWindowPos2fvARB\0"
-    "glWindowPos2ivARB\0"
-    "glWindowPos2svARB\0"
-    "glWindowPos3dARB\0"
-    "glWindowPos3fARB\0"
-    "glWindowPos3iARB\0"
-    "glWindowPos3sARB\0"
-    "glWindowPos3dvARB\0"
-    "glWindowPos3fvARB\0"
-    "glWindowPos3ivARB\0"
-    "glWindowPos3svARB\0"
-    "glBindProgramARB\0"
-    "glDeleteProgramsARB\0"
-    "glGenProgramsARB\0"
-    "glIsProgramARB\0"
-    "glGetVertexAttribPointervARB\0"
-    "glBlendColorEXT\0"
-    "glTexImage3DEXT\0"
-    "glTexSubImage3DEXT\0"
-    "glTexSubImage1DEXT\0"
-    "glTexSubImage2DEXT\0"
-    "glCopyTexImage1DEXT\0"
-    "glCopyTexImage2DEXT\0"
-    "glCopyTexSubImage1DEXT\0"
-    "glCopyTexSubImage2DEXT\0"
-    "glCopyTexSubImage3DEXT\0"
-    "glHistogramEXT\0"
-    "glMinmaxEXT\0"
-    "glResetHistogramEXT\0"
-    "glResetMinmaxEXT\0"
-    "glConvolutionFilter1DEXT\0"
-    "glConvolutionFilter2DEXT\0"
-    "glConvolutionParameterfEXT\0"
-    "glConvolutionParameterfvEXT\0"
-    "glConvolutionParameteriEXT\0"
-    "glConvolutionParameterivEXT\0"
-    "glCopyConvolutionFilter1DEXT\0"
-    "glCopyConvolutionFilter2DEXT\0"
-    "glSeparableFilter2DEXT\0"
-    "glColorTableSGI\0"
-    "glColorTableParameterfvSGI\0"
-    "glColorTableParameterivSGI\0"
-    "glCopyColorTableSGI\0"
-    "glBindTextureEXT\0"
-    "glDeleteTexturesEXT\0"
-    "glPrioritizeTexturesEXT\0"
-    "glArrayElementEXT\0"
-    "glDrawArraysEXT\0"
-    "glGetPointervEXT\0"
-    "glBlendEquationEXT\0"
-    "glColorSubTableEXT\0"
-    "glCopyColorSubTableEXT\0"
-    "glColorTableEXT\0"
-    "glDrawRangeElementsEXT\0"
-    "glSampleMaskEXT\0"
-    "glSamplePatternEXT\0"
-    "glDrawBuffersATI\0"
     "glBlendEquationSeparateATI\0"
-    "glBlendFuncSeparateINGR\0"
-    "glPointParameterfSGIS\0"
-    "glPointParameterfvSGIS\0"
     ;
 
 static const glprocs_table_t static_functions[] = {
@@ -1640,403 +1640,403 @@ static const glprocs_table_t static_functions[] = {
     NAME_FUNC_OFFSET(  9934, glProgramParameter4dNV, _gloffset_ProgramParameter4dNV ),
     NAME_FUNC_OFFSET(  9957, glProgramParameter4dvNV, _gloffset_ProgramParameter4dvNV ),
     NAME_FUNC_OFFSET(  9981, glProgramParameter4fNV, _gloffset_ProgramParameter4fNV ),
-    NAME_FUNC_OFFSET(  10004, glProgramParameter4fvNV, _gloffset_ProgramParameter4fvNV ),
-    NAME_FUNC_OFFSET(  10028, glProgramParameters4dvNV, _gloffset_ProgramParameters4dvNV ),
-    NAME_FUNC_OFFSET(  10053, glProgramParameters4fvNV, _gloffset_ProgramParameters4fvNV ),
-    NAME_FUNC_OFFSET(  10078, glRequestResidentProgramsNV, _gloffset_RequestResidentProgramsNV ),
-    NAME_FUNC_OFFSET(  10106, glTrackMatrixNV, _gloffset_TrackMatrixNV ),
-    NAME_FUNC_OFFSET(  10122, glVertexAttribPointerNV, _gloffset_VertexAttribPointerNV ),
-    NAME_FUNC_OFFSET(  10146, glVertexAttrib1dARB, _gloffset_VertexAttrib1dARB ),
-    NAME_FUNC_OFFSET(  10166, glVertexAttrib1dvARB, _gloffset_VertexAttrib1dvARB ),
-    NAME_FUNC_OFFSET(  10187, glVertexAttrib1fARB, _gloffset_VertexAttrib1fARB ),
-    NAME_FUNC_OFFSET(  10207, glVertexAttrib1fvARB, _gloffset_VertexAttrib1fvARB ),
-    NAME_FUNC_OFFSET(  10228, glVertexAttrib1sARB, _gloffset_VertexAttrib1sARB ),
-    NAME_FUNC_OFFSET(  10248, glVertexAttrib1svARB, _gloffset_VertexAttrib1svARB ),
-    NAME_FUNC_OFFSET(  10269, glVertexAttrib2dARB, _gloffset_VertexAttrib2dARB ),
-    NAME_FUNC_OFFSET(  10289, glVertexAttrib2dvARB, _gloffset_VertexAttrib2dvARB ),
-    NAME_FUNC_OFFSET(  10310, glVertexAttrib2fARB, _gloffset_VertexAttrib2fARB ),
-    NAME_FUNC_OFFSET(  10330, glVertexAttrib2fvARB, _gloffset_VertexAttrib2fvARB ),
-    NAME_FUNC_OFFSET(  10351, glVertexAttrib2sARB, _gloffset_VertexAttrib2sARB ),
-    NAME_FUNC_OFFSET(  10371, glVertexAttrib2svARB, _gloffset_VertexAttrib2svARB ),
-    NAME_FUNC_OFFSET(  10392, glVertexAttrib3dARB, _gloffset_VertexAttrib3dARB ),
-    NAME_FUNC_OFFSET(  10412, glVertexAttrib3dvARB, _gloffset_VertexAttrib3dvARB ),
-    NAME_FUNC_OFFSET(  10433, glVertexAttrib3fARB, _gloffset_VertexAttrib3fARB ),
-    NAME_FUNC_OFFSET(  10453, glVertexAttrib3fvARB, _gloffset_VertexAttrib3fvARB ),
-    NAME_FUNC_OFFSET(  10474, glVertexAttrib3sARB, _gloffset_VertexAttrib3sARB ),
-    NAME_FUNC_OFFSET(  10494, glVertexAttrib3svARB, _gloffset_VertexAttrib3svARB ),
-    NAME_FUNC_OFFSET(  10515, glVertexAttrib4dARB, _gloffset_VertexAttrib4dARB ),
-    NAME_FUNC_OFFSET(  10535, glVertexAttrib4dvARB, _gloffset_VertexAttrib4dvARB ),
-    NAME_FUNC_OFFSET(  10556, glVertexAttrib4fARB, _gloffset_VertexAttrib4fARB ),
-    NAME_FUNC_OFFSET(  10576, glVertexAttrib4fvARB, _gloffset_VertexAttrib4fvARB ),
-    NAME_FUNC_OFFSET(  10597, glVertexAttrib4sARB, _gloffset_VertexAttrib4sARB ),
-    NAME_FUNC_OFFSET(  10617, glVertexAttrib4svARB, _gloffset_VertexAttrib4svARB ),
-    NAME_FUNC_OFFSET(  10638, glVertexAttrib4NubARB, _gloffset_VertexAttrib4NubARB ),
-    NAME_FUNC_OFFSET(  10660, glVertexAttrib4NubvARB, _gloffset_VertexAttrib4NubvARB ),
-    NAME_FUNC_OFFSET(  10683, glVertexAttribs1dvNV, _gloffset_VertexAttribs1dvNV ),
-    NAME_FUNC_OFFSET(  10704, glVertexAttribs1fvNV, _gloffset_VertexAttribs1fvNV ),
-    NAME_FUNC_OFFSET(  10725, glVertexAttribs1svNV, _gloffset_VertexAttribs1svNV ),
-    NAME_FUNC_OFFSET(  10746, glVertexAttribs2dvNV, _gloffset_VertexAttribs2dvNV ),
-    NAME_FUNC_OFFSET(  10767, glVertexAttribs2fvNV, _gloffset_VertexAttribs2fvNV ),
-    NAME_FUNC_OFFSET(  10788, glVertexAttribs2svNV, _gloffset_VertexAttribs2svNV ),
-    NAME_FUNC_OFFSET(  10809, glVertexAttribs3dvNV, _gloffset_VertexAttribs3dvNV ),
-    NAME_FUNC_OFFSET(  10830, glVertexAttribs3fvNV, _gloffset_VertexAttribs3fvNV ),
-    NAME_FUNC_OFFSET(  10851, glVertexAttribs3svNV, _gloffset_VertexAttribs3svNV ),
-    NAME_FUNC_OFFSET(  10872, glVertexAttribs4dvNV, _gloffset_VertexAttribs4dvNV ),
-    NAME_FUNC_OFFSET(  10893, glVertexAttribs4fvNV, _gloffset_VertexAttribs4fvNV ),
-    NAME_FUNC_OFFSET(  10914, glVertexAttribs4svNV, _gloffset_VertexAttribs4svNV ),
-    NAME_FUNC_OFFSET(  10935, glVertexAttribs4ubvNV, _gloffset_VertexAttribs4ubvNV ),
-    NAME_FUNC_OFFSET(  10957, glPointParameteriNV, _gloffset_PointParameteriNV ),
-    NAME_FUNC_OFFSET(  10977, glPointParameterivNV, _gloffset_PointParameterivNV ),
-    NAME_FUNC_OFFSET(  10998, glMultiDrawArraysEXT, _gloffset_MultiDrawArraysEXT ),
-    NAME_FUNC_OFFSET(  11019, glMultiDrawElementsEXT, _gloffset_MultiDrawElementsEXT ),
-    NAME_FUNC_OFFSET(  11042, glActiveStencilFaceEXT, _gloffset_ActiveStencilFaceEXT ),
-    NAME_FUNC_OFFSET(  11065, glDeleteFencesNV, _gloffset_DeleteFencesNV ),
-    NAME_FUNC_OFFSET(  11082, glGenFencesNV, _gloffset_GenFencesNV ),
-    NAME_FUNC_OFFSET(  11096, glIsFenceNV, _gloffset_IsFenceNV ),
-    NAME_FUNC_OFFSET(  11108, glTestFenceNV, _gloffset_TestFenceNV ),
-    NAME_FUNC_OFFSET(  11122, glGetFenceivNV, _gloffset_GetFenceivNV ),
-    NAME_FUNC_OFFSET(  11137, glFinishFenceNV, _gloffset_FinishFenceNV ),
-    NAME_FUNC_OFFSET(  11153, glSetFenceNV, _gloffset_SetFenceNV ),
-    NAME_FUNC_OFFSET(  11166, glVertexAttrib4bvARB, _gloffset_VertexAttrib4bvARB ),
-    NAME_FUNC_OFFSET(  11187, glVertexAttrib4ivARB, _gloffset_VertexAttrib4ivARB ),
-    NAME_FUNC_OFFSET(  11208, glVertexAttrib4ubvARB, _gloffset_VertexAttrib4ubvARB ),
-    NAME_FUNC_OFFSET(  11230, glVertexAttrib4usvARB, _gloffset_VertexAttrib4usvARB ),
-    NAME_FUNC_OFFSET(  11252, glVertexAttrib4uivARB, _gloffset_VertexAttrib4uivARB ),
-    NAME_FUNC_OFFSET(  11274, glVertexAttrib4NbvARB, _gloffset_VertexAttrib4NbvARB ),
-    NAME_FUNC_OFFSET(  11296, glVertexAttrib4NsvARB, _gloffset_VertexAttrib4NsvARB ),
-    NAME_FUNC_OFFSET(  11318, glVertexAttrib4NivARB, _gloffset_VertexAttrib4NivARB ),
-    NAME_FUNC_OFFSET(  11340, glVertexAttrib4NusvARB, _gloffset_VertexAttrib4NusvARB ),
-    NAME_FUNC_OFFSET(  11363, glVertexAttrib4NuivARB, _gloffset_VertexAttrib4NuivARB ),
-    NAME_FUNC_OFFSET(  11386, glVertexAttribPointerARB, _gloffset_VertexAttribPointerARB ),
-    NAME_FUNC_OFFSET(  11411, glEnableVertexAttribArrayARB, _gloffset_EnableVertexAttribArrayARB ),
-    NAME_FUNC_OFFSET(  11440, glDisableVertexAttribArrayARB, _gloffset_DisableVertexAttribArrayARB ),
-    NAME_FUNC_OFFSET(  11470, glProgramStringARB, _gloffset_ProgramStringARB ),
-    NAME_FUNC_OFFSET(  11489, glProgramEnvParameter4dARB, _gloffset_ProgramEnvParameter4dARB ),
-    NAME_FUNC_OFFSET(  11516, glProgramEnvParameter4dvARB, _gloffset_ProgramEnvParameter4dvARB ),
-    NAME_FUNC_OFFSET(  11544, glProgramEnvParameter4fARB, _gloffset_ProgramEnvParameter4fARB ),
-    NAME_FUNC_OFFSET(  11571, glProgramEnvParameter4fvARB, _gloffset_ProgramEnvParameter4fvARB ),
-    NAME_FUNC_OFFSET(  11599, glProgramLocalParameter4dARB, _gloffset_ProgramLocalParameter4dARB ),
-    NAME_FUNC_OFFSET(  11628, glProgramLocalParameter4dvARB, _gloffset_ProgramLocalParameter4dvARB ),
-    NAME_FUNC_OFFSET(  11658, glProgramLocalParameter4fARB, _gloffset_ProgramLocalParameter4fARB ),
-    NAME_FUNC_OFFSET(  11687, glProgramLocalParameter4fvARB, _gloffset_ProgramLocalParameter4fvARB ),
-    NAME_FUNC_OFFSET(  11717, glGetProgramEnvParameterdvARB, _gloffset_GetProgramEnvParameterdvARB ),
-    NAME_FUNC_OFFSET(  11747, glGetProgramEnvParameterfvARB, _gloffset_GetProgramEnvParameterfvARB ),
-    NAME_FUNC_OFFSET(  11777, glGetProgramLocalParameterdvARB, _gloffset_GetProgramLocalParameterdvARB ),
-    NAME_FUNC_OFFSET(  11809, glGetProgramLocalParameterfvARB, _gloffset_GetProgramLocalParameterfvARB ),
-    NAME_FUNC_OFFSET(  11841, glGetProgramivARB, _gloffset_GetProgramivARB ),
-    NAME_FUNC_OFFSET(  11859, glGetProgramStringARB, _gloffset_GetProgramStringARB ),
-    NAME_FUNC_OFFSET(  11881, glProgramNamedParameter4fNV, _gloffset_ProgramNamedParameter4fNV ),
-    NAME_FUNC_OFFSET(  11909, glProgramNamedParameter4dNV, _gloffset_ProgramNamedParameter4dNV ),
-    NAME_FUNC_OFFSET(  11937, glProgramNamedParameter4fvNV, _gloffset_ProgramNamedParameter4fvNV ),
-    NAME_FUNC_OFFSET(  11966, glProgramNamedParameter4dvNV, _gloffset_ProgramNamedParameter4dvNV ),
-    NAME_FUNC_OFFSET(  11995, glGetProgramNamedParameterfvNV, _gloffset_GetProgramNamedParameterfvNV ),
-    NAME_FUNC_OFFSET(  12026, glGetProgramNamedParameterdvNV, _gloffset_GetProgramNamedParameterdvNV ),
-    NAME_FUNC_OFFSET(  12057, glBindBufferARB, _gloffset_BindBufferARB ),
-    NAME_FUNC_OFFSET(  12073, glBufferDataARB, _gloffset_BufferDataARB ),
-    NAME_FUNC_OFFSET(  12089, glBufferSubDataARB, _gloffset_BufferSubDataARB ),
-    NAME_FUNC_OFFSET(  12108, glDeleteBuffersARB, _gloffset_DeleteBuffersARB ),
-    NAME_FUNC_OFFSET(  12127, glGenBuffersARB, _gloffset_GenBuffersARB ),
-    NAME_FUNC_OFFSET(  12143, glGetBufferParameterivARB, _gloffset_GetBufferParameterivARB ),
-    NAME_FUNC_OFFSET(  12169, glGetBufferPointervARB, _gloffset_GetBufferPointervARB ),
-    NAME_FUNC_OFFSET(  12192, glGetBufferSubDataARB, _gloffset_GetBufferSubDataARB ),
-    NAME_FUNC_OFFSET(  12214, glIsBufferARB, _gloffset_IsBufferARB ),
-    NAME_FUNC_OFFSET(  12228, glMapBufferARB, _gloffset_MapBufferARB ),
-    NAME_FUNC_OFFSET(  12243, glUnmapBufferARB, _gloffset_UnmapBufferARB ),
-    NAME_FUNC_OFFSET(  12260, glDepthBoundsEXT, _gloffset_DepthBoundsEXT ),
-    NAME_FUNC_OFFSET(  12277, glGenQueriesARB, _gloffset_GenQueriesARB ),
-    NAME_FUNC_OFFSET(  12293, glDeleteQueriesARB, _gloffset_DeleteQueriesARB ),
-    NAME_FUNC_OFFSET(  12312, glIsQueryARB, _gloffset_IsQueryARB ),
-    NAME_FUNC_OFFSET(  12325, glBeginQueryARB, _gloffset_BeginQueryARB ),
-    NAME_FUNC_OFFSET(  12341, glEndQueryARB, _gloffset_EndQueryARB ),
-    NAME_FUNC_OFFSET(  12355, glGetQueryivARB, _gloffset_GetQueryivARB ),
-    NAME_FUNC_OFFSET(  12371, glGetQueryObjectivARB, _gloffset_GetQueryObjectivARB ),
-    NAME_FUNC_OFFSET(  12393, glGetQueryObjectuivARB, _gloffset_GetQueryObjectuivARB ),
-    NAME_FUNC_OFFSET(  12416, glMultiModeDrawArraysIBM, _gloffset_MultiModeDrawArraysIBM ),
-    NAME_FUNC_OFFSET(  12441, glMultiModeDrawElementsIBM, _gloffset_MultiModeDrawElementsIBM ),
-    NAME_FUNC_OFFSET(  12468, glBlendEquationSeparateEXT, _gloffset_BlendEquationSeparateEXT ),
-    NAME_FUNC_OFFSET(  12495, glDeleteObjectARB, _gloffset_DeleteObjectARB ),
-    NAME_FUNC_OFFSET(  12513, glGetHandleARB, _gloffset_GetHandleARB ),
-    NAME_FUNC_OFFSET(  12528, glDetachObjectARB, _gloffset_DetachObjectARB ),
-    NAME_FUNC_OFFSET(  12546, glCreateShaderObjectARB, _gloffset_CreateShaderObjectARB ),
-    NAME_FUNC_OFFSET(  12570, glShaderSourceARB, _gloffset_ShaderSourceARB ),
-    NAME_FUNC_OFFSET(  12588, glCompileShaderARB, _gloffset_CompileShaderARB ),
-    NAME_FUNC_OFFSET(  12607, glCreateProgramObjectARB, _gloffset_CreateProgramObjectARB ),
-    NAME_FUNC_OFFSET(  12632, glAttachObjectARB, _gloffset_AttachObjectARB ),
-    NAME_FUNC_OFFSET(  12650, glLinkProgramARB, _gloffset_LinkProgramARB ),
-    NAME_FUNC_OFFSET(  12667, glUseProgramObjectARB, _gloffset_UseProgramObjectARB ),
-    NAME_FUNC_OFFSET(  12689, glValidateProgramARB, _gloffset_ValidateProgramARB ),
-    NAME_FUNC_OFFSET(  12710, glUniform1fARB, _gloffset_Uniform1fARB ),
-    NAME_FUNC_OFFSET(  12725, glUniform2fARB, _gloffset_Uniform2fARB ),
-    NAME_FUNC_OFFSET(  12740, glUniform3fARB, _gloffset_Uniform3fARB ),
-    NAME_FUNC_OFFSET(  12755, glUniform4fARB, _gloffset_Uniform4fARB ),
-    NAME_FUNC_OFFSET(  12770, glUniform1iARB, _gloffset_Uniform1iARB ),
-    NAME_FUNC_OFFSET(  12785, glUniform2iARB, _gloffset_Uniform2iARB ),
-    NAME_FUNC_OFFSET(  12800, glUniform3iARB, _gloffset_Uniform3iARB ),
-    NAME_FUNC_OFFSET(  12815, glUniform4iARB, _gloffset_Uniform4iARB ),
-    NAME_FUNC_OFFSET(  12830, glUniform1fvARB, _gloffset_Uniform1fvARB ),
-    NAME_FUNC_OFFSET(  12846, glUniform2fvARB, _gloffset_Uniform2fvARB ),
-    NAME_FUNC_OFFSET(  12862, glUniform3fvARB, _gloffset_Uniform3fvARB ),
-    NAME_FUNC_OFFSET(  12878, glUniform4fvARB, _gloffset_Uniform4fvARB ),
-    NAME_FUNC_OFFSET(  12894, glUniform1ivARB, _gloffset_Uniform1ivARB ),
-    NAME_FUNC_OFFSET(  12910, glUniform2ivARB, _gloffset_Uniform2ivARB ),
-    NAME_FUNC_OFFSET(  12926, glUniform3ivARB, _gloffset_Uniform3ivARB ),
-    NAME_FUNC_OFFSET(  12942, glUniform4ivARB, _gloffset_Uniform4ivARB ),
-    NAME_FUNC_OFFSET(  12958, glUniformMatrix2fvARB, _gloffset_UniformMatrix2fvARB ),
-    NAME_FUNC_OFFSET(  12980, glUniformMatrix3fvARB, _gloffset_UniformMatrix3fvARB ),
-    NAME_FUNC_OFFSET(  13002, glUniformMatrix4fvARB, _gloffset_UniformMatrix4fvARB ),
-    NAME_FUNC_OFFSET(  13024, glGetObjectParameterfvARB, _gloffset_GetObjectParameterfvARB ),
-    NAME_FUNC_OFFSET(  13050, glGetObjectParameterivARB, _gloffset_GetObjectParameterivARB ),
-    NAME_FUNC_OFFSET(  13076, glGetInfoLogARB, _gloffset_GetInfoLogARB ),
-    NAME_FUNC_OFFSET(  13092, glGetAttachedObjectsARB, _gloffset_GetAttachedObjectsARB ),
-    NAME_FUNC_OFFSET(  13116, glGetUniformLocationARB, _gloffset_GetUniformLocationARB ),
-    NAME_FUNC_OFFSET(  13140, glGetActiveUniformARB, _gloffset_GetActiveUniformARB ),
-    NAME_FUNC_OFFSET(  13162, glGetUniformfvARB, _gloffset_GetUniformfvARB ),
-    NAME_FUNC_OFFSET(  13180, glGetUniformivARB, _gloffset_GetUniformivARB ),
-    NAME_FUNC_OFFSET(  13198, glGetShaderSourceARB, _gloffset_GetShaderSourceARB ),
-    NAME_FUNC_OFFSET(  13219, glBindAttribLocationARB, _gloffset_BindAttribLocationARB ),
-    NAME_FUNC_OFFSET(  13243, glGetActiveAttribARB, _gloffset_GetActiveAttribARB ),
-    NAME_FUNC_OFFSET(  13264, glGetAttribLocationARB, _gloffset_GetAttribLocationARB ),
-    NAME_FUNC_OFFSET(  13287, glGetVertexAttribdvNV, _gloffset_GetVertexAttribdvNV ),
-    NAME_FUNC_OFFSET(  13309, glGetVertexAttribfvNV, _gloffset_GetVertexAttribfvNV ),
-    NAME_FUNC_OFFSET(  13331, glGetVertexAttribivNV, _gloffset_GetVertexAttribivNV ),
-    NAME_FUNC_OFFSET(  13353, glVertexAttrib1dNV, _gloffset_VertexAttrib1dNV ),
-    NAME_FUNC_OFFSET(  13372, glVertexAttrib1dvNV, _gloffset_VertexAttrib1dvNV ),
-    NAME_FUNC_OFFSET(  13392, glVertexAttrib1fNV, _gloffset_VertexAttrib1fNV ),
-    NAME_FUNC_OFFSET(  13411, glVertexAttrib1fvNV, _gloffset_VertexAttrib1fvNV ),
-    NAME_FUNC_OFFSET(  13431, glVertexAttrib1sNV, _gloffset_VertexAttrib1sNV ),
-    NAME_FUNC_OFFSET(  13450, glVertexAttrib1svNV, _gloffset_VertexAttrib1svNV ),
-    NAME_FUNC_OFFSET(  13470, glVertexAttrib2dNV, _gloffset_VertexAttrib2dNV ),
-    NAME_FUNC_OFFSET(  13489, glVertexAttrib2dvNV, _gloffset_VertexAttrib2dvNV ),
-    NAME_FUNC_OFFSET(  13509, glVertexAttrib2fNV, _gloffset_VertexAttrib2fNV ),
-    NAME_FUNC_OFFSET(  13528, glVertexAttrib2fvNV, _gloffset_VertexAttrib2fvNV ),
-    NAME_FUNC_OFFSET(  13548, glVertexAttrib2sNV, _gloffset_VertexAttrib2sNV ),
-    NAME_FUNC_OFFSET(  13567, glVertexAttrib2svNV, _gloffset_VertexAttrib2svNV ),
-    NAME_FUNC_OFFSET(  13587, glVertexAttrib3dNV, _gloffset_VertexAttrib3dNV ),
-    NAME_FUNC_OFFSET(  13606, glVertexAttrib3dvNV, _gloffset_VertexAttrib3dvNV ),
-    NAME_FUNC_OFFSET(  13626, glVertexAttrib3fNV, _gloffset_VertexAttrib3fNV ),
-    NAME_FUNC_OFFSET(  13645, glVertexAttrib3fvNV, _gloffset_VertexAttrib3fvNV ),
-    NAME_FUNC_OFFSET(  13665, glVertexAttrib3sNV, _gloffset_VertexAttrib3sNV ),
-    NAME_FUNC_OFFSET(  13684, glVertexAttrib3svNV, _gloffset_VertexAttrib3svNV ),
-    NAME_FUNC_OFFSET(  13704, glVertexAttrib4dNV, _gloffset_VertexAttrib4dNV ),
-    NAME_FUNC_OFFSET(  13723, glVertexAttrib4dvNV, _gloffset_VertexAttrib4dvNV ),
-    NAME_FUNC_OFFSET(  13743, glVertexAttrib4fNV, _gloffset_VertexAttrib4fNV ),
-    NAME_FUNC_OFFSET(  13762, glVertexAttrib4fvNV, _gloffset_VertexAttrib4fvNV ),
-    NAME_FUNC_OFFSET(  13782, glVertexAttrib4sNV, _gloffset_VertexAttrib4sNV ),
-    NAME_FUNC_OFFSET(  13801, glVertexAttrib4svNV, _gloffset_VertexAttrib4svNV ),
-    NAME_FUNC_OFFSET(  13821, glVertexAttrib4ubNV, _gloffset_VertexAttrib4ubNV ),
-    NAME_FUNC_OFFSET(  13841, glVertexAttrib4ubvNV, _gloffset_VertexAttrib4ubvNV ),
-    NAME_FUNC_OFFSET(  13862, glGenFragmentShadersATI, _gloffset_GenFragmentShadersATI ),
-    NAME_FUNC_OFFSET(  13886, glBindFragmentShaderATI, _gloffset_BindFragmentShaderATI ),
-    NAME_FUNC_OFFSET(  13910, glDeleteFragmentShaderATI, _gloffset_DeleteFragmentShaderATI ),
-    NAME_FUNC_OFFSET(  13936, glBeginFragmentShaderATI, _gloffset_BeginFragmentShaderATI ),
-    NAME_FUNC_OFFSET(  13961, glEndFragmentShaderATI, _gloffset_EndFragmentShaderATI ),
-    NAME_FUNC_OFFSET(  13984, glPassTexCoordATI, _gloffset_PassTexCoordATI ),
-    NAME_FUNC_OFFSET(  14002, glSampleMapATI, _gloffset_SampleMapATI ),
-    NAME_FUNC_OFFSET(  14017, glColorFragmentOp1ATI, _gloffset_ColorFragmentOp1ATI ),
-    NAME_FUNC_OFFSET(  14039, glColorFragmentOp2ATI, _gloffset_ColorFragmentOp2ATI ),
-    NAME_FUNC_OFFSET(  14061, glColorFragmentOp3ATI, _gloffset_ColorFragmentOp3ATI ),
-    NAME_FUNC_OFFSET(  14083, glAlphaFragmentOp1ATI, _gloffset_AlphaFragmentOp1ATI ),
-    NAME_FUNC_OFFSET(  14105, glAlphaFragmentOp2ATI, _gloffset_AlphaFragmentOp2ATI ),
-    NAME_FUNC_OFFSET(  14127, glAlphaFragmentOp3ATI, _gloffset_AlphaFragmentOp3ATI ),
-    NAME_FUNC_OFFSET(  14149, glSetFragmentShaderConstantATI, _gloffset_SetFragmentShaderConstantATI ),
-    NAME_FUNC_OFFSET(  14180, glIsRenderbufferEXT, _gloffset_IsRenderbufferEXT ),
-    NAME_FUNC_OFFSET(  14200, glBindRenderbufferEXT, _gloffset_BindRenderbufferEXT ),
-    NAME_FUNC_OFFSET(  14222, glDeleteRenderbuffersEXT, _gloffset_DeleteRenderbuffersEXT ),
-    NAME_FUNC_OFFSET(  14247, glGenRenderbuffersEXT, _gloffset_GenRenderbuffersEXT ),
-    NAME_FUNC_OFFSET(  14269, glRenderbufferStorageEXT, _gloffset_RenderbufferStorageEXT ),
-    NAME_FUNC_OFFSET(  14294, glGetRenderbufferParameterivEXT, _gloffset_GetRenderbufferParameterivEXT ),
-    NAME_FUNC_OFFSET(  14326, glIsFramebufferEXT, _gloffset_IsFramebufferEXT ),
-    NAME_FUNC_OFFSET(  14345, glBindFramebufferEXT, _gloffset_BindFramebufferEXT ),
-    NAME_FUNC_OFFSET(  14366, glDeleteFramebuffersEXT, _gloffset_DeleteFramebuffersEXT ),
-    NAME_FUNC_OFFSET(  14390, glGenFramebuffersEXT, _gloffset_GenFramebuffersEXT ),
-    NAME_FUNC_OFFSET(  14411, glCheckFramebufferStatusEXT, _gloffset_CheckFramebufferStatusEXT ),
-    NAME_FUNC_OFFSET(  14439, glFramebufferTexture1DEXT, _gloffset_FramebufferTexture1DEXT ),
-    NAME_FUNC_OFFSET(  14465, glFramebufferTexture2DEXT, _gloffset_FramebufferTexture2DEXT ),
-    NAME_FUNC_OFFSET(  14491, glFramebufferTexture3DEXT, _gloffset_FramebufferTexture3DEXT ),
-    NAME_FUNC_OFFSET(  14517, glFramebufferRenderbufferEXT, _gloffset_FramebufferRenderbufferEXT ),
-    NAME_FUNC_OFFSET(  14546, glGetFramebufferAttachmentParameterivEXT, _gloffset_GetFramebufferAttachmentParameterivEXT ),
-    NAME_FUNC_OFFSET(  14587, glGenerateMipmapEXT, _gloffset_GenerateMipmapEXT ),
-    NAME_FUNC_OFFSET(  14607, glStencilFuncSeparate, _gloffset_StencilFuncSeparate ),
-    NAME_FUNC_OFFSET(  14629, glStencilOpSeparate, _gloffset_StencilOpSeparate ),
-    NAME_FUNC_OFFSET(  14649, glStencilMaskSeparate, _gloffset_StencilMaskSeparate ),
-    NAME_FUNC_OFFSET(  14671, glActiveTexture, _gloffset_ActiveTextureARB ),
-    NAME_FUNC_OFFSET(  14687, glClientActiveTexture, _gloffset_ClientActiveTextureARB ),
-    NAME_FUNC_OFFSET(  14709, glMultiTexCoord1d, _gloffset_MultiTexCoord1dARB ),
-    NAME_FUNC_OFFSET(  14727, glMultiTexCoord1dv, _gloffset_MultiTexCoord1dvARB ),
-    NAME_FUNC_OFFSET(  14746, glMultiTexCoord1f, _gloffset_MultiTexCoord1fARB ),
-    NAME_FUNC_OFFSET(  14764, glMultiTexCoord1fv, _gloffset_MultiTexCoord1fvARB ),
-    NAME_FUNC_OFFSET(  14783, glMultiTexCoord1i, _gloffset_MultiTexCoord1iARB ),
-    NAME_FUNC_OFFSET(  14801, glMultiTexCoord1iv, _gloffset_MultiTexCoord1ivARB ),
-    NAME_FUNC_OFFSET(  14820, glMultiTexCoord1s, _gloffset_MultiTexCoord1sARB ),
-    NAME_FUNC_OFFSET(  14838, glMultiTexCoord1sv, _gloffset_MultiTexCoord1svARB ),
-    NAME_FUNC_OFFSET(  14857, glMultiTexCoord2d, _gloffset_MultiTexCoord2dARB ),
-    NAME_FUNC_OFFSET(  14875, glMultiTexCoord2dv, _gloffset_MultiTexCoord2dvARB ),
-    NAME_FUNC_OFFSET(  14894, glMultiTexCoord2f, _gloffset_MultiTexCoord2fARB ),
-    NAME_FUNC_OFFSET(  14912, glMultiTexCoord2fv, _gloffset_MultiTexCoord2fvARB ),
-    NAME_FUNC_OFFSET(  14931, glMultiTexCoord2i, _gloffset_MultiTexCoord2iARB ),
-    NAME_FUNC_OFFSET(  14949, glMultiTexCoord2iv, _gloffset_MultiTexCoord2ivARB ),
-    NAME_FUNC_OFFSET(  14968, glMultiTexCoord2s, _gloffset_MultiTexCoord2sARB ),
-    NAME_FUNC_OFFSET(  14986, glMultiTexCoord2sv, _gloffset_MultiTexCoord2svARB ),
-    NAME_FUNC_OFFSET(  15005, glMultiTexCoord3d, _gloffset_MultiTexCoord3dARB ),
-    NAME_FUNC_OFFSET(  15023, glMultiTexCoord3dv, _gloffset_MultiTexCoord3dvARB ),
-    NAME_FUNC_OFFSET(  15042, glMultiTexCoord3f, _gloffset_MultiTexCoord3fARB ),
-    NAME_FUNC_OFFSET(  15060, glMultiTexCoord3fv, _gloffset_MultiTexCoord3fvARB ),
-    NAME_FUNC_OFFSET(  15079, glMultiTexCoord3i, _gloffset_MultiTexCoord3iARB ),
-    NAME_FUNC_OFFSET(  15097, glMultiTexCoord3iv, _gloffset_MultiTexCoord3ivARB ),
-    NAME_FUNC_OFFSET(  15116, glMultiTexCoord3s, _gloffset_MultiTexCoord3sARB ),
-    NAME_FUNC_OFFSET(  15134, glMultiTexCoord3sv, _gloffset_MultiTexCoord3svARB ),
-    NAME_FUNC_OFFSET(  15153, glMultiTexCoord4d, _gloffset_MultiTexCoord4dARB ),
-    NAME_FUNC_OFFSET(  15171, glMultiTexCoord4dv, _gloffset_MultiTexCoord4dvARB ),
-    NAME_FUNC_OFFSET(  15190, glMultiTexCoord4f, _gloffset_MultiTexCoord4fARB ),
-    NAME_FUNC_OFFSET(  15208, glMultiTexCoord4fv, _gloffset_MultiTexCoord4fvARB ),
-    NAME_FUNC_OFFSET(  15227, glMultiTexCoord4i, _gloffset_MultiTexCoord4iARB ),
-    NAME_FUNC_OFFSET(  15245, glMultiTexCoord4iv, _gloffset_MultiTexCoord4ivARB ),
-    NAME_FUNC_OFFSET(  15264, glMultiTexCoord4s, _gloffset_MultiTexCoord4sARB ),
-    NAME_FUNC_OFFSET(  15282, glMultiTexCoord4sv, _gloffset_MultiTexCoord4svARB ),
-    NAME_FUNC_OFFSET(  15301, glLoadTransposeMatrixf, _gloffset_LoadTransposeMatrixfARB ),
-    NAME_FUNC_OFFSET(  15324, glLoadTransposeMatrixd, _gloffset_LoadTransposeMatrixdARB ),
-    NAME_FUNC_OFFSET(  15347, glMultTransposeMatrixf, _gloffset_MultTransposeMatrixfARB ),
-    NAME_FUNC_OFFSET(  15370, glMultTransposeMatrixd, _gloffset_MultTransposeMatrixdARB ),
-    NAME_FUNC_OFFSET(  15393, glSampleCoverage, _gloffset_SampleCoverageARB ),
-    NAME_FUNC_OFFSET(  15410, glCompressedTexImage3D, _gloffset_CompressedTexImage3DARB ),
-    NAME_FUNC_OFFSET(  15433, glCompressedTexImage2D, _gloffset_CompressedTexImage2DARB ),
-    NAME_FUNC_OFFSET(  15456, glCompressedTexImage1D, _gloffset_CompressedTexImage1DARB ),
-    NAME_FUNC_OFFSET(  15479, glCompressedTexSubImage3D, _gloffset_CompressedTexSubImage3DARB ),
-    NAME_FUNC_OFFSET(  15505, glCompressedTexSubImage2D, _gloffset_CompressedTexSubImage2DARB ),
-    NAME_FUNC_OFFSET(  15531, glCompressedTexSubImage1D, _gloffset_CompressedTexSubImage1DARB ),
-    NAME_FUNC_OFFSET(  15557, glGetCompressedTexImage, _gloffset_GetCompressedTexImageARB ),
-    NAME_FUNC_OFFSET(  15581, glBlendFuncSeparate, _gloffset_BlendFuncSeparateEXT ),
-    NAME_FUNC_OFFSET(  15601, glFogCoordf, _gloffset_FogCoordfEXT ),
-    NAME_FUNC_OFFSET(  15613, glFogCoordfv, _gloffset_FogCoordfvEXT ),
-    NAME_FUNC_OFFSET(  15626, glFogCoordd, _gloffset_FogCoorddEXT ),
-    NAME_FUNC_OFFSET(  15638, glFogCoorddv, _gloffset_FogCoorddvEXT ),
-    NAME_FUNC_OFFSET(  15651, glFogCoordPointer, _gloffset_FogCoordPointerEXT ),
-    NAME_FUNC_OFFSET(  15669, glMultiDrawArrays, _gloffset_MultiDrawArraysEXT ),
-    NAME_FUNC_OFFSET(  15687, glMultiDrawElements, _gloffset_MultiDrawElementsEXT ),
-    NAME_FUNC_OFFSET(  15707, glPointParameterf, _gloffset_PointParameterfEXT ),
-    NAME_FUNC_OFFSET(  15725, glPointParameterfv, _gloffset_PointParameterfvEXT ),
-    NAME_FUNC_OFFSET(  15744, glPointParameteri, _gloffset_PointParameteriNV ),
-    NAME_FUNC_OFFSET(  15762, glPointParameteriv, _gloffset_PointParameterivNV ),
-    NAME_FUNC_OFFSET(  15781, glSecondaryColor3b, _gloffset_SecondaryColor3bEXT ),
-    NAME_FUNC_OFFSET(  15800, glSecondaryColor3bv, _gloffset_SecondaryColor3bvEXT ),
-    NAME_FUNC_OFFSET(  15820, glSecondaryColor3d, _gloffset_SecondaryColor3dEXT ),
-    NAME_FUNC_OFFSET(  15839, glSecondaryColor3dv, _gloffset_SecondaryColor3dvEXT ),
-    NAME_FUNC_OFFSET(  15859, glSecondaryColor3f, _gloffset_SecondaryColor3fEXT ),
-    NAME_FUNC_OFFSET(  15878, glSecondaryColor3fv, _gloffset_SecondaryColor3fvEXT ),
-    NAME_FUNC_OFFSET(  15898, glSecondaryColor3i, _gloffset_SecondaryColor3iEXT ),
-    NAME_FUNC_OFFSET(  15917, glSecondaryColor3iv, _gloffset_SecondaryColor3ivEXT ),
-    NAME_FUNC_OFFSET(  15937, glSecondaryColor3s, _gloffset_SecondaryColor3sEXT ),
-    NAME_FUNC_OFFSET(  15956, glSecondaryColor3sv, _gloffset_SecondaryColor3svEXT ),
-    NAME_FUNC_OFFSET(  15976, glSecondaryColor3ub, _gloffset_SecondaryColor3ubEXT ),
-    NAME_FUNC_OFFSET(  15996, glSecondaryColor3ubv, _gloffset_SecondaryColor3ubvEXT ),
-    NAME_FUNC_OFFSET(  16017, glSecondaryColor3ui, _gloffset_SecondaryColor3uiEXT ),
-    NAME_FUNC_OFFSET(  16037, glSecondaryColor3uiv, _gloffset_SecondaryColor3uivEXT ),
-    NAME_FUNC_OFFSET(  16058, glSecondaryColor3us, _gloffset_SecondaryColor3usEXT ),
-    NAME_FUNC_OFFSET(  16078, glSecondaryColor3usv, _gloffset_SecondaryColor3usvEXT ),
-    NAME_FUNC_OFFSET(  16099, glSecondaryColorPointer, _gloffset_SecondaryColorPointerEXT ),
-    NAME_FUNC_OFFSET(  16123, glWindowPos2d, _gloffset_WindowPos2dMESA ),
-    NAME_FUNC_OFFSET(  16137, glWindowPos2dv, _gloffset_WindowPos2dvMESA ),
-    NAME_FUNC_OFFSET(  16152, glWindowPos2f, _gloffset_WindowPos2fMESA ),
-    NAME_FUNC_OFFSET(  16166, glWindowPos2fv, _gloffset_WindowPos2fvMESA ),
-    NAME_FUNC_OFFSET(  16181, glWindowPos2i, _gloffset_WindowPos2iMESA ),
-    NAME_FUNC_OFFSET(  16195, glWindowPos2iv, _gloffset_WindowPos2ivMESA ),
-    NAME_FUNC_OFFSET(  16210, glWindowPos2s, _gloffset_WindowPos2sMESA ),
-    NAME_FUNC_OFFSET(  16224, glWindowPos2sv, _gloffset_WindowPos2svMESA ),
-    NAME_FUNC_OFFSET(  16239, glWindowPos3d, _gloffset_WindowPos3dMESA ),
-    NAME_FUNC_OFFSET(  16253, glWindowPos3dv, _gloffset_WindowPos3dvMESA ),
-    NAME_FUNC_OFFSET(  16268, glWindowPos3f, _gloffset_WindowPos3fMESA ),
-    NAME_FUNC_OFFSET(  16282, glWindowPos3fv, _gloffset_WindowPos3fvMESA ),
-    NAME_FUNC_OFFSET(  16297, glWindowPos3i, _gloffset_WindowPos3iMESA ),
-    NAME_FUNC_OFFSET(  16311, glWindowPos3iv, _gloffset_WindowPos3ivMESA ),
-    NAME_FUNC_OFFSET(  16326, glWindowPos3s, _gloffset_WindowPos3sMESA ),
-    NAME_FUNC_OFFSET(  16340, glWindowPos3sv, _gloffset_WindowPos3svMESA ),
-    NAME_FUNC_OFFSET(  16355, glBindBuffer, _gloffset_BindBufferARB ),
-    NAME_FUNC_OFFSET(  16368, glBufferData, _gloffset_BufferDataARB ),
-    NAME_FUNC_OFFSET(  16381, glBufferSubData, _gloffset_BufferSubDataARB ),
-    NAME_FUNC_OFFSET(  16397, glDeleteBuffers, _gloffset_DeleteBuffersARB ),
-    NAME_FUNC_OFFSET(  16413, glGenBuffers, _gloffset_GenBuffersARB ),
-    NAME_FUNC_OFFSET(  16426, glGetBufferParameteriv, _gloffset_GetBufferParameterivARB ),
-    NAME_FUNC_OFFSET(  16449, glGetBufferPointerv, _gloffset_GetBufferPointervARB ),
-    NAME_FUNC_OFFSET(  16469, glGetBufferSubData, _gloffset_GetBufferSubDataARB ),
-    NAME_FUNC_OFFSET(  16488, glIsBuffer, _gloffset_IsBufferARB ),
-    NAME_FUNC_OFFSET(  16499, glMapBuffer, _gloffset_MapBufferARB ),
-    NAME_FUNC_OFFSET(  16511, glUnmapBuffer, _gloffset_UnmapBufferARB ),
-    NAME_FUNC_OFFSET(  16525, glGenQueries, _gloffset_GenQueriesARB ),
-    NAME_FUNC_OFFSET(  16538, glDeleteQueries, _gloffset_DeleteQueriesARB ),
-    NAME_FUNC_OFFSET(  16554, glIsQuery, _gloffset_IsQueryARB ),
-    NAME_FUNC_OFFSET(  16564, glBeginQuery, _gloffset_BeginQueryARB ),
-    NAME_FUNC_OFFSET(  16577, glEndQuery, _gloffset_EndQueryARB ),
-    NAME_FUNC_OFFSET(  16588, glGetQueryiv, _gloffset_GetQueryivARB ),
-    NAME_FUNC_OFFSET(  16601, glGetQueryObjectiv, _gloffset_GetQueryObjectivARB ),
-    NAME_FUNC_OFFSET(  16620, glGetQueryObjectuiv, _gloffset_GetQueryObjectuivARB ),
-    NAME_FUNC_OFFSET(  16640, glPointParameterfARB, _gloffset_PointParameterfEXT ),
-    NAME_FUNC_OFFSET(  16661, glPointParameterfvARB, _gloffset_PointParameterfvEXT ),
-    NAME_FUNC_OFFSET(  16683, glWindowPos2dARB, _gloffset_WindowPos2dMESA ),
-    NAME_FUNC_OFFSET(  16700, glWindowPos2fARB, _gloffset_WindowPos2fMESA ),
-    NAME_FUNC_OFFSET(  16717, glWindowPos2iARB, _gloffset_WindowPos2iMESA ),
-    NAME_FUNC_OFFSET(  16734, glWindowPos2sARB, _gloffset_WindowPos2sMESA ),
-    NAME_FUNC_OFFSET(  16751, glWindowPos2dvARB, _gloffset_WindowPos2dvMESA ),
-    NAME_FUNC_OFFSET(  16769, glWindowPos2fvARB, _gloffset_WindowPos2fvMESA ),
-    NAME_FUNC_OFFSET(  16787, glWindowPos2ivARB, _gloffset_WindowPos2ivMESA ),
-    NAME_FUNC_OFFSET(  16805, glWindowPos2svARB, _gloffset_WindowPos2svMESA ),
-    NAME_FUNC_OFFSET(  16823, glWindowPos3dARB, _gloffset_WindowPos3dMESA ),
-    NAME_FUNC_OFFSET(  16840, glWindowPos3fARB, _gloffset_WindowPos3fMESA ),
-    NAME_FUNC_OFFSET(  16857, glWindowPos3iARB, _gloffset_WindowPos3iMESA ),
-    NAME_FUNC_OFFSET(  16874, glWindowPos3sARB, _gloffset_WindowPos3sMESA ),
-    NAME_FUNC_OFFSET(  16891, glWindowPos3dvARB, _gloffset_WindowPos3dvMESA ),
-    NAME_FUNC_OFFSET(  16909, glWindowPos3fvARB, _gloffset_WindowPos3fvMESA ),
-    NAME_FUNC_OFFSET(  16927, glWindowPos3ivARB, _gloffset_WindowPos3ivMESA ),
-    NAME_FUNC_OFFSET(  16945, glWindowPos3svARB, _gloffset_WindowPos3svMESA ),
-    NAME_FUNC_OFFSET(  16963, glBindProgramARB, _gloffset_BindProgramNV ),
-    NAME_FUNC_OFFSET(  16980, glDeleteProgramsARB, _gloffset_DeleteProgramsNV ),
-    NAME_FUNC_OFFSET(  17000, glGenProgramsARB, _gloffset_GenProgramsNV ),
-    NAME_FUNC_OFFSET(  17017, glIsProgramARB, _gloffset_IsProgramNV ),
-    NAME_FUNC_OFFSET(  17032, glGetVertexAttribPointervARB, _gloffset_GetVertexAttribPointervNV ),
-    NAME_FUNC_OFFSET(  17061, glBlendColorEXT, _gloffset_BlendColor ),
-    NAME_FUNC_OFFSET(  17077, glTexImage3DEXT, _gloffset_TexImage3D ),
-    NAME_FUNC_OFFSET(  17093, glTexSubImage3DEXT, _gloffset_TexSubImage3D ),
-    NAME_FUNC_OFFSET(  17112, glTexSubImage1DEXT, _gloffset_TexSubImage1D ),
-    NAME_FUNC_OFFSET(  17131, glTexSubImage2DEXT, _gloffset_TexSubImage2D ),
-    NAME_FUNC_OFFSET(  17150, glCopyTexImage1DEXT, _gloffset_CopyTexImage1D ),
-    NAME_FUNC_OFFSET(  17170, glCopyTexImage2DEXT, _gloffset_CopyTexImage2D ),
-    NAME_FUNC_OFFSET(  17190, glCopyTexSubImage1DEXT, _gloffset_CopyTexSubImage1D ),
-    NAME_FUNC_OFFSET(  17213, glCopyTexSubImage2DEXT, _gloffset_CopyTexSubImage2D ),
-    NAME_FUNC_OFFSET(  17236, glCopyTexSubImage3DEXT, _gloffset_CopyTexSubImage3D ),
-    NAME_FUNC_OFFSET(  17259, glHistogramEXT, _gloffset_Histogram ),
-    NAME_FUNC_OFFSET(  17274, glMinmaxEXT, _gloffset_Minmax ),
-    NAME_FUNC_OFFSET(  17286, glResetHistogramEXT, _gloffset_ResetHistogram ),
-    NAME_FUNC_OFFSET(  17306, glResetMinmaxEXT, _gloffset_ResetMinmax ),
-    NAME_FUNC_OFFSET(  17323, glConvolutionFilter1DEXT, _gloffset_ConvolutionFilter1D ),
-    NAME_FUNC_OFFSET(  17348, glConvolutionFilter2DEXT, _gloffset_ConvolutionFilter2D ),
-    NAME_FUNC_OFFSET(  17373, glConvolutionParameterfEXT, _gloffset_ConvolutionParameterf ),
-    NAME_FUNC_OFFSET(  17400, glConvolutionParameterfvEXT, _gloffset_ConvolutionParameterfv ),
-    NAME_FUNC_OFFSET(  17428, glConvolutionParameteriEXT, _gloffset_ConvolutionParameteri ),
-    NAME_FUNC_OFFSET(  17455, glConvolutionParameterivEXT, _gloffset_ConvolutionParameteriv ),
-    NAME_FUNC_OFFSET(  17483, glCopyConvolutionFilter1DEXT, _gloffset_CopyConvolutionFilter1D ),
-    NAME_FUNC_OFFSET(  17512, glCopyConvolutionFilter2DEXT, _gloffset_CopyConvolutionFilter2D ),
-    NAME_FUNC_OFFSET(  17541, glSeparableFilter2DEXT, _gloffset_SeparableFilter2D ),
-    NAME_FUNC_OFFSET(  17564, glColorTableSGI, _gloffset_ColorTable ),
-    NAME_FUNC_OFFSET(  17580, glColorTableParameterfvSGI, _gloffset_ColorTableParameterfv ),
-    NAME_FUNC_OFFSET(  17607, glColorTableParameterivSGI, _gloffset_ColorTableParameteriv ),
-    NAME_FUNC_OFFSET(  17634, glCopyColorTableSGI, _gloffset_CopyColorTable ),
-    NAME_FUNC_OFFSET(  17654, glBindTextureEXT, _gloffset_BindTexture ),
-    NAME_FUNC_OFFSET(  17671, glDeleteTexturesEXT, _gloffset_DeleteTextures ),
-    NAME_FUNC_OFFSET(  17691, glPrioritizeTexturesEXT, _gloffset_PrioritizeTextures ),
-    NAME_FUNC_OFFSET(  17715, glArrayElementEXT, _gloffset_ArrayElement ),
-    NAME_FUNC_OFFSET(  17733, glDrawArraysEXT, _gloffset_DrawArrays ),
-    NAME_FUNC_OFFSET(  17749, glGetPointervEXT, _gloffset_GetPointerv ),
-    NAME_FUNC_OFFSET(  17766, glBlendEquationEXT, _gloffset_BlendEquation ),
-    NAME_FUNC_OFFSET(  17785, glColorSubTableEXT, _gloffset_ColorSubTable ),
-    NAME_FUNC_OFFSET(  17804, glCopyColorSubTableEXT, _gloffset_CopyColorSubTable ),
-    NAME_FUNC_OFFSET(  17827, glColorTableEXT, _gloffset_ColorTable ),
-    NAME_FUNC_OFFSET(  17843, glDrawRangeElementsEXT, _gloffset_DrawRangeElements ),
-    NAME_FUNC_OFFSET(  17866, glSampleMaskEXT, _gloffset_SampleMaskSGIS ),
-    NAME_FUNC_OFFSET(  17882, glSamplePatternEXT, _gloffset_SamplePatternSGIS ),
-    NAME_FUNC_OFFSET(  17901, glDrawBuffersATI, _gloffset_DrawBuffersARB ),
-    NAME_FUNC_OFFSET(  17918, glBlendEquationSeparateATI, _gloffset_BlendEquationSeparateEXT ),
-    NAME_FUNC_OFFSET(  17945, glBlendFuncSeparateINGR, _gloffset_BlendFuncSeparateEXT ),
-    NAME_FUNC_OFFSET(  17969, glPointParameterfSGIS, _gloffset_PointParameterfEXT ),
-    NAME_FUNC_OFFSET(  17991, glPointParameterfvSGIS, _gloffset_PointParameterfvEXT ),
+    NAME_FUNC_OFFSET( 10004, glProgramParameter4fvNV, _gloffset_ProgramParameter4fvNV ),
+    NAME_FUNC_OFFSET( 10028, glProgramParameters4dvNV, _gloffset_ProgramParameters4dvNV ),
+    NAME_FUNC_OFFSET( 10053, glProgramParameters4fvNV, _gloffset_ProgramParameters4fvNV ),
+    NAME_FUNC_OFFSET( 10078, glRequestResidentProgramsNV, _gloffset_RequestResidentProgramsNV ),
+    NAME_FUNC_OFFSET( 10106, glTrackMatrixNV, _gloffset_TrackMatrixNV ),
+    NAME_FUNC_OFFSET( 10122, glVertexAttribPointerNV, _gloffset_VertexAttribPointerNV ),
+    NAME_FUNC_OFFSET( 10146, glVertexAttrib1dARB, _gloffset_VertexAttrib1dARB ),
+    NAME_FUNC_OFFSET( 10166, glVertexAttrib1dvARB, _gloffset_VertexAttrib1dvARB ),
+    NAME_FUNC_OFFSET( 10187, glVertexAttrib1fARB, _gloffset_VertexAttrib1fARB ),
+    NAME_FUNC_OFFSET( 10207, glVertexAttrib1fvARB, _gloffset_VertexAttrib1fvARB ),
+    NAME_FUNC_OFFSET( 10228, glVertexAttrib1sARB, _gloffset_VertexAttrib1sARB ),
+    NAME_FUNC_OFFSET( 10248, glVertexAttrib1svARB, _gloffset_VertexAttrib1svARB ),
+    NAME_FUNC_OFFSET( 10269, glVertexAttrib2dARB, _gloffset_VertexAttrib2dARB ),
+    NAME_FUNC_OFFSET( 10289, glVertexAttrib2dvARB, _gloffset_VertexAttrib2dvARB ),
+    NAME_FUNC_OFFSET( 10310, glVertexAttrib2fARB, _gloffset_VertexAttrib2fARB ),
+    NAME_FUNC_OFFSET( 10330, glVertexAttrib2fvARB, _gloffset_VertexAttrib2fvARB ),
+    NAME_FUNC_OFFSET( 10351, glVertexAttrib2sARB, _gloffset_VertexAttrib2sARB ),
+    NAME_FUNC_OFFSET( 10371, glVertexAttrib2svARB, _gloffset_VertexAttrib2svARB ),
+    NAME_FUNC_OFFSET( 10392, glVertexAttrib3dARB, _gloffset_VertexAttrib3dARB ),
+    NAME_FUNC_OFFSET( 10412, glVertexAttrib3dvARB, _gloffset_VertexAttrib3dvARB ),
+    NAME_FUNC_OFFSET( 10433, glVertexAttrib3fARB, _gloffset_VertexAttrib3fARB ),
+    NAME_FUNC_OFFSET( 10453, glVertexAttrib3fvARB, _gloffset_VertexAttrib3fvARB ),
+    NAME_FUNC_OFFSET( 10474, glVertexAttrib3sARB, _gloffset_VertexAttrib3sARB ),
+    NAME_FUNC_OFFSET( 10494, glVertexAttrib3svARB, _gloffset_VertexAttrib3svARB ),
+    NAME_FUNC_OFFSET( 10515, glVertexAttrib4dARB, _gloffset_VertexAttrib4dARB ),
+    NAME_FUNC_OFFSET( 10535, glVertexAttrib4dvARB, _gloffset_VertexAttrib4dvARB ),
+    NAME_FUNC_OFFSET( 10556, glVertexAttrib4fARB, _gloffset_VertexAttrib4fARB ),
+    NAME_FUNC_OFFSET( 10576, glVertexAttrib4fvARB, _gloffset_VertexAttrib4fvARB ),
+    NAME_FUNC_OFFSET( 10597, glVertexAttrib4sARB, _gloffset_VertexAttrib4sARB ),
+    NAME_FUNC_OFFSET( 10617, glVertexAttrib4svARB, _gloffset_VertexAttrib4svARB ),
+    NAME_FUNC_OFFSET( 10638, glVertexAttrib4NubARB, _gloffset_VertexAttrib4NubARB ),
+    NAME_FUNC_OFFSET( 10660, glVertexAttrib4NubvARB, _gloffset_VertexAttrib4NubvARB ),
+    NAME_FUNC_OFFSET( 10683, glVertexAttribs1dvNV, _gloffset_VertexAttribs1dvNV ),
+    NAME_FUNC_OFFSET( 10704, glVertexAttribs1fvNV, _gloffset_VertexAttribs1fvNV ),
+    NAME_FUNC_OFFSET( 10725, glVertexAttribs1svNV, _gloffset_VertexAttribs1svNV ),
+    NAME_FUNC_OFFSET( 10746, glVertexAttribs2dvNV, _gloffset_VertexAttribs2dvNV ),
+    NAME_FUNC_OFFSET( 10767, glVertexAttribs2fvNV, _gloffset_VertexAttribs2fvNV ),
+    NAME_FUNC_OFFSET( 10788, glVertexAttribs2svNV, _gloffset_VertexAttribs2svNV ),
+    NAME_FUNC_OFFSET( 10809, glVertexAttribs3dvNV, _gloffset_VertexAttribs3dvNV ),
+    NAME_FUNC_OFFSET( 10830, glVertexAttribs3fvNV, _gloffset_VertexAttribs3fvNV ),
+    NAME_FUNC_OFFSET( 10851, glVertexAttribs3svNV, _gloffset_VertexAttribs3svNV ),
+    NAME_FUNC_OFFSET( 10872, glVertexAttribs4dvNV, _gloffset_VertexAttribs4dvNV ),
+    NAME_FUNC_OFFSET( 10893, glVertexAttribs4fvNV, _gloffset_VertexAttribs4fvNV ),
+    NAME_FUNC_OFFSET( 10914, glVertexAttribs4svNV, _gloffset_VertexAttribs4svNV ),
+    NAME_FUNC_OFFSET( 10935, glVertexAttribs4ubvNV, _gloffset_VertexAttribs4ubvNV ),
+    NAME_FUNC_OFFSET( 10957, glPointParameteriNV, _gloffset_PointParameteriNV ),
+    NAME_FUNC_OFFSET( 10977, glPointParameterivNV, _gloffset_PointParameterivNV ),
+    NAME_FUNC_OFFSET( 10998, glMultiDrawArraysEXT, _gloffset_MultiDrawArraysEXT ),
+    NAME_FUNC_OFFSET( 11019, glMultiDrawElementsEXT, _gloffset_MultiDrawElementsEXT ),
+    NAME_FUNC_OFFSET( 11042, glActiveStencilFaceEXT, _gloffset_ActiveStencilFaceEXT ),
+    NAME_FUNC_OFFSET( 11065, glDeleteFencesNV, _gloffset_DeleteFencesNV ),
+    NAME_FUNC_OFFSET( 11082, glGenFencesNV, _gloffset_GenFencesNV ),
+    NAME_FUNC_OFFSET( 11096, glIsFenceNV, _gloffset_IsFenceNV ),
+    NAME_FUNC_OFFSET( 11108, glTestFenceNV, _gloffset_TestFenceNV ),
+    NAME_FUNC_OFFSET( 11122, glGetFenceivNV, _gloffset_GetFenceivNV ),
+    NAME_FUNC_OFFSET( 11137, glFinishFenceNV, _gloffset_FinishFenceNV ),
+    NAME_FUNC_OFFSET( 11153, glSetFenceNV, _gloffset_SetFenceNV ),
+    NAME_FUNC_OFFSET( 11166, glVertexAttrib4bvARB, _gloffset_VertexAttrib4bvARB ),
+    NAME_FUNC_OFFSET( 11187, glVertexAttrib4ivARB, _gloffset_VertexAttrib4ivARB ),
+    NAME_FUNC_OFFSET( 11208, glVertexAttrib4ubvARB, _gloffset_VertexAttrib4ubvARB ),
+    NAME_FUNC_OFFSET( 11230, glVertexAttrib4usvARB, _gloffset_VertexAttrib4usvARB ),
+    NAME_FUNC_OFFSET( 11252, glVertexAttrib4uivARB, _gloffset_VertexAttrib4uivARB ),
+    NAME_FUNC_OFFSET( 11274, glVertexAttrib4NbvARB, _gloffset_VertexAttrib4NbvARB ),
+    NAME_FUNC_OFFSET( 11296, glVertexAttrib4NsvARB, _gloffset_VertexAttrib4NsvARB ),
+    NAME_FUNC_OFFSET( 11318, glVertexAttrib4NivARB, _gloffset_VertexAttrib4NivARB ),
+    NAME_FUNC_OFFSET( 11340, glVertexAttrib4NusvARB, _gloffset_VertexAttrib4NusvARB ),
+    NAME_FUNC_OFFSET( 11363, glVertexAttrib4NuivARB, _gloffset_VertexAttrib4NuivARB ),
+    NAME_FUNC_OFFSET( 11386, glVertexAttribPointerARB, _gloffset_VertexAttribPointerARB ),
+    NAME_FUNC_OFFSET( 11411, glEnableVertexAttribArrayARB, _gloffset_EnableVertexAttribArrayARB ),
+    NAME_FUNC_OFFSET( 11440, glDisableVertexAttribArrayARB, _gloffset_DisableVertexAttribArrayARB ),
+    NAME_FUNC_OFFSET( 11470, glProgramStringARB, _gloffset_ProgramStringARB ),
+    NAME_FUNC_OFFSET( 11489, glProgramEnvParameter4dARB, _gloffset_ProgramEnvParameter4dARB ),
+    NAME_FUNC_OFFSET( 11516, glProgramEnvParameter4dvARB, _gloffset_ProgramEnvParameter4dvARB ),
+    NAME_FUNC_OFFSET( 11544, glProgramEnvParameter4fARB, _gloffset_ProgramEnvParameter4fARB ),
+    NAME_FUNC_OFFSET( 11571, glProgramEnvParameter4fvARB, _gloffset_ProgramEnvParameter4fvARB ),
+    NAME_FUNC_OFFSET( 11599, glProgramLocalParameter4dARB, _gloffset_ProgramLocalParameter4dARB ),
+    NAME_FUNC_OFFSET( 11628, glProgramLocalParameter4dvARB, _gloffset_ProgramLocalParameter4dvARB ),
+    NAME_FUNC_OFFSET( 11658, glProgramLocalParameter4fARB, _gloffset_ProgramLocalParameter4fARB ),
+    NAME_FUNC_OFFSET( 11687, glProgramLocalParameter4fvARB, _gloffset_ProgramLocalParameter4fvARB ),
+    NAME_FUNC_OFFSET( 11717, glGetProgramEnvParameterdvARB, _gloffset_GetProgramEnvParameterdvARB ),
+    NAME_FUNC_OFFSET( 11747, glGetProgramEnvParameterfvARB, _gloffset_GetProgramEnvParameterfvARB ),
+    NAME_FUNC_OFFSET( 11777, glGetProgramLocalParameterdvARB, _gloffset_GetProgramLocalParameterdvARB ),
+    NAME_FUNC_OFFSET( 11809, glGetProgramLocalParameterfvARB, _gloffset_GetProgramLocalParameterfvARB ),
+    NAME_FUNC_OFFSET( 11841, glGetProgramivARB, _gloffset_GetProgramivARB ),
+    NAME_FUNC_OFFSET( 11859, glGetProgramStringARB, _gloffset_GetProgramStringARB ),
+    NAME_FUNC_OFFSET( 11881, glProgramNamedParameter4fNV, _gloffset_ProgramNamedParameter4fNV ),
+    NAME_FUNC_OFFSET( 11909, glProgramNamedParameter4dNV, _gloffset_ProgramNamedParameter4dNV ),
+    NAME_FUNC_OFFSET( 11937, glProgramNamedParameter4fvNV, _gloffset_ProgramNamedParameter4fvNV ),
+    NAME_FUNC_OFFSET( 11966, glProgramNamedParameter4dvNV, _gloffset_ProgramNamedParameter4dvNV ),
+    NAME_FUNC_OFFSET( 11995, glGetProgramNamedParameterfvNV, _gloffset_GetProgramNamedParameterfvNV ),
+    NAME_FUNC_OFFSET( 12026, glGetProgramNamedParameterdvNV, _gloffset_GetProgramNamedParameterdvNV ),
+    NAME_FUNC_OFFSET( 12057, glBindBufferARB, _gloffset_BindBufferARB ),
+    NAME_FUNC_OFFSET( 12073, glBufferDataARB, _gloffset_BufferDataARB ),
+    NAME_FUNC_OFFSET( 12089, glBufferSubDataARB, _gloffset_BufferSubDataARB ),
+    NAME_FUNC_OFFSET( 12108, glDeleteBuffersARB, _gloffset_DeleteBuffersARB ),
+    NAME_FUNC_OFFSET( 12127, glGenBuffersARB, _gloffset_GenBuffersARB ),
+    NAME_FUNC_OFFSET( 12143, glGetBufferParameterivARB, _gloffset_GetBufferParameterivARB ),
+    NAME_FUNC_OFFSET( 12169, glGetBufferPointervARB, _gloffset_GetBufferPointervARB ),
+    NAME_FUNC_OFFSET( 12192, glGetBufferSubDataARB, _gloffset_GetBufferSubDataARB ),
+    NAME_FUNC_OFFSET( 12214, glIsBufferARB, _gloffset_IsBufferARB ),
+    NAME_FUNC_OFFSET( 12228, glMapBufferARB, _gloffset_MapBufferARB ),
+    NAME_FUNC_OFFSET( 12243, glUnmapBufferARB, _gloffset_UnmapBufferARB ),
+    NAME_FUNC_OFFSET( 12260, glDepthBoundsEXT, _gloffset_DepthBoundsEXT ),
+    NAME_FUNC_OFFSET( 12277, glGenQueriesARB, _gloffset_GenQueriesARB ),
+    NAME_FUNC_OFFSET( 12293, glDeleteQueriesARB, _gloffset_DeleteQueriesARB ),
+    NAME_FUNC_OFFSET( 12312, glIsQueryARB, _gloffset_IsQueryARB ),
+    NAME_FUNC_OFFSET( 12325, glBeginQueryARB, _gloffset_BeginQueryARB ),
+    NAME_FUNC_OFFSET( 12341, glEndQueryARB, _gloffset_EndQueryARB ),
+    NAME_FUNC_OFFSET( 12355, glGetQueryivARB, _gloffset_GetQueryivARB ),
+    NAME_FUNC_OFFSET( 12371, glGetQueryObjectivARB, _gloffset_GetQueryObjectivARB ),
+    NAME_FUNC_OFFSET( 12393, glGetQueryObjectuivARB, _gloffset_GetQueryObjectuivARB ),
+    NAME_FUNC_OFFSET( 12416, glMultiModeDrawArraysIBM, _gloffset_MultiModeDrawArraysIBM ),
+    NAME_FUNC_OFFSET( 12441, glMultiModeDrawElementsIBM, _gloffset_MultiModeDrawElementsIBM ),
+    NAME_FUNC_OFFSET( 12468, glBlendEquationSeparateEXT, _gloffset_BlendEquationSeparateEXT ),
+    NAME_FUNC_OFFSET( 12495, glDeleteObjectARB, _gloffset_DeleteObjectARB ),
+    NAME_FUNC_OFFSET( 12513, glGetHandleARB, _gloffset_GetHandleARB ),
+    NAME_FUNC_OFFSET( 12528, glDetachObjectARB, _gloffset_DetachObjectARB ),
+    NAME_FUNC_OFFSET( 12546, glCreateShaderObjectARB, _gloffset_CreateShaderObjectARB ),
+    NAME_FUNC_OFFSET( 12570, glShaderSourceARB, _gloffset_ShaderSourceARB ),
+    NAME_FUNC_OFFSET( 12588, glCompileShaderARB, _gloffset_CompileShaderARB ),
+    NAME_FUNC_OFFSET( 12607, glCreateProgramObjectARB, _gloffset_CreateProgramObjectARB ),
+    NAME_FUNC_OFFSET( 12632, glAttachObjectARB, _gloffset_AttachObjectARB ),
+    NAME_FUNC_OFFSET( 12650, glLinkProgramARB, _gloffset_LinkProgramARB ),
+    NAME_FUNC_OFFSET( 12667, glUseProgramObjectARB, _gloffset_UseProgramObjectARB ),
+    NAME_FUNC_OFFSET( 12689, glValidateProgramARB, _gloffset_ValidateProgramARB ),
+    NAME_FUNC_OFFSET( 12710, glUniform1fARB, _gloffset_Uniform1fARB ),
+    NAME_FUNC_OFFSET( 12725, glUniform2fARB, _gloffset_Uniform2fARB ),
+    NAME_FUNC_OFFSET( 12740, glUniform3fARB, _gloffset_Uniform3fARB ),
+    NAME_FUNC_OFFSET( 12755, glUniform4fARB, _gloffset_Uniform4fARB ),
+    NAME_FUNC_OFFSET( 12770, glUniform1iARB, _gloffset_Uniform1iARB ),
+    NAME_FUNC_OFFSET( 12785, glUniform2iARB, _gloffset_Uniform2iARB ),
+    NAME_FUNC_OFFSET( 12800, glUniform3iARB, _gloffset_Uniform3iARB ),
+    NAME_FUNC_OFFSET( 12815, glUniform4iARB, _gloffset_Uniform4iARB ),
+    NAME_FUNC_OFFSET( 12830, glUniform1fvARB, _gloffset_Uniform1fvARB ),
+    NAME_FUNC_OFFSET( 12846, glUniform2fvARB, _gloffset_Uniform2fvARB ),
+    NAME_FUNC_OFFSET( 12862, glUniform3fvARB, _gloffset_Uniform3fvARB ),
+    NAME_FUNC_OFFSET( 12878, glUniform4fvARB, _gloffset_Uniform4fvARB ),
+    NAME_FUNC_OFFSET( 12894, glUniform1ivARB, _gloffset_Uniform1ivARB ),
+    NAME_FUNC_OFFSET( 12910, glUniform2ivARB, _gloffset_Uniform2ivARB ),
+    NAME_FUNC_OFFSET( 12926, glUniform3ivARB, _gloffset_Uniform3ivARB ),
+    NAME_FUNC_OFFSET( 12942, glUniform4ivARB, _gloffset_Uniform4ivARB ),
+    NAME_FUNC_OFFSET( 12958, glUniformMatrix2fvARB, _gloffset_UniformMatrix2fvARB ),
+    NAME_FUNC_OFFSET( 12980, glUniformMatrix3fvARB, _gloffset_UniformMatrix3fvARB ),
+    NAME_FUNC_OFFSET( 13002, glUniformMatrix4fvARB, _gloffset_UniformMatrix4fvARB ),
+    NAME_FUNC_OFFSET( 13024, glGetObjectParameterfvARB, _gloffset_GetObjectParameterfvARB ),
+    NAME_FUNC_OFFSET( 13050, glGetObjectParameterivARB, _gloffset_GetObjectParameterivARB ),
+    NAME_FUNC_OFFSET( 13076, glGetInfoLogARB, _gloffset_GetInfoLogARB ),
+    NAME_FUNC_OFFSET( 13092, glGetAttachedObjectsARB, _gloffset_GetAttachedObjectsARB ),
+    NAME_FUNC_OFFSET( 13116, glGetUniformLocationARB, _gloffset_GetUniformLocationARB ),
+    NAME_FUNC_OFFSET( 13140, glGetActiveUniformARB, _gloffset_GetActiveUniformARB ),
+    NAME_FUNC_OFFSET( 13162, glGetUniformfvARB, _gloffset_GetUniformfvARB ),
+    NAME_FUNC_OFFSET( 13180, glGetUniformivARB, _gloffset_GetUniformivARB ),
+    NAME_FUNC_OFFSET( 13198, glGetShaderSourceARB, _gloffset_GetShaderSourceARB ),
+    NAME_FUNC_OFFSET( 13219, glBindAttribLocationARB, _gloffset_BindAttribLocationARB ),
+    NAME_FUNC_OFFSET( 13243, glGetActiveAttribARB, _gloffset_GetActiveAttribARB ),
+    NAME_FUNC_OFFSET( 13264, glGetAttribLocationARB, _gloffset_GetAttribLocationARB ),
+    NAME_FUNC_OFFSET( 13287, glGetVertexAttribdvNV, _gloffset_GetVertexAttribdvNV ),
+    NAME_FUNC_OFFSET( 13309, glGetVertexAttribfvNV, _gloffset_GetVertexAttribfvNV ),
+    NAME_FUNC_OFFSET( 13331, glGetVertexAttribivNV, _gloffset_GetVertexAttribivNV ),
+    NAME_FUNC_OFFSET( 13353, glVertexAttrib1dNV, _gloffset_VertexAttrib1dNV ),
+    NAME_FUNC_OFFSET( 13372, glVertexAttrib1dvNV, _gloffset_VertexAttrib1dvNV ),
+    NAME_FUNC_OFFSET( 13392, glVertexAttrib1fNV, _gloffset_VertexAttrib1fNV ),
+    NAME_FUNC_OFFSET( 13411, glVertexAttrib1fvNV, _gloffset_VertexAttrib1fvNV ),
+    NAME_FUNC_OFFSET( 13431, glVertexAttrib1sNV, _gloffset_VertexAttrib1sNV ),
+    NAME_FUNC_OFFSET( 13450, glVertexAttrib1svNV, _gloffset_VertexAttrib1svNV ),
+    NAME_FUNC_OFFSET( 13470, glVertexAttrib2dNV, _gloffset_VertexAttrib2dNV ),
+    NAME_FUNC_OFFSET( 13489, glVertexAttrib2dvNV, _gloffset_VertexAttrib2dvNV ),
+    NAME_FUNC_OFFSET( 13509, glVertexAttrib2fNV, _gloffset_VertexAttrib2fNV ),
+    NAME_FUNC_OFFSET( 13528, glVertexAttrib2fvNV, _gloffset_VertexAttrib2fvNV ),
+    NAME_FUNC_OFFSET( 13548, glVertexAttrib2sNV, _gloffset_VertexAttrib2sNV ),
+    NAME_FUNC_OFFSET( 13567, glVertexAttrib2svNV, _gloffset_VertexAttrib2svNV ),
+    NAME_FUNC_OFFSET( 13587, glVertexAttrib3dNV, _gloffset_VertexAttrib3dNV ),
+    NAME_FUNC_OFFSET( 13606, glVertexAttrib3dvNV, _gloffset_VertexAttrib3dvNV ),
+    NAME_FUNC_OFFSET( 13626, glVertexAttrib3fNV, _gloffset_VertexAttrib3fNV ),
+    NAME_FUNC_OFFSET( 13645, glVertexAttrib3fvNV, _gloffset_VertexAttrib3fvNV ),
+    NAME_FUNC_OFFSET( 13665, glVertexAttrib3sNV, _gloffset_VertexAttrib3sNV ),
+    NAME_FUNC_OFFSET( 13684, glVertexAttrib3svNV, _gloffset_VertexAttrib3svNV ),
+    NAME_FUNC_OFFSET( 13704, glVertexAttrib4dNV, _gloffset_VertexAttrib4dNV ),
+    NAME_FUNC_OFFSET( 13723, glVertexAttrib4dvNV, _gloffset_VertexAttrib4dvNV ),
+    NAME_FUNC_OFFSET( 13743, glVertexAttrib4fNV, _gloffset_VertexAttrib4fNV ),
+    NAME_FUNC_OFFSET( 13762, glVertexAttrib4fvNV, _gloffset_VertexAttrib4fvNV ),
+    NAME_FUNC_OFFSET( 13782, glVertexAttrib4sNV, _gloffset_VertexAttrib4sNV ),
+    NAME_FUNC_OFFSET( 13801, glVertexAttrib4svNV, _gloffset_VertexAttrib4svNV ),
+    NAME_FUNC_OFFSET( 13821, glVertexAttrib4ubNV, _gloffset_VertexAttrib4ubNV ),
+    NAME_FUNC_OFFSET( 13841, glVertexAttrib4ubvNV, _gloffset_VertexAttrib4ubvNV ),
+    NAME_FUNC_OFFSET( 13862, glGenFragmentShadersATI, _gloffset_GenFragmentShadersATI ),
+    NAME_FUNC_OFFSET( 13886, glBindFragmentShaderATI, _gloffset_BindFragmentShaderATI ),
+    NAME_FUNC_OFFSET( 13910, glDeleteFragmentShaderATI, _gloffset_DeleteFragmentShaderATI ),
+    NAME_FUNC_OFFSET( 13936, glBeginFragmentShaderATI, _gloffset_BeginFragmentShaderATI ),
+    NAME_FUNC_OFFSET( 13961, glEndFragmentShaderATI, _gloffset_EndFragmentShaderATI ),
+    NAME_FUNC_OFFSET( 13984, glPassTexCoordATI, _gloffset_PassTexCoordATI ),
+    NAME_FUNC_OFFSET( 14002, glSampleMapATI, _gloffset_SampleMapATI ),
+    NAME_FUNC_OFFSET( 14017, glColorFragmentOp1ATI, _gloffset_ColorFragmentOp1ATI ),
+    NAME_FUNC_OFFSET( 14039, glColorFragmentOp2ATI, _gloffset_ColorFragmentOp2ATI ),
+    NAME_FUNC_OFFSET( 14061, glColorFragmentOp3ATI, _gloffset_ColorFragmentOp3ATI ),
+    NAME_FUNC_OFFSET( 14083, glAlphaFragmentOp1ATI, _gloffset_AlphaFragmentOp1ATI ),
+    NAME_FUNC_OFFSET( 14105, glAlphaFragmentOp2ATI, _gloffset_AlphaFragmentOp2ATI ),
+    NAME_FUNC_OFFSET( 14127, glAlphaFragmentOp3ATI, _gloffset_AlphaFragmentOp3ATI ),
+    NAME_FUNC_OFFSET( 14149, glSetFragmentShaderConstantATI, _gloffset_SetFragmentShaderConstantATI ),
+    NAME_FUNC_OFFSET( 14180, glIsRenderbufferEXT, _gloffset_IsRenderbufferEXT ),
+    NAME_FUNC_OFFSET( 14200, glBindRenderbufferEXT, _gloffset_BindRenderbufferEXT ),
+    NAME_FUNC_OFFSET( 14222, glDeleteRenderbuffersEXT, _gloffset_DeleteRenderbuffersEXT ),
+    NAME_FUNC_OFFSET( 14247, glGenRenderbuffersEXT, _gloffset_GenRenderbuffersEXT ),
+    NAME_FUNC_OFFSET( 14269, glRenderbufferStorageEXT, _gloffset_RenderbufferStorageEXT ),
+    NAME_FUNC_OFFSET( 14294, glGetRenderbufferParameterivEXT, _gloffset_GetRenderbufferParameterivEXT ),
+    NAME_FUNC_OFFSET( 14326, glIsFramebufferEXT, _gloffset_IsFramebufferEXT ),
+    NAME_FUNC_OFFSET( 14345, glBindFramebufferEXT, _gloffset_BindFramebufferEXT ),
+    NAME_FUNC_OFFSET( 14366, glDeleteFramebuffersEXT, _gloffset_DeleteFramebuffersEXT ),
+    NAME_FUNC_OFFSET( 14390, glGenFramebuffersEXT, _gloffset_GenFramebuffersEXT ),
+    NAME_FUNC_OFFSET( 14411, glCheckFramebufferStatusEXT, _gloffset_CheckFramebufferStatusEXT ),
+    NAME_FUNC_OFFSET( 14439, glFramebufferTexture1DEXT, _gloffset_FramebufferTexture1DEXT ),
+    NAME_FUNC_OFFSET( 14465, glFramebufferTexture2DEXT, _gloffset_FramebufferTexture2DEXT ),
+    NAME_FUNC_OFFSET( 14491, glFramebufferTexture3DEXT, _gloffset_FramebufferTexture3DEXT ),
+    NAME_FUNC_OFFSET( 14517, glFramebufferRenderbufferEXT, _gloffset_FramebufferRenderbufferEXT ),
+    NAME_FUNC_OFFSET( 14546, glGetFramebufferAttachmentParameterivEXT, _gloffset_GetFramebufferAttachmentParameterivEXT ),
+    NAME_FUNC_OFFSET( 14587, glGenerateMipmapEXT, _gloffset_GenerateMipmapEXT ),
+    NAME_FUNC_OFFSET( 14607, glStencilFuncSeparate, _gloffset_StencilFuncSeparate ),
+    NAME_FUNC_OFFSET( 14629, glStencilOpSeparate, _gloffset_StencilOpSeparate ),
+    NAME_FUNC_OFFSET( 14649, glStencilMaskSeparate, _gloffset_StencilMaskSeparate ),
+    NAME_FUNC_OFFSET( 14671, glArrayElementEXT, _gloffset_ArrayElement ),
+    NAME_FUNC_OFFSET( 14689, glBindTextureEXT, _gloffset_BindTexture ),
+    NAME_FUNC_OFFSET( 14706, glDrawArraysEXT, _gloffset_DrawArrays ),
+    NAME_FUNC_OFFSET( 14722, glCopyTexImage1DEXT, _gloffset_CopyTexImage1D ),
+    NAME_FUNC_OFFSET( 14742, glCopyTexImage2DEXT, _gloffset_CopyTexImage2D ),
+    NAME_FUNC_OFFSET( 14762, glCopyTexSubImage1DEXT, _gloffset_CopyTexSubImage1D ),
+    NAME_FUNC_OFFSET( 14785, glCopyTexSubImage2DEXT, _gloffset_CopyTexSubImage2D ),
+    NAME_FUNC_OFFSET( 14808, glDeleteTexturesEXT, _gloffset_DeleteTextures ),
+    NAME_FUNC_OFFSET( 14828, glGetPointervEXT, _gloffset_GetPointerv ),
+    NAME_FUNC_OFFSET( 14845, glPrioritizeTexturesEXT, _gloffset_PrioritizeTextures ),
+    NAME_FUNC_OFFSET( 14869, glTexSubImage1DEXT, _gloffset_TexSubImage1D ),
+    NAME_FUNC_OFFSET( 14888, glTexSubImage2DEXT, _gloffset_TexSubImage2D ),
+    NAME_FUNC_OFFSET( 14907, glBlendColorEXT, _gloffset_BlendColor ),
+    NAME_FUNC_OFFSET( 14923, glBlendEquationEXT, _gloffset_BlendEquation ),
+    NAME_FUNC_OFFSET( 14942, glDrawRangeElementsEXT, _gloffset_DrawRangeElements ),
+    NAME_FUNC_OFFSET( 14965, glColorTableSGI, _gloffset_ColorTable ),
+    NAME_FUNC_OFFSET( 14981, glColorTableEXT, _gloffset_ColorTable ),
+    NAME_FUNC_OFFSET( 14997, glColorTableParameterfvSGI, _gloffset_ColorTableParameterfv ),
+    NAME_FUNC_OFFSET( 15024, glColorTableParameterivSGI, _gloffset_ColorTableParameteriv ),
+    NAME_FUNC_OFFSET( 15051, glCopyColorTableSGI, _gloffset_CopyColorTable ),
+    NAME_FUNC_OFFSET( 15071, glColorSubTableEXT, _gloffset_ColorSubTable ),
+    NAME_FUNC_OFFSET( 15090, glCopyColorSubTableEXT, _gloffset_CopyColorSubTable ),
+    NAME_FUNC_OFFSET( 15113, glConvolutionFilter1DEXT, _gloffset_ConvolutionFilter1D ),
+    NAME_FUNC_OFFSET( 15138, glConvolutionFilter2DEXT, _gloffset_ConvolutionFilter2D ),
+    NAME_FUNC_OFFSET( 15163, glConvolutionParameterfEXT, _gloffset_ConvolutionParameterf ),
+    NAME_FUNC_OFFSET( 15190, glConvolutionParameterfvEXT, _gloffset_ConvolutionParameterfv ),
+    NAME_FUNC_OFFSET( 15218, glConvolutionParameteriEXT, _gloffset_ConvolutionParameteri ),
+    NAME_FUNC_OFFSET( 15245, glConvolutionParameterivEXT, _gloffset_ConvolutionParameteriv ),
+    NAME_FUNC_OFFSET( 15273, glCopyConvolutionFilter1DEXT, _gloffset_CopyConvolutionFilter1D ),
+    NAME_FUNC_OFFSET( 15302, glCopyConvolutionFilter2DEXT, _gloffset_CopyConvolutionFilter2D ),
+    NAME_FUNC_OFFSET( 15331, glSeparableFilter2DEXT, _gloffset_SeparableFilter2D ),
+    NAME_FUNC_OFFSET( 15354, glHistogramEXT, _gloffset_Histogram ),
+    NAME_FUNC_OFFSET( 15369, glMinmaxEXT, _gloffset_Minmax ),
+    NAME_FUNC_OFFSET( 15381, glResetHistogramEXT, _gloffset_ResetHistogram ),
+    NAME_FUNC_OFFSET( 15401, glResetMinmaxEXT, _gloffset_ResetMinmax ),
+    NAME_FUNC_OFFSET( 15418, glTexImage3DEXT, _gloffset_TexImage3D ),
+    NAME_FUNC_OFFSET( 15434, glTexSubImage3DEXT, _gloffset_TexSubImage3D ),
+    NAME_FUNC_OFFSET( 15453, glCopyTexSubImage3DEXT, _gloffset_CopyTexSubImage3D ),
+    NAME_FUNC_OFFSET( 15476, glActiveTexture, _gloffset_ActiveTextureARB ),
+    NAME_FUNC_OFFSET( 15492, glClientActiveTexture, _gloffset_ClientActiveTextureARB ),
+    NAME_FUNC_OFFSET( 15514, glMultiTexCoord1d, _gloffset_MultiTexCoord1dARB ),
+    NAME_FUNC_OFFSET( 15532, glMultiTexCoord1dv, _gloffset_MultiTexCoord1dvARB ),
+    NAME_FUNC_OFFSET( 15551, glMultiTexCoord1f, _gloffset_MultiTexCoord1fARB ),
+    NAME_FUNC_OFFSET( 15569, glMultiTexCoord1fv, _gloffset_MultiTexCoord1fvARB ),
+    NAME_FUNC_OFFSET( 15588, glMultiTexCoord1i, _gloffset_MultiTexCoord1iARB ),
+    NAME_FUNC_OFFSET( 15606, glMultiTexCoord1iv, _gloffset_MultiTexCoord1ivARB ),
+    NAME_FUNC_OFFSET( 15625, glMultiTexCoord1s, _gloffset_MultiTexCoord1sARB ),
+    NAME_FUNC_OFFSET( 15643, glMultiTexCoord1sv, _gloffset_MultiTexCoord1svARB ),
+    NAME_FUNC_OFFSET( 15662, glMultiTexCoord2d, _gloffset_MultiTexCoord2dARB ),
+    NAME_FUNC_OFFSET( 15680, glMultiTexCoord2dv, _gloffset_MultiTexCoord2dvARB ),
+    NAME_FUNC_OFFSET( 15699, glMultiTexCoord2f, _gloffset_MultiTexCoord2fARB ),
+    NAME_FUNC_OFFSET( 15717, glMultiTexCoord2fv, _gloffset_MultiTexCoord2fvARB ),
+    NAME_FUNC_OFFSET( 15736, glMultiTexCoord2i, _gloffset_MultiTexCoord2iARB ),
+    NAME_FUNC_OFFSET( 15754, glMultiTexCoord2iv, _gloffset_MultiTexCoord2ivARB ),
+    NAME_FUNC_OFFSET( 15773, glMultiTexCoord2s, _gloffset_MultiTexCoord2sARB ),
+    NAME_FUNC_OFFSET( 15791, glMultiTexCoord2sv, _gloffset_MultiTexCoord2svARB ),
+    NAME_FUNC_OFFSET( 15810, glMultiTexCoord3d, _gloffset_MultiTexCoord3dARB ),
+    NAME_FUNC_OFFSET( 15828, glMultiTexCoord3dv, _gloffset_MultiTexCoord3dvARB ),
+    NAME_FUNC_OFFSET( 15847, glMultiTexCoord3f, _gloffset_MultiTexCoord3fARB ),
+    NAME_FUNC_OFFSET( 15865, glMultiTexCoord3fv, _gloffset_MultiTexCoord3fvARB ),
+    NAME_FUNC_OFFSET( 15884, glMultiTexCoord3i, _gloffset_MultiTexCoord3iARB ),
+    NAME_FUNC_OFFSET( 15902, glMultiTexCoord3iv, _gloffset_MultiTexCoord3ivARB ),
+    NAME_FUNC_OFFSET( 15921, glMultiTexCoord3s, _gloffset_MultiTexCoord3sARB ),
+    NAME_FUNC_OFFSET( 15939, glMultiTexCoord3sv, _gloffset_MultiTexCoord3svARB ),
+    NAME_FUNC_OFFSET( 15958, glMultiTexCoord4d, _gloffset_MultiTexCoord4dARB ),
+    NAME_FUNC_OFFSET( 15976, glMultiTexCoord4dv, _gloffset_MultiTexCoord4dvARB ),
+    NAME_FUNC_OFFSET( 15995, glMultiTexCoord4f, _gloffset_MultiTexCoord4fARB ),
+    NAME_FUNC_OFFSET( 16013, glMultiTexCoord4fv, _gloffset_MultiTexCoord4fvARB ),
+    NAME_FUNC_OFFSET( 16032, glMultiTexCoord4i, _gloffset_MultiTexCoord4iARB ),
+    NAME_FUNC_OFFSET( 16050, glMultiTexCoord4iv, _gloffset_MultiTexCoord4ivARB ),
+    NAME_FUNC_OFFSET( 16069, glMultiTexCoord4s, _gloffset_MultiTexCoord4sARB ),
+    NAME_FUNC_OFFSET( 16087, glMultiTexCoord4sv, _gloffset_MultiTexCoord4svARB ),
+    NAME_FUNC_OFFSET( 16106, glLoadTransposeMatrixf, _gloffset_LoadTransposeMatrixfARB ),
+    NAME_FUNC_OFFSET( 16129, glLoadTransposeMatrixd, _gloffset_LoadTransposeMatrixdARB ),
+    NAME_FUNC_OFFSET( 16152, glMultTransposeMatrixf, _gloffset_MultTransposeMatrixfARB ),
+    NAME_FUNC_OFFSET( 16175, glMultTransposeMatrixd, _gloffset_MultTransposeMatrixdARB ),
+    NAME_FUNC_OFFSET( 16198, glSampleCoverage, _gloffset_SampleCoverageARB ),
+    NAME_FUNC_OFFSET( 16215, glDrawBuffersATI, _gloffset_DrawBuffersARB ),
+    NAME_FUNC_OFFSET( 16232, glSampleMaskEXT, _gloffset_SampleMaskSGIS ),
+    NAME_FUNC_OFFSET( 16248, glSamplePatternEXT, _gloffset_SamplePatternSGIS ),
+    NAME_FUNC_OFFSET( 16267, glPointParameterf, _gloffset_PointParameterfEXT ),
+    NAME_FUNC_OFFSET( 16285, glPointParameterfARB, _gloffset_PointParameterfEXT ),
+    NAME_FUNC_OFFSET( 16306, glPointParameterfSGIS, _gloffset_PointParameterfEXT ),
+    NAME_FUNC_OFFSET( 16328, glPointParameterfv, _gloffset_PointParameterfvEXT ),
+    NAME_FUNC_OFFSET( 16347, glPointParameterfvARB, _gloffset_PointParameterfvEXT ),
+    NAME_FUNC_OFFSET( 16369, glPointParameterfvSGIS, _gloffset_PointParameterfvEXT ),
+    NAME_FUNC_OFFSET( 16392, glWindowPos2d, _gloffset_WindowPos2dMESA ),
+    NAME_FUNC_OFFSET( 16406, glWindowPos2dARB, _gloffset_WindowPos2dMESA ),
+    NAME_FUNC_OFFSET( 16423, glWindowPos2dv, _gloffset_WindowPos2dvMESA ),
+    NAME_FUNC_OFFSET( 16438, glWindowPos2dvARB, _gloffset_WindowPos2dvMESA ),
+    NAME_FUNC_OFFSET( 16456, glWindowPos2f, _gloffset_WindowPos2fMESA ),
+    NAME_FUNC_OFFSET( 16470, glWindowPos2fARB, _gloffset_WindowPos2fMESA ),
+    NAME_FUNC_OFFSET( 16487, glWindowPos2fv, _gloffset_WindowPos2fvMESA ),
+    NAME_FUNC_OFFSET( 16502, glWindowPos2fvARB, _gloffset_WindowPos2fvMESA ),
+    NAME_FUNC_OFFSET( 16520, glWindowPos2i, _gloffset_WindowPos2iMESA ),
+    NAME_FUNC_OFFSET( 16534, glWindowPos2iARB, _gloffset_WindowPos2iMESA ),
+    NAME_FUNC_OFFSET( 16551, glWindowPos2iv, _gloffset_WindowPos2ivMESA ),
+    NAME_FUNC_OFFSET( 16566, glWindowPos2ivARB, _gloffset_WindowPos2ivMESA ),
+    NAME_FUNC_OFFSET( 16584, glWindowPos2s, _gloffset_WindowPos2sMESA ),
+    NAME_FUNC_OFFSET( 16598, glWindowPos2sARB, _gloffset_WindowPos2sMESA ),
+    NAME_FUNC_OFFSET( 16615, glWindowPos2sv, _gloffset_WindowPos2svMESA ),
+    NAME_FUNC_OFFSET( 16630, glWindowPos2svARB, _gloffset_WindowPos2svMESA ),
+    NAME_FUNC_OFFSET( 16648, glWindowPos3d, _gloffset_WindowPos3dMESA ),
+    NAME_FUNC_OFFSET( 16662, glWindowPos3dARB, _gloffset_WindowPos3dMESA ),
+    NAME_FUNC_OFFSET( 16679, glWindowPos3dv, _gloffset_WindowPos3dvMESA ),
+    NAME_FUNC_OFFSET( 16694, glWindowPos3dvARB, _gloffset_WindowPos3dvMESA ),
+    NAME_FUNC_OFFSET( 16712, glWindowPos3f, _gloffset_WindowPos3fMESA ),
+    NAME_FUNC_OFFSET( 16726, glWindowPos3fARB, _gloffset_WindowPos3fMESA ),
+    NAME_FUNC_OFFSET( 16743, glWindowPos3fv, _gloffset_WindowPos3fvMESA ),
+    NAME_FUNC_OFFSET( 16758, glWindowPos3fvARB, _gloffset_WindowPos3fvMESA ),
+    NAME_FUNC_OFFSET( 16776, glWindowPos3i, _gloffset_WindowPos3iMESA ),
+    NAME_FUNC_OFFSET( 16790, glWindowPos3iARB, _gloffset_WindowPos3iMESA ),
+    NAME_FUNC_OFFSET( 16807, glWindowPos3iv, _gloffset_WindowPos3ivMESA ),
+    NAME_FUNC_OFFSET( 16822, glWindowPos3ivARB, _gloffset_WindowPos3ivMESA ),
+    NAME_FUNC_OFFSET( 16840, glWindowPos3s, _gloffset_WindowPos3sMESA ),
+    NAME_FUNC_OFFSET( 16854, glWindowPos3sARB, _gloffset_WindowPos3sMESA ),
+    NAME_FUNC_OFFSET( 16871, glWindowPos3sv, _gloffset_WindowPos3svMESA ),
+    NAME_FUNC_OFFSET( 16886, glWindowPos3svARB, _gloffset_WindowPos3svMESA ),
+    NAME_FUNC_OFFSET( 16904, glBlendFuncSeparate, _gloffset_BlendFuncSeparateEXT ),
+    NAME_FUNC_OFFSET( 16924, glBlendFuncSeparateINGR, _gloffset_BlendFuncSeparateEXT ),
+    NAME_FUNC_OFFSET( 16948, glFogCoordf, _gloffset_FogCoordfEXT ),
+    NAME_FUNC_OFFSET( 16960, glFogCoordfv, _gloffset_FogCoordfvEXT ),
+    NAME_FUNC_OFFSET( 16973, glFogCoordd, _gloffset_FogCoorddEXT ),
+    NAME_FUNC_OFFSET( 16985, glFogCoorddv, _gloffset_FogCoorddvEXT ),
+    NAME_FUNC_OFFSET( 16998, glFogCoordPointer, _gloffset_FogCoordPointerEXT ),
+    NAME_FUNC_OFFSET( 17016, glCompressedTexImage3D, _gloffset_CompressedTexImage3DARB ),
+    NAME_FUNC_OFFSET( 17039, glCompressedTexImage2D, _gloffset_CompressedTexImage2DARB ),
+    NAME_FUNC_OFFSET( 17062, glCompressedTexImage1D, _gloffset_CompressedTexImage1DARB ),
+    NAME_FUNC_OFFSET( 17085, glCompressedTexSubImage3D, _gloffset_CompressedTexSubImage3DARB ),
+    NAME_FUNC_OFFSET( 17111, glCompressedTexSubImage2D, _gloffset_CompressedTexSubImage2DARB ),
+    NAME_FUNC_OFFSET( 17137, glCompressedTexSubImage1D, _gloffset_CompressedTexSubImage1DARB ),
+    NAME_FUNC_OFFSET( 17163, glGetCompressedTexImage, _gloffset_GetCompressedTexImageARB ),
+    NAME_FUNC_OFFSET( 17187, glSecondaryColor3b, _gloffset_SecondaryColor3bEXT ),
+    NAME_FUNC_OFFSET( 17206, glSecondaryColor3bv, _gloffset_SecondaryColor3bvEXT ),
+    NAME_FUNC_OFFSET( 17226, glSecondaryColor3d, _gloffset_SecondaryColor3dEXT ),
+    NAME_FUNC_OFFSET( 17245, glSecondaryColor3dv, _gloffset_SecondaryColor3dvEXT ),
+    NAME_FUNC_OFFSET( 17265, glSecondaryColor3f, _gloffset_SecondaryColor3fEXT ),
+    NAME_FUNC_OFFSET( 17284, glSecondaryColor3fv, _gloffset_SecondaryColor3fvEXT ),
+    NAME_FUNC_OFFSET( 17304, glSecondaryColor3i, _gloffset_SecondaryColor3iEXT ),
+    NAME_FUNC_OFFSET( 17323, glSecondaryColor3iv, _gloffset_SecondaryColor3ivEXT ),
+    NAME_FUNC_OFFSET( 17343, glSecondaryColor3s, _gloffset_SecondaryColor3sEXT ),
+    NAME_FUNC_OFFSET( 17362, glSecondaryColor3sv, _gloffset_SecondaryColor3svEXT ),
+    NAME_FUNC_OFFSET( 17382, glSecondaryColor3ub, _gloffset_SecondaryColor3ubEXT ),
+    NAME_FUNC_OFFSET( 17402, glSecondaryColor3ubv, _gloffset_SecondaryColor3ubvEXT ),
+    NAME_FUNC_OFFSET( 17423, glSecondaryColor3ui, _gloffset_SecondaryColor3uiEXT ),
+    NAME_FUNC_OFFSET( 17443, glSecondaryColor3uiv, _gloffset_SecondaryColor3uivEXT ),
+    NAME_FUNC_OFFSET( 17464, glSecondaryColor3us, _gloffset_SecondaryColor3usEXT ),
+    NAME_FUNC_OFFSET( 17484, glSecondaryColor3usv, _gloffset_SecondaryColor3usvEXT ),
+    NAME_FUNC_OFFSET( 17505, glSecondaryColorPointer, _gloffset_SecondaryColorPointerEXT ),
+    NAME_FUNC_OFFSET( 17529, glBindProgramARB, _gloffset_BindProgramNV ),
+    NAME_FUNC_OFFSET( 17546, glDeleteProgramsARB, _gloffset_DeleteProgramsNV ),
+    NAME_FUNC_OFFSET( 17566, glGenProgramsARB, _gloffset_GenProgramsNV ),
+    NAME_FUNC_OFFSET( 17583, glGetVertexAttribPointervARB, _gloffset_GetVertexAttribPointervNV ),
+    NAME_FUNC_OFFSET( 17612, glIsProgramARB, _gloffset_IsProgramNV ),
+    NAME_FUNC_OFFSET( 17627, glPointParameteri, _gloffset_PointParameteriNV ),
+    NAME_FUNC_OFFSET( 17645, glPointParameteriv, _gloffset_PointParameterivNV ),
+    NAME_FUNC_OFFSET( 17664, glMultiDrawArrays, _gloffset_MultiDrawArraysEXT ),
+    NAME_FUNC_OFFSET( 17682, glMultiDrawElements, _gloffset_MultiDrawElementsEXT ),
+    NAME_FUNC_OFFSET( 17702, glBindBuffer, _gloffset_BindBufferARB ),
+    NAME_FUNC_OFFSET( 17715, glBufferData, _gloffset_BufferDataARB ),
+    NAME_FUNC_OFFSET( 17728, glBufferSubData, _gloffset_BufferSubDataARB ),
+    NAME_FUNC_OFFSET( 17744, glDeleteBuffers, _gloffset_DeleteBuffersARB ),
+    NAME_FUNC_OFFSET( 17760, glGenBuffers, _gloffset_GenBuffersARB ),
+    NAME_FUNC_OFFSET( 17773, glGetBufferParameteriv, _gloffset_GetBufferParameterivARB ),
+    NAME_FUNC_OFFSET( 17796, glGetBufferPointerv, _gloffset_GetBufferPointervARB ),
+    NAME_FUNC_OFFSET( 17816, glGetBufferSubData, _gloffset_GetBufferSubDataARB ),
+    NAME_FUNC_OFFSET( 17835, glIsBuffer, _gloffset_IsBufferARB ),
+    NAME_FUNC_OFFSET( 17846, glMapBuffer, _gloffset_MapBufferARB ),
+    NAME_FUNC_OFFSET( 17858, glUnmapBuffer, _gloffset_UnmapBufferARB ),
+    NAME_FUNC_OFFSET( 17872, glGenQueries, _gloffset_GenQueriesARB ),
+    NAME_FUNC_OFFSET( 17885, glDeleteQueries, _gloffset_DeleteQueriesARB ),
+    NAME_FUNC_OFFSET( 17901, glIsQuery, _gloffset_IsQueryARB ),
+    NAME_FUNC_OFFSET( 17911, glBeginQuery, _gloffset_BeginQueryARB ),
+    NAME_FUNC_OFFSET( 17924, glEndQuery, _gloffset_EndQueryARB ),
+    NAME_FUNC_OFFSET( 17935, glGetQueryiv, _gloffset_GetQueryivARB ),
+    NAME_FUNC_OFFSET( 17948, glGetQueryObjectiv, _gloffset_GetQueryObjectivARB ),
+    NAME_FUNC_OFFSET( 17967, glGetQueryObjectuiv, _gloffset_GetQueryObjectuivARB ),
+    NAME_FUNC_OFFSET( 17987, glBlendEquationSeparateATI, _gloffset_BlendEquationSeparateEXT ),
     NAME_FUNC_OFFSET( -1, NULL, 0 )
 };
 
diff --git a/src/mesa/glapi/typeexpr.py b/src/mesa/glapi/typeexpr.py
new file mode 100644
index 00000000000..eface2a521f
--- /dev/null
+++ b/src/mesa/glapi/typeexpr.py
@@ -0,0 +1,288 @@
+#!/usr/bin/env python
+
+# (C) Copyright IBM Corporation 2005
+# All Rights Reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# on the rights to use, copy, modify, merge, publish, distribute, sub
+# license, and/or sell copies of the Software, and to permit persons to whom
+# the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice (including the next
+# paragraph) shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
+# IBM AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#
+# Authors:
+#    Ian Romanick <[email protected]>
+
+import string, copy
+
+class type_node:
+	def __init__(self):
+		self.pointer = 0
+		self.const = 0
+		self.signed = 1
+		self.integer = 1
+
+		# If elements is set to non-zero, then field is an array.
+		self.elements = 0
+
+		self.name = None
+		self.size = 0
+		return
+
+
+	def string(self):
+		s = ""
+		
+		if self.pointer:
+			s = "* "
+
+		if self.const:
+			s += "const "
+
+		if not self.pointer:
+			if self.integer:
+				if self.signed:
+					s += "signed "
+				else:
+					s += "unsigned "
+
+			if self.name:
+				s += "%s " % (self.name)
+
+		return s
+
+
+class type_table:
+	def __init__(self):
+		self.types_by_name = {}
+		return
+
+
+	def add_type(self, type_expr):
+		self.types_by_name[ type_expr.get_base_name() ] = type_expr
+		return
+
+
+	def find_type(self, name):
+		if name in self.types_by_name:
+			return self.types_by_name[ name ]
+		else:
+			return None
+
+
+def create_initial_types():
+	tt = type_table()
+
+	basic_types = [ ["char",   1, 1], \
+	                ["short",  2, 1], \
+	                ["int",    4, 1], \
+	                ["long",   4, 1], \
+			["float",  4, 0], \
+			["double", 8, 0], \
+			["enum",   4, 1] ]
+
+
+	for [type_name, type_size, integer] in basic_types:
+		te = type_expression(None)
+		tn = type_node()
+		tn.name = type_name
+		tn.size = type_size
+		tn.integer = integer
+		te.expr.append(tn)
+		tt.add_type( te )
+
+	type_expression.built_in_types = tt
+	return
+
+
+class type_expression:
+	built_in_types = None
+
+	def __init__(self, type_string, extra_types = None):
+		self.expr = []
+
+		if not type_string: return
+
+		self.original_string = type_string
+
+		if not type_expression.built_in_types:
+			raise RuntimeError("create_initial_types must be called before creating type_expression objects.")
+
+		
+		elements = string.split( string.replace( type_string, "*", " * " ) )
+
+		const = 0
+		t = None
+		signed = 0
+		unsigned = 0
+
+		for i in elements:
+			if i == "const":
+				if t and t.pointer:
+					t.const = 1
+				else:
+					const = 1
+			elif i == "signed":
+				signed = 1
+			elif i == "unsigned":
+				unsigned = 1
+			elif i == "*":
+				# This is a quirky special-case because of the
+				# way the C works for types.  If 'unsigned' is
+				# specified all by itself, it is treated the
+				# same as "unsigned int".
+
+				if unsigned:
+					self.set_base_type( "int", signed, unsigned, const, extra_types )
+					const = 0
+					signed = 0
+					unsigned = 0
+
+				if not self.expr:
+					raise RuntimeError("Invalid type expression (dangling pointer)")
+
+				if signed:
+					raise RuntimeError("Invalid type expression (signed / unsigned applied to pointer)")
+
+				t = type_node()
+				t.pointer = 1
+				self.expr.append( t )
+			else:
+				if self.expr:
+					raise RuntimeError('Invalid type expression (garbage after pointer qualifier -> "%s")' % (self.original_string))
+
+				self.set_base_type( i, signed, unsigned, const, extra_types )
+				const = 0
+				signed = 0
+				unsigned = 0
+
+			if signed and unsigned:
+				raise RuntimeError("Invalid type expression (both signed and unsigned specified)")
+				
+
+		if const:
+			raise RuntimeError("Invalid type expression (dangling const)")
+
+		if unsigned:
+			raise RuntimeError("Invalid type expression (dangling signed)")
+
+		if signed:
+			raise RuntimeError("Invalid type expression (dangling unsigned)")
+
+		return
+
+
+	def set_base_type(self, type_name, signed, unsigned, const, extra_types):
+		te = type_expression.built_in_types.find_type( type_name )
+		if not te:
+			te = extra_types.find_type( type_name )
+
+		if not te:
+			raise RuntimeError('Unknown base type "%s".' % (type_name))
+
+		self.expr = copy.deepcopy(te.expr)
+
+		t = self.expr[ len(self.expr) - 1 ]
+		t.const = const
+		if signed:
+			t.signed = 1
+		elif unsigned:
+			t.signed = 0
+
+
+	def set_base_type_node(self, tn):
+		self.expr = [tn]
+		return
+
+
+	def set_elements(self, count):
+		tn = self.expr[0]
+
+		tn.elements = count
+		return
+
+
+	def string(self):
+		s = ""
+		for t in self.expr:
+			s += t.string()
+
+		return s
+
+
+	def get_base_type_node(self):
+		return self.expr[0]
+
+
+	def get_base_name(self):
+		if len(self.expr):
+			return self.expr[0].name
+		else:
+			return None
+
+
+	def get_element_size(self):
+		tn = self.expr[0]
+
+		if tn.elements:
+			return tn.elements * tn.size
+		else:
+			return tn.size
+
+
+	def get_element_count(self):
+		tn = self.expr[0]
+		return tn.elements
+
+
+	def get_stack_size(self):
+		tn = self.expr[ len(self.expr) - 1 ]
+
+		if tn.elements or tn.pointer:
+			return 4
+		elif not tn.integer:
+			return tn.size
+		else:
+			return 4
+
+
+	def is_pointer(self):
+		tn = self.expr[ len(self.expr) - 1 ]
+		return tn.pointer
+
+
+	def format_string(self):
+		tn = self.expr[ len(self.expr) - 1 ]
+		if tn.pointer:
+			return "%p"
+		elif not tn.integer:
+			return "%f"
+		else:
+			return "%d"
+
+
+
+if __name__ == '__main__':
+	
+	types_to_try = [ "int", "int *", "const int *", "int * const", "const int * const", \
+	                 "unsigned * const *", \
+			 "float", "const double", "double * const"]
+
+	create_initial_types()
+
+	for t in types_to_try:
+		print 'Trying "%s"...' % (t)
+		te = type_expression( t )
+		print 'Got "%s" (%u, %u).' % (te.string(), te.get_stack_size(), te.get_element_size())
diff --git a/src/mesa/main/enums.c b/src/mesa/main/enums.c
index ed63742b368..c653e0c48ff 100644
--- a/src/mesa/main/enums.c
+++ b/src/mesa/main/enums.c
@@ -2138,1152 +2138,1152 @@ static const enum_elt all_enums[1612] =
    {  9922, 0x0000802C }, /* GL_HISTOGRAM_LUMINANCE_SIZE_EXT */
    {  9954, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE */
    {  9976, 0x00008028 }, /* GL_HISTOGRAM_RED_SIZE_EXT */
-   {  10002, 0x0000802D }, /* GL_HISTOGRAM_SINK */
-   {  10020, 0x0000802D }, /* GL_HISTOGRAM_SINK_EXT */
-   {  10042, 0x00008026 }, /* GL_HISTOGRAM_WIDTH */
-   {  10061, 0x00008026 }, /* GL_HISTOGRAM_WIDTH_EXT */
-   {  10084, 0x0000862A }, /* GL_IDENTITY_NV */
-   {  10099, 0x00008150 }, /* GL_IGNORE_BORDER_HP */
-   {  10119, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
-   {  10159, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
-   {  10197, 0x00001E02 }, /* GL_INCR */
-   {  10205, 0x00008507 }, /* GL_INCR_WRAP */
-   {  10218, 0x00008507 }, /* GL_INCR_WRAP_EXT */
-   {  10235, 0x00008077 }, /* GL_INDEX_ARRAY */
-   {  10250, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING */
-   {  10280, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING_ARB */
-   {  10314, 0x00008091 }, /* GL_INDEX_ARRAY_POINTER */
-   {  10337, 0x00008086 }, /* GL_INDEX_ARRAY_STRIDE */
-   {  10359, 0x00008085 }, /* GL_INDEX_ARRAY_TYPE */
-   {  10379, 0x00000D51 }, /* GL_INDEX_BITS */
-   {  10393, 0x00000C20 }, /* GL_INDEX_CLEAR_VALUE */
-   {  10414, 0x00000BF1 }, /* GL_INDEX_LOGIC_OP */
-   {  10432, 0x00000C30 }, /* GL_INDEX_MODE */
-   {  10446, 0x00000D13 }, /* GL_INDEX_OFFSET */
-   {  10462, 0x00000D12 }, /* GL_INDEX_SHIFT */
-   {  10477, 0x00000C21 }, /* GL_INDEX_WRITEMASK */
-   {  10496, 0x00001404 }, /* GL_INT */
-   {  10503, 0x00008049 }, /* GL_INTENSITY */
-   {  10516, 0x0000804C }, /* GL_INTENSITY12 */
-   {  10531, 0x0000804C }, /* GL_INTENSITY12_EXT */
-   {  10550, 0x0000804D }, /* GL_INTENSITY16 */
-   {  10565, 0x0000804D }, /* GL_INTENSITY16_EXT */
-   {  10584, 0x0000804A }, /* GL_INTENSITY4 */
-   {  10598, 0x0000804A }, /* GL_INTENSITY4_EXT */
-   {  10616, 0x0000804B }, /* GL_INTENSITY8 */
-   {  10630, 0x0000804B }, /* GL_INTENSITY8_EXT */
-   {  10648, 0x00008049 }, /* GL_INTENSITY_EXT */
-   {  10665, 0x00008575 }, /* GL_INTERPOLATE */
-   {  10680, 0x00008575 }, /* GL_INTERPOLATE_ARB */
-   {  10699, 0x00008575 }, /* GL_INTERPOLATE_EXT */
-   {  10718, 0x00008B53 }, /* GL_INT_VEC2_ARB */
-   {  10734, 0x00008B54 }, /* GL_INT_VEC3_ARB */
-   {  10750, 0x00008B55 }, /* GL_INT_VEC4_ARB */
-   {  10766, 0x00000500 }, /* GL_INVALID_ENUM */
-   {  10782, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */
-   {  10819, 0x00000502 }, /* GL_INVALID_OPERATION */
-   {  10840, 0x00000501 }, /* GL_INVALID_VALUE */
-   {  10857, 0x0000862B }, /* GL_INVERSE_NV */
-   {  10871, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */
-   {  10895, 0x0000150A }, /* GL_INVERT */
-   {  10905, 0x00001E00 }, /* GL_KEEP */
-   {  10913, 0x00000406 }, /* GL_LEFT */
-   {  10921, 0x00000203 }, /* GL_LEQUAL */
-   {  10931, 0x00000201 }, /* GL_LESS */
-   {  10939, 0x00004000 }, /* GL_LIGHT0 */
-   {  10949, 0x00004001 }, /* GL_LIGHT1 */
-   {  10959, 0x00004002 }, /* GL_LIGHT2 */
-   {  10969, 0x00004003 }, /* GL_LIGHT3 */
-   {  10979, 0x00004004 }, /* GL_LIGHT4 */
-   {  10989, 0x00004005 }, /* GL_LIGHT5 */
-   {  10999, 0x00004006 }, /* GL_LIGHT6 */
-   {  11009, 0x00004007 }, /* GL_LIGHT7 */
-   {  11019, 0x00000B50 }, /* GL_LIGHTING */
-   {  11031, 0x00000040 }, /* GL_LIGHTING_BIT */
-   {  11047, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */
-   {  11070, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */
-   {  11099, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */
-   {  11132, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
-   {  11160, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */
-   {  11184, 0x00001B01 }, /* GL_LINE */
-   {  11192, 0x00002601 }, /* GL_LINEAR */
-   {  11202, 0x00001208 }, /* GL_LINEAR_ATTENUATION */
-   {  11224, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
-   {  11254, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
-   {  11285, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */
-   {  11309, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */
-   {  11334, 0x00000001 }, /* GL_LINES */
-   {  11343, 0x00000004 }, /* GL_LINE_BIT */
-   {  11355, 0x00000002 }, /* GL_LINE_LOOP */
-   {  11368, 0x00000707 }, /* GL_LINE_RESET_TOKEN */
-   {  11388, 0x00000B20 }, /* GL_LINE_SMOOTH */
-   {  11403, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */
-   {  11423, 0x00000B24 }, /* GL_LINE_STIPPLE */
-   {  11439, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */
-   {  11463, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */
-   {  11486, 0x00000003 }, /* GL_LINE_STRIP */
-   {  11500, 0x00000702 }, /* GL_LINE_TOKEN */
-   {  11514, 0x00000B21 }, /* GL_LINE_WIDTH */
-   {  11528, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */
-   {  11554, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */
-   {  11574, 0x00000B32 }, /* GL_LIST_BASE */
-   {  11587, 0x00020000 }, /* GL_LIST_BIT */
-   {  11599, 0x00000B33 }, /* GL_LIST_INDEX */
-   {  11613, 0x00000B30 }, /* GL_LIST_MODE */
-   {  11626, 0x00000101 }, /* GL_LOAD */
-   {  11634, 0x00000BF1 }, /* GL_LOGIC_OP */
-   {  11646, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */
-   {  11663, 0x00001909 }, /* GL_LUMINANCE */
-   {  11676, 0x00008041 }, /* GL_LUMINANCE12 */
-   {  11691, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */
-   {  11714, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */
-   {  11741, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */
-   {  11763, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */
-   {  11789, 0x00008041 }, /* GL_LUMINANCE12_EXT */
-   {  11808, 0x00008042 }, /* GL_LUMINANCE16 */
-   {  11823, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */
-   {  11846, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */
-   {  11873, 0x00008042 }, /* GL_LUMINANCE16_EXT */
-   {  11892, 0x0000803F }, /* GL_LUMINANCE4 */
-   {  11906, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */
-   {  11927, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */
-   {  11952, 0x0000803F }, /* GL_LUMINANCE4_EXT */
-   {  11970, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */
-   {  11991, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */
-   {  12016, 0x00008040 }, /* GL_LUMINANCE8 */
-   {  12030, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */
-   {  12051, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */
-   {  12076, 0x00008040 }, /* GL_LUMINANCE8_EXT */
-   {  12094, 0x0000190A }, /* GL_LUMINANCE_ALPHA */
-   {  12113, 0x00000D90 }, /* GL_MAP1_COLOR_4 */
-   {  12129, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */
-   {  12149, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */
-   {  12171, 0x00000D91 }, /* GL_MAP1_INDEX */
-   {  12185, 0x00000D92 }, /* GL_MAP1_NORMAL */
-   {  12200, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */
-   {  12224, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */
-   {  12248, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */
-   {  12272, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */
-   {  12296, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */
-   {  12313, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */
-   {  12330, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
-   {  12358, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
-   {  12387, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
-   {  12416, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
-   {  12445, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
-   {  12474, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
-   {  12503, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
-   {  12532, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
-   {  12560, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
-   {  12588, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
-   {  12616, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
-   {  12644, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
-   {  12672, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
-   {  12700, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
-   {  12728, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
-   {  12756, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
-   {  12784, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */
-   {  12800, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */
-   {  12820, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */
-   {  12842, 0x00000DB1 }, /* GL_MAP2_INDEX */
-   {  12856, 0x00000DB2 }, /* GL_MAP2_NORMAL */
-   {  12871, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */
-   {  12895, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */
-   {  12919, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */
-   {  12943, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */
-   {  12967, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */
-   {  12984, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */
-   {  13001, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
-   {  13029, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
-   {  13058, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
-   {  13087, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
-   {  13116, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
-   {  13145, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
-   {  13174, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
-   {  13203, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
-   {  13231, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
-   {  13259, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
-   {  13287, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
-   {  13315, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
-   {  13343, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
-   {  13371, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */
-   {  13399, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
-   {  13427, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
-   {  13455, 0x00000D10 }, /* GL_MAP_COLOR */
-   {  13468, 0x00000D11 }, /* GL_MAP_STENCIL */
-   {  13483, 0x000088C0 }, /* GL_MATRIX0_ARB */
-   {  13498, 0x00008630 }, /* GL_MATRIX0_NV */
-   {  13512, 0x000088CA }, /* GL_MATRIX10_ARB */
-   {  13528, 0x000088CB }, /* GL_MATRIX11_ARB */
-   {  13544, 0x000088CC }, /* GL_MATRIX12_ARB */
-   {  13560, 0x000088CD }, /* GL_MATRIX13_ARB */
-   {  13576, 0x000088CE }, /* GL_MATRIX14_ARB */
-   {  13592, 0x000088CF }, /* GL_MATRIX15_ARB */
-   {  13608, 0x000088D0 }, /* GL_MATRIX16_ARB */
-   {  13624, 0x000088D1 }, /* GL_MATRIX17_ARB */
-   {  13640, 0x000088D2 }, /* GL_MATRIX18_ARB */
-   {  13656, 0x000088D3 }, /* GL_MATRIX19_ARB */
-   {  13672, 0x000088C1 }, /* GL_MATRIX1_ARB */
-   {  13687, 0x00008631 }, /* GL_MATRIX1_NV */
-   {  13701, 0x000088D4 }, /* GL_MATRIX20_ARB */
-   {  13717, 0x000088D5 }, /* GL_MATRIX21_ARB */
-   {  13733, 0x000088D6 }, /* GL_MATRIX22_ARB */
-   {  13749, 0x000088D7 }, /* GL_MATRIX23_ARB */
-   {  13765, 0x000088D8 }, /* GL_MATRIX24_ARB */
-   {  13781, 0x000088D9 }, /* GL_MATRIX25_ARB */
-   {  13797, 0x000088DA }, /* GL_MATRIX26_ARB */
-   {  13813, 0x000088DB }, /* GL_MATRIX27_ARB */
-   {  13829, 0x000088DC }, /* GL_MATRIX28_ARB */
-   {  13845, 0x000088DD }, /* GL_MATRIX29_ARB */
-   {  13861, 0x000088C2 }, /* GL_MATRIX2_ARB */
-   {  13876, 0x00008632 }, /* GL_MATRIX2_NV */
-   {  13890, 0x000088DE }, /* GL_MATRIX30_ARB */
-   {  13906, 0x000088DF }, /* GL_MATRIX31_ARB */
-   {  13922, 0x000088C3 }, /* GL_MATRIX3_ARB */
-   {  13937, 0x00008633 }, /* GL_MATRIX3_NV */
-   {  13951, 0x000088C4 }, /* GL_MATRIX4_ARB */
-   {  13966, 0x00008634 }, /* GL_MATRIX4_NV */
-   {  13980, 0x000088C5 }, /* GL_MATRIX5_ARB */
-   {  13995, 0x00008635 }, /* GL_MATRIX5_NV */
-   {  14009, 0x000088C6 }, /* GL_MATRIX6_ARB */
-   {  14024, 0x00008636 }, /* GL_MATRIX6_NV */
-   {  14038, 0x000088C7 }, /* GL_MATRIX7_ARB */
-   {  14053, 0x00008637 }, /* GL_MATRIX7_NV */
-   {  14067, 0x000088C8 }, /* GL_MATRIX8_ARB */
-   {  14082, 0x000088C9 }, /* GL_MATRIX9_ARB */
-   {  14097, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */
-   {  14123, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
-   {  14157, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
-   {  14188, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
-   {  14221, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
-   {  14252, 0x00000BA0 }, /* GL_MATRIX_MODE */
-   {  14267, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */
-   {  14289, 0x00008008 }, /* GL_MAX */
-   {  14296, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */
-   {  14319, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */
-   {  14345, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
-   {  14378, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
-   {  14404, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-   {  14438, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */
-   {  14457, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
-   {  14486, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
-   {  14518, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */
-   {  14554, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */
-   {  14594, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */
-   {  14620, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */
-   {  14650, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */
-   {  14675, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */
-   {  14704, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
-   {  14733, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */
-   {  14766, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */
-   {  14790, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */
-   {  14814, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */
-   {  14838, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */
-   {  14863, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */
-   {  14881, 0x00008008 }, /* GL_MAX_EXT */
-   {  14892, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */
-   {  14931, 0x00000D31 }, /* GL_MAX_LIGHTS */
-   {  14945, 0x00000B31 }, /* GL_MAX_LIST_NESTING */
-   {  14965, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
-   {  15003, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */
-   {  15032, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */
-   {  15056, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */
-   {  15084, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */
-   {  15107, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
-   {  15144, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
-   {  15180, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
-   {  15207, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
-   {  15236, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
-   {  15270, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
-   {  15306, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
-   {  15333, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
-   {  15365, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
-   {  15401, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
-   {  15430, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
-   {  15459, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */
-   {  15487, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
-   {  15525, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-   {  15569, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-   {  15612, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
-   {  15646, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-   {  15685, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
-   {  15722, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
-   {  15760, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-   {  15803, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-   {  15846, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
-   {  15876, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
-   {  15907, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
-   {  15943, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
-   {  15979, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */
-   {  16009, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
-   {  16043, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */
-   {  16076, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
-   {  16105, 0x00008504 }, /* GL_MAX_SHININESS_NV */
-   {  16125, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */
-   {  16149, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */
-   {  16175, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */
-   {  16206, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */
-   {  16230, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
-   {  16264, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */
-   {  16284, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */
-   {  16311, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */
-   {  16332, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */
-   {  16357, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */
-   {  16382, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */
-   {  16417, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */
-   {  16443, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */
-   {  16469, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */
-   {  16507, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */
-   {  16544, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */
-   {  16568, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */
-   {  16589, 0x00008007 }, /* GL_MIN */
-   {  16596, 0x0000802E }, /* GL_MINMAX */
-   {  16606, 0x0000802E }, /* GL_MINMAX_EXT */
-   {  16620, 0x0000802F }, /* GL_MINMAX_FORMAT */
-   {  16637, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */
-   {  16658, 0x00008030 }, /* GL_MINMAX_SINK */
-   {  16673, 0x00008030 }, /* GL_MINMAX_SINK_EXT */
-   {  16692, 0x00008007 }, /* GL_MIN_EXT */
-   {  16703, 0x00008370 }, /* GL_MIRRORED_REPEAT */
-   {  16722, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */
-   {  16745, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */
-   {  16768, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */
-   {  16788, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */
-   {  16808, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
-   {  16838, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */
-   {  16866, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
-   {  16894, 0x00001700 }, /* GL_MODELVIEW */
-   {  16907, 0x00001700 }, /* GL_MODELVIEW0_ARB */
-   {  16925, 0x0000872A }, /* GL_MODELVIEW10_ARB */
-   {  16944, 0x0000872B }, /* GL_MODELVIEW11_ARB */
-   {  16963, 0x0000872C }, /* GL_MODELVIEW12_ARB */
-   {  16982, 0x0000872D }, /* GL_MODELVIEW13_ARB */
-   {  17001, 0x0000872E }, /* GL_MODELVIEW14_ARB */
-   {  17020, 0x0000872F }, /* GL_MODELVIEW15_ARB */
-   {  17039, 0x00008730 }, /* GL_MODELVIEW16_ARB */
-   {  17058, 0x00008731 }, /* GL_MODELVIEW17_ARB */
-   {  17077, 0x00008732 }, /* GL_MODELVIEW18_ARB */
-   {  17096, 0x00008733 }, /* GL_MODELVIEW19_ARB */
-   {  17115, 0x0000850A }, /* GL_MODELVIEW1_ARB */
-   {  17133, 0x00008734 }, /* GL_MODELVIEW20_ARB */
-   {  17152, 0x00008735 }, /* GL_MODELVIEW21_ARB */
-   {  17171, 0x00008736 }, /* GL_MODELVIEW22_ARB */
-   {  17190, 0x00008737 }, /* GL_MODELVIEW23_ARB */
-   {  17209, 0x00008738 }, /* GL_MODELVIEW24_ARB */
-   {  17228, 0x00008739 }, /* GL_MODELVIEW25_ARB */
-   {  17247, 0x0000873A }, /* GL_MODELVIEW26_ARB */
-   {  17266, 0x0000873B }, /* GL_MODELVIEW27_ARB */
-   {  17285, 0x0000873C }, /* GL_MODELVIEW28_ARB */
-   {  17304, 0x0000873D }, /* GL_MODELVIEW29_ARB */
-   {  17323, 0x00008722 }, /* GL_MODELVIEW2_ARB */
-   {  17341, 0x0000873E }, /* GL_MODELVIEW30_ARB */
-   {  17360, 0x0000873F }, /* GL_MODELVIEW31_ARB */
-   {  17379, 0x00008723 }, /* GL_MODELVIEW3_ARB */
-   {  17397, 0x00008724 }, /* GL_MODELVIEW4_ARB */
-   {  17415, 0x00008725 }, /* GL_MODELVIEW5_ARB */
-   {  17433, 0x00008726 }, /* GL_MODELVIEW6_ARB */
-   {  17451, 0x00008727 }, /* GL_MODELVIEW7_ARB */
-   {  17469, 0x00008728 }, /* GL_MODELVIEW8_ARB */
-   {  17487, 0x00008729 }, /* GL_MODELVIEW9_ARB */
-   {  17505, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */
-   {  17525, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */
-   {  17552, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */
-   {  17577, 0x00002100 }, /* GL_MODULATE */
-   {  17589, 0x00008744 }, /* GL_MODULATE_ADD_ATI */
-   {  17609, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */
-   {  17636, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */
-   {  17661, 0x00000103 }, /* GL_MULT */
-   {  17669, 0x0000809D }, /* GL_MULTISAMPLE */
-   {  17684, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */
-   {  17704, 0x0000809D }, /* GL_MULTISAMPLE_ARB */
-   {  17723, 0x20000000 }, /* GL_MULTISAMPLE_BIT */
-   {  17742, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */
-   {  17766, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */
-   {  17789, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */
-   {  17819, 0x00002A25 }, /* GL_N3F_V3F */
-   {  17830, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */
-   {  17850, 0x0000150E }, /* GL_NAND */
-   {  17858, 0x00002600 }, /* GL_NEAREST */
-   {  17869, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
-   {  17900, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
-   {  17932, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */
-   {  17957, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */
-   {  17983, 0x00000200 }, /* GL_NEVER */
-   {  17992, 0x00001102 }, /* GL_NICEST */
-   {  18002, 0x00000000 }, /* GL_NONE */
-   {  18010, 0x00001505 }, /* GL_NOOP */
-   {  18018, 0x00001508 }, /* GL_NOR */
-   {  18025, 0x00000BA1 }, /* GL_NORMALIZE */
-   {  18038, 0x00008075 }, /* GL_NORMAL_ARRAY */
-   {  18054, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
-   {  18085, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */
-   {  18120, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */
-   {  18144, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */
-   {  18167, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */
-   {  18188, 0x00008511 }, /* GL_NORMAL_MAP */
-   {  18202, 0x00008511 }, /* GL_NORMAL_MAP_ARB */
-   {  18220, 0x00008511 }, /* GL_NORMAL_MAP_NV */
-   {  18237, 0x00000205 }, /* GL_NOTEQUAL */
-   {  18249, 0x00000000 }, /* GL_NO_ERROR */
-   {  18261, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
-   {  18295, 0x000086A2 }, /* GL_NUM_TEXTURE_COMPRESSED_FORMATS_ARB */
-   {  18333, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */
-   {  18365, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */
-   {  18407, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */
-   {  18437, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */
-   {  18477, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */
-   {  18508, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */
-   {  18537, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */
-   {  18565, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */
-   {  18595, 0x00002401 }, /* GL_OBJECT_LINEAR */
-   {  18612, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */
-   {  18638, 0x00002501 }, /* GL_OBJECT_PLANE */
-   {  18654, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */
-   {  18689, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */
-   {  18711, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */
-   {  18730, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */
-   {  18760, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */
-   {  18781, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */
-   {  18809, 0x00000001 }, /* GL_ONE */
-   {  18816, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */
-   {  18844, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */
-   {  18876, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */
-   {  18904, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */
-   {  18936, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */
-   {  18959, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */
-   {  18982, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */
-   {  19005, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */
-   {  19028, 0x00008598 }, /* GL_OPERAND0_ALPHA */
-   {  19046, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */
-   {  19068, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */
-   {  19090, 0x00008590 }, /* GL_OPERAND0_RGB */
-   {  19106, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */
-   {  19126, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */
-   {  19146, 0x00008599 }, /* GL_OPERAND1_ALPHA */
-   {  19164, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */
-   {  19186, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */
-   {  19208, 0x00008591 }, /* GL_OPERAND1_RGB */
-   {  19224, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */
-   {  19244, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */
-   {  19264, 0x0000859A }, /* GL_OPERAND2_ALPHA */
-   {  19282, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */
-   {  19304, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */
-   {  19326, 0x00008592 }, /* GL_OPERAND2_RGB */
-   {  19342, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */
-   {  19362, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */
-   {  19382, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */
-   {  19403, 0x00008593 }, /* GL_OPERAND3_RGB_NV */
-   {  19422, 0x00001507 }, /* GL_OR */
-   {  19428, 0x00000A01 }, /* GL_ORDER */
-   {  19437, 0x0000150D }, /* GL_OR_INVERTED */
-   {  19452, 0x0000150B }, /* GL_OR_REVERSE */
-   {  19466, 0x00000505 }, /* GL_OUT_OF_MEMORY */
-   {  19483, 0x00000D05 }, /* GL_PACK_ALIGNMENT */
-   {  19501, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */
-   {  19522, 0x00008758 }, /* GL_PACK_INVERT_MESA */
-   {  19542, 0x00000D01 }, /* GL_PACK_LSB_FIRST */
-   {  19560, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */
-   {  19579, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */
-   {  19599, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */
-   {  19619, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */
-   {  19637, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */
-   {  19656, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */
-   {  19681, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */
-   {  19705, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */
-   {  19726, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */
-   {  19748, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */
-   {  19770, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */
-   {  19795, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */
-   {  19819, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */
-   {  19840, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */
-   {  19862, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */
-   {  19884, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */
-   {  19906, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */
-   {  19937, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */
-   {  19957, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */
-   {  19982, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */
-   {  20002, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */
-   {  20027, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */
-   {  20047, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */
-   {  20072, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */
-   {  20092, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */
-   {  20117, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */
-   {  20137, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */
-   {  20162, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */
-   {  20182, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */
-   {  20207, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */
-   {  20227, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */
-   {  20252, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */
-   {  20272, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */
-   {  20297, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */
-   {  20317, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */
-   {  20342, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */
-   {  20362, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */
-   {  20387, 0x00000020 }, /* GL_PIXEL_MODE_BIT */
-   {  20405, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */
-   {  20438, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */
-   {  20463, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */
-   {  20498, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */
-   {  20525, 0x00001B00 }, /* GL_POINT */
-   {  20534, 0x00000000 }, /* GL_POINTS */
-   {  20544, 0x00000002 }, /* GL_POINT_BIT */
-   {  20557, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */
-   {  20587, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */
-   {  20621, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */
-   {  20655, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */
-   {  20690, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */
-   {  20719, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */
-   {  20752, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */
-   {  20785, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */
-   {  20819, 0x00000B11 }, /* GL_POINT_SIZE */
-   {  20833, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */
-   {  20859, 0x00008127 }, /* GL_POINT_SIZE_MAX */
-   {  20877, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */
-   {  20899, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */
-   {  20921, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */
-   {  20944, 0x00008126 }, /* GL_POINT_SIZE_MIN */
-   {  20962, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */
-   {  20984, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */
-   {  21006, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */
-   {  21029, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */
-   {  21049, 0x00000B10 }, /* GL_POINT_SMOOTH */
-   {  21065, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */
-   {  21086, 0x00008861 }, /* GL_POINT_SPRITE_ARB */
-   {  21106, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */
-   {  21135, 0x00008861 }, /* GL_POINT_SPRITE_NV */
-   {  21154, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */
-   {  21180, 0x00000701 }, /* GL_POINT_TOKEN */
-   {  21195, 0x00000009 }, /* GL_POLYGON */
-   {  21206, 0x00000008 }, /* GL_POLYGON_BIT */
-   {  21221, 0x00000B40 }, /* GL_POLYGON_MODE */
-   {  21237, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */
-   {  21260, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */
-   {  21285, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */
-   {  21308, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */
-   {  21331, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */
-   {  21355, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */
-   {  21379, 0x00000B41 }, /* GL_POLYGON_SMOOTH */
-   {  21397, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */
-   {  21420, 0x00000B42 }, /* GL_POLYGON_STIPPLE */
-   {  21439, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */
-   {  21462, 0x00000703 }, /* GL_POLYGON_TOKEN */
-   {  21479, 0x00001203 }, /* GL_POSITION */
-   {  21491, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
-   {  21523, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */
-   {  21559, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
-   {  21592, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */
-   {  21629, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
-   {  21660, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */
-   {  21695, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
-   {  21727, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */
-   {  21763, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
-   {  21796, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
-   {  21828, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */
-   {  21864, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
-   {  21897, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */
-   {  21934, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */
-   {  21964, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */
-   {  21998, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */
-   {  22029, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */
-   {  22064, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
-   {  22095, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */
-   {  22130, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
-   {  22162, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */
-   {  22198, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */
-   {  22228, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */
-   {  22262, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */
-   {  22293, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */
-   {  22328, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */
-   {  22360, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */
-   {  22391, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */
-   {  22426, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */
-   {  22458, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */
-   {  22494, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */
-   {  22523, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */
-   {  22556, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */
-   {  22586, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */
-   {  22620, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
-   {  22659, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
-   {  22692, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
-   {  22732, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
-   {  22766, 0x00008578 }, /* GL_PREVIOUS */
-   {  22778, 0x00008578 }, /* GL_PREVIOUS_ARB */
-   {  22794, 0x00008578 }, /* GL_PREVIOUS_EXT */
-   {  22810, 0x00008577 }, /* GL_PRIMARY_COLOR */
-   {  22827, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */
-   {  22848, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */
-   {  22869, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
-   {  22902, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
-   {  22934, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */
-   {  22957, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */
-   {  22980, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */
-   {  23010, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */
-   {  23039, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */
-   {  23067, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */
-   {  23089, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */
-   {  23117, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */
-   {  23145, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */
-   {  23167, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */
-   {  23188, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
-   {  23228, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-   {  23267, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
-   {  23297, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-   {  23332, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
-   {  23365, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
-   {  23399, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
-   {  23438, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-   {  23477, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */
-   {  23499, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */
-   {  23525, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */
-   {  23549, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */
-   {  23572, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */
-   {  23594, 0x00008628 }, /* GL_PROGRAM_STRING_NV */
-   {  23615, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */
-   {  23636, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */
-   {  23663, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
-   {  23695, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
-   {  23727, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
-   {  23762, 0x00001701 }, /* GL_PROJECTION */
-   {  23776, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */
-   {  23797, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */
-   {  23823, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */
-   {  23844, 0x00008025 }, /* GL_PROXY_HISTOGRAM */
-   {  23863, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */
-   {  23886, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
-   {  23925, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
-   {  23963, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */
-   {  23983, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */
-   {  24007, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */
-   {  24027, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */
-   {  24051, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */
-   {  24071, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
-   {  24104, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */
-   {  24130, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */
-   {  24160, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
-   {  24191, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */
-   {  24221, 0x00002003 }, /* GL_Q */
-   {  24226, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */
-   {  24251, 0x00000007 }, /* GL_QUADS */
-   {  24260, 0x00008614 }, /* GL_QUAD_MESH_SUN */
-   {  24277, 0x00000008 }, /* GL_QUAD_STRIP */
-   {  24291, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */
-   {  24313, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */
-   {  24339, 0x00008866 }, /* GL_QUERY_RESULT */
-   {  24355, 0x00008866 }, /* GL_QUERY_RESULT_ARB */
-   {  24375, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */
-   {  24401, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */
-   {  24431, 0x00002002 }, /* GL_R */
-   {  24436, 0x00002A10 }, /* GL_R3_G3_B2 */
-   {  24448, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
-   {  24481, 0x00000C02 }, /* GL_READ_BUFFER */
-   {  24496, 0x000088B8 }, /* GL_READ_ONLY */
-   {  24509, 0x000088B8 }, /* GL_READ_ONLY_ARB */
-   {  24526, 0x000088BA }, /* GL_READ_WRITE */
-   {  24540, 0x000088BA }, /* GL_READ_WRITE_ARB */
-   {  24558, 0x00001903 }, /* GL_RED */
-   {  24565, 0x00008016 }, /* GL_REDUCE */
-   {  24575, 0x00008016 }, /* GL_REDUCE_EXT */
-   {  24589, 0x00000D15 }, /* GL_RED_BIAS */
-   {  24601, 0x00000D52 }, /* GL_RED_BITS */
-   {  24613, 0x00000D14 }, /* GL_RED_SCALE */
-   {  24626, 0x00008512 }, /* GL_REFLECTION_MAP */
-   {  24644, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */
-   {  24666, 0x00008512 }, /* GL_REFLECTION_MAP_NV */
-   {  24687, 0x00001C00 }, /* GL_RENDER */
-   {  24697, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */
-   {  24725, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */
-   {  24745, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */
-   {  24772, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
-   {  24808, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */
-   {  24834, 0x00001F01 }, /* GL_RENDERER */
-   {  24846, 0x00000C40 }, /* GL_RENDER_MODE */
-   {  24861, 0x00002901 }, /* GL_REPEAT */
-   {  24871, 0x00001E01 }, /* GL_REPLACE */
-   {  24882, 0x00008062 }, /* GL_REPLACE_EXT */
-   {  24897, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */
-   {  24920, 0x0000803A }, /* GL_RESCALE_NORMAL */
-   {  24938, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */
-   {  24960, 0x00000102 }, /* GL_RETURN */
-   {  24970, 0x00001907 }, /* GL_RGB */
-   {  24977, 0x00008052 }, /* GL_RGB10 */
-   {  24986, 0x00008059 }, /* GL_RGB10_A2 */
-   {  24998, 0x00008059 }, /* GL_RGB10_A2_EXT */
-   {  25014, 0x00008052 }, /* GL_RGB10_EXT */
-   {  25027, 0x00008053 }, /* GL_RGB12 */
-   {  25036, 0x00008053 }, /* GL_RGB12_EXT */
-   {  25049, 0x00008054 }, /* GL_RGB16 */
-   {  25058, 0x00008054 }, /* GL_RGB16_EXT */
-   {  25071, 0x0000804E }, /* GL_RGB2_EXT */
-   {  25083, 0x0000804F }, /* GL_RGB4 */
-   {  25091, 0x0000804F }, /* GL_RGB4_EXT */
-   {  25103, 0x000083A1 }, /* GL_RGB4_S3TC */
-   {  25116, 0x00008050 }, /* GL_RGB5 */
-   {  25124, 0x00008057 }, /* GL_RGB5_A1 */
-   {  25135, 0x00008057 }, /* GL_RGB5_A1_EXT */
-   {  25150, 0x00008050 }, /* GL_RGB5_EXT */
-   {  25162, 0x00008051 }, /* GL_RGB8 */
-   {  25170, 0x00008051 }, /* GL_RGB8_EXT */
-   {  25182, 0x00001908 }, /* GL_RGBA */
-   {  25190, 0x0000805A }, /* GL_RGBA12 */
-   {  25200, 0x0000805A }, /* GL_RGBA12_EXT */
-   {  25214, 0x0000805B }, /* GL_RGBA16 */
-   {  25224, 0x0000805B }, /* GL_RGBA16_EXT */
-   {  25238, 0x00008055 }, /* GL_RGBA2 */
-   {  25247, 0x00008055 }, /* GL_RGBA2_EXT */
-   {  25260, 0x00008056 }, /* GL_RGBA4 */
-   {  25269, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */
-   {  25288, 0x00008056 }, /* GL_RGBA4_EXT */
-   {  25301, 0x000083A3 }, /* GL_RGBA4_S3TC */
-   {  25315, 0x00008058 }, /* GL_RGBA8 */
-   {  25324, 0x00008058 }, /* GL_RGBA8_EXT */
-   {  25337, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */
-   {  25355, 0x00000C31 }, /* GL_RGBA_MODE */
-   {  25368, 0x000083A2 }, /* GL_RGBA_S3TC */
-   {  25381, 0x000083A0 }, /* GL_RGB_S3TC */
-   {  25393, 0x00008573 }, /* GL_RGB_SCALE */
-   {  25406, 0x00008573 }, /* GL_RGB_SCALE_ARB */
-   {  25423, 0x00008573 }, /* GL_RGB_SCALE_EXT */
-   {  25440, 0x00000407 }, /* GL_RIGHT */
-   {  25449, 0x00002000 }, /* GL_S */
-   {  25454, 0x000080A9 }, /* GL_SAMPLES */
-   {  25465, 0x000086B4 }, /* GL_SAMPLES_3DFX */
-   {  25481, 0x000080A9 }, /* GL_SAMPLES_ARB */
-   {  25496, 0x00008914 }, /* GL_SAMPLES_PASSED */
-   {  25514, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */
-   {  25536, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
-   {  25564, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */
-   {  25596, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */
-   {  25619, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */
-   {  25646, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */
-   {  25664, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */
-   {  25687, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */
-   {  25709, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */
-   {  25728, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */
-   {  25751, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */
-   {  25777, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */
-   {  25807, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */
-   {  25832, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */
-   {  25861, 0x00080000 }, /* GL_SCISSOR_BIT */
-   {  25876, 0x00000C10 }, /* GL_SCISSOR_BOX */
-   {  25891, 0x00000C11 }, /* GL_SCISSOR_TEST */
-   {  25907, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */
-   {  25932, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
-   {  25972, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */
-   {  26016, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
-   {  26049, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
-   {  26079, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
-   {  26111, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
-   {  26141, 0x00001C02 }, /* GL_SELECT */
-   {  26151, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */
-   {  26179, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */
-   {  26204, 0x00008012 }, /* GL_SEPARABLE_2D */
-   {  26220, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */
-   {  26247, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */
-   {  26278, 0x0000150F }, /* GL_SET */
-   {  26285, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */
-   {  26306, 0x00000B54 }, /* GL_SHADE_MODEL */
-   {  26321, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */
-   {  26344, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */
-   {  26374, 0x00001601 }, /* GL_SHININESS */
-   {  26387, 0x00001402 }, /* GL_SHORT */
-   {  26396, 0x000081F9 }, /* GL_SINGLE_COLOR */
-   {  26412, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */
-   {  26432, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */
-   {  26451, 0x00001D01 }, /* GL_SMOOTH */
-   {  26461, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */
-   {  26494, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */
-   {  26521, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */
-   {  26554, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */
-   {  26581, 0x00008588 }, /* GL_SOURCE0_ALPHA */
-   {  26598, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */
-   {  26619, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */
-   {  26640, 0x00008580 }, /* GL_SOURCE0_RGB */
-   {  26655, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */
-   {  26674, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */
-   {  26693, 0x00008589 }, /* GL_SOURCE1_ALPHA */
-   {  26710, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */
-   {  26731, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */
-   {  26752, 0x00008581 }, /* GL_SOURCE1_RGB */
-   {  26767, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */
-   {  26786, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */
-   {  26805, 0x0000858A }, /* GL_SOURCE2_ALPHA */
-   {  26822, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */
-   {  26843, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */
-   {  26864, 0x00008582 }, /* GL_SOURCE2_RGB */
-   {  26879, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */
-   {  26898, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */
-   {  26917, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */
-   {  26937, 0x00008583 }, /* GL_SOURCE3_RGB_NV */
-   {  26955, 0x00001202 }, /* GL_SPECULAR */
-   {  26967, 0x00002402 }, /* GL_SPHERE_MAP */
-   {  26981, 0x00001206 }, /* GL_SPOT_CUTOFF */
-   {  26996, 0x00001204 }, /* GL_SPOT_DIRECTION */
-   {  27014, 0x00001205 }, /* GL_SPOT_EXPONENT */
-   {  27031, 0x00008588 }, /* GL_SRC0_ALPHA */
-   {  27045, 0x00008580 }, /* GL_SRC0_RGB */
-   {  27057, 0x00008589 }, /* GL_SRC1_ALPHA */
-   {  27071, 0x00008581 }, /* GL_SRC1_RGB */
-   {  27083, 0x0000858A }, /* GL_SRC2_ALPHA */
-   {  27097, 0x00008582 }, /* GL_SRC2_RGB */
-   {  27109, 0x00000302 }, /* GL_SRC_ALPHA */
-   {  27122, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */
-   {  27144, 0x00000300 }, /* GL_SRC_COLOR */
-   {  27157, 0x00000503 }, /* GL_STACK_OVERFLOW */
-   {  27175, 0x00000504 }, /* GL_STACK_UNDERFLOW */
-   {  27194, 0x000088E6 }, /* GL_STATIC_COPY */
-   {  27209, 0x000088E6 }, /* GL_STATIC_COPY_ARB */
-   {  27228, 0x000088E4 }, /* GL_STATIC_DRAW */
-   {  27243, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */
-   {  27262, 0x000088E5 }, /* GL_STATIC_READ */
-   {  27277, 0x000088E5 }, /* GL_STATIC_READ_ARB */
-   {  27296, 0x00001802 }, /* GL_STENCIL */
-   {  27307, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */
-   {  27333, 0x00000D57 }, /* GL_STENCIL_BITS */
-   {  27349, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */
-   {  27371, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */
-   {  27394, 0x00000B94 }, /* GL_STENCIL_FAIL */
-   {  27410, 0x00000B92 }, /* GL_STENCIL_FUNC */
-   {  27426, 0x00001901 }, /* GL_STENCIL_INDEX */
-   {  27443, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */
-   {  27466, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */
-   {  27488, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */
-   {  27510, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */
-   {  27532, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */
-   {  27553, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */
-   {  27580, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */
-   {  27607, 0x00000B97 }, /* GL_STENCIL_REF */
-   {  27622, 0x00000B90 }, /* GL_STENCIL_TEST */
-   {  27638, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
-   {  27667, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */
-   {  27689, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */
-   {  27710, 0x00000C33 }, /* GL_STEREO */
-   {  27720, 0x000088E2 }, /* GL_STREAM_COPY */
-   {  27735, 0x000088E2 }, /* GL_STREAM_COPY_ARB */
-   {  27754, 0x000088E0 }, /* GL_STREAM_DRAW */
-   {  27769, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */
-   {  27788, 0x000088E1 }, /* GL_STREAM_READ */
-   {  27803, 0x000088E1 }, /* GL_STREAM_READ_ARB */
-   {  27822, 0x00000D50 }, /* GL_SUBPIXEL_BITS */
-   {  27839, 0x000084E7 }, /* GL_SUBTRACT */
-   {  27851, 0x000084E7 }, /* GL_SUBTRACT_ARB */
-   {  27867, 0x00002001 }, /* GL_T */
-   {  27872, 0x00002A2A }, /* GL_T2F_C3F_V3F */
-   {  27887, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */
-   {  27906, 0x00002A29 }, /* GL_T2F_C4UB_V3F */
-   {  27922, 0x00002A2B }, /* GL_T2F_N3F_V3F */
-   {  27937, 0x00002A27 }, /* GL_T2F_V3F */
-   {  27948, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */
-   {  27967, 0x00002A28 }, /* GL_T4F_V4F */
-   {  27978, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */
-   {  28001, 0x00001702 }, /* GL_TEXTURE */
-   {  28012, 0x000084C0 }, /* GL_TEXTURE0 */
-   {  28024, 0x000084C0 }, /* GL_TEXTURE0_ARB */
-   {  28040, 0x000084C1 }, /* GL_TEXTURE1 */
-   {  28052, 0x000084CA }, /* GL_TEXTURE10 */
-   {  28065, 0x000084CA }, /* GL_TEXTURE10_ARB */
-   {  28082, 0x000084CB }, /* GL_TEXTURE11 */
-   {  28095, 0x000084CB }, /* GL_TEXTURE11_ARB */
-   {  28112, 0x000084CC }, /* GL_TEXTURE12 */
-   {  28125, 0x000084CC }, /* GL_TEXTURE12_ARB */
-   {  28142, 0x000084CD }, /* GL_TEXTURE13 */
-   {  28155, 0x000084CD }, /* GL_TEXTURE13_ARB */
-   {  28172, 0x000084CE }, /* GL_TEXTURE14 */
-   {  28185, 0x000084CE }, /* GL_TEXTURE14_ARB */
-   {  28202, 0x000084CF }, /* GL_TEXTURE15 */
-   {  28215, 0x000084CF }, /* GL_TEXTURE15_ARB */
-   {  28232, 0x000084D0 }, /* GL_TEXTURE16 */
-   {  28245, 0x000084D0 }, /* GL_TEXTURE16_ARB */
-   {  28262, 0x000084D1 }, /* GL_TEXTURE17 */
-   {  28275, 0x000084D1 }, /* GL_TEXTURE17_ARB */
-   {  28292, 0x000084D2 }, /* GL_TEXTURE18 */
-   {  28305, 0x000084D2 }, /* GL_TEXTURE18_ARB */
-   {  28322, 0x000084D3 }, /* GL_TEXTURE19 */
-   {  28335, 0x000084D3 }, /* GL_TEXTURE19_ARB */
-   {  28352, 0x000084C1 }, /* GL_TEXTURE1_ARB */
-   {  28368, 0x000084C2 }, /* GL_TEXTURE2 */
-   {  28380, 0x000084D4 }, /* GL_TEXTURE20 */
-   {  28393, 0x000084D4 }, /* GL_TEXTURE20_ARB */
-   {  28410, 0x000084D5 }, /* GL_TEXTURE21 */
-   {  28423, 0x000084D5 }, /* GL_TEXTURE21_ARB */
-   {  28440, 0x000084D6 }, /* GL_TEXTURE22 */
-   {  28453, 0x000084D6 }, /* GL_TEXTURE22_ARB */
-   {  28470, 0x000084D7 }, /* GL_TEXTURE23 */
-   {  28483, 0x000084D7 }, /* GL_TEXTURE23_ARB */
-   {  28500, 0x000084D8 }, /* GL_TEXTURE24 */
-   {  28513, 0x000084D8 }, /* GL_TEXTURE24_ARB */
-   {  28530, 0x000084D9 }, /* GL_TEXTURE25 */
-   {  28543, 0x000084D9 }, /* GL_TEXTURE25_ARB */
-   {  28560, 0x000084DA }, /* GL_TEXTURE26 */
-   {  28573, 0x000084DA }, /* GL_TEXTURE26_ARB */
-   {  28590, 0x000084DB }, /* GL_TEXTURE27 */
-   {  28603, 0x000084DB }, /* GL_TEXTURE27_ARB */
-   {  28620, 0x000084DC }, /* GL_TEXTURE28 */
-   {  28633, 0x000084DC }, /* GL_TEXTURE28_ARB */
-   {  28650, 0x000084DD }, /* GL_TEXTURE29 */
-   {  28663, 0x000084DD }, /* GL_TEXTURE29_ARB */
-   {  28680, 0x000084C2 }, /* GL_TEXTURE2_ARB */
-   {  28696, 0x000084C3 }, /* GL_TEXTURE3 */
-   {  28708, 0x000084DE }, /* GL_TEXTURE30 */
-   {  28721, 0x000084DE }, /* GL_TEXTURE30_ARB */
-   {  28738, 0x000084DF }, /* GL_TEXTURE31 */
-   {  28751, 0x000084DF }, /* GL_TEXTURE31_ARB */
-   {  28768, 0x000084C3 }, /* GL_TEXTURE3_ARB */
-   {  28784, 0x000084C4 }, /* GL_TEXTURE4 */
-   {  28796, 0x000084C4 }, /* GL_TEXTURE4_ARB */
-   {  28812, 0x000084C5 }, /* GL_TEXTURE5 */
-   {  28824, 0x000084C5 }, /* GL_TEXTURE5_ARB */
-   {  28840, 0x000084C6 }, /* GL_TEXTURE6 */
-   {  28852, 0x000084C6 }, /* GL_TEXTURE6_ARB */
-   {  28868, 0x000084C7 }, /* GL_TEXTURE7 */
-   {  28880, 0x000084C7 }, /* GL_TEXTURE7_ARB */
-   {  28896, 0x000084C8 }, /* GL_TEXTURE8 */
-   {  28908, 0x000084C8 }, /* GL_TEXTURE8_ARB */
-   {  28924, 0x000084C9 }, /* GL_TEXTURE9 */
-   {  28936, 0x000084C9 }, /* GL_TEXTURE9_ARB */
-   {  28952, 0x00000DE0 }, /* GL_TEXTURE_1D */
-   {  28966, 0x00000DE1 }, /* GL_TEXTURE_2D */
-   {  28980, 0x0000806F }, /* GL_TEXTURE_3D */
-   {  28994, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */
-   {  29016, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */
-   {  29042, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */
-   {  29064, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */
-   {  29086, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */
-   {  29108, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */
-   {  29130, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */
-   {  29158, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */
-   {  29190, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
-   {  29223, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */
-   {  29255, 0x00040000 }, /* GL_TEXTURE_BIT */
-   {  29270, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */
-   {  29291, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */
-   {  29316, 0x00001005 }, /* GL_TEXTURE_BORDER */
-   {  29334, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */
-   {  29358, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
-   {  29389, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
-   {  29419, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
-   {  29449, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
-   {  29484, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
-   {  29515, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-   {  29553, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */
-   {  29580, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
-   {  29612, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
-   {  29646, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */
-   {  29670, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */
-   {  29698, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */
-   {  29722, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */
-   {  29750, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
-   {  29783, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */
-   {  29807, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */
-   {  29829, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */
-   {  29851, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */
-   {  29877, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */
-   {  29911, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
-   {  29944, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */
-   {  29981, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */
-   {  30009, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */
-   {  30041, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */
-   {  30064, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
-   {  30102, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */
-   {  30144, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */
-   {  30175, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */
-   {  30203, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
-   {  30233, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */
-   {  30261, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */
-   {  30281, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */
-   {  30305, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
-   {  30336, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */
-   {  30371, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
-   {  30402, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */
-   {  30437, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
-   {  30468, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */
-   {  30503, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
-   {  30534, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */
-   {  30569, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
-   {  30600, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */
-   {  30635, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
-   {  30666, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */
-   {  30701, 0x00008071 }, /* GL_TEXTURE_DEPTH */
-   {  30718, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */
-   {  30740, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */
-   {  30766, 0x00002300 }, /* GL_TEXTURE_ENV */
-   {  30781, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */
-   {  30802, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */
-   {  30822, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */
-   {  30848, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */
-   {  30868, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */
-   {  30885, 0x00000C62 }, /* GL_TEXTURE_GEN_R */
-   {  30902, 0x00000C60 }, /* GL_TEXTURE_GEN_S */
-   {  30919, 0x00000C61 }, /* GL_TEXTURE_GEN_T */
-   {  30936, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */
-   {  30961, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */
-   {  30983, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */
-   {  31009, 0x00001001 }, /* GL_TEXTURE_HEIGHT */
-   {  31027, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */
-   {  31053, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */
-   {  31079, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */
-   {  31109, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */
-   {  31136, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */
-   {  31161, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */
-   {  31181, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */
-   {  31205, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
-   {  31232, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
-   {  31259, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
-   {  31286, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */
-   {  31312, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */
-   {  31342, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */
-   {  31364, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */
-   {  31382, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
-   {  31412, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
-   {  31440, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
-   {  31468, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
-   {  31496, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */
-   {  31517, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */
-   {  31536, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */
-   {  31558, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */
-   {  31577, 0x00008066 }, /* GL_TEXTURE_PRIORITY */
-   {  31597, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */
-   {  31622, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */
-   {  31646, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */
-   {  31666, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */
-   {  31690, 0x00008067 }, /* GL_TEXTURE_RESIDENT */
-   {  31710, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */
-   {  31733, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */
-   {  31758, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
-   {  31792, 0x00001000 }, /* GL_TEXTURE_WIDTH */
-   {  31809, 0x00008072 }, /* GL_TEXTURE_WRAP_R */
-   {  31827, 0x00002802 }, /* GL_TEXTURE_WRAP_S */
-   {  31845, 0x00002803 }, /* GL_TEXTURE_WRAP_T */
-   {  31863, 0x00008648 }, /* GL_TRACK_MATRIX_NV */
-   {  31882, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */
-   {  31911, 0x00001000 }, /* GL_TRANSFORM_BIT */
-   {  31928, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */
-   {  31954, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */
-   {  31984, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
-   {  32016, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
-   {  32046, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */
-   {  32080, 0x0000862C }, /* GL_TRANSPOSE_NV */
-   {  32096, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */
-   {  32127, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */
-   {  32162, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */
-   {  32190, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */
-   {  32222, 0x00000004 }, /* GL_TRIANGLES */
-   {  32235, 0x00000006 }, /* GL_TRIANGLE_FAN */
-   {  32251, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */
-   {  32272, 0x00000005 }, /* GL_TRIANGLE_STRIP */
-   {  32290, 0x00000001 }, /* GL_TRUE */
-   {  32298, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */
-   {  32318, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */
-   {  32341, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */
-   {  32361, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */
-   {  32382, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */
-   {  32404, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */
-   {  32426, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */
-   {  32446, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */
-   {  32467, 0x00001401 }, /* GL_UNSIGNED_BYTE */
-   {  32484, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */
-   {  32511, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */
-   {  32534, 0x00001405 }, /* GL_UNSIGNED_INT */
-   {  32550, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */
-   {  32577, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */
-   {  32601, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */
-   {  32632, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */
-   {  32656, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */
-   {  32684, 0x00001403 }, /* GL_UNSIGNED_SHORT */
-   {  32702, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
-   {  32732, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */
-   {  32758, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
-   {  32788, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */
-   {  32814, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */
-   {  32838, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */
-   {  32866, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */
-   {  32894, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */
-   {  32921, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
-   {  32953, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */
-   {  32984, 0x00002A20 }, /* GL_V2F */
-   {  32991, 0x00002A21 }, /* GL_V3F */
-   {  32998, 0x00001F00 }, /* GL_VENDOR */
-   {  33008, 0x00001F02 }, /* GL_VERSION */
-   {  33019, 0x00008074 }, /* GL_VERTEX_ARRAY */
-   {  33035, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
-   {  33066, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */
-   {  33101, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */
-   {  33125, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */
-   {  33146, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */
-   {  33169, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */
-   {  33190, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
-   {  33217, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
-   {  33245, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
-   {  33273, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
-   {  33301, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
-   {  33329, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
-   {  33357, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
-   {  33385, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
-   {  33412, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
-   {  33439, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
-   {  33466, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
-   {  33493, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
-   {  33520, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
-   {  33547, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
-   {  33574, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
-   {  33601, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
-   {  33628, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
-   {  33666, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */
-   {  33708, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */
-   {  33743, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */
-   {  33781, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */
-   {  33816, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */
-   {  33848, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */
-   {  33882, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */
-   {  33914, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */
-   {  33934, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */
-   {  33956, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */
-   {  33985, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */
-   {  34006, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */
-   {  34039, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */
-   {  34071, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */
-   {  34102, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */
-   {  34132, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */
-   {  34153, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */
-   {  34180, 0x00000BA2 }, /* GL_VIEWPORT */
-   {  34192, 0x00000800 }, /* GL_VIEWPORT_BIT */
-   {  34208, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */
-   {  34228, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
-   {  34259, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */
-   {  34294, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */
-   {  34322, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */
-   {  34347, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
-   {  34374, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */
-   {  34399, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */
-   {  34423, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */
-   {  34442, 0x000088B9 }, /* GL_WRITE_ONLY */
-   {  34456, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */
-   {  34474, 0x00001506 }, /* GL_XOR */
-   {  34481, 0x000085B9 }, /* GL_YCBCR_422_APPLE */
-   {  34500, 0x00008757 }, /* GL_YCBCR_MESA */
-   {  34514, 0x00000000 }, /* GL_ZERO */
-   {  34522, 0x00000D16 }, /* GL_ZOOM_X */
-   {  34532, 0x00000D17 }, /* GL_ZOOM_Y */
+   { 10002, 0x0000802D }, /* GL_HISTOGRAM_SINK */
+   { 10020, 0x0000802D }, /* GL_HISTOGRAM_SINK_EXT */
+   { 10042, 0x00008026 }, /* GL_HISTOGRAM_WIDTH */
+   { 10061, 0x00008026 }, /* GL_HISTOGRAM_WIDTH_EXT */
+   { 10084, 0x0000862A }, /* GL_IDENTITY_NV */
+   { 10099, 0x00008150 }, /* GL_IGNORE_BORDER_HP */
+   { 10119, 0x00008B9B }, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
+   { 10159, 0x00008B9A }, /* GL_IMPLEMENTATION_COLOR_READ_TYPE_OES */
+   { 10197, 0x00001E02 }, /* GL_INCR */
+   { 10205, 0x00008507 }, /* GL_INCR_WRAP */
+   { 10218, 0x00008507 }, /* GL_INCR_WRAP_EXT */
+   { 10235, 0x00008077 }, /* GL_INDEX_ARRAY */
+   { 10250, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING */
+   { 10280, 0x00008899 }, /* GL_INDEX_ARRAY_BUFFER_BINDING_ARB */
+   { 10314, 0x00008091 }, /* GL_INDEX_ARRAY_POINTER */
+   { 10337, 0x00008086 }, /* GL_INDEX_ARRAY_STRIDE */
+   { 10359, 0x00008085 }, /* GL_INDEX_ARRAY_TYPE */
+   { 10379, 0x00000D51 }, /* GL_INDEX_BITS */
+   { 10393, 0x00000C20 }, /* GL_INDEX_CLEAR_VALUE */
+   { 10414, 0x00000BF1 }, /* GL_INDEX_LOGIC_OP */
+   { 10432, 0x00000C30 }, /* GL_INDEX_MODE */
+   { 10446, 0x00000D13 }, /* GL_INDEX_OFFSET */
+   { 10462, 0x00000D12 }, /* GL_INDEX_SHIFT */
+   { 10477, 0x00000C21 }, /* GL_INDEX_WRITEMASK */
+   { 10496, 0x00001404 }, /* GL_INT */
+   { 10503, 0x00008049 }, /* GL_INTENSITY */
+   { 10516, 0x0000804C }, /* GL_INTENSITY12 */
+   { 10531, 0x0000804C }, /* GL_INTENSITY12_EXT */
+   { 10550, 0x0000804D }, /* GL_INTENSITY16 */
+   { 10565, 0x0000804D }, /* GL_INTENSITY16_EXT */
+   { 10584, 0x0000804A }, /* GL_INTENSITY4 */
+   { 10598, 0x0000804A }, /* GL_INTENSITY4_EXT */
+   { 10616, 0x0000804B }, /* GL_INTENSITY8 */
+   { 10630, 0x0000804B }, /* GL_INTENSITY8_EXT */
+   { 10648, 0x00008049 }, /* GL_INTENSITY_EXT */
+   { 10665, 0x00008575 }, /* GL_INTERPOLATE */
+   { 10680, 0x00008575 }, /* GL_INTERPOLATE_ARB */
+   { 10699, 0x00008575 }, /* GL_INTERPOLATE_EXT */
+   { 10718, 0x00008B53 }, /* GL_INT_VEC2_ARB */
+   { 10734, 0x00008B54 }, /* GL_INT_VEC3_ARB */
+   { 10750, 0x00008B55 }, /* GL_INT_VEC4_ARB */
+   { 10766, 0x00000500 }, /* GL_INVALID_ENUM */
+   { 10782, 0x00000506 }, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */
+   { 10819, 0x00000502 }, /* GL_INVALID_OPERATION */
+   { 10840, 0x00000501 }, /* GL_INVALID_VALUE */
+   { 10857, 0x0000862B }, /* GL_INVERSE_NV */
+   { 10871, 0x0000862D }, /* GL_INVERSE_TRANSPOSE_NV */
+   { 10895, 0x0000150A }, /* GL_INVERT */
+   { 10905, 0x00001E00 }, /* GL_KEEP */
+   { 10913, 0x00000406 }, /* GL_LEFT */
+   { 10921, 0x00000203 }, /* GL_LEQUAL */
+   { 10931, 0x00000201 }, /* GL_LESS */
+   { 10939, 0x00004000 }, /* GL_LIGHT0 */
+   { 10949, 0x00004001 }, /* GL_LIGHT1 */
+   { 10959, 0x00004002 }, /* GL_LIGHT2 */
+   { 10969, 0x00004003 }, /* GL_LIGHT3 */
+   { 10979, 0x00004004 }, /* GL_LIGHT4 */
+   { 10989, 0x00004005 }, /* GL_LIGHT5 */
+   { 10999, 0x00004006 }, /* GL_LIGHT6 */
+   { 11009, 0x00004007 }, /* GL_LIGHT7 */
+   { 11019, 0x00000B50 }, /* GL_LIGHTING */
+   { 11031, 0x00000040 }, /* GL_LIGHTING_BIT */
+   { 11047, 0x00000B53 }, /* GL_LIGHT_MODEL_AMBIENT */
+   { 11070, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL */
+   { 11099, 0x000081F8 }, /* GL_LIGHT_MODEL_COLOR_CONTROL_EXT */
+   { 11132, 0x00000B51 }, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
+   { 11160, 0x00000B52 }, /* GL_LIGHT_MODEL_TWO_SIDE */
+   { 11184, 0x00001B01 }, /* GL_LINE */
+   { 11192, 0x00002601 }, /* GL_LINEAR */
+   { 11202, 0x00001208 }, /* GL_LINEAR_ATTENUATION */
+   { 11224, 0x00008170 }, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
+   { 11254, 0x0000844F }, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
+   { 11285, 0x00002703 }, /* GL_LINEAR_MIPMAP_LINEAR */
+   { 11309, 0x00002701 }, /* GL_LINEAR_MIPMAP_NEAREST */
+   { 11334, 0x00000001 }, /* GL_LINES */
+   { 11343, 0x00000004 }, /* GL_LINE_BIT */
+   { 11355, 0x00000002 }, /* GL_LINE_LOOP */
+   { 11368, 0x00000707 }, /* GL_LINE_RESET_TOKEN */
+   { 11388, 0x00000B20 }, /* GL_LINE_SMOOTH */
+   { 11403, 0x00000C52 }, /* GL_LINE_SMOOTH_HINT */
+   { 11423, 0x00000B24 }, /* GL_LINE_STIPPLE */
+   { 11439, 0x00000B25 }, /* GL_LINE_STIPPLE_PATTERN */
+   { 11463, 0x00000B26 }, /* GL_LINE_STIPPLE_REPEAT */
+   { 11486, 0x00000003 }, /* GL_LINE_STRIP */
+   { 11500, 0x00000702 }, /* GL_LINE_TOKEN */
+   { 11514, 0x00000B21 }, /* GL_LINE_WIDTH */
+   { 11528, 0x00000B23 }, /* GL_LINE_WIDTH_GRANULARITY */
+   { 11554, 0x00000B22 }, /* GL_LINE_WIDTH_RANGE */
+   { 11574, 0x00000B32 }, /* GL_LIST_BASE */
+   { 11587, 0x00020000 }, /* GL_LIST_BIT */
+   { 11599, 0x00000B33 }, /* GL_LIST_INDEX */
+   { 11613, 0x00000B30 }, /* GL_LIST_MODE */
+   { 11626, 0x00000101 }, /* GL_LOAD */
+   { 11634, 0x00000BF1 }, /* GL_LOGIC_OP */
+   { 11646, 0x00000BF0 }, /* GL_LOGIC_OP_MODE */
+   { 11663, 0x00001909 }, /* GL_LUMINANCE */
+   { 11676, 0x00008041 }, /* GL_LUMINANCE12 */
+   { 11691, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12 */
+   { 11714, 0x00008047 }, /* GL_LUMINANCE12_ALPHA12_EXT */
+   { 11741, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4 */
+   { 11763, 0x00008046 }, /* GL_LUMINANCE12_ALPHA4_EXT */
+   { 11789, 0x00008041 }, /* GL_LUMINANCE12_EXT */
+   { 11808, 0x00008042 }, /* GL_LUMINANCE16 */
+   { 11823, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16 */
+   { 11846, 0x00008048 }, /* GL_LUMINANCE16_ALPHA16_EXT */
+   { 11873, 0x00008042 }, /* GL_LUMINANCE16_EXT */
+   { 11892, 0x0000803F }, /* GL_LUMINANCE4 */
+   { 11906, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4 */
+   { 11927, 0x00008043 }, /* GL_LUMINANCE4_ALPHA4_EXT */
+   { 11952, 0x0000803F }, /* GL_LUMINANCE4_EXT */
+   { 11970, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2 */
+   { 11991, 0x00008044 }, /* GL_LUMINANCE6_ALPHA2_EXT */
+   { 12016, 0x00008040 }, /* GL_LUMINANCE8 */
+   { 12030, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8 */
+   { 12051, 0x00008045 }, /* GL_LUMINANCE8_ALPHA8_EXT */
+   { 12076, 0x00008040 }, /* GL_LUMINANCE8_EXT */
+   { 12094, 0x0000190A }, /* GL_LUMINANCE_ALPHA */
+   { 12113, 0x00000D90 }, /* GL_MAP1_COLOR_4 */
+   { 12129, 0x00000DD0 }, /* GL_MAP1_GRID_DOMAIN */
+   { 12149, 0x00000DD1 }, /* GL_MAP1_GRID_SEGMENTS */
+   { 12171, 0x00000D91 }, /* GL_MAP1_INDEX */
+   { 12185, 0x00000D92 }, /* GL_MAP1_NORMAL */
+   { 12200, 0x00000D93 }, /* GL_MAP1_TEXTURE_COORD_1 */
+   { 12224, 0x00000D94 }, /* GL_MAP1_TEXTURE_COORD_2 */
+   { 12248, 0x00000D95 }, /* GL_MAP1_TEXTURE_COORD_3 */
+   { 12272, 0x00000D96 }, /* GL_MAP1_TEXTURE_COORD_4 */
+   { 12296, 0x00000D97 }, /* GL_MAP1_VERTEX_3 */
+   { 12313, 0x00000D98 }, /* GL_MAP1_VERTEX_4 */
+   { 12330, 0x00008660 }, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
+   { 12358, 0x0000866A }, /* GL_MAP1_VERTEX_ATTRIB10_4_NV */
+   { 12387, 0x0000866B }, /* GL_MAP1_VERTEX_ATTRIB11_4_NV */
+   { 12416, 0x0000866C }, /* GL_MAP1_VERTEX_ATTRIB12_4_NV */
+   { 12445, 0x0000866D }, /* GL_MAP1_VERTEX_ATTRIB13_4_NV */
+   { 12474, 0x0000866E }, /* GL_MAP1_VERTEX_ATTRIB14_4_NV */
+   { 12503, 0x0000866F }, /* GL_MAP1_VERTEX_ATTRIB15_4_NV */
+   { 12532, 0x00008661 }, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
+   { 12560, 0x00008662 }, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
+   { 12588, 0x00008663 }, /* GL_MAP1_VERTEX_ATTRIB3_4_NV */
+   { 12616, 0x00008664 }, /* GL_MAP1_VERTEX_ATTRIB4_4_NV */
+   { 12644, 0x00008665 }, /* GL_MAP1_VERTEX_ATTRIB5_4_NV */
+   { 12672, 0x00008666 }, /* GL_MAP1_VERTEX_ATTRIB6_4_NV */
+   { 12700, 0x00008667 }, /* GL_MAP1_VERTEX_ATTRIB7_4_NV */
+   { 12728, 0x00008668 }, /* GL_MAP1_VERTEX_ATTRIB8_4_NV */
+   { 12756, 0x00008669 }, /* GL_MAP1_VERTEX_ATTRIB9_4_NV */
+   { 12784, 0x00000DB0 }, /* GL_MAP2_COLOR_4 */
+   { 12800, 0x00000DD2 }, /* GL_MAP2_GRID_DOMAIN */
+   { 12820, 0x00000DD3 }, /* GL_MAP2_GRID_SEGMENTS */
+   { 12842, 0x00000DB1 }, /* GL_MAP2_INDEX */
+   { 12856, 0x00000DB2 }, /* GL_MAP2_NORMAL */
+   { 12871, 0x00000DB3 }, /* GL_MAP2_TEXTURE_COORD_1 */
+   { 12895, 0x00000DB4 }, /* GL_MAP2_TEXTURE_COORD_2 */
+   { 12919, 0x00000DB5 }, /* GL_MAP2_TEXTURE_COORD_3 */
+   { 12943, 0x00000DB6 }, /* GL_MAP2_TEXTURE_COORD_4 */
+   { 12967, 0x00000DB7 }, /* GL_MAP2_VERTEX_3 */
+   { 12984, 0x00000DB8 }, /* GL_MAP2_VERTEX_4 */
+   { 13001, 0x00008670 }, /* GL_MAP2_VERTEX_ATTRIB0_4_NV */
+   { 13029, 0x0000867A }, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
+   { 13058, 0x0000867B }, /* GL_MAP2_VERTEX_ATTRIB11_4_NV */
+   { 13087, 0x0000867C }, /* GL_MAP2_VERTEX_ATTRIB12_4_NV */
+   { 13116, 0x0000867D }, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
+   { 13145, 0x0000867E }, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
+   { 13174, 0x0000867F }, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
+   { 13203, 0x00008671 }, /* GL_MAP2_VERTEX_ATTRIB1_4_NV */
+   { 13231, 0x00008672 }, /* GL_MAP2_VERTEX_ATTRIB2_4_NV */
+   { 13259, 0x00008673 }, /* GL_MAP2_VERTEX_ATTRIB3_4_NV */
+   { 13287, 0x00008674 }, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
+   { 13315, 0x00008675 }, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
+   { 13343, 0x00008676 }, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
+   { 13371, 0x00008677 }, /* GL_MAP2_VERTEX_ATTRIB7_4_NV */
+   { 13399, 0x00008678 }, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
+   { 13427, 0x00008679 }, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
+   { 13455, 0x00000D10 }, /* GL_MAP_COLOR */
+   { 13468, 0x00000D11 }, /* GL_MAP_STENCIL */
+   { 13483, 0x000088C0 }, /* GL_MATRIX0_ARB */
+   { 13498, 0x00008630 }, /* GL_MATRIX0_NV */
+   { 13512, 0x000088CA }, /* GL_MATRIX10_ARB */
+   { 13528, 0x000088CB }, /* GL_MATRIX11_ARB */
+   { 13544, 0x000088CC }, /* GL_MATRIX12_ARB */
+   { 13560, 0x000088CD }, /* GL_MATRIX13_ARB */
+   { 13576, 0x000088CE }, /* GL_MATRIX14_ARB */
+   { 13592, 0x000088CF }, /* GL_MATRIX15_ARB */
+   { 13608, 0x000088D0 }, /* GL_MATRIX16_ARB */
+   { 13624, 0x000088D1 }, /* GL_MATRIX17_ARB */
+   { 13640, 0x000088D2 }, /* GL_MATRIX18_ARB */
+   { 13656, 0x000088D3 }, /* GL_MATRIX19_ARB */
+   { 13672, 0x000088C1 }, /* GL_MATRIX1_ARB */
+   { 13687, 0x00008631 }, /* GL_MATRIX1_NV */
+   { 13701, 0x000088D4 }, /* GL_MATRIX20_ARB */
+   { 13717, 0x000088D5 }, /* GL_MATRIX21_ARB */
+   { 13733, 0x000088D6 }, /* GL_MATRIX22_ARB */
+   { 13749, 0x000088D7 }, /* GL_MATRIX23_ARB */
+   { 13765, 0x000088D8 }, /* GL_MATRIX24_ARB */
+   { 13781, 0x000088D9 }, /* GL_MATRIX25_ARB */
+   { 13797, 0x000088DA }, /* GL_MATRIX26_ARB */
+   { 13813, 0x000088DB }, /* GL_MATRIX27_ARB */
+   { 13829, 0x000088DC }, /* GL_MATRIX28_ARB */
+   { 13845, 0x000088DD }, /* GL_MATRIX29_ARB */
+   { 13861, 0x000088C2 }, /* GL_MATRIX2_ARB */
+   { 13876, 0x00008632 }, /* GL_MATRIX2_NV */
+   { 13890, 0x000088DE }, /* GL_MATRIX30_ARB */
+   { 13906, 0x000088DF }, /* GL_MATRIX31_ARB */
+   { 13922, 0x000088C3 }, /* GL_MATRIX3_ARB */
+   { 13937, 0x00008633 }, /* GL_MATRIX3_NV */
+   { 13951, 0x000088C4 }, /* GL_MATRIX4_ARB */
+   { 13966, 0x00008634 }, /* GL_MATRIX4_NV */
+   { 13980, 0x000088C5 }, /* GL_MATRIX5_ARB */
+   { 13995, 0x00008635 }, /* GL_MATRIX5_NV */
+   { 14009, 0x000088C6 }, /* GL_MATRIX6_ARB */
+   { 14024, 0x00008636 }, /* GL_MATRIX6_NV */
+   { 14038, 0x000088C7 }, /* GL_MATRIX7_ARB */
+   { 14053, 0x00008637 }, /* GL_MATRIX7_NV */
+   { 14067, 0x000088C8 }, /* GL_MATRIX8_ARB */
+   { 14082, 0x000088C9 }, /* GL_MATRIX9_ARB */
+   { 14097, 0x00008844 }, /* GL_MATRIX_INDEX_ARRAY_ARB */
+   { 14123, 0x00008849 }, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
+   { 14157, 0x00008846 }, /* GL_MATRIX_INDEX_ARRAY_SIZE_ARB */
+   { 14188, 0x00008848 }, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
+   { 14221, 0x00008847 }, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
+   { 14252, 0x00000BA0 }, /* GL_MATRIX_MODE */
+   { 14267, 0x00008840 }, /* GL_MATRIX_PALETTE_ARB */
+   { 14289, 0x00008008 }, /* GL_MAX */
+   { 14296, 0x00008073 }, /* GL_MAX_3D_TEXTURE_SIZE */
+   { 14319, 0x00000D35 }, /* GL_MAX_ATTRIB_STACK_DEPTH */
+   { 14345, 0x00000D3B }, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
+   { 14378, 0x00008177 }, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
+   { 14404, 0x00008178 }, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+   { 14438, 0x00000D32 }, /* GL_MAX_CLIP_PLANES */
+   { 14457, 0x00008CDF }, /* GL_MAX_COLOR_ATTACHMENTS_EXT */
+   { 14486, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
+   { 14518, 0x000080B3 }, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI */
+   { 14554, 0x00008B4D }, /* GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB */
+   { 14594, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT */
+   { 14620, 0x0000801B }, /* GL_MAX_CONVOLUTION_HEIGHT_EXT */
+   { 14650, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH */
+   { 14675, 0x0000801A }, /* GL_MAX_CONVOLUTION_WIDTH_EXT */
+   { 14704, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
+   { 14733, 0x0000851C }, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB */
+   { 14766, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ARB */
+   { 14790, 0x00008824 }, /* GL_MAX_DRAW_BUFFERS_ATI */
+   { 14814, 0x000080E9 }, /* GL_MAX_ELEMENTS_INDICES */
+   { 14838, 0x000080E8 }, /* GL_MAX_ELEMENTS_VERTICES */
+   { 14863, 0x00000D30 }, /* GL_MAX_EVAL_ORDER */
+   { 14881, 0x00008008 }, /* GL_MAX_EXT */
+   { 14892, 0x00008B49 }, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */
+   { 14931, 0x00000D31 }, /* GL_MAX_LIGHTS */
+   { 14945, 0x00000B31 }, /* GL_MAX_LIST_NESTING */
+   { 14965, 0x00008841 }, /* GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB */
+   { 15003, 0x00000D36 }, /* GL_MAX_MODELVIEW_STACK_DEPTH */
+   { 15032, 0x00000D37 }, /* GL_MAX_NAME_STACK_DEPTH */
+   { 15056, 0x00008842 }, /* GL_MAX_PALETTE_MATRICES_ARB */
+   { 15084, 0x00000D34 }, /* GL_MAX_PIXEL_MAP_TABLE */
+   { 15107, 0x000088B1 }, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
+   { 15144, 0x0000880B }, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
+   { 15180, 0x000088AD }, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
+   { 15207, 0x000088F5 }, /* GL_MAX_PROGRAM_CALL_DEPTH_NV */
+   { 15236, 0x000088B5 }, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
+   { 15270, 0x000088F4 }, /* GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */
+   { 15306, 0x000088F6 }, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
+   { 15333, 0x000088A1 }, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
+   { 15365, 0x000088B4 }, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
+   { 15401, 0x000088F8 }, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
+   { 15430, 0x000088F7 }, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
+   { 15459, 0x0000862F }, /* GL_MAX_PROGRAM_MATRICES_ARB */
+   { 15487, 0x0000862E }, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
+   { 15525, 0x000088B3 }, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+   { 15569, 0x0000880E }, /* GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+   { 15612, 0x000088AF }, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
+   { 15646, 0x000088A3 }, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+   { 15685, 0x000088AB }, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
+   { 15722, 0x000088A7 }, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
+   { 15760, 0x00008810 }, /* GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+   { 15803, 0x0000880F }, /* GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+   { 15846, 0x000088A9 }, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
+   { 15876, 0x000088A5 }, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
+   { 15907, 0x0000880D }, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
+   { 15943, 0x0000880C }, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
+   { 15979, 0x00000D38 }, /* GL_MAX_PROJECTION_STACK_DEPTH */
+   { 16009, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
+   { 16043, 0x000084F8 }, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_NV */
+   { 16076, 0x000084E8 }, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
+   { 16105, 0x00008504 }, /* GL_MAX_SHININESS_NV */
+   { 16125, 0x00008505 }, /* GL_MAX_SPOT_EXPONENT_NV */
+   { 16149, 0x00008871 }, /* GL_MAX_TEXTURE_COORDS_ARB */
+   { 16175, 0x00008872 }, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */
+   { 16206, 0x000084FD }, /* GL_MAX_TEXTURE_LOD_BIAS */
+   { 16230, 0x000084FF }, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
+   { 16264, 0x00000D33 }, /* GL_MAX_TEXTURE_SIZE */
+   { 16284, 0x00000D39 }, /* GL_MAX_TEXTURE_STACK_DEPTH */
+   { 16311, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS */
+   { 16332, 0x000084E2 }, /* GL_MAX_TEXTURE_UNITS_ARB */
+   { 16357, 0x0000862F }, /* GL_MAX_TRACK_MATRICES_NV */
+   { 16382, 0x0000862E }, /* GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV */
+   { 16417, 0x00008B4B }, /* GL_MAX_VARYING_FLOATS_ARB */
+   { 16443, 0x00008869 }, /* GL_MAX_VERTEX_ATTRIBS_ARB */
+   { 16469, 0x00008B4C }, /* GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */
+   { 16507, 0x00008B4A }, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */
+   { 16544, 0x000086A4 }, /* GL_MAX_VERTEX_UNITS_ARB */
+   { 16568, 0x00000D3A }, /* GL_MAX_VIEWPORT_DIMS */
+   { 16589, 0x00008007 }, /* GL_MIN */
+   { 16596, 0x0000802E }, /* GL_MINMAX */
+   { 16606, 0x0000802E }, /* GL_MINMAX_EXT */
+   { 16620, 0x0000802F }, /* GL_MINMAX_FORMAT */
+   { 16637, 0x0000802F }, /* GL_MINMAX_FORMAT_EXT */
+   { 16658, 0x00008030 }, /* GL_MINMAX_SINK */
+   { 16673, 0x00008030 }, /* GL_MINMAX_SINK_EXT */
+   { 16692, 0x00008007 }, /* GL_MIN_EXT */
+   { 16703, 0x00008370 }, /* GL_MIRRORED_REPEAT */
+   { 16722, 0x00008370 }, /* GL_MIRRORED_REPEAT_ARB */
+   { 16745, 0x00008370 }, /* GL_MIRRORED_REPEAT_IBM */
+   { 16768, 0x00008742 }, /* GL_MIRROR_CLAMP_ATI */
+   { 16788, 0x00008742 }, /* GL_MIRROR_CLAMP_EXT */
+   { 16808, 0x00008912 }, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
+   { 16838, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_ATI */
+   { 16866, 0x00008743 }, /* GL_MIRROR_CLAMP_TO_EDGE_EXT */
+   { 16894, 0x00001700 }, /* GL_MODELVIEW */
+   { 16907, 0x00001700 }, /* GL_MODELVIEW0_ARB */
+   { 16925, 0x0000872A }, /* GL_MODELVIEW10_ARB */
+   { 16944, 0x0000872B }, /* GL_MODELVIEW11_ARB */
+   { 16963, 0x0000872C }, /* GL_MODELVIEW12_ARB */
+   { 16982, 0x0000872D }, /* GL_MODELVIEW13_ARB */
+   { 17001, 0x0000872E }, /* GL_MODELVIEW14_ARB */
+   { 17020, 0x0000872F }, /* GL_MODELVIEW15_ARB */
+   { 17039, 0x00008730 }, /* GL_MODELVIEW16_ARB */
+   { 17058, 0x00008731 }, /* GL_MODELVIEW17_ARB */
+   { 17077, 0x00008732 }, /* GL_MODELVIEW18_ARB */
+   { 17096, 0x00008733 }, /* GL_MODELVIEW19_ARB */
+   { 17115, 0x0000850A }, /* GL_MODELVIEW1_ARB */
+   { 17133, 0x00008734 }, /* GL_MODELVIEW20_ARB */
+   { 17152, 0x00008735 }, /* GL_MODELVIEW21_ARB */
+   { 17171, 0x00008736 }, /* GL_MODELVIEW22_ARB */
+   { 17190, 0x00008737 }, /* GL_MODELVIEW23_ARB */
+   { 17209, 0x00008738 }, /* GL_MODELVIEW24_ARB */
+   { 17228, 0x00008739 }, /* GL_MODELVIEW25_ARB */
+   { 17247, 0x0000873A }, /* GL_MODELVIEW26_ARB */
+   { 17266, 0x0000873B }, /* GL_MODELVIEW27_ARB */
+   { 17285, 0x0000873C }, /* GL_MODELVIEW28_ARB */
+   { 17304, 0x0000873D }, /* GL_MODELVIEW29_ARB */
+   { 17323, 0x00008722 }, /* GL_MODELVIEW2_ARB */
+   { 17341, 0x0000873E }, /* GL_MODELVIEW30_ARB */
+   { 17360, 0x0000873F }, /* GL_MODELVIEW31_ARB */
+   { 17379, 0x00008723 }, /* GL_MODELVIEW3_ARB */
+   { 17397, 0x00008724 }, /* GL_MODELVIEW4_ARB */
+   { 17415, 0x00008725 }, /* GL_MODELVIEW5_ARB */
+   { 17433, 0x00008726 }, /* GL_MODELVIEW6_ARB */
+   { 17451, 0x00008727 }, /* GL_MODELVIEW7_ARB */
+   { 17469, 0x00008728 }, /* GL_MODELVIEW8_ARB */
+   { 17487, 0x00008729 }, /* GL_MODELVIEW9_ARB */
+   { 17505, 0x00000BA6 }, /* GL_MODELVIEW_MATRIX */
+   { 17525, 0x00008629 }, /* GL_MODELVIEW_PROJECTION_NV */
+   { 17552, 0x00000BA3 }, /* GL_MODELVIEW_STACK_DEPTH */
+   { 17577, 0x00002100 }, /* GL_MODULATE */
+   { 17589, 0x00008744 }, /* GL_MODULATE_ADD_ATI */
+   { 17609, 0x00008745 }, /* GL_MODULATE_SIGNED_ADD_ATI */
+   { 17636, 0x00008746 }, /* GL_MODULATE_SUBTRACT_ATI */
+   { 17661, 0x00000103 }, /* GL_MULT */
+   { 17669, 0x0000809D }, /* GL_MULTISAMPLE */
+   { 17684, 0x000086B2 }, /* GL_MULTISAMPLE_3DFX */
+   { 17704, 0x0000809D }, /* GL_MULTISAMPLE_ARB */
+   { 17723, 0x20000000 }, /* GL_MULTISAMPLE_BIT */
+   { 17742, 0x20000000 }, /* GL_MULTISAMPLE_BIT_3DFX */
+   { 17766, 0x20000000 }, /* GL_MULTISAMPLE_BIT_ARB */
+   { 17789, 0x00008534 }, /* GL_MULTISAMPLE_FILTER_HINT_NV */
+   { 17819, 0x00002A25 }, /* GL_N3F_V3F */
+   { 17830, 0x00000D70 }, /* GL_NAME_STACK_DEPTH */
+   { 17850, 0x0000150E }, /* GL_NAND */
+   { 17858, 0x00002600 }, /* GL_NEAREST */
+   { 17869, 0x0000844E }, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
+   { 17900, 0x0000844D }, /* GL_NEAREST_CLIPMAP_NEAREST_SGIX */
+   { 17932, 0x00002702 }, /* GL_NEAREST_MIPMAP_LINEAR */
+   { 17957, 0x00002700 }, /* GL_NEAREST_MIPMAP_NEAREST */
+   { 17983, 0x00000200 }, /* GL_NEVER */
+   { 17992, 0x00001102 }, /* GL_NICEST */
+   { 18002, 0x00000000 }, /* GL_NONE */
+   { 18010, 0x00001505 }, /* GL_NOOP */
+   { 18018, 0x00001508 }, /* GL_NOR */
+   { 18025, 0x00000BA1 }, /* GL_NORMALIZE */
+   { 18038, 0x00008075 }, /* GL_NORMAL_ARRAY */
+   { 18054, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
+   { 18085, 0x00008897 }, /* GL_NORMAL_ARRAY_BUFFER_BINDING_ARB */
+   { 18120, 0x0000808F }, /* GL_NORMAL_ARRAY_POINTER */
+   { 18144, 0x0000807F }, /* GL_NORMAL_ARRAY_STRIDE */
+   { 18167, 0x0000807E }, /* GL_NORMAL_ARRAY_TYPE */
+   { 18188, 0x00008511 }, /* GL_NORMAL_MAP */
+   { 18202, 0x00008511 }, /* GL_NORMAL_MAP_ARB */
+   { 18220, 0x00008511 }, /* GL_NORMAL_MAP_NV */
+   { 18237, 0x00000205 }, /* GL_NOTEQUAL */
+   { 18249, 0x00000000 }, /* GL_NO_ERROR */
+   { 18261, 0x000086A2 }, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
+   { 18295, 0x000086A2 }, /* GL_NUM_TEXTURE_COMPRESSED_FORMATS_ARB */
+   { 18333, 0x00008B89 }, /* GL_OBJECT_ACTIVE_ATTRIBUTES_ARB */
+   { 18365, 0x00008B8A }, /* GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB */
+   { 18407, 0x00008B86 }, /* GL_OBJECT_ACTIVE_UNIFORMS_ARB */
+   { 18437, 0x00008B87 }, /* GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB */
+   { 18477, 0x00008B85 }, /* GL_OBJECT_ATTACHED_OBJECTS_ARB */
+   { 18508, 0x00008B81 }, /* GL_OBJECT_COMPILE_STATUS_ARB */
+   { 18537, 0x00008B80 }, /* GL_OBJECT_DELETE_STATUS_ARB */
+   { 18565, 0x00008B84 }, /* GL_OBJECT_INFO_LOG_LENGTH_ARB */
+   { 18595, 0x00002401 }, /* GL_OBJECT_LINEAR */
+   { 18612, 0x00008B82 }, /* GL_OBJECT_LINK_STATUS_ARB */
+   { 18638, 0x00002501 }, /* GL_OBJECT_PLANE */
+   { 18654, 0x00008B88 }, /* GL_OBJECT_SHADER_SOURCE_LENGTH_ARB */
+   { 18689, 0x00008B4F }, /* GL_OBJECT_SUBTYPE_ARB */
+   { 18711, 0x00008B4E }, /* GL_OBJECT_TYPE_ARB */
+   { 18730, 0x00008B83 }, /* GL_OBJECT_VALIDATE_STATUS_ARB */
+   { 18760, 0x00008165 }, /* GL_OCCLUSION_TEST_HP */
+   { 18781, 0x00008166 }, /* GL_OCCLUSION_TEST_RESULT_HP */
+   { 18809, 0x00000001 }, /* GL_ONE */
+   { 18816, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA */
+   { 18844, 0x00008004 }, /* GL_ONE_MINUS_CONSTANT_ALPHA_EXT */
+   { 18876, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR */
+   { 18904, 0x00008002 }, /* GL_ONE_MINUS_CONSTANT_COLOR_EXT */
+   { 18936, 0x00000305 }, /* GL_ONE_MINUS_DST_ALPHA */
+   { 18959, 0x00000307 }, /* GL_ONE_MINUS_DST_COLOR */
+   { 18982, 0x00000303 }, /* GL_ONE_MINUS_SRC_ALPHA */
+   { 19005, 0x00000301 }, /* GL_ONE_MINUS_SRC_COLOR */
+   { 19028, 0x00008598 }, /* GL_OPERAND0_ALPHA */
+   { 19046, 0x00008598 }, /* GL_OPERAND0_ALPHA_ARB */
+   { 19068, 0x00008598 }, /* GL_OPERAND0_ALPHA_EXT */
+   { 19090, 0x00008590 }, /* GL_OPERAND0_RGB */
+   { 19106, 0x00008590 }, /* GL_OPERAND0_RGB_ARB */
+   { 19126, 0x00008590 }, /* GL_OPERAND0_RGB_EXT */
+   { 19146, 0x00008599 }, /* GL_OPERAND1_ALPHA */
+   { 19164, 0x00008599 }, /* GL_OPERAND1_ALPHA_ARB */
+   { 19186, 0x00008599 }, /* GL_OPERAND1_ALPHA_EXT */
+   { 19208, 0x00008591 }, /* GL_OPERAND1_RGB */
+   { 19224, 0x00008591 }, /* GL_OPERAND1_RGB_ARB */
+   { 19244, 0x00008591 }, /* GL_OPERAND1_RGB_EXT */
+   { 19264, 0x0000859A }, /* GL_OPERAND2_ALPHA */
+   { 19282, 0x0000859A }, /* GL_OPERAND2_ALPHA_ARB */
+   { 19304, 0x0000859A }, /* GL_OPERAND2_ALPHA_EXT */
+   { 19326, 0x00008592 }, /* GL_OPERAND2_RGB */
+   { 19342, 0x00008592 }, /* GL_OPERAND2_RGB_ARB */
+   { 19362, 0x00008592 }, /* GL_OPERAND2_RGB_EXT */
+   { 19382, 0x0000859B }, /* GL_OPERAND3_ALPHA_NV */
+   { 19403, 0x00008593 }, /* GL_OPERAND3_RGB_NV */
+   { 19422, 0x00001507 }, /* GL_OR */
+   { 19428, 0x00000A01 }, /* GL_ORDER */
+   { 19437, 0x0000150D }, /* GL_OR_INVERTED */
+   { 19452, 0x0000150B }, /* GL_OR_REVERSE */
+   { 19466, 0x00000505 }, /* GL_OUT_OF_MEMORY */
+   { 19483, 0x00000D05 }, /* GL_PACK_ALIGNMENT */
+   { 19501, 0x0000806C }, /* GL_PACK_IMAGE_HEIGHT */
+   { 19522, 0x00008758 }, /* GL_PACK_INVERT_MESA */
+   { 19542, 0x00000D01 }, /* GL_PACK_LSB_FIRST */
+   { 19560, 0x00000D02 }, /* GL_PACK_ROW_LENGTH */
+   { 19579, 0x0000806B }, /* GL_PACK_SKIP_IMAGES */
+   { 19599, 0x00000D04 }, /* GL_PACK_SKIP_PIXELS */
+   { 19619, 0x00000D03 }, /* GL_PACK_SKIP_ROWS */
+   { 19637, 0x00000D00 }, /* GL_PACK_SWAP_BYTES */
+   { 19656, 0x00008B92 }, /* GL_PALETTE4_R5_G6_B5_OES */
+   { 19681, 0x00008B94 }, /* GL_PALETTE4_RGB5_A1_OES */
+   { 19705, 0x00008B90 }, /* GL_PALETTE4_RGB8_OES */
+   { 19726, 0x00008B93 }, /* GL_PALETTE4_RGBA4_OES */
+   { 19748, 0x00008B91 }, /* GL_PALETTE4_RGBA8_OES */
+   { 19770, 0x00008B97 }, /* GL_PALETTE8_R5_G6_B5_OES */
+   { 19795, 0x00008B99 }, /* GL_PALETTE8_RGB5_A1_OES */
+   { 19819, 0x00008B95 }, /* GL_PALETTE8_RGB8_OES */
+   { 19840, 0x00008B98 }, /* GL_PALETTE8_RGBA4_OES */
+   { 19862, 0x00008B96 }, /* GL_PALETTE8_RGBA8_OES */
+   { 19884, 0x00000700 }, /* GL_PASS_THROUGH_TOKEN */
+   { 19906, 0x00000C50 }, /* GL_PERSPECTIVE_CORRECTION_HINT */
+   { 19937, 0x00000C79 }, /* GL_PIXEL_MAP_A_TO_A */
+   { 19957, 0x00000CB9 }, /* GL_PIXEL_MAP_A_TO_A_SIZE */
+   { 19982, 0x00000C78 }, /* GL_PIXEL_MAP_B_TO_B */
+   { 20002, 0x00000CB8 }, /* GL_PIXEL_MAP_B_TO_B_SIZE */
+   { 20027, 0x00000C77 }, /* GL_PIXEL_MAP_G_TO_G */
+   { 20047, 0x00000CB7 }, /* GL_PIXEL_MAP_G_TO_G_SIZE */
+   { 20072, 0x00000C75 }, /* GL_PIXEL_MAP_I_TO_A */
+   { 20092, 0x00000CB5 }, /* GL_PIXEL_MAP_I_TO_A_SIZE */
+   { 20117, 0x00000C74 }, /* GL_PIXEL_MAP_I_TO_B */
+   { 20137, 0x00000CB4 }, /* GL_PIXEL_MAP_I_TO_B_SIZE */
+   { 20162, 0x00000C73 }, /* GL_PIXEL_MAP_I_TO_G */
+   { 20182, 0x00000CB3 }, /* GL_PIXEL_MAP_I_TO_G_SIZE */
+   { 20207, 0x00000C70 }, /* GL_PIXEL_MAP_I_TO_I */
+   { 20227, 0x00000CB0 }, /* GL_PIXEL_MAP_I_TO_I_SIZE */
+   { 20252, 0x00000C72 }, /* GL_PIXEL_MAP_I_TO_R */
+   { 20272, 0x00000CB2 }, /* GL_PIXEL_MAP_I_TO_R_SIZE */
+   { 20297, 0x00000C76 }, /* GL_PIXEL_MAP_R_TO_R */
+   { 20317, 0x00000CB6 }, /* GL_PIXEL_MAP_R_TO_R_SIZE */
+   { 20342, 0x00000C71 }, /* GL_PIXEL_MAP_S_TO_S */
+   { 20362, 0x00000CB1 }, /* GL_PIXEL_MAP_S_TO_S_SIZE */
+   { 20387, 0x00000020 }, /* GL_PIXEL_MODE_BIT */
+   { 20405, 0x000088ED }, /* GL_PIXEL_PACK_BUFFER_BINDING_EXT */
+   { 20438, 0x000088EB }, /* GL_PIXEL_PACK_BUFFER_EXT */
+   { 20463, 0x000088EF }, /* GL_PIXEL_UNPACK_BUFFER_BINDING_EXT */
+   { 20498, 0x000088EC }, /* GL_PIXEL_UNPACK_BUFFER_EXT */
+   { 20525, 0x00001B00 }, /* GL_POINT */
+   { 20534, 0x00000000 }, /* GL_POINTS */
+   { 20544, 0x00000002 }, /* GL_POINT_BIT */
+   { 20557, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION */
+   { 20587, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_ARB */
+   { 20621, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_EXT */
+   { 20655, 0x00008129 }, /* GL_POINT_DISTANCE_ATTENUATION_SGIS */
+   { 20690, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE */
+   { 20719, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_ARB */
+   { 20752, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_EXT */
+   { 20785, 0x00008128 }, /* GL_POINT_FADE_THRESHOLD_SIZE_SGIS */
+   { 20819, 0x00000B11 }, /* GL_POINT_SIZE */
+   { 20833, 0x00000B13 }, /* GL_POINT_SIZE_GRANULARITY */
+   { 20859, 0x00008127 }, /* GL_POINT_SIZE_MAX */
+   { 20877, 0x00008127 }, /* GL_POINT_SIZE_MAX_ARB */
+   { 20899, 0x00008127 }, /* GL_POINT_SIZE_MAX_EXT */
+   { 20921, 0x00008127 }, /* GL_POINT_SIZE_MAX_SGIS */
+   { 20944, 0x00008126 }, /* GL_POINT_SIZE_MIN */
+   { 20962, 0x00008126 }, /* GL_POINT_SIZE_MIN_ARB */
+   { 20984, 0x00008126 }, /* GL_POINT_SIZE_MIN_EXT */
+   { 21006, 0x00008126 }, /* GL_POINT_SIZE_MIN_SGIS */
+   { 21029, 0x00000B12 }, /* GL_POINT_SIZE_RANGE */
+   { 21049, 0x00000B10 }, /* GL_POINT_SMOOTH */
+   { 21065, 0x00000C51 }, /* GL_POINT_SMOOTH_HINT */
+   { 21086, 0x00008861 }, /* GL_POINT_SPRITE_ARB */
+   { 21106, 0x00008CA0 }, /* GL_POINT_SPRITE_COORD_ORIGIN */
+   { 21135, 0x00008861 }, /* GL_POINT_SPRITE_NV */
+   { 21154, 0x00008863 }, /* GL_POINT_SPRITE_R_MODE_NV */
+   { 21180, 0x00000701 }, /* GL_POINT_TOKEN */
+   { 21195, 0x00000009 }, /* GL_POLYGON */
+   { 21206, 0x00000008 }, /* GL_POLYGON_BIT */
+   { 21221, 0x00000B40 }, /* GL_POLYGON_MODE */
+   { 21237, 0x00008039 }, /* GL_POLYGON_OFFSET_BIAS */
+   { 21260, 0x00008038 }, /* GL_POLYGON_OFFSET_FACTOR */
+   { 21285, 0x00008037 }, /* GL_POLYGON_OFFSET_FILL */
+   { 21308, 0x00002A02 }, /* GL_POLYGON_OFFSET_LINE */
+   { 21331, 0x00002A01 }, /* GL_POLYGON_OFFSET_POINT */
+   { 21355, 0x00002A00 }, /* GL_POLYGON_OFFSET_UNITS */
+   { 21379, 0x00000B41 }, /* GL_POLYGON_SMOOTH */
+   { 21397, 0x00000C53 }, /* GL_POLYGON_SMOOTH_HINT */
+   { 21420, 0x00000B42 }, /* GL_POLYGON_STIPPLE */
+   { 21439, 0x00000010 }, /* GL_POLYGON_STIPPLE_BIT */
+   { 21462, 0x00000703 }, /* GL_POLYGON_TOKEN */
+   { 21479, 0x00001203 }, /* GL_POSITION */
+   { 21491, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
+   { 21523, 0x000080BB }, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI */
+   { 21559, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
+   { 21592, 0x000080B7 }, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI */
+   { 21629, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
+   { 21660, 0x000080BA }, /* GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI */
+   { 21695, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
+   { 21727, 0x000080B6 }, /* GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI */
+   { 21763, 0x000080D2 }, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
+   { 21796, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
+   { 21828, 0x000080B9 }, /* GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI */
+   { 21864, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
+   { 21897, 0x000080B5 }, /* GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI */
+   { 21934, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS */
+   { 21964, 0x000080B8 }, /* GL_POST_COLOR_MATRIX_RED_BIAS_SGI */
+   { 21998, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE */
+   { 22029, 0x000080B4 }, /* GL_POST_COLOR_MATRIX_RED_SCALE_SGI */
+   { 22064, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
+   { 22095, 0x00008023 }, /* GL_POST_CONVOLUTION_ALPHA_BIAS_EXT */
+   { 22130, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
+   { 22162, 0x0000801F }, /* GL_POST_CONVOLUTION_ALPHA_SCALE_EXT */
+   { 22198, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS */
+   { 22228, 0x00008022 }, /* GL_POST_CONVOLUTION_BLUE_BIAS_EXT */
+   { 22262, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE */
+   { 22293, 0x0000801E }, /* GL_POST_CONVOLUTION_BLUE_SCALE_EXT */
+   { 22328, 0x000080D1 }, /* GL_POST_CONVOLUTION_COLOR_TABLE */
+   { 22360, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS */
+   { 22391, 0x00008021 }, /* GL_POST_CONVOLUTION_GREEN_BIAS_EXT */
+   { 22426, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE */
+   { 22458, 0x0000801D }, /* GL_POST_CONVOLUTION_GREEN_SCALE_EXT */
+   { 22494, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS */
+   { 22523, 0x00008020 }, /* GL_POST_CONVOLUTION_RED_BIAS_EXT */
+   { 22556, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE */
+   { 22586, 0x0000801C }, /* GL_POST_CONVOLUTION_RED_SCALE_EXT */
+   { 22620, 0x0000817B }, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
+   { 22659, 0x00008179 }, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
+   { 22692, 0x0000817C }, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
+   { 22732, 0x0000817A }, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
+   { 22766, 0x00008578 }, /* GL_PREVIOUS */
+   { 22778, 0x00008578 }, /* GL_PREVIOUS_ARB */
+   { 22794, 0x00008578 }, /* GL_PREVIOUS_EXT */
+   { 22810, 0x00008577 }, /* GL_PRIMARY_COLOR */
+   { 22827, 0x00008577 }, /* GL_PRIMARY_COLOR_ARB */
+   { 22848, 0x00008577 }, /* GL_PRIMARY_COLOR_EXT */
+   { 22869, 0x000088B0 }, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
+   { 22902, 0x00008805 }, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
+   { 22934, 0x000088AC }, /* GL_PROGRAM_ATTRIBS_ARB */
+   { 22957, 0x00008677 }, /* GL_PROGRAM_BINDING_ARB */
+   { 22980, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_ARB */
+   { 23010, 0x0000864B }, /* GL_PROGRAM_ERROR_POSITION_NV */
+   { 23039, 0x00008874 }, /* GL_PROGRAM_ERROR_STRING_ARB */
+   { 23067, 0x00008876 }, /* GL_PROGRAM_FORMAT_ARB */
+   { 23089, 0x00008875 }, /* GL_PROGRAM_FORMAT_ASCII_ARB */
+   { 23117, 0x000088A0 }, /* GL_PROGRAM_INSTRUCTIONS_ARB */
+   { 23145, 0x00008627 }, /* GL_PROGRAM_LENGTH_ARB */
+   { 23167, 0x00008627 }, /* GL_PROGRAM_LENGTH_NV */
+   { 23188, 0x000088B2 }, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+   { 23228, 0x00008808 }, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+   { 23267, 0x000088AE }, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
+   { 23297, 0x000088A2 }, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+   { 23332, 0x000088AA }, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
+   { 23365, 0x000088A6 }, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
+   { 23399, 0x0000880A }, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+   { 23438, 0x00008809 }, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+   { 23477, 0x00008B40 }, /* GL_PROGRAM_OBJECT_ARB */
+   { 23499, 0x000088A8 }, /* GL_PROGRAM_PARAMETERS_ARB */
+   { 23525, 0x00008644 }, /* GL_PROGRAM_PARAMETER_NV */
+   { 23549, 0x00008647 }, /* GL_PROGRAM_RESIDENT_NV */
+   { 23572, 0x00008628 }, /* GL_PROGRAM_STRING_ARB */
+   { 23594, 0x00008628 }, /* GL_PROGRAM_STRING_NV */
+   { 23615, 0x00008646 }, /* GL_PROGRAM_TARGET_NV */
+   { 23636, 0x000088A4 }, /* GL_PROGRAM_TEMPORARIES_ARB */
+   { 23663, 0x00008807 }, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
+   { 23695, 0x00008806 }, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
+   { 23727, 0x000088B6 }, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
+   { 23762, 0x00001701 }, /* GL_PROJECTION */
+   { 23776, 0x00000BA7 }, /* GL_PROJECTION_MATRIX */
+   { 23797, 0x00000BA4 }, /* GL_PROJECTION_STACK_DEPTH */
+   { 23823, 0x000080D3 }, /* GL_PROXY_COLOR_TABLE */
+   { 23844, 0x00008025 }, /* GL_PROXY_HISTOGRAM */
+   { 23863, 0x00008025 }, /* GL_PROXY_HISTOGRAM_EXT */
+   { 23886, 0x000080D5 }, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
+   { 23925, 0x000080D4 }, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
+   { 23963, 0x00008063 }, /* GL_PROXY_TEXTURE_1D */
+   { 23983, 0x00008063 }, /* GL_PROXY_TEXTURE_1D_EXT */
+   { 24007, 0x00008064 }, /* GL_PROXY_TEXTURE_2D */
+   { 24027, 0x00008064 }, /* GL_PROXY_TEXTURE_2D_EXT */
+   { 24051, 0x00008070 }, /* GL_PROXY_TEXTURE_3D */
+   { 24071, 0x000080BD }, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
+   { 24104, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP */
+   { 24130, 0x0000851B }, /* GL_PROXY_TEXTURE_CUBE_MAP_ARB */
+   { 24160, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
+   { 24191, 0x000084F7 }, /* GL_PROXY_TEXTURE_RECTANGLE_NV */
+   { 24221, 0x00002003 }, /* GL_Q */
+   { 24226, 0x00001209 }, /* GL_QUADRATIC_ATTENUATION */
+   { 24251, 0x00000007 }, /* GL_QUADS */
+   { 24260, 0x00008614 }, /* GL_QUAD_MESH_SUN */
+   { 24277, 0x00000008 }, /* GL_QUAD_STRIP */
+   { 24291, 0x00008864 }, /* GL_QUERY_COUNTER_BITS */
+   { 24313, 0x00008864 }, /* GL_QUERY_COUNTER_BITS_ARB */
+   { 24339, 0x00008866 }, /* GL_QUERY_RESULT */
+   { 24355, 0x00008866 }, /* GL_QUERY_RESULT_ARB */
+   { 24375, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE */
+   { 24401, 0x00008867 }, /* GL_QUERY_RESULT_AVAILABLE_ARB */
+   { 24431, 0x00002002 }, /* GL_R */
+   { 24436, 0x00002A10 }, /* GL_R3_G3_B2 */
+   { 24448, 0x00019262 }, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
+   { 24481, 0x00000C02 }, /* GL_READ_BUFFER */
+   { 24496, 0x000088B8 }, /* GL_READ_ONLY */
+   { 24509, 0x000088B8 }, /* GL_READ_ONLY_ARB */
+   { 24526, 0x000088BA }, /* GL_READ_WRITE */
+   { 24540, 0x000088BA }, /* GL_READ_WRITE_ARB */
+   { 24558, 0x00001903 }, /* GL_RED */
+   { 24565, 0x00008016 }, /* GL_REDUCE */
+   { 24575, 0x00008016 }, /* GL_REDUCE_EXT */
+   { 24589, 0x00000D15 }, /* GL_RED_BIAS */
+   { 24601, 0x00000D52 }, /* GL_RED_BITS */
+   { 24613, 0x00000D14 }, /* GL_RED_SCALE */
+   { 24626, 0x00008512 }, /* GL_REFLECTION_MAP */
+   { 24644, 0x00008512 }, /* GL_REFLECTION_MAP_ARB */
+   { 24666, 0x00008512 }, /* GL_REFLECTION_MAP_NV */
+   { 24687, 0x00001C00 }, /* GL_RENDER */
+   { 24697, 0x00008CA7 }, /* GL_RENDERBUFFER_BINDING_EXT */
+   { 24725, 0x00008D41 }, /* GL_RENDERBUFFER_EXT */
+   { 24745, 0x00008D43 }, /* GL_RENDERBUFFER_HEIGHT_EXT */
+   { 24772, 0x00008D44 }, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
+   { 24808, 0x00008D42 }, /* GL_RENDERBUFFER_WIDTH_EXT */
+   { 24834, 0x00001F01 }, /* GL_RENDERER */
+   { 24846, 0x00000C40 }, /* GL_RENDER_MODE */
+   { 24861, 0x00002901 }, /* GL_REPEAT */
+   { 24871, 0x00001E01 }, /* GL_REPLACE */
+   { 24882, 0x00008062 }, /* GL_REPLACE_EXT */
+   { 24897, 0x00008153 }, /* GL_REPLICATE_BORDER_HP */
+   { 24920, 0x0000803A }, /* GL_RESCALE_NORMAL */
+   { 24938, 0x0000803A }, /* GL_RESCALE_NORMAL_EXT */
+   { 24960, 0x00000102 }, /* GL_RETURN */
+   { 24970, 0x00001907 }, /* GL_RGB */
+   { 24977, 0x00008052 }, /* GL_RGB10 */
+   { 24986, 0x00008059 }, /* GL_RGB10_A2 */
+   { 24998, 0x00008059 }, /* GL_RGB10_A2_EXT */
+   { 25014, 0x00008052 }, /* GL_RGB10_EXT */
+   { 25027, 0x00008053 }, /* GL_RGB12 */
+   { 25036, 0x00008053 }, /* GL_RGB12_EXT */
+   { 25049, 0x00008054 }, /* GL_RGB16 */
+   { 25058, 0x00008054 }, /* GL_RGB16_EXT */
+   { 25071, 0x0000804E }, /* GL_RGB2_EXT */
+   { 25083, 0x0000804F }, /* GL_RGB4 */
+   { 25091, 0x0000804F }, /* GL_RGB4_EXT */
+   { 25103, 0x000083A1 }, /* GL_RGB4_S3TC */
+   { 25116, 0x00008050 }, /* GL_RGB5 */
+   { 25124, 0x00008057 }, /* GL_RGB5_A1 */
+   { 25135, 0x00008057 }, /* GL_RGB5_A1_EXT */
+   { 25150, 0x00008050 }, /* GL_RGB5_EXT */
+   { 25162, 0x00008051 }, /* GL_RGB8 */
+   { 25170, 0x00008051 }, /* GL_RGB8_EXT */
+   { 25182, 0x00001908 }, /* GL_RGBA */
+   { 25190, 0x0000805A }, /* GL_RGBA12 */
+   { 25200, 0x0000805A }, /* GL_RGBA12_EXT */
+   { 25214, 0x0000805B }, /* GL_RGBA16 */
+   { 25224, 0x0000805B }, /* GL_RGBA16_EXT */
+   { 25238, 0x00008055 }, /* GL_RGBA2 */
+   { 25247, 0x00008055 }, /* GL_RGBA2_EXT */
+   { 25260, 0x00008056 }, /* GL_RGBA4 */
+   { 25269, 0x000083A5 }, /* GL_RGBA4_DXT5_S3TC */
+   { 25288, 0x00008056 }, /* GL_RGBA4_EXT */
+   { 25301, 0x000083A3 }, /* GL_RGBA4_S3TC */
+   { 25315, 0x00008058 }, /* GL_RGBA8 */
+   { 25324, 0x00008058 }, /* GL_RGBA8_EXT */
+   { 25337, 0x000083A4 }, /* GL_RGBA_DXT5_S3TC */
+   { 25355, 0x00000C31 }, /* GL_RGBA_MODE */
+   { 25368, 0x000083A2 }, /* GL_RGBA_S3TC */
+   { 25381, 0x000083A0 }, /* GL_RGB_S3TC */
+   { 25393, 0x00008573 }, /* GL_RGB_SCALE */
+   { 25406, 0x00008573 }, /* GL_RGB_SCALE_ARB */
+   { 25423, 0x00008573 }, /* GL_RGB_SCALE_EXT */
+   { 25440, 0x00000407 }, /* GL_RIGHT */
+   { 25449, 0x00002000 }, /* GL_S */
+   { 25454, 0x000080A9 }, /* GL_SAMPLES */
+   { 25465, 0x000086B4 }, /* GL_SAMPLES_3DFX */
+   { 25481, 0x000080A9 }, /* GL_SAMPLES_ARB */
+   { 25496, 0x00008914 }, /* GL_SAMPLES_PASSED */
+   { 25514, 0x00008914 }, /* GL_SAMPLES_PASSED_ARB */
+   { 25536, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
+   { 25564, 0x0000809E }, /* GL_SAMPLE_ALPHA_TO_COVERAGE_ARB */
+   { 25596, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE */
+   { 25619, 0x0000809F }, /* GL_SAMPLE_ALPHA_TO_ONE_ARB */
+   { 25646, 0x000080A8 }, /* GL_SAMPLE_BUFFERS */
+   { 25664, 0x000086B3 }, /* GL_SAMPLE_BUFFERS_3DFX */
+   { 25687, 0x000080A8 }, /* GL_SAMPLE_BUFFERS_ARB */
+   { 25709, 0x000080A0 }, /* GL_SAMPLE_COVERAGE */
+   { 25728, 0x000080A0 }, /* GL_SAMPLE_COVERAGE_ARB */
+   { 25751, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT */
+   { 25777, 0x000080AB }, /* GL_SAMPLE_COVERAGE_INVERT_ARB */
+   { 25807, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE */
+   { 25832, 0x000080AA }, /* GL_SAMPLE_COVERAGE_VALUE_ARB */
+   { 25861, 0x00080000 }, /* GL_SCISSOR_BIT */
+   { 25876, 0x00000C10 }, /* GL_SCISSOR_BOX */
+   { 25891, 0x00000C11 }, /* GL_SCISSOR_TEST */
+   { 25907, 0x0000845E }, /* GL_SECONDARY_COLOR_ARRAY */
+   { 25932, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
+   { 25972, 0x0000889C }, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB */
+   { 26016, 0x0000845D }, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
+   { 26049, 0x0000845A }, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
+   { 26079, 0x0000845C }, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
+   { 26111, 0x0000845B }, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
+   { 26141, 0x00001C02 }, /* GL_SELECT */
+   { 26151, 0x00000DF3 }, /* GL_SELECTION_BUFFER_POINTER */
+   { 26179, 0x00000DF4 }, /* GL_SELECTION_BUFFER_SIZE */
+   { 26204, 0x00008012 }, /* GL_SEPARABLE_2D */
+   { 26220, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR */
+   { 26247, 0x000081FA }, /* GL_SEPARATE_SPECULAR_COLOR_EXT */
+   { 26278, 0x0000150F }, /* GL_SET */
+   { 26285, 0x00008B48 }, /* GL_SHADER_OBJECT_ARB */
+   { 26306, 0x00000B54 }, /* GL_SHADE_MODEL */
+   { 26321, 0x000080BF }, /* GL_SHADOW_AMBIENT_SGIX */
+   { 26344, 0x000081FB }, /* GL_SHARED_TEXTURE_PALETTE_EXT */
+   { 26374, 0x00001601 }, /* GL_SHININESS */
+   { 26387, 0x00001402 }, /* GL_SHORT */
+   { 26396, 0x000081F9 }, /* GL_SINGLE_COLOR */
+   { 26412, 0x000081F9 }, /* GL_SINGLE_COLOR_EXT */
+   { 26432, 0x000085CC }, /* GL_SLICE_ACCUM_SUN */
+   { 26451, 0x00001D01 }, /* GL_SMOOTH */
+   { 26461, 0x00000B23 }, /* GL_SMOOTH_LINE_WIDTH_GRANULARITY */
+   { 26494, 0x00000B22 }, /* GL_SMOOTH_LINE_WIDTH_RANGE */
+   { 26521, 0x00000B13 }, /* GL_SMOOTH_POINT_SIZE_GRANULARITY */
+   { 26554, 0x00000B12 }, /* GL_SMOOTH_POINT_SIZE_RANGE */
+   { 26581, 0x00008588 }, /* GL_SOURCE0_ALPHA */
+   { 26598, 0x00008588 }, /* GL_SOURCE0_ALPHA_ARB */
+   { 26619, 0x00008588 }, /* GL_SOURCE0_ALPHA_EXT */
+   { 26640, 0x00008580 }, /* GL_SOURCE0_RGB */
+   { 26655, 0x00008580 }, /* GL_SOURCE0_RGB_ARB */
+   { 26674, 0x00008580 }, /* GL_SOURCE0_RGB_EXT */
+   { 26693, 0x00008589 }, /* GL_SOURCE1_ALPHA */
+   { 26710, 0x00008589 }, /* GL_SOURCE1_ALPHA_ARB */
+   { 26731, 0x00008589 }, /* GL_SOURCE1_ALPHA_EXT */
+   { 26752, 0x00008581 }, /* GL_SOURCE1_RGB */
+   { 26767, 0x00008581 }, /* GL_SOURCE1_RGB_ARB */
+   { 26786, 0x00008581 }, /* GL_SOURCE1_RGB_EXT */
+   { 26805, 0x0000858A }, /* GL_SOURCE2_ALPHA */
+   { 26822, 0x0000858A }, /* GL_SOURCE2_ALPHA_ARB */
+   { 26843, 0x0000858A }, /* GL_SOURCE2_ALPHA_EXT */
+   { 26864, 0x00008582 }, /* GL_SOURCE2_RGB */
+   { 26879, 0x00008582 }, /* GL_SOURCE2_RGB_ARB */
+   { 26898, 0x00008582 }, /* GL_SOURCE2_RGB_EXT */
+   { 26917, 0x0000858B }, /* GL_SOURCE3_ALPHA_NV */
+   { 26937, 0x00008583 }, /* GL_SOURCE3_RGB_NV */
+   { 26955, 0x00001202 }, /* GL_SPECULAR */
+   { 26967, 0x00002402 }, /* GL_SPHERE_MAP */
+   { 26981, 0x00001206 }, /* GL_SPOT_CUTOFF */
+   { 26996, 0x00001204 }, /* GL_SPOT_DIRECTION */
+   { 27014, 0x00001205 }, /* GL_SPOT_EXPONENT */
+   { 27031, 0x00008588 }, /* GL_SRC0_ALPHA */
+   { 27045, 0x00008580 }, /* GL_SRC0_RGB */
+   { 27057, 0x00008589 }, /* GL_SRC1_ALPHA */
+   { 27071, 0x00008581 }, /* GL_SRC1_RGB */
+   { 27083, 0x0000858A }, /* GL_SRC2_ALPHA */
+   { 27097, 0x00008582 }, /* GL_SRC2_RGB */
+   { 27109, 0x00000302 }, /* GL_SRC_ALPHA */
+   { 27122, 0x00000308 }, /* GL_SRC_ALPHA_SATURATE */
+   { 27144, 0x00000300 }, /* GL_SRC_COLOR */
+   { 27157, 0x00000503 }, /* GL_STACK_OVERFLOW */
+   { 27175, 0x00000504 }, /* GL_STACK_UNDERFLOW */
+   { 27194, 0x000088E6 }, /* GL_STATIC_COPY */
+   { 27209, 0x000088E6 }, /* GL_STATIC_COPY_ARB */
+   { 27228, 0x000088E4 }, /* GL_STATIC_DRAW */
+   { 27243, 0x000088E4 }, /* GL_STATIC_DRAW_ARB */
+   { 27262, 0x000088E5 }, /* GL_STATIC_READ */
+   { 27277, 0x000088E5 }, /* GL_STATIC_READ_ARB */
+   { 27296, 0x00001802 }, /* GL_STENCIL */
+   { 27307, 0x00008D20 }, /* GL_STENCIL_ATTACHMENT_EXT */
+   { 27333, 0x00000D57 }, /* GL_STENCIL_BITS */
+   { 27349, 0x00000400 }, /* GL_STENCIL_BUFFER_BIT */
+   { 27371, 0x00000B91 }, /* GL_STENCIL_CLEAR_VALUE */
+   { 27394, 0x00000B94 }, /* GL_STENCIL_FAIL */
+   { 27410, 0x00000B92 }, /* GL_STENCIL_FUNC */
+   { 27426, 0x00001901 }, /* GL_STENCIL_INDEX */
+   { 27443, 0x00008D49 }, /* GL_STENCIL_INDEX16_EXT */
+   { 27466, 0x00008D46 }, /* GL_STENCIL_INDEX1_EXT */
+   { 27488, 0x00008D47 }, /* GL_STENCIL_INDEX4_EXT */
+   { 27510, 0x00008D48 }, /* GL_STENCIL_INDEX8_EXT */
+   { 27532, 0x00008D45 }, /* GL_STENCIL_INDEX_EXT */
+   { 27553, 0x00000B95 }, /* GL_STENCIL_PASS_DEPTH_FAIL */
+   { 27580, 0x00000B96 }, /* GL_STENCIL_PASS_DEPTH_PASS */
+   { 27607, 0x00000B97 }, /* GL_STENCIL_REF */
+   { 27622, 0x00000B90 }, /* GL_STENCIL_TEST */
+   { 27638, 0x00008910 }, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
+   { 27667, 0x00000B93 }, /* GL_STENCIL_VALUE_MASK */
+   { 27689, 0x00000B98 }, /* GL_STENCIL_WRITEMASK */
+   { 27710, 0x00000C33 }, /* GL_STEREO */
+   { 27720, 0x000088E2 }, /* GL_STREAM_COPY */
+   { 27735, 0x000088E2 }, /* GL_STREAM_COPY_ARB */
+   { 27754, 0x000088E0 }, /* GL_STREAM_DRAW */
+   { 27769, 0x000088E0 }, /* GL_STREAM_DRAW_ARB */
+   { 27788, 0x000088E1 }, /* GL_STREAM_READ */
+   { 27803, 0x000088E1 }, /* GL_STREAM_READ_ARB */
+   { 27822, 0x00000D50 }, /* GL_SUBPIXEL_BITS */
+   { 27839, 0x000084E7 }, /* GL_SUBTRACT */
+   { 27851, 0x000084E7 }, /* GL_SUBTRACT_ARB */
+   { 27867, 0x00002001 }, /* GL_T */
+   { 27872, 0x00002A2A }, /* GL_T2F_C3F_V3F */
+   { 27887, 0x00002A2C }, /* GL_T2F_C4F_N3F_V3F */
+   { 27906, 0x00002A29 }, /* GL_T2F_C4UB_V3F */
+   { 27922, 0x00002A2B }, /* GL_T2F_N3F_V3F */
+   { 27937, 0x00002A27 }, /* GL_T2F_V3F */
+   { 27948, 0x00002A2D }, /* GL_T4F_C4F_N3F_V4F */
+   { 27967, 0x00002A28 }, /* GL_T4F_V4F */
+   { 27978, 0x00008031 }, /* GL_TABLE_TOO_LARGE_EXT */
+   { 28001, 0x00001702 }, /* GL_TEXTURE */
+   { 28012, 0x000084C0 }, /* GL_TEXTURE0 */
+   { 28024, 0x000084C0 }, /* GL_TEXTURE0_ARB */
+   { 28040, 0x000084C1 }, /* GL_TEXTURE1 */
+   { 28052, 0x000084CA }, /* GL_TEXTURE10 */
+   { 28065, 0x000084CA }, /* GL_TEXTURE10_ARB */
+   { 28082, 0x000084CB }, /* GL_TEXTURE11 */
+   { 28095, 0x000084CB }, /* GL_TEXTURE11_ARB */
+   { 28112, 0x000084CC }, /* GL_TEXTURE12 */
+   { 28125, 0x000084CC }, /* GL_TEXTURE12_ARB */
+   { 28142, 0x000084CD }, /* GL_TEXTURE13 */
+   { 28155, 0x000084CD }, /* GL_TEXTURE13_ARB */
+   { 28172, 0x000084CE }, /* GL_TEXTURE14 */
+   { 28185, 0x000084CE }, /* GL_TEXTURE14_ARB */
+   { 28202, 0x000084CF }, /* GL_TEXTURE15 */
+   { 28215, 0x000084CF }, /* GL_TEXTURE15_ARB */
+   { 28232, 0x000084D0 }, /* GL_TEXTURE16 */
+   { 28245, 0x000084D0 }, /* GL_TEXTURE16_ARB */
+   { 28262, 0x000084D1 }, /* GL_TEXTURE17 */
+   { 28275, 0x000084D1 }, /* GL_TEXTURE17_ARB */
+   { 28292, 0x000084D2 }, /* GL_TEXTURE18 */
+   { 28305, 0x000084D2 }, /* GL_TEXTURE18_ARB */
+   { 28322, 0x000084D3 }, /* GL_TEXTURE19 */
+   { 28335, 0x000084D3 }, /* GL_TEXTURE19_ARB */
+   { 28352, 0x000084C1 }, /* GL_TEXTURE1_ARB */
+   { 28368, 0x000084C2 }, /* GL_TEXTURE2 */
+   { 28380, 0x000084D4 }, /* GL_TEXTURE20 */
+   { 28393, 0x000084D4 }, /* GL_TEXTURE20_ARB */
+   { 28410, 0x000084D5 }, /* GL_TEXTURE21 */
+   { 28423, 0x000084D5 }, /* GL_TEXTURE21_ARB */
+   { 28440, 0x000084D6 }, /* GL_TEXTURE22 */
+   { 28453, 0x000084D6 }, /* GL_TEXTURE22_ARB */
+   { 28470, 0x000084D7 }, /* GL_TEXTURE23 */
+   { 28483, 0x000084D7 }, /* GL_TEXTURE23_ARB */
+   { 28500, 0x000084D8 }, /* GL_TEXTURE24 */
+   { 28513, 0x000084D8 }, /* GL_TEXTURE24_ARB */
+   { 28530, 0x000084D9 }, /* GL_TEXTURE25 */
+   { 28543, 0x000084D9 }, /* GL_TEXTURE25_ARB */
+   { 28560, 0x000084DA }, /* GL_TEXTURE26 */
+   { 28573, 0x000084DA }, /* GL_TEXTURE26_ARB */
+   { 28590, 0x000084DB }, /* GL_TEXTURE27 */
+   { 28603, 0x000084DB }, /* GL_TEXTURE27_ARB */
+   { 28620, 0x000084DC }, /* GL_TEXTURE28 */
+   { 28633, 0x000084DC }, /* GL_TEXTURE28_ARB */
+   { 28650, 0x000084DD }, /* GL_TEXTURE29 */
+   { 28663, 0x000084DD }, /* GL_TEXTURE29_ARB */
+   { 28680, 0x000084C2 }, /* GL_TEXTURE2_ARB */
+   { 28696, 0x000084C3 }, /* GL_TEXTURE3 */
+   { 28708, 0x000084DE }, /* GL_TEXTURE30 */
+   { 28721, 0x000084DE }, /* GL_TEXTURE30_ARB */
+   { 28738, 0x000084DF }, /* GL_TEXTURE31 */
+   { 28751, 0x000084DF }, /* GL_TEXTURE31_ARB */
+   { 28768, 0x000084C3 }, /* GL_TEXTURE3_ARB */
+   { 28784, 0x000084C4 }, /* GL_TEXTURE4 */
+   { 28796, 0x000084C4 }, /* GL_TEXTURE4_ARB */
+   { 28812, 0x000084C5 }, /* GL_TEXTURE5 */
+   { 28824, 0x000084C5 }, /* GL_TEXTURE5_ARB */
+   { 28840, 0x000084C6 }, /* GL_TEXTURE6 */
+   { 28852, 0x000084C6 }, /* GL_TEXTURE6_ARB */
+   { 28868, 0x000084C7 }, /* GL_TEXTURE7 */
+   { 28880, 0x000084C7 }, /* GL_TEXTURE7_ARB */
+   { 28896, 0x000084C8 }, /* GL_TEXTURE8 */
+   { 28908, 0x000084C8 }, /* GL_TEXTURE8_ARB */
+   { 28924, 0x000084C9 }, /* GL_TEXTURE9 */
+   { 28936, 0x000084C9 }, /* GL_TEXTURE9_ARB */
+   { 28952, 0x00000DE0 }, /* GL_TEXTURE_1D */
+   { 28966, 0x00000DE1 }, /* GL_TEXTURE_2D */
+   { 28980, 0x0000806F }, /* GL_TEXTURE_3D */
+   { 28994, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE */
+   { 29016, 0x0000805F }, /* GL_TEXTURE_ALPHA_SIZE_EXT */
+   { 29042, 0x0000813C }, /* GL_TEXTURE_BASE_LEVEL */
+   { 29064, 0x00008068 }, /* GL_TEXTURE_BINDING_1D */
+   { 29086, 0x00008069 }, /* GL_TEXTURE_BINDING_2D */
+   { 29108, 0x0000806A }, /* GL_TEXTURE_BINDING_3D */
+   { 29130, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP */
+   { 29158, 0x00008514 }, /* GL_TEXTURE_BINDING_CUBE_MAP_ARB */
+   { 29190, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
+   { 29223, 0x000084F6 }, /* GL_TEXTURE_BINDING_RECTANGLE_NV */
+   { 29255, 0x00040000 }, /* GL_TEXTURE_BIT */
+   { 29270, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE */
+   { 29291, 0x0000805E }, /* GL_TEXTURE_BLUE_SIZE_EXT */
+   { 29316, 0x00001005 }, /* GL_TEXTURE_BORDER */
+   { 29334, 0x00001004 }, /* GL_TEXTURE_BORDER_COLOR */
+   { 29358, 0x00008171 }, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
+   { 29389, 0x00008176 }, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
+   { 29419, 0x00008172 }, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
+   { 29449, 0x00008175 }, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
+   { 29484, 0x00008173 }, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
+   { 29515, 0x00008174 }, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+   { 29553, 0x000080BC }, /* GL_TEXTURE_COLOR_TABLE_SGI */
+   { 29580, 0x000081EF }, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
+   { 29612, 0x000080BF }, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
+   { 29646, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC */
+   { 29670, 0x0000884D }, /* GL_TEXTURE_COMPARE_FUNC_ARB */
+   { 29698, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE */
+   { 29722, 0x0000884C }, /* GL_TEXTURE_COMPARE_MODE_ARB */
+   { 29750, 0x0000819B }, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
+   { 29783, 0x0000819A }, /* GL_TEXTURE_COMPARE_SGIX */
+   { 29807, 0x00001003 }, /* GL_TEXTURE_COMPONENTS */
+   { 29829, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED */
+   { 29851, 0x000086A1 }, /* GL_TEXTURE_COMPRESSED_ARB */
+   { 29877, 0x000086A3 }, /* GL_TEXTURE_COMPRESSED_FORMATS_ARB */
+   { 29911, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
+   { 29944, 0x000086A0 }, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB */
+   { 29981, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT */
+   { 30009, 0x000084EF }, /* GL_TEXTURE_COMPRESSION_HINT_ARB */
+   { 30041, 0x00008078 }, /* GL_TEXTURE_COORD_ARRAY */
+   { 30064, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
+   { 30102, 0x0000889A }, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB */
+   { 30144, 0x00008092 }, /* GL_TEXTURE_COORD_ARRAY_POINTER */
+   { 30175, 0x00008088 }, /* GL_TEXTURE_COORD_ARRAY_SIZE */
+   { 30203, 0x0000808A }, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
+   { 30233, 0x00008089 }, /* GL_TEXTURE_COORD_ARRAY_TYPE */
+   { 30261, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP */
+   { 30281, 0x00008513 }, /* GL_TEXTURE_CUBE_MAP_ARB */
+   { 30305, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
+   { 30336, 0x00008516 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB */
+   { 30371, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
+   { 30402, 0x00008518 }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB */
+   { 30437, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
+   { 30468, 0x0000851A }, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB */
+   { 30503, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
+   { 30534, 0x00008515 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB */
+   { 30569, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
+   { 30600, 0x00008517 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB */
+   { 30635, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
+   { 30666, 0x00008519 }, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB */
+   { 30701, 0x00008071 }, /* GL_TEXTURE_DEPTH */
+   { 30718, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE */
+   { 30740, 0x0000884A }, /* GL_TEXTURE_DEPTH_SIZE_ARB */
+   { 30766, 0x00002300 }, /* GL_TEXTURE_ENV */
+   { 30781, 0x00002201 }, /* GL_TEXTURE_ENV_COLOR */
+   { 30802, 0x00002200 }, /* GL_TEXTURE_ENV_MODE */
+   { 30822, 0x00008500 }, /* GL_TEXTURE_FILTER_CONTROL */
+   { 30848, 0x00002500 }, /* GL_TEXTURE_GEN_MODE */
+   { 30868, 0x00000C63 }, /* GL_TEXTURE_GEN_Q */
+   { 30885, 0x00000C62 }, /* GL_TEXTURE_GEN_R */
+   { 30902, 0x00000C60 }, /* GL_TEXTURE_GEN_S */
+   { 30919, 0x00000C61 }, /* GL_TEXTURE_GEN_T */
+   { 30936, 0x0000819D }, /* GL_TEXTURE_GEQUAL_R_SGIX */
+   { 30961, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE */
+   { 30983, 0x0000805D }, /* GL_TEXTURE_GREEN_SIZE_EXT */
+   { 31009, 0x00001001 }, /* GL_TEXTURE_HEIGHT */
+   { 31027, 0x000080ED }, /* GL_TEXTURE_INDEX_SIZE_EXT */
+   { 31053, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE */
+   { 31079, 0x00008061 }, /* GL_TEXTURE_INTENSITY_SIZE_EXT */
+   { 31109, 0x00001003 }, /* GL_TEXTURE_INTERNAL_FORMAT */
+   { 31136, 0x0000819C }, /* GL_TEXTURE_LEQUAL_R_SGIX */
+   { 31161, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS */
+   { 31181, 0x00008501 }, /* GL_TEXTURE_LOD_BIAS_EXT */
+   { 31205, 0x00008190 }, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
+   { 31232, 0x0000818E }, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
+   { 31259, 0x0000818F }, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
+   { 31286, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE */
+   { 31312, 0x00008060 }, /* GL_TEXTURE_LUMINANCE_SIZE_EXT */
+   { 31342, 0x00002800 }, /* GL_TEXTURE_MAG_FILTER */
+   { 31364, 0x00000BA8 }, /* GL_TEXTURE_MATRIX */
+   { 31382, 0x000084FE }, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
+   { 31412, 0x0000836B }, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
+   { 31440, 0x00008369 }, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
+   { 31468, 0x0000836A }, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
+   { 31496, 0x0000813D }, /* GL_TEXTURE_MAX_LEVEL */
+   { 31517, 0x0000813B }, /* GL_TEXTURE_MAX_LOD */
+   { 31536, 0x00002801 }, /* GL_TEXTURE_MIN_FILTER */
+   { 31558, 0x0000813A }, /* GL_TEXTURE_MIN_LOD */
+   { 31577, 0x00008066 }, /* GL_TEXTURE_PRIORITY */
+   { 31597, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_ARB */
+   { 31622, 0x000084F5 }, /* GL_TEXTURE_RECTANGLE_NV */
+   { 31646, 0x0000805C }, /* GL_TEXTURE_RED_SIZE */
+   { 31666, 0x0000805C }, /* GL_TEXTURE_RED_SIZE_EXT */
+   { 31690, 0x00008067 }, /* GL_TEXTURE_RESIDENT */
+   { 31710, 0x00000BA5 }, /* GL_TEXTURE_STACK_DEPTH */
+   { 31733, 0x00008065 }, /* GL_TEXTURE_TOO_LARGE_EXT */
+   { 31758, 0x0000888F }, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
+   { 31792, 0x00001000 }, /* GL_TEXTURE_WIDTH */
+   { 31809, 0x00008072 }, /* GL_TEXTURE_WRAP_R */
+   { 31827, 0x00002802 }, /* GL_TEXTURE_WRAP_S */
+   { 31845, 0x00002803 }, /* GL_TEXTURE_WRAP_T */
+   { 31863, 0x00008648 }, /* GL_TRACK_MATRIX_NV */
+   { 31882, 0x00008649 }, /* GL_TRACK_MATRIX_TRANSFORM_NV */
+   { 31911, 0x00001000 }, /* GL_TRANSFORM_BIT */
+   { 31928, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX */
+   { 31954, 0x000084E6 }, /* GL_TRANSPOSE_COLOR_MATRIX_ARB */
+   { 31984, 0x000088B7 }, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
+   { 32016, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
+   { 32046, 0x000084E3 }, /* GL_TRANSPOSE_MODELVIEW_MATRIX_ARB */
+   { 32080, 0x0000862C }, /* GL_TRANSPOSE_NV */
+   { 32096, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX */
+   { 32127, 0x000084E4 }, /* GL_TRANSPOSE_PROJECTION_MATRIX_ARB */
+   { 32162, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX */
+   { 32190, 0x000084E5 }, /* GL_TRANSPOSE_TEXTURE_MATRIX_ARB */
+   { 32222, 0x00000004 }, /* GL_TRIANGLES */
+   { 32235, 0x00000006 }, /* GL_TRIANGLE_FAN */
+   { 32251, 0x00008615 }, /* GL_TRIANGLE_MESH_SUN */
+   { 32272, 0x00000005 }, /* GL_TRIANGLE_STRIP */
+   { 32290, 0x00000001 }, /* GL_TRUE */
+   { 32298, 0x00000CF5 }, /* GL_UNPACK_ALIGNMENT */
+   { 32318, 0x0000806E }, /* GL_UNPACK_IMAGE_HEIGHT */
+   { 32341, 0x00000CF1 }, /* GL_UNPACK_LSB_FIRST */
+   { 32361, 0x00000CF2 }, /* GL_UNPACK_ROW_LENGTH */
+   { 32382, 0x0000806D }, /* GL_UNPACK_SKIP_IMAGES */
+   { 32404, 0x00000CF4 }, /* GL_UNPACK_SKIP_PIXELS */
+   { 32426, 0x00000CF3 }, /* GL_UNPACK_SKIP_ROWS */
+   { 32446, 0x00000CF0 }, /* GL_UNPACK_SWAP_BYTES */
+   { 32467, 0x00001401 }, /* GL_UNSIGNED_BYTE */
+   { 32484, 0x00008362 }, /* GL_UNSIGNED_BYTE_2_3_3_REV */
+   { 32511, 0x00008032 }, /* GL_UNSIGNED_BYTE_3_3_2 */
+   { 32534, 0x00001405 }, /* GL_UNSIGNED_INT */
+   { 32550, 0x00008036 }, /* GL_UNSIGNED_INT_10_10_10_2 */
+   { 32577, 0x000084FA }, /* GL_UNSIGNED_INT_24_8_NV */
+   { 32601, 0x00008368 }, /* GL_UNSIGNED_INT_2_10_10_10_REV */
+   { 32632, 0x00008035 }, /* GL_UNSIGNED_INT_8_8_8_8 */
+   { 32656, 0x00008367 }, /* GL_UNSIGNED_INT_8_8_8_8_REV */
+   { 32684, 0x00001403 }, /* GL_UNSIGNED_SHORT */
+   { 32702, 0x00008366 }, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
+   { 32732, 0x00008033 }, /* GL_UNSIGNED_SHORT_4_4_4_4 */
+   { 32758, 0x00008365 }, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
+   { 32788, 0x00008034 }, /* GL_UNSIGNED_SHORT_5_5_5_1 */
+   { 32814, 0x00008363 }, /* GL_UNSIGNED_SHORT_5_6_5 */
+   { 32838, 0x00008364 }, /* GL_UNSIGNED_SHORT_5_6_5_REV */
+   { 32866, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_APPLE */
+   { 32894, 0x000085BA }, /* GL_UNSIGNED_SHORT_8_8_MESA */
+   { 32921, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
+   { 32953, 0x000085BB }, /* GL_UNSIGNED_SHORT_8_8_REV_MESA */
+   { 32984, 0x00002A20 }, /* GL_V2F */
+   { 32991, 0x00002A21 }, /* GL_V3F */
+   { 32998, 0x00001F00 }, /* GL_VENDOR */
+   { 33008, 0x00001F02 }, /* GL_VERSION */
+   { 33019, 0x00008074 }, /* GL_VERTEX_ARRAY */
+   { 33035, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
+   { 33066, 0x00008896 }, /* GL_VERTEX_ARRAY_BUFFER_BINDING_ARB */
+   { 33101, 0x0000808E }, /* GL_VERTEX_ARRAY_POINTER */
+   { 33125, 0x0000807A }, /* GL_VERTEX_ARRAY_SIZE */
+   { 33146, 0x0000807C }, /* GL_VERTEX_ARRAY_STRIDE */
+   { 33169, 0x0000807B }, /* GL_VERTEX_ARRAY_TYPE */
+   { 33190, 0x00008650 }, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
+   { 33217, 0x0000865A }, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
+   { 33245, 0x0000865B }, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
+   { 33273, 0x0000865C }, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
+   { 33301, 0x0000865D }, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
+   { 33329, 0x0000865E }, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
+   { 33357, 0x0000865F }, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
+   { 33385, 0x00008651 }, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
+   { 33412, 0x00008652 }, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
+   { 33439, 0x00008653 }, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
+   { 33466, 0x00008654 }, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
+   { 33493, 0x00008655 }, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
+   { 33520, 0x00008656 }, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
+   { 33547, 0x00008657 }, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
+   { 33574, 0x00008658 }, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
+   { 33601, 0x00008659 }, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
+   { 33628, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
+   { 33666, 0x0000889F }, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB */
+   { 33708, 0x00008622 }, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */
+   { 33743, 0x0000886A }, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */
+   { 33781, 0x00008645 }, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */
+   { 33816, 0x00008623 }, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */
+   { 33848, 0x00008624 }, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */
+   { 33882, 0x00008625 }, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */
+   { 33914, 0x000086A7 }, /* GL_VERTEX_BLEND_ARB */
+   { 33934, 0x00008620 }, /* GL_VERTEX_PROGRAM_ARB */
+   { 33956, 0x0000864A }, /* GL_VERTEX_PROGRAM_BINDING_NV */
+   { 33985, 0x00008620 }, /* GL_VERTEX_PROGRAM_NV */
+   { 34006, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */
+   { 34039, 0x00008642 }, /* GL_VERTEX_PROGRAM_POINT_SIZE_NV */
+   { 34071, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */
+   { 34102, 0x00008643 }, /* GL_VERTEX_PROGRAM_TWO_SIDE_NV */
+   { 34132, 0x00008B31 }, /* GL_VERTEX_SHADER_ARB */
+   { 34153, 0x00008621 }, /* GL_VERTEX_STATE_PROGRAM_NV */
+   { 34180, 0x00000BA2 }, /* GL_VIEWPORT */
+   { 34192, 0x00000800 }, /* GL_VIEWPORT_BIT */
+   { 34208, 0x000086AD }, /* GL_WEIGHT_ARRAY_ARB */
+   { 34228, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
+   { 34259, 0x0000889E }, /* GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB */
+   { 34294, 0x000086AC }, /* GL_WEIGHT_ARRAY_POINTER_ARB */
+   { 34322, 0x000086AB }, /* GL_WEIGHT_ARRAY_SIZE_ARB */
+   { 34347, 0x000086AA }, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
+   { 34374, 0x000086A9 }, /* GL_WEIGHT_ARRAY_TYPE_ARB */
+   { 34399, 0x000086A6 }, /* GL_WEIGHT_SUM_UNITY_ARB */
+   { 34423, 0x000081D4 }, /* GL_WRAP_BORDER_SUN */
+   { 34442, 0x000088B9 }, /* GL_WRITE_ONLY */
+   { 34456, 0x000088B9 }, /* GL_WRITE_ONLY_ARB */
+   { 34474, 0x00001506 }, /* GL_XOR */
+   { 34481, 0x000085B9 }, /* GL_YCBCR_422_APPLE */
+   { 34500, 0x00008757 }, /* GL_YCBCR_MESA */
+   { 34514, 0x00000000 }, /* GL_ZERO */
+   { 34522, 0x00000D16 }, /* GL_ZOOM_X */
+   { 34532, 0x00000D17 }, /* GL_ZOOM_Y */
 };
 
 static const unsigned reduced_enums[1232] =
 {
        389, /* GL_FALSE */
-       1519, /* GL_TRUE */
+       561, /* GL_LINES */
        563, /* GL_LINE_LOOP */
        570, /* GL_LINE_STRIP */
-       1515, /* GL_TRIANGLES */
-       1518, /* GL_TRIANGLE_STRIP */
-       1516, /* GL_TRIANGLE_FAN */
-       1112, /* GL_QUADS */
-       1114, /* GL_QUAD_STRIP */
-       1002, /* GL_POLYGON */
-       1014, /* GL_POLYGON_STIPPLE_BIT */
+      1515, /* GL_TRIANGLES */
+      1518, /* GL_TRIANGLE_STRIP */
+      1516, /* GL_TRIANGLE_FAN */
+      1112, /* GL_QUADS */
+      1114, /* GL_QUAD_STRIP */
+      1002, /* GL_POLYGON */
+      1014, /* GL_POLYGON_STIPPLE_BIT */
        968, /* GL_PIXEL_MODE_BIT */
        548, /* GL_LIGHTING_BIT */
        405, /* GL_FOG_BIT */
          8, /* GL_ACCUM */
        579, /* GL_LOAD */
-       1152, /* GL_RETURN */
+      1152, /* GL_RETURN */
        841, /* GL_MULT */
         19, /* GL_ADD */
        857, /* GL_NEVER */
@@ -3294,15 +3294,15 @@ static const unsigned reduced_enums[1232] =
        872, /* GL_NOTEQUAL */
        466, /* GL_GEQUAL */
         42, /* GL_ALWAYS */
-       1276, /* GL_SRC_COLOR */
+      1276, /* GL_SRC_COLOR */
        901, /* GL_ONE_MINUS_SRC_COLOR */
-       1274, /* GL_SRC_ALPHA */
+      1274, /* GL_SRC_ALPHA */
        900, /* GL_ONE_MINUS_SRC_ALPHA */
        359, /* GL_DST_ALPHA */
        898, /* GL_ONE_MINUS_DST_ALPHA */
        360, /* GL_DST_COLOR */
        899, /* GL_ONE_MINUS_DST_COLOR */
-       1275, /* GL_SRC_ALPHA_SATURATE */
+      1275, /* GL_SRC_ALPHA_SATURATE */
        454, /* GL_FRONT_LEFT */
        455, /* GL_FRONT_RIGHT */
         64, /* GL_BACK_LEFT */
@@ -3310,7 +3310,7 @@ static const unsigned reduced_enums[1232] =
        451, /* GL_FRONT */
         63, /* GL_BACK */
        536, /* GL_LEFT */
-       1192, /* GL_RIGHT */
+      1192, /* GL_RIGHT */
        452, /* GL_FRONT_AND_BACK */
         58, /* GL_AUX0 */
         59, /* GL_AUX1 */
@@ -3319,8 +3319,8 @@ static const unsigned reduced_enums[1232] =
        528, /* GL_INVALID_ENUM */
        531, /* GL_INVALID_VALUE */
        530, /* GL_INVALID_OPERATION */
-       1277, /* GL_STACK_OVERFLOW */
-       1278, /* GL_STACK_UNDERFLOW */
+      1277, /* GL_STACK_OVERFLOW */
+      1278, /* GL_STACK_UNDERFLOW */
        926, /* GL_OUT_OF_MEMORY */
        529, /* GL_INVALID_FRAMEBUFFER_OPERATION_EXT */
          0, /* GL_2D */
@@ -3329,9 +3329,9 @@ static const unsigned reduced_enums[1232] =
          4, /* GL_3D_COLOR_TEXTURE */
          6, /* GL_4D_COLOR_TEXTURE */
        946, /* GL_PASS_THROUGH_TOKEN */
-       1001, /* GL_POINT_TOKEN */
+      1001, /* GL_POINT_TOKEN */
        571, /* GL_LINE_TOKEN */
-       1015, /* GL_POLYGON_TOKEN */
+      1015, /* GL_POLYGON_TOKEN */
         69, /* GL_BITMAP_TOKEN */
        358, /* GL_DRAW_PIXEL_TOKEN */
        248, /* GL_COPY_PIXEL_TOKEN */
@@ -3368,9 +3368,9 @@ static const unsigned reduced_enums[1232] =
        732, /* GL_MAX_LIST_NESTING */
        575, /* GL_LIST_BASE */
        577, /* GL_LIST_INDEX */
-       1004, /* GL_POLYGON_MODE */
-       1011, /* GL_POLYGON_SMOOTH */
-       1013, /* GL_POLYGON_STIPPLE */
+      1004, /* GL_POLYGON_MODE */
+      1011, /* GL_POLYGON_SMOOTH */
+      1013, /* GL_POLYGON_STIPPLE */
        367, /* GL_EDGE_FLAG */
        249, /* GL_CULL_FACE */
        250, /* GL_CULL_FACE_MODE */
@@ -3379,7 +3379,7 @@ static const unsigned reduced_enums[1232] =
        552, /* GL_LIGHT_MODEL_LOCAL_VIEWER */
        553, /* GL_LIGHT_MODEL_TWO_SIDE */
        549, /* GL_LIGHT_MODEL_AMBIENT */
-       1230, /* GL_SHADE_MODEL */
+      1230, /* GL_SHADE_MODEL */
        158, /* GL_COLOR_MATERIAL_FACE */
        159, /* GL_COLOR_MATERIAL_PARAMETER */
        157, /* GL_COLOR_MATERIAL */
@@ -3396,24 +3396,24 @@ static const unsigned reduced_enums[1232] =
        292, /* GL_DEPTH_CLEAR_VALUE */
        303, /* GL_DEPTH_FUNC */
         12, /* GL_ACCUM_CLEAR_VALUE */
-       1301, /* GL_STENCIL_TEST */
-       1289, /* GL_STENCIL_CLEAR_VALUE */
-       1291, /* GL_STENCIL_FUNC */
-       1303, /* GL_STENCIL_VALUE_MASK */
-       1290, /* GL_STENCIL_FAIL */
-       1298, /* GL_STENCIL_PASS_DEPTH_FAIL */
-       1299, /* GL_STENCIL_PASS_DEPTH_PASS */
-       1300, /* GL_STENCIL_REF */
-       1304, /* GL_STENCIL_WRITEMASK */
+      1301, /* GL_STENCIL_TEST */
+      1289, /* GL_STENCIL_CLEAR_VALUE */
+      1291, /* GL_STENCIL_FUNC */
+      1303, /* GL_STENCIL_VALUE_MASK */
+      1290, /* GL_STENCIL_FAIL */
+      1298, /* GL_STENCIL_PASS_DEPTH_FAIL */
+      1299, /* GL_STENCIL_PASS_DEPTH_PASS */
+      1300, /* GL_STENCIL_REF */
+      1304, /* GL_STENCIL_WRITEMASK */
        705, /* GL_MATRIX_MODE */
        862, /* GL_NORMALIZE */
-       1593, /* GL_VIEWPORT */
+      1593, /* GL_VIEWPORT */
        836, /* GL_MODELVIEW_STACK_DEPTH */
-       1094, /* GL_PROJECTION_STACK_DEPTH */
-       1495, /* GL_TEXTURE_STACK_DEPTH */
+      1094, /* GL_PROJECTION_STACK_DEPTH */
+      1495, /* GL_TEXTURE_STACK_DEPTH */
        834, /* GL_MODELVIEW_MATRIX */
-       1093, /* GL_PROJECTION_MATRIX */
-       1480, /* GL_TEXTURE_MATRIX */
+      1093, /* GL_PROJECTION_MATRIX */
+      1480, /* GL_TEXTURE_MATRIX */
         56, /* GL_ATTRIB_STACK_DEPTH */
        117, /* GL_CLIENT_ATTRIB_STACK_DEPTH */
         39, /* GL_ALPHA_TEST */
@@ -3424,31 +3424,31 @@ static const unsigned reduced_enums[1232] =
         80, /* GL_BLEND_SRC */
         70, /* GL_BLEND */
        581, /* GL_LOGIC_OP_MODE */
-       580, /* GL_LOGIC_OP */
+       506, /* GL_INDEX_LOGIC_OP */
        156, /* GL_COLOR_LOGIC_OP */
         62, /* GL_AUX_BUFFERS */
        325, /* GL_DRAW_BUFFER */
-       1124, /* GL_READ_BUFFER */
-       1213, /* GL_SCISSOR_BOX */
-       1214, /* GL_SCISSOR_TEST */
+      1124, /* GL_READ_BUFFER */
+      1213, /* GL_SCISSOR_BOX */
+      1214, /* GL_SCISSOR_TEST */
        505, /* GL_INDEX_CLEAR_VALUE */
        510, /* GL_INDEX_WRITEMASK */
        153, /* GL_COLOR_CLEAR_VALUE */
        185, /* GL_COLOR_WRITEMASK */
        507, /* GL_INDEX_MODE */
-       1186, /* GL_RGBA_MODE */
+      1186, /* GL_RGBA_MODE */
        324, /* GL_DOUBLEBUFFER */
-       1305, /* GL_STEREO */
-       1145, /* GL_RENDER_MODE */
+      1305, /* GL_STEREO */
+      1145, /* GL_RENDER_MODE */
        947, /* GL_PERSPECTIVE_CORRECTION_HINT */
        996, /* GL_POINT_SMOOTH_HINT */
        566, /* GL_LINE_SMOOTH_HINT */
-       1012, /* GL_POLYGON_SMOOTH_HINT */
+      1012, /* GL_POLYGON_SMOOTH_HINT */
        425, /* GL_FOG_HINT */
-       1461, /* GL_TEXTURE_GEN_S */
-       1462, /* GL_TEXTURE_GEN_T */
-       1460, /* GL_TEXTURE_GEN_R */
-       1459, /* GL_TEXTURE_GEN_Q */
+      1461, /* GL_TEXTURE_GEN_S */
+      1462, /* GL_TEXTURE_GEN_T */
+      1460, /* GL_TEXTURE_GEN_R */
+      1459, /* GL_TEXTURE_GEN_Q */
        960, /* GL_PIXEL_MAP_I_TO_I */
        966, /* GL_PIXEL_MAP_S_TO_S */
        962, /* GL_PIXEL_MAP_I_TO_R */
@@ -3469,12 +3469,12 @@ static const unsigned reduced_enums[1232] =
        953, /* GL_PIXEL_MAP_G_TO_G_SIZE */
        951, /* GL_PIXEL_MAP_B_TO_B_SIZE */
        949, /* GL_PIXEL_MAP_A_TO_A_SIZE */
-       1527, /* GL_UNPACK_SWAP_BYTES */
-       1522, /* GL_UNPACK_LSB_FIRST */
-       1523, /* GL_UNPACK_ROW_LENGTH */
-       1526, /* GL_UNPACK_SKIP_ROWS */
-       1525, /* GL_UNPACK_SKIP_PIXELS */
-       1520, /* GL_UNPACK_ALIGNMENT */
+      1527, /* GL_UNPACK_SWAP_BYTES */
+      1522, /* GL_UNPACK_LSB_FIRST */
+      1523, /* GL_UNPACK_ROW_LENGTH */
+      1526, /* GL_UNPACK_SKIP_ROWS */
+      1525, /* GL_UNPACK_SKIP_PIXELS */
+      1520, /* GL_UNPACK_ALIGNMENT */
        935, /* GL_PACK_SWAP_BYTES */
        930, /* GL_PACK_LSB_FIRST */
        931, /* GL_PACK_ROW_LENGTH */
@@ -3485,10 +3485,10 @@ static const unsigned reduced_enums[1232] =
        659, /* GL_MAP_STENCIL */
        509, /* GL_INDEX_SHIFT */
        508, /* GL_INDEX_OFFSET */
-       1134, /* GL_RED_SCALE */
-       1132, /* GL_RED_BIAS */
-       1610, /* GL_ZOOM_X */
-       1611, /* GL_ZOOM_Y */
+      1134, /* GL_RED_SCALE */
+      1132, /* GL_RED_BIAS */
+      1610, /* GL_ZOOM_X */
+      1611, /* GL_ZOOM_Y */
        471, /* GL_GREEN_SCALE */
        469, /* GL_GREEN_BIAS */
         86, /* GL_BLUE_SCALE */
@@ -3509,14 +3509,14 @@ static const unsigned reduced_enums[1232] =
        774, /* GL_MAX_TEXTURE_STACK_DEPTH */
        784, /* GL_MAX_VIEWPORT_DIMS */
        710, /* GL_MAX_CLIENT_ATTRIB_STACK_DEPTH */
-       1312, /* GL_SUBPIXEL_BITS */
+      1312, /* GL_SUBPIXEL_BITS */
        504, /* GL_INDEX_BITS */
-       1133, /* GL_RED_BITS */
+      1133, /* GL_RED_BITS */
        470, /* GL_GREEN_BITS */
         85, /* GL_BLUE_BITS */
         37, /* GL_ALPHA_BITS */
        287, /* GL_DEPTH_BITS */
-       1287, /* GL_STENCIL_BITS */
+      1287, /* GL_STENCIL_BITS */
         14, /* GL_ACCUM_RED_BITS */
         13, /* GL_ACCUM_GREEN_BITS */
         10, /* GL_ACCUM_BLUE_BITS */
@@ -3545,39 +3545,39 @@ static const unsigned reduced_enums[1232] =
        606, /* GL_MAP1_GRID_SEGMENTS */
        632, /* GL_MAP2_GRID_DOMAIN */
        633, /* GL_MAP2_GRID_SEGMENTS */
-       1389, /* GL_TEXTURE_1D */
-       1390, /* GL_TEXTURE_2D */
+      1389, /* GL_TEXTURE_1D */
+      1390, /* GL_TEXTURE_2D */
        392, /* GL_FEEDBACK_BUFFER_POINTER */
        393, /* GL_FEEDBACK_BUFFER_SIZE */
        394, /* GL_FEEDBACK_BUFFER_TYPE */
-       1223, /* GL_SELECTION_BUFFER_POINTER */
-       1224, /* GL_SELECTION_BUFFER_SIZE */
-       1498, /* GL_TEXTURE_WIDTH */
-       1466, /* GL_TEXTURE_HEIGHT */
-       1422, /* GL_TEXTURE_COMPONENTS */
-       1406, /* GL_TEXTURE_BORDER_COLOR */
-       1405, /* GL_TEXTURE_BORDER */
+      1223, /* GL_SELECTION_BUFFER_POINTER */
+      1224, /* GL_SELECTION_BUFFER_SIZE */
+      1498, /* GL_TEXTURE_WIDTH */
+      1466, /* GL_TEXTURE_HEIGHT */
+      1422, /* GL_TEXTURE_COMPONENTS */
+      1406, /* GL_TEXTURE_BORDER_COLOR */
+      1405, /* GL_TEXTURE_BORDER */
        316, /* GL_DONT_CARE */
        390, /* GL_FASTEST */
        858, /* GL_NICEST */
         43, /* GL_AMBIENT */
        313, /* GL_DIFFUSE */
-       1263, /* GL_SPECULAR */
-       1016, /* GL_POSITION */
-       1266, /* GL_SPOT_DIRECTION */
-       1267, /* GL_SPOT_EXPONENT */
-       1265, /* GL_SPOT_CUTOFF */
+      1263, /* GL_SPECULAR */
+      1016, /* GL_POSITION */
+      1266, /* GL_SPOT_DIRECTION */
+      1267, /* GL_SPOT_EXPONENT */
+      1265, /* GL_SPOT_CUTOFF */
        223, /* GL_CONSTANT_ATTENUATION */
        556, /* GL_LINEAR_ATTENUATION */
-       1111, /* GL_QUADRATIC_ATTENUATION */
+      1111, /* GL_QUADRATIC_ATTENUATION */
        198, /* GL_COMPILE */
        199, /* GL_COMPILE_AND_EXECUTE */
        101, /* GL_BYTE */
-       1528, /* GL_UNSIGNED_BYTE */
-       1234, /* GL_SHORT */
-       1537, /* GL_UNSIGNED_SHORT */
+      1528, /* GL_UNSIGNED_BYTE */
+      1234, /* GL_SHORT */
+      1537, /* GL_UNSIGNED_SHORT */
        511, /* GL_INT */
-       1531, /* GL_UNSIGNED_INT */
+      1531, /* GL_UNSIGNED_INT */
        397, /* GL_FLOAT */
          1, /* GL_2_BYTES */
          5, /* GL_3_BYTES */
@@ -3589,7 +3589,7 @@ static const unsigned reduced_enums[1232] =
        246, /* GL_COPY */
         46, /* GL_AND_INVERTED */
        860, /* GL_NOOP */
-       1606, /* GL_XOR */
+      1606, /* GL_XOR */
        922, /* GL_OR */
        861, /* GL_NOR */
        380, /* GL_EQUIV */
@@ -3598,58 +3598,58 @@ static const unsigned reduced_enums[1232] =
        247, /* GL_COPY_INVERTED */
        924, /* GL_OR_INVERTED */
        851, /* GL_NAND */
-       1228, /* GL_SET */
+      1228, /* GL_SET */
        377, /* GL_EMISSION */
-       1233, /* GL_SHININESS */
+      1233, /* GL_SHININESS */
         44, /* GL_AMBIENT_AND_DIFFUSE */
        155, /* GL_COLOR_INDEXES */
        801, /* GL_MODELVIEW */
-       1092, /* GL_PROJECTION */
-       1324, /* GL_TEXTURE */
+      1092, /* GL_PROJECTION */
+      1324, /* GL_TEXTURE */
        128, /* GL_COLOR */
        284, /* GL_DEPTH */
-       1285, /* GL_STENCIL */
+      1285, /* GL_STENCIL */
        154, /* GL_COLOR_INDEX */
-       1292, /* GL_STENCIL_INDEX */
+      1292, /* GL_STENCIL_INDEX */
        293, /* GL_DEPTH_COMPONENT */
-       1129, /* GL_RED */
+      1129, /* GL_RED */
        468, /* GL_GREEN */
         83, /* GL_BLUE */
         27, /* GL_ALPHA */
-       1153, /* GL_RGB */
-       1172, /* GL_RGBA */
+      1153, /* GL_RGB */
+      1172, /* GL_RGBA */
        582, /* GL_LUMINANCE */
        603, /* GL_LUMINANCE_ALPHA */
         68, /* GL_BITMAP */
        973, /* GL_POINT */
        554, /* GL_LINE */
        395, /* GL_FILL */
-       1138, /* GL_RENDER */
+      1138, /* GL_RENDER */
        391, /* GL_FEEDBACK */
-       1222, /* GL_SELECT */
+      1222, /* GL_SELECT */
        396, /* GL_FLAT */
-       1238, /* GL_SMOOTH */
+      1238, /* GL_SMOOTH */
        535, /* GL_KEEP */
-       1147, /* GL_REPLACE */
+      1147, /* GL_REPLACE */
        495, /* GL_INCR */
        281, /* GL_DECR */
-       1550, /* GL_VENDOR */
-       1144, /* GL_RENDERER */
-       1551, /* GL_VERSION */
+      1550, /* GL_VENDOR */
+      1144, /* GL_RENDERER */
+      1551, /* GL_VERSION */
        384, /* GL_EXTENSIONS */
-       1193, /* GL_S */
-       1315, /* GL_T */
-       1121, /* GL_R */
-       1110, /* GL_Q */
+      1193, /* GL_S */
+      1315, /* GL_T */
+      1121, /* GL_R */
+      1110, /* GL_Q */
        837, /* GL_MODULATE */
        280, /* GL_DECAL */
-       1456, /* GL_TEXTURE_ENV_MODE */
-       1455, /* GL_TEXTURE_ENV_COLOR */
-       1454, /* GL_TEXTURE_ENV */
+      1456, /* GL_TEXTURE_ENV_MODE */
+      1455, /* GL_TEXTURE_ENV_COLOR */
+      1454, /* GL_TEXTURE_ENV */
        385, /* GL_EYE_LINEAR */
        884, /* GL_OBJECT_LINEAR */
-       1264, /* GL_SPHERE_MAP */
-       1458, /* GL_TEXTURE_GEN_MODE */
+      1264, /* GL_SPHERE_MAP */
+      1458, /* GL_TEXTURE_GEN_MODE */
        886, /* GL_OBJECT_PLANE */
        386, /* GL_EYE_PLANE */
        852, /* GL_NEAREST */
@@ -3658,30 +3658,30 @@ static const unsigned reduced_enums[1232] =
        560, /* GL_LINEAR_MIPMAP_NEAREST */
        855, /* GL_NEAREST_MIPMAP_LINEAR */
        559, /* GL_LINEAR_MIPMAP_LINEAR */
-       1479, /* GL_TEXTURE_MAG_FILTER */
-       1487, /* GL_TEXTURE_MIN_FILTER */
-       1500, /* GL_TEXTURE_WRAP_S */
-       1501, /* GL_TEXTURE_WRAP_T */
+      1479, /* GL_TEXTURE_MAG_FILTER */
+      1487, /* GL_TEXTURE_MIN_FILTER */
+      1500, /* GL_TEXTURE_WRAP_S */
+      1501, /* GL_TEXTURE_WRAP_T */
        107, /* GL_CLAMP */
-       1146, /* GL_REPEAT */
-       1010, /* GL_POLYGON_OFFSET_UNITS */
-       1009, /* GL_POLYGON_OFFSET_POINT */
-       1008, /* GL_POLYGON_OFFSET_LINE */
-       1122, /* GL_R3_G3_B2 */
-       1548, /* GL_V2F */
-       1549, /* GL_V3F */
+      1146, /* GL_REPEAT */
+      1010, /* GL_POLYGON_OFFSET_UNITS */
+      1009, /* GL_POLYGON_OFFSET_POINT */
+      1008, /* GL_POLYGON_OFFSET_LINE */
+      1122, /* GL_R3_G3_B2 */
+      1548, /* GL_V2F */
+      1549, /* GL_V3F */
        104, /* GL_C4UB_V2F */
        105, /* GL_C4UB_V3F */
        102, /* GL_C3F_V3F */
        849, /* GL_N3F_V3F */
        103, /* GL_C4F_N3F_V3F */
-       1320, /* GL_T2F_V3F */
-       1322, /* GL_T4F_V4F */
-       1318, /* GL_T2F_C4UB_V3F */
-       1316, /* GL_T2F_C3F_V3F */
-       1319, /* GL_T2F_N3F_V3F */
-       1317, /* GL_T2F_C4F_N3F_V3F */
-       1321, /* GL_T4F_C4F_N3F_V4F */
+      1320, /* GL_T2F_V3F */
+      1322, /* GL_T4F_V4F */
+      1318, /* GL_T2F_C4UB_V3F */
+      1316, /* GL_T2F_C3F_V3F */
+      1319, /* GL_T2F_N3F_V3F */
+      1317, /* GL_T2F_C4F_N3F_V3F */
+      1321, /* GL_T4F_C4F_N3F_V4F */
        120, /* GL_CLIP_PLANE0 */
        121, /* GL_CLIP_PLANE1 */
        122, /* GL_CLIP_PLANE2 */
@@ -3710,26 +3710,26 @@ static const unsigned reduced_enums[1232] =
        458, /* GL_FUNC_REVERSE_SUBTRACT */
        228, /* GL_CONVOLUTION_1D */
        229, /* GL_CONVOLUTION_2D */
-       1225, /* GL_SEPARABLE_2D */
+      1225, /* GL_SEPARABLE_2D */
        232, /* GL_CONVOLUTION_BORDER_MODE */
        236, /* GL_CONVOLUTION_FILTER_SCALE */
        234, /* GL_CONVOLUTION_FILTER_BIAS */
-       1130, /* GL_REDUCE */
+      1130, /* GL_REDUCE */
        238, /* GL_CONVOLUTION_FORMAT */
        242, /* GL_CONVOLUTION_WIDTH */
        240, /* GL_CONVOLUTION_HEIGHT */
        720, /* GL_MAX_CONVOLUTION_WIDTH */
        718, /* GL_MAX_CONVOLUTION_HEIGHT */
-       1049, /* GL_POST_CONVOLUTION_RED_SCALE */
-       1045, /* GL_POST_CONVOLUTION_GREEN_SCALE */
-       1040, /* GL_POST_CONVOLUTION_BLUE_SCALE */
-       1036, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
-       1047, /* GL_POST_CONVOLUTION_RED_BIAS */
-       1043, /* GL_POST_CONVOLUTION_GREEN_BIAS */
-       1038, /* GL_POST_CONVOLUTION_BLUE_BIAS */
-       1034, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
+      1049, /* GL_POST_CONVOLUTION_RED_SCALE */
+      1045, /* GL_POST_CONVOLUTION_GREEN_SCALE */
+      1040, /* GL_POST_CONVOLUTION_BLUE_SCALE */
+      1036, /* GL_POST_CONVOLUTION_ALPHA_SCALE */
+      1047, /* GL_POST_CONVOLUTION_RED_BIAS */
+      1043, /* GL_POST_CONVOLUTION_GREEN_BIAS */
+      1038, /* GL_POST_CONVOLUTION_BLUE_BIAS */
+      1034, /* GL_POST_CONVOLUTION_ALPHA_BIAS */
        473, /* GL_HISTOGRAM */
-       1096, /* GL_PROXY_HISTOGRAM */
+      1096, /* GL_PROXY_HISTOGRAM */
        489, /* GL_HISTOGRAM_WIDTH */
        479, /* GL_HISTOGRAM_FORMAT */
        485, /* GL_HISTOGRAM_RED_SIZE */
@@ -3741,16 +3741,16 @@ static const unsigned reduced_enums[1232] =
        786, /* GL_MINMAX */
        788, /* GL_MINMAX_FORMAT */
        790, /* GL_MINMAX_SINK */
-       1323, /* GL_TABLE_TOO_LARGE_EXT */
-       1530, /* GL_UNSIGNED_BYTE_3_3_2 */
-       1539, /* GL_UNSIGNED_SHORT_4_4_4_4 */
-       1541, /* GL_UNSIGNED_SHORT_5_5_5_1 */
-       1535, /* GL_UNSIGNED_INT_8_8_8_8 */
-       1532, /* GL_UNSIGNED_INT_10_10_10_2 */
-       1007, /* GL_POLYGON_OFFSET_FILL */
-       1006, /* GL_POLYGON_OFFSET_FACTOR */
-       1005, /* GL_POLYGON_OFFSET_BIAS */
-       1150, /* GL_RESCALE_NORMAL */
+      1323, /* GL_TABLE_TOO_LARGE_EXT */
+      1530, /* GL_UNSIGNED_BYTE_3_3_2 */
+      1539, /* GL_UNSIGNED_SHORT_4_4_4_4 */
+      1541, /* GL_UNSIGNED_SHORT_5_5_5_1 */
+      1535, /* GL_UNSIGNED_INT_8_8_8_8 */
+      1532, /* GL_UNSIGNED_INT_10_10_10_2 */
+      1007, /* GL_POLYGON_OFFSET_FILL */
+      1006, /* GL_POLYGON_OFFSET_FACTOR */
+      1005, /* GL_POLYGON_OFFSET_BIAS */
+      1150, /* GL_RESCALE_NORMAL */
         32, /* GL_ALPHA4 */
         34, /* GL_ALPHA8 */
         28, /* GL_ALPHA12 */
@@ -3770,53 +3770,53 @@ static const unsigned reduced_enums[1232] =
        519, /* GL_INTENSITY8 */
        513, /* GL_INTENSITY12 */
        515, /* GL_INTENSITY16 */
-       1162, /* GL_RGB2_EXT */
-       1163, /* GL_RGB4 */
-       1166, /* GL_RGB5 */
-       1170, /* GL_RGB8 */
-       1154, /* GL_RGB10 */
-       1158, /* GL_RGB12 */
-       1160, /* GL_RGB16 */
-       1177, /* GL_RGBA2 */
-       1179, /* GL_RGBA4 */
-       1167, /* GL_RGB5_A1 */
-       1183, /* GL_RGBA8 */
-       1155, /* GL_RGB10_A2 */
-       1173, /* GL_RGBA12 */
-       1175, /* GL_RGBA16 */
-       1492, /* GL_TEXTURE_RED_SIZE */
-       1464, /* GL_TEXTURE_GREEN_SIZE */
-       1403, /* GL_TEXTURE_BLUE_SIZE */
-       1392, /* GL_TEXTURE_ALPHA_SIZE */
-       1477, /* GL_TEXTURE_LUMINANCE_SIZE */
-       1468, /* GL_TEXTURE_INTENSITY_SIZE */
-       1148, /* GL_REPLACE_EXT */
-       1100, /* GL_PROXY_TEXTURE_1D */
-       1102, /* GL_PROXY_TEXTURE_2D */
-       1496, /* GL_TEXTURE_TOO_LARGE_EXT */
-       1489, /* GL_TEXTURE_PRIORITY */
-       1494, /* GL_TEXTURE_RESIDENT */
-       1395, /* GL_TEXTURE_BINDING_1D */
-       1396, /* GL_TEXTURE_BINDING_2D */
-       1397, /* GL_TEXTURE_BINDING_3D */
+      1162, /* GL_RGB2_EXT */
+      1163, /* GL_RGB4 */
+      1166, /* GL_RGB5 */
+      1170, /* GL_RGB8 */
+      1154, /* GL_RGB10 */
+      1158, /* GL_RGB12 */
+      1160, /* GL_RGB16 */
+      1177, /* GL_RGBA2 */
+      1179, /* GL_RGBA4 */
+      1167, /* GL_RGB5_A1 */
+      1183, /* GL_RGBA8 */
+      1155, /* GL_RGB10_A2 */
+      1173, /* GL_RGBA12 */
+      1175, /* GL_RGBA16 */
+      1492, /* GL_TEXTURE_RED_SIZE */
+      1464, /* GL_TEXTURE_GREEN_SIZE */
+      1403, /* GL_TEXTURE_BLUE_SIZE */
+      1392, /* GL_TEXTURE_ALPHA_SIZE */
+      1477, /* GL_TEXTURE_LUMINANCE_SIZE */
+      1468, /* GL_TEXTURE_INTENSITY_SIZE */
+      1148, /* GL_REPLACE_EXT */
+      1100, /* GL_PROXY_TEXTURE_1D */
+      1102, /* GL_PROXY_TEXTURE_2D */
+      1496, /* GL_TEXTURE_TOO_LARGE_EXT */
+      1489, /* GL_TEXTURE_PRIORITY */
+      1494, /* GL_TEXTURE_RESIDENT */
+      1395, /* GL_TEXTURE_BINDING_1D */
+      1396, /* GL_TEXTURE_BINDING_2D */
+      1397, /* GL_TEXTURE_BINDING_3D */
        932, /* GL_PACK_SKIP_IMAGES */
        928, /* GL_PACK_IMAGE_HEIGHT */
-       1524, /* GL_UNPACK_SKIP_IMAGES */
-       1521, /* GL_UNPACK_IMAGE_HEIGHT */
-       1391, /* GL_TEXTURE_3D */
-       1104, /* GL_PROXY_TEXTURE_3D */
-       1451, /* GL_TEXTURE_DEPTH */
-       1499, /* GL_TEXTURE_WRAP_R */
+      1524, /* GL_UNPACK_SKIP_IMAGES */
+      1521, /* GL_UNPACK_IMAGE_HEIGHT */
+      1391, /* GL_TEXTURE_3D */
+      1104, /* GL_PROXY_TEXTURE_3D */
+      1451, /* GL_TEXTURE_DEPTH */
+      1499, /* GL_TEXTURE_WRAP_R */
        708, /* GL_MAX_3D_TEXTURE_SIZE */
-       1552, /* GL_VERTEX_ARRAY */
+      1552, /* GL_VERTEX_ARRAY */
        863, /* GL_NORMAL_ARRAY */
        129, /* GL_COLOR_ARRAY */
        498, /* GL_INDEX_ARRAY */
-       1430, /* GL_TEXTURE_COORD_ARRAY */
+      1430, /* GL_TEXTURE_COORD_ARRAY */
        368, /* GL_EDGE_FLAG_ARRAY */
-       1556, /* GL_VERTEX_ARRAY_SIZE */
-       1558, /* GL_VERTEX_ARRAY_TYPE */
-       1557, /* GL_VERTEX_ARRAY_STRIDE */
+      1556, /* GL_VERTEX_ARRAY_SIZE */
+      1558, /* GL_VERTEX_ARRAY_TYPE */
+      1557, /* GL_VERTEX_ARRAY_STRIDE */
        868, /* GL_NORMAL_ARRAY_TYPE */
        867, /* GL_NORMAL_ARRAY_STRIDE */
        133, /* GL_COLOR_ARRAY_SIZE */
@@ -3824,48 +3824,48 @@ static const unsigned reduced_enums[1232] =
        134, /* GL_COLOR_ARRAY_STRIDE */
        503, /* GL_INDEX_ARRAY_TYPE */
        502, /* GL_INDEX_ARRAY_STRIDE */
-       1434, /* GL_TEXTURE_COORD_ARRAY_SIZE */
-       1436, /* GL_TEXTURE_COORD_ARRAY_TYPE */
-       1435, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
+      1434, /* GL_TEXTURE_COORD_ARRAY_SIZE */
+      1436, /* GL_TEXTURE_COORD_ARRAY_TYPE */
+      1435, /* GL_TEXTURE_COORD_ARRAY_STRIDE */
        372, /* GL_EDGE_FLAG_ARRAY_STRIDE */
-       1555, /* GL_VERTEX_ARRAY_POINTER */
+      1555, /* GL_VERTEX_ARRAY_POINTER */
        866, /* GL_NORMAL_ARRAY_POINTER */
        132, /* GL_COLOR_ARRAY_POINTER */
        501, /* GL_INDEX_ARRAY_POINTER */
-       1433, /* GL_TEXTURE_COORD_ARRAY_POINTER */
+      1433, /* GL_TEXTURE_COORD_ARRAY_POINTER */
        371, /* GL_EDGE_FLAG_ARRAY_POINTER */
        842, /* GL_MULTISAMPLE */
-       1199, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
-       1201, /* GL_SAMPLE_ALPHA_TO_ONE */
-       1206, /* GL_SAMPLE_COVERAGE */
-       1203, /* GL_SAMPLE_BUFFERS */
-       1194, /* GL_SAMPLES */
-       1210, /* GL_SAMPLE_COVERAGE_VALUE */
-       1208, /* GL_SAMPLE_COVERAGE_INVERT */
+      1199, /* GL_SAMPLE_ALPHA_TO_COVERAGE */
+      1201, /* GL_SAMPLE_ALPHA_TO_ONE */
+      1206, /* GL_SAMPLE_COVERAGE */
+      1203, /* GL_SAMPLE_BUFFERS */
+      1194, /* GL_SAMPLES */
+      1210, /* GL_SAMPLE_COVERAGE_VALUE */
+      1208, /* GL_SAMPLE_COVERAGE_INVERT */
        160, /* GL_COLOR_MATRIX */
        162, /* GL_COLOR_MATRIX_STACK_DEPTH */
        715, /* GL_MAX_COLOR_MATRIX_STACK_DEPTH */
-       1032, /* GL_POST_COLOR_MATRIX_RED_SCALE */
-       1028, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
-       1023, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
-       1019, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
-       1030, /* GL_POST_COLOR_MATRIX_RED_BIAS */
-       1026, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
-       1021, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
-       1017, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
-       1413, /* GL_TEXTURE_COLOR_TABLE_SGI */
-       1105, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
-       1415, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
+      1032, /* GL_POST_COLOR_MATRIX_RED_SCALE */
+      1028, /* GL_POST_COLOR_MATRIX_GREEN_SCALE */
+      1023, /* GL_POST_COLOR_MATRIX_BLUE_SCALE */
+      1019, /* GL_POST_COLOR_MATRIX_ALPHA_SCALE */
+      1030, /* GL_POST_COLOR_MATRIX_RED_BIAS */
+      1026, /* GL_POST_COLOR_MATRIX_GREEN_BIAS */
+      1021, /* GL_POST_COLOR_MATRIX_BLUE_BIAS */
+      1017, /* GL_POST_COLOR_MATRIX_ALPHA_BIAS */
+      1413, /* GL_TEXTURE_COLOR_TABLE_SGI */
+      1105, /* GL_PROXY_TEXTURE_COLOR_TABLE_SGI */
+      1415, /* GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
         75, /* GL_BLEND_DST_RGB */
         82, /* GL_BLEND_SRC_RGB */
         74, /* GL_BLEND_DST_ALPHA */
         81, /* GL_BLEND_SRC_ALPHA */
        166, /* GL_COLOR_TABLE */
-       1042, /* GL_POST_CONVOLUTION_COLOR_TABLE */
-       1025, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
-       1095, /* GL_PROXY_COLOR_TABLE */
-       1099, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
-       1098, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
+      1042, /* GL_POST_CONVOLUTION_COLOR_TABLE */
+      1025, /* GL_POST_COLOR_MATRIX_COLOR_TABLE */
+      1095, /* GL_PROXY_COLOR_TABLE */
+      1099, /* GL_PROXY_POST_CONVOLUTION_COLOR_TABLE */
+      1098, /* GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE */
        182, /* GL_COLOR_TABLE_SCALE */
        169, /* GL_COLOR_TABLE_BIAS */
        172, /* GL_COLOR_TABLE_FORMAT */
@@ -3880,7 +3880,7 @@ static const unsigned reduced_enums[1232] =
         67, /* GL_BGRA */
        727, /* GL_MAX_ELEMENTS_VERTICES */
        726, /* GL_MAX_ELEMENTS_INDICES */
-       1467, /* GL_TEXTURE_INDEX_SIZE_EXT */
+      1467, /* GL_TEXTURE_INDEX_SIZE_EXT */
        126, /* GL_CLIP_VOLUME_CLIPPING_HINT_EXT */
        990, /* GL_POINT_SIZE_MIN */
        986, /* GL_POINT_SIZE_MAX */
@@ -3888,69 +3888,69 @@ static const unsigned reduced_enums[1232] =
        976, /* GL_POINT_DISTANCE_ATTENUATION */
        108, /* GL_CLAMP_TO_BORDER */
        111, /* GL_CLAMP_TO_EDGE */
-       1488, /* GL_TEXTURE_MIN_LOD */
-       1486, /* GL_TEXTURE_MAX_LOD */
-       1394, /* GL_TEXTURE_BASE_LEVEL */
-       1485, /* GL_TEXTURE_MAX_LEVEL */
+      1488, /* GL_TEXTURE_MIN_LOD */
+      1486, /* GL_TEXTURE_MAX_LOD */
+      1394, /* GL_TEXTURE_BASE_LEVEL */
+      1485, /* GL_TEXTURE_MAX_LEVEL */
        492, /* GL_IGNORE_BORDER_HP */
        224, /* GL_CONSTANT_BORDER_HP */
-       1149, /* GL_REPLICATE_BORDER_HP */
+      1149, /* GL_REPLICATE_BORDER_HP */
        230, /* GL_CONVOLUTION_BORDER_COLOR */
        891, /* GL_OCCLUSION_TEST_HP */
        892, /* GL_OCCLUSION_TEST_RESULT_HP */
        557, /* GL_LINEAR_CLIPMAP_LINEAR_SGIX */
-       1407, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
-       1409, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
-       1411, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
-       1412, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-       1410, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
-       1408, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
+      1407, /* GL_TEXTURE_CLIPMAP_CENTER_SGIX */
+      1409, /* GL_TEXTURE_CLIPMAP_FRAME_SGIX */
+      1411, /* GL_TEXTURE_CLIPMAP_OFFSET_SGIX */
+      1412, /* GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX */
+      1410, /* GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX */
+      1408, /* GL_TEXTURE_CLIPMAP_DEPTH_SGIX */
        711, /* GL_MAX_CLIPMAP_DEPTH_SGIX */
        712, /* GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX */
-       1052, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
-       1054, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
-       1051, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
-       1053, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
-       1475, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
-       1476, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
-       1474, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
+      1052, /* GL_POST_TEXTURE_FILTER_BIAS_SGIX */
+      1054, /* GL_POST_TEXTURE_FILTER_SCALE_SGIX */
+      1051, /* GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX */
+      1053, /* GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX */
+      1475, /* GL_TEXTURE_LOD_BIAS_S_SGIX */
+      1476, /* GL_TEXTURE_LOD_BIAS_T_SGIX */
+      1474, /* GL_TEXTURE_LOD_BIAS_R_SGIX */
        462, /* GL_GENERATE_MIPMAP */
        463, /* GL_GENERATE_MIPMAP_HINT */
        428, /* GL_FOG_OFFSET_SGIX */
        429, /* GL_FOG_OFFSET_VALUE_SGIX */
-       1421, /* GL_TEXTURE_COMPARE_SGIX */
-       1420, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
-       1471, /* GL_TEXTURE_LEQUAL_R_SGIX */
-       1463, /* GL_TEXTURE_GEQUAL_R_SGIX */
+      1421, /* GL_TEXTURE_COMPARE_SGIX */
+      1420, /* GL_TEXTURE_COMPARE_OPERATOR_SGIX */
+      1471, /* GL_TEXTURE_LEQUAL_R_SGIX */
+      1463, /* GL_TEXTURE_GEQUAL_R_SGIX */
        294, /* GL_DEPTH_COMPONENT16 */
        297, /* GL_DEPTH_COMPONENT24 */
        300, /* GL_DEPTH_COMPONENT32 */
        251, /* GL_CULL_VERTEX_EXT */
        253, /* GL_CULL_VERTEX_OBJECT_POSITION_EXT */
        252, /* GL_CULL_VERTEX_EYE_POSITION_EXT */
-       1603, /* GL_WRAP_BORDER_SUN */
-       1414, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
+      1603, /* GL_WRAP_BORDER_SUN */
+      1414, /* GL_TEXTURE_COLOR_WRITEMASK_SGIS */
        550, /* GL_LIGHT_MODEL_COLOR_CONTROL */
-       1235, /* GL_SINGLE_COLOR */
-       1226, /* GL_SEPARATE_SPECULAR_COLOR */
-       1232, /* GL_SHARED_TEXTURE_PALETTE_EXT */
-       1529, /* GL_UNSIGNED_BYTE_2_3_3_REV */
-       1542, /* GL_UNSIGNED_SHORT_5_6_5 */
-       1543, /* GL_UNSIGNED_SHORT_5_6_5_REV */
-       1540, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
-       1538, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
-       1536, /* GL_UNSIGNED_INT_8_8_8_8_REV */
-       1534, /* GL_UNSIGNED_INT_2_10_10_10_REV */
-       1483, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
-       1484, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
-       1482, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
+      1235, /* GL_SINGLE_COLOR */
+      1226, /* GL_SEPARATE_SPECULAR_COLOR */
+      1232, /* GL_SHARED_TEXTURE_PALETTE_EXT */
+      1529, /* GL_UNSIGNED_BYTE_2_3_3_REV */
+      1542, /* GL_UNSIGNED_SHORT_5_6_5 */
+      1543, /* GL_UNSIGNED_SHORT_5_6_5_REV */
+      1540, /* GL_UNSIGNED_SHORT_4_4_4_4_REV */
+      1538, /* GL_UNSIGNED_SHORT_1_5_5_5_REV */
+      1536, /* GL_UNSIGNED_INT_8_8_8_8_REV */
+      1534, /* GL_UNSIGNED_INT_2_10_10_10_REV */
+      1483, /* GL_TEXTURE_MAX_CLAMP_S_SGIX */
+      1484, /* GL_TEXTURE_MAX_CLAMP_T_SGIX */
+      1482, /* GL_TEXTURE_MAX_CLAMP_R_SGIX */
        793, /* GL_MIRRORED_REPEAT */
-       1188, /* GL_RGB_S3TC */
-       1165, /* GL_RGB4_S3TC */
-       1187, /* GL_RGBA_S3TC */
-       1182, /* GL_RGBA4_S3TC */
-       1185, /* GL_RGBA_DXT5_S3TC */
-       1180, /* GL_RGBA4_DXT5_S3TC */
+      1188, /* GL_RGB_S3TC */
+      1165, /* GL_RGB4_S3TC */
+      1187, /* GL_RGBA_S3TC */
+      1182, /* GL_RGBA4_S3TC */
+      1185, /* GL_RGBA_DXT5_S3TC */
+      1180, /* GL_RGBA4_DXT5_S3TC */
        217, /* GL_COMPRESSED_RGB_S3TC_DXT1_EXT */
        212, /* GL_COMPRESSED_RGBA_S3TC_DXT1_EXT */
        213, /* GL_COMPRESSED_RGBA_S3TC_DXT3_EXT */
@@ -3959,62 +3959,62 @@ static const unsigned reduced_enums[1232] =
        853, /* GL_NEAREST_CLIPMAP_LINEAR_SGIX */
        558, /* GL_LINEAR_CLIPMAP_NEAREST_SGIX */
        415, /* GL_FOG_COORDINATE_SOURCE */
-       408, /* GL_FOG_COORDINATE */
+       407, /* GL_FOG_COORD */
        431, /* GL_FRAGMENT_DEPTH */
-       258, /* GL_CURRENT_FOG_COORDINATE */
+       257, /* GL_CURRENT_FOG_COORD */
        414, /* GL_FOG_COORDINATE_ARRAY_TYPE */
        413, /* GL_FOG_COORDINATE_ARRAY_STRIDE */
        412, /* GL_FOG_COORDINATE_ARRAY_POINTER */
        409, /* GL_FOG_COORDINATE_ARRAY */
        164, /* GL_COLOR_SUM */
        275, /* GL_CURRENT_SECONDARY_COLOR */
-       1219, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
-       1221, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
-       1220, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
-       1218, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
-       1215, /* GL_SECONDARY_COLOR_ARRAY */
+      1219, /* GL_SECONDARY_COLOR_ARRAY_SIZE */
+      1221, /* GL_SECONDARY_COLOR_ARRAY_TYPE */
+      1220, /* GL_SECONDARY_COLOR_ARRAY_STRIDE */
+      1218, /* GL_SECONDARY_COLOR_ARRAY_POINTER */
+      1215, /* GL_SECONDARY_COLOR_ARRAY */
         24, /* GL_ALIASED_POINT_SIZE_RANGE */
         23, /* GL_ALIASED_LINE_WIDTH_RANGE */
-       1325, /* GL_TEXTURE0 */
-       1327, /* GL_TEXTURE1 */
-       1349, /* GL_TEXTURE2 */
-       1371, /* GL_TEXTURE3 */
-       1377, /* GL_TEXTURE4 */
-       1379, /* GL_TEXTURE5 */
-       1381, /* GL_TEXTURE6 */
-       1383, /* GL_TEXTURE7 */
-       1385, /* GL_TEXTURE8 */
-       1387, /* GL_TEXTURE9 */
-       1328, /* GL_TEXTURE10 */
-       1330, /* GL_TEXTURE11 */
-       1332, /* GL_TEXTURE12 */
-       1334, /* GL_TEXTURE13 */
-       1336, /* GL_TEXTURE14 */
-       1338, /* GL_TEXTURE15 */
-       1340, /* GL_TEXTURE16 */
-       1342, /* GL_TEXTURE17 */
-       1344, /* GL_TEXTURE18 */
-       1346, /* GL_TEXTURE19 */
-       1350, /* GL_TEXTURE20 */
-       1352, /* GL_TEXTURE21 */
-       1354, /* GL_TEXTURE22 */
-       1356, /* GL_TEXTURE23 */
-       1358, /* GL_TEXTURE24 */
-       1360, /* GL_TEXTURE25 */
-       1362, /* GL_TEXTURE26 */
-       1364, /* GL_TEXTURE27 */
-       1366, /* GL_TEXTURE28 */
-       1368, /* GL_TEXTURE29 */
-       1372, /* GL_TEXTURE30 */
-       1374, /* GL_TEXTURE31 */
+      1325, /* GL_TEXTURE0 */
+      1327, /* GL_TEXTURE1 */
+      1349, /* GL_TEXTURE2 */
+      1371, /* GL_TEXTURE3 */
+      1377, /* GL_TEXTURE4 */
+      1379, /* GL_TEXTURE5 */
+      1381, /* GL_TEXTURE6 */
+      1383, /* GL_TEXTURE7 */
+      1385, /* GL_TEXTURE8 */
+      1387, /* GL_TEXTURE9 */
+      1328, /* GL_TEXTURE10 */
+      1330, /* GL_TEXTURE11 */
+      1332, /* GL_TEXTURE12 */
+      1334, /* GL_TEXTURE13 */
+      1336, /* GL_TEXTURE14 */
+      1338, /* GL_TEXTURE15 */
+      1340, /* GL_TEXTURE16 */
+      1342, /* GL_TEXTURE17 */
+      1344, /* GL_TEXTURE18 */
+      1346, /* GL_TEXTURE19 */
+      1350, /* GL_TEXTURE20 */
+      1352, /* GL_TEXTURE21 */
+      1354, /* GL_TEXTURE22 */
+      1356, /* GL_TEXTURE23 */
+      1358, /* GL_TEXTURE24 */
+      1360, /* GL_TEXTURE25 */
+      1362, /* GL_TEXTURE26 */
+      1364, /* GL_TEXTURE27 */
+      1366, /* GL_TEXTURE28 */
+      1368, /* GL_TEXTURE29 */
+      1372, /* GL_TEXTURE30 */
+      1374, /* GL_TEXTURE31 */
         16, /* GL_ACTIVE_TEXTURE */
        114, /* GL_CLIENT_ACTIVE_TEXTURE */
        775, /* GL_MAX_TEXTURE_UNITS */
-       1508, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
-       1511, /* GL_TRANSPOSE_PROJECTION_MATRIX */
-       1513, /* GL_TRANSPOSE_TEXTURE_MATRIX */
-       1505, /* GL_TRANSPOSE_COLOR_MATRIX */
-       1313, /* GL_SUBTRACT */
+      1508, /* GL_TRANSPOSE_MODELVIEW_MATRIX */
+      1511, /* GL_TRANSPOSE_PROJECTION_MATRIX */
+      1513, /* GL_TRANSPOSE_TEXTURE_MATRIX */
+      1505, /* GL_TRANSPOSE_COLOR_MATRIX */
+      1313, /* GL_SUBTRACT */
        766, /* GL_MAX_RENDERBUFFER_SIZE_EXT */
        200, /* GL_COMPRESSED_ALPHA */
        204, /* GL_COMPRESSED_LUMINANCE */
@@ -4022,18 +4022,18 @@ static const unsigned reduced_enums[1232] =
        202, /* GL_COMPRESSED_INTENSITY */
        208, /* GL_COMPRESSED_RGB */
        209, /* GL_COMPRESSED_RGBA */
-       1428, /* GL_TEXTURE_COMPRESSION_HINT */
-       1490, /* GL_TEXTURE_RECTANGLE_ARB */
-       1400, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
-       1108, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
+      1428, /* GL_TEXTURE_COMPRESSION_HINT */
+      1490, /* GL_TEXTURE_RECTANGLE_ARB */
+      1400, /* GL_TEXTURE_BINDING_RECTANGLE_ARB */
+      1108, /* GL_PROXY_TEXTURE_RECTANGLE_ARB */
        764, /* GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB */
        306, /* GL_DEPTH_STENCIL_NV */
-       1533, /* GL_UNSIGNED_INT_24_8_NV */
+      1533, /* GL_UNSIGNED_INT_24_8_NV */
        771, /* GL_MAX_TEXTURE_LOD_BIAS */
-       1481, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
+      1481, /* GL_TEXTURE_MAX_ANISOTROPY_EXT */
        772, /* GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT */
-       1457, /* GL_TEXTURE_FILTER_CONTROL */
-       1472, /* GL_TEXTURE_LOD_BIAS */
+      1457, /* GL_TEXTURE_FILTER_CONTROL */
+      1472, /* GL_TEXTURE_LOD_BIAS */
        187, /* GL_COMBINE4 */
        767, /* GL_MAX_SHININESS_NV */
        768, /* GL_MAX_SPOT_EXPONENT_NV */
@@ -4041,16 +4041,16 @@ static const unsigned reduced_enums[1232] =
        282, /* GL_DECR_WRAP */
        813, /* GL_MODELVIEW1_ARB */
        869, /* GL_NORMAL_MAP */
-       1135, /* GL_REFLECTION_MAP */
-       1437, /* GL_TEXTURE_CUBE_MAP */
-       1398, /* GL_TEXTURE_BINDING_CUBE_MAP */
-       1445, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
-       1439, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
-       1447, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
-       1441, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
-       1449, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
-       1443, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
-       1106, /* GL_PROXY_TEXTURE_CUBE_MAP */
+      1135, /* GL_REFLECTION_MAP */
+      1437, /* GL_TEXTURE_CUBE_MAP */
+      1398, /* GL_TEXTURE_BINDING_CUBE_MAP */
+      1445, /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
+      1439, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
+      1447, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
+      1441, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
+      1449, /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
+      1443, /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
+      1106, /* GL_PROXY_TEXTURE_CUBE_MAP */
        722, /* GL_MAX_CUBE_MAP_TEXTURE_SIZE */
        848, /* GL_MULTISAMPLE_FILTER_HINT_NV */
        423, /* GL_FOG_DISTANCE_MODE_NV */
@@ -4059,20 +4059,20 @@ static const unsigned reduced_enums[1232] =
        186, /* GL_COMBINE */
        193, /* GL_COMBINE_RGB */
        188, /* GL_COMBINE_ALPHA */
-       1189, /* GL_RGB_SCALE */
+      1189, /* GL_RGB_SCALE */
         20, /* GL_ADD_SIGNED */
        522, /* GL_INTERPOLATE */
        219, /* GL_CONSTANT */
-       1058, /* GL_PRIMARY_COLOR */
-       1055, /* GL_PREVIOUS */
-       1246, /* GL_SOURCE0_RGB */
-       1252, /* GL_SOURCE1_RGB */
-       1258, /* GL_SOURCE2_RGB */
-       1262, /* GL_SOURCE3_RGB_NV */
-       1243, /* GL_SOURCE0_ALPHA */
-       1249, /* GL_SOURCE1_ALPHA */
-       1255, /* GL_SOURCE2_ALPHA */
-       1261, /* GL_SOURCE3_ALPHA_NV */
+      1058, /* GL_PRIMARY_COLOR */
+      1055, /* GL_PREVIOUS */
+      1246, /* GL_SOURCE0_RGB */
+      1252, /* GL_SOURCE1_RGB */
+      1258, /* GL_SOURCE2_RGB */
+      1262, /* GL_SOURCE3_RGB_NV */
+      1243, /* GL_SOURCE0_ALPHA */
+      1249, /* GL_SOURCE1_ALPHA */
+      1255, /* GL_SOURCE2_ALPHA */
+      1261, /* GL_SOURCE3_ALPHA_NV */
        905, /* GL_OPERAND0_RGB */
        911, /* GL_OPERAND1_RGB */
        917, /* GL_OPERAND2_RGB */
@@ -4081,25 +4081,25 @@ static const unsigned reduced_enums[1232] =
        908, /* GL_OPERAND1_ALPHA */
        914, /* GL_OPERAND2_ALPHA */
        920, /* GL_OPERAND3_ALPHA_NV */
-       1607, /* GL_YCBCR_422_APPLE */
-       1544, /* GL_UNSIGNED_SHORT_8_8_APPLE */
-       1546, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
-       1237, /* GL_SLICE_ACCUM_SUN */
-       1113, /* GL_QUAD_MESH_SUN */
-       1517, /* GL_TRIANGLE_MESH_SUN */
-       1584, /* GL_VERTEX_PROGRAM_ARB */
-       1592, /* GL_VERTEX_STATE_PROGRAM_NV */
-       1577, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */
-       1580, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */
-       1581, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */
-       1582, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */
+      1607, /* GL_YCBCR_422_APPLE */
+      1544, /* GL_UNSIGNED_SHORT_8_8_APPLE */
+      1546, /* GL_UNSIGNED_SHORT_8_8_REV_APPLE */
+      1237, /* GL_SLICE_ACCUM_SUN */
+      1113, /* GL_QUAD_MESH_SUN */
+      1517, /* GL_TRIANGLE_MESH_SUN */
+      1584, /* GL_VERTEX_PROGRAM_ARB */
+      1592, /* GL_VERTEX_STATE_PROGRAM_NV */
+      1577, /* GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB */
+      1580, /* GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB */
+      1581, /* GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB */
+      1582, /* GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB */
        277, /* GL_CURRENT_VERTEX_ATTRIB_ARB */
-       1071, /* GL_PROGRAM_LENGTH_ARB */
-       1085, /* GL_PROGRAM_STRING_ARB */
+      1071, /* GL_PROGRAM_LENGTH_ARB */
+      1085, /* GL_PROGRAM_STRING_ARB */
        835, /* GL_MODELVIEW_PROJECTION_NV */
        491, /* GL_IDENTITY_NV */
        532, /* GL_INVERSE_NV */
-       1510, /* GL_TRANSPOSE_NV */
+      1510, /* GL_TRANSPOSE_NV */
        533, /* GL_INVERSE_TRANSPOSE_NV */
        750, /* GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB */
        749, /* GL_MAX_PROGRAM_MATRICES_ARB */
@@ -4113,33 +4113,33 @@ static const unsigned reduced_enums[1232] =
        697, /* GL_MATRIX7_NV */
        263, /* GL_CURRENT_MATRIX_STACK_DEPTH_ARB */
        260, /* GL_CURRENT_MATRIX_ARB */
-       1587, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */
-       1589, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */
-       1083, /* GL_PROGRAM_PARAMETER_NV */
-       1579, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */
-       1087, /* GL_PROGRAM_TARGET_NV */
-       1084, /* GL_PROGRAM_RESIDENT_NV */
-       1502, /* GL_TRACK_MATRIX_NV */
-       1503, /* GL_TRACK_MATRIX_TRANSFORM_NV */
-       1585, /* GL_VERTEX_PROGRAM_BINDING_NV */
-       1065, /* GL_PROGRAM_ERROR_POSITION_ARB */
+      1587, /* GL_VERTEX_PROGRAM_POINT_SIZE_ARB */
+      1589, /* GL_VERTEX_PROGRAM_TWO_SIDE_ARB */
+      1083, /* GL_PROGRAM_PARAMETER_NV */
+      1579, /* GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB */
+      1087, /* GL_PROGRAM_TARGET_NV */
+      1084, /* GL_PROGRAM_RESIDENT_NV */
+      1502, /* GL_TRACK_MATRIX_NV */
+      1503, /* GL_TRACK_MATRIX_TRANSFORM_NV */
+      1585, /* GL_VERTEX_PROGRAM_BINDING_NV */
+      1065, /* GL_PROGRAM_ERROR_POSITION_ARB */
        291, /* GL_DEPTH_CLAMP_NV */
-       1559, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
-       1566, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
-       1567, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
-       1568, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
-       1569, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
-       1570, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
-       1571, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
-       1572, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
-       1573, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
-       1574, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
-       1560, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
-       1561, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
-       1562, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
-       1563, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
-       1564, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
-       1565, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
+      1559, /* GL_VERTEX_ATTRIB_ARRAY0_NV */
+      1566, /* GL_VERTEX_ATTRIB_ARRAY1_NV */
+      1567, /* GL_VERTEX_ATTRIB_ARRAY2_NV */
+      1568, /* GL_VERTEX_ATTRIB_ARRAY3_NV */
+      1569, /* GL_VERTEX_ATTRIB_ARRAY4_NV */
+      1570, /* GL_VERTEX_ATTRIB_ARRAY5_NV */
+      1571, /* GL_VERTEX_ATTRIB_ARRAY6_NV */
+      1572, /* GL_VERTEX_ATTRIB_ARRAY7_NV */
+      1573, /* GL_VERTEX_ATTRIB_ARRAY8_NV */
+      1574, /* GL_VERTEX_ATTRIB_ARRAY9_NV */
+      1560, /* GL_VERTEX_ATTRIB_ARRAY10_NV */
+      1561, /* GL_VERTEX_ATTRIB_ARRAY11_NV */
+      1562, /* GL_VERTEX_ATTRIB_ARRAY12_NV */
+      1563, /* GL_VERTEX_ATTRIB_ARRAY13_NV */
+      1564, /* GL_VERTEX_ATTRIB_ARRAY14_NV */
+      1565, /* GL_VERTEX_ATTRIB_ARRAY15_NV */
        615, /* GL_MAP1_VERTEX_ATTRIB0_4_NV */
        622, /* GL_MAP1_VERTEX_ATTRIB1_4_NV */
        623, /* GL_MAP1_VERTEX_ATTRIB2_4_NV */
@@ -4163,7 +4163,7 @@ static const unsigned reduced_enums[1232] =
        652, /* GL_MAP2_VERTEX_ATTRIB4_4_NV */
        653, /* GL_MAP2_VERTEX_ATTRIB5_4_NV */
        654, /* GL_MAP2_VERTEX_ATTRIB6_4_NV */
-       1064, /* GL_PROGRAM_BINDING_ARB */
+      1064, /* GL_PROGRAM_BINDING_ARB */
        656, /* GL_MAP2_VERTEX_ATTRIB8_4_NV */
        657, /* GL_MAP2_VERTEX_ATTRIB9_4_NV */
        643, /* GL_MAP2_VERTEX_ATTRIB10_4_NV */
@@ -4172,27 +4172,27 @@ static const unsigned reduced_enums[1232] =
        646, /* GL_MAP2_VERTEX_ATTRIB13_4_NV */
        647, /* GL_MAP2_VERTEX_ATTRIB14_4_NV */
        648, /* GL_MAP2_VERTEX_ATTRIB15_4_NV */
-       1426, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
-       1423, /* GL_TEXTURE_COMPRESSED */
+      1426, /* GL_TEXTURE_COMPRESSED_IMAGE_SIZE */
+      1423, /* GL_TEXTURE_COMPRESSED */
        874, /* GL_NUM_COMPRESSED_TEXTURE_FORMATS */
        218, /* GL_COMPRESSED_TEXTURE_FORMATS */
        783, /* GL_MAX_VERTEX_UNITS_ARB */
         18, /* GL_ACTIVE_VERTEX_UNITS_ARB */
-       1602, /* GL_WEIGHT_SUM_UNITY_ARB */
-       1583, /* GL_VERTEX_BLEND_ARB */
+      1602, /* GL_WEIGHT_SUM_UNITY_ARB */
+      1583, /* GL_VERTEX_BLEND_ARB */
        278, /* GL_CURRENT_WEIGHT_ARB */
-       1601, /* GL_WEIGHT_ARRAY_TYPE_ARB */
-       1600, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
-       1599, /* GL_WEIGHT_ARRAY_SIZE_ARB */
-       1598, /* GL_WEIGHT_ARRAY_POINTER_ARB */
-       1595, /* GL_WEIGHT_ARRAY_ARB */
+      1601, /* GL_WEIGHT_ARRAY_TYPE_ARB */
+      1600, /* GL_WEIGHT_ARRAY_STRIDE_ARB */
+      1599, /* GL_WEIGHT_ARRAY_SIZE_ARB */
+      1598, /* GL_WEIGHT_ARRAY_POINTER_ARB */
+      1595, /* GL_WEIGHT_ARRAY_ARB */
        317, /* GL_DOT3_RGB */
        318, /* GL_DOT3_RGBA */
        216, /* GL_COMPRESSED_RGB_FXT1_3DFX */
        211, /* GL_COMPRESSED_RGBA_FXT1_3DFX */
        843, /* GL_MULTISAMPLE_3DFX */
-       1204, /* GL_SAMPLE_BUFFERS_3DFX */
-       1195, /* GL_SAMPLES_3DFX */
+      1204, /* GL_SAMPLE_BUFFERS_3DFX */
+      1195, /* GL_SAMPLES_3DFX */
        824, /* GL_MODELVIEW2_ARB */
        827, /* GL_MODELVIEW3_ARB */
        828, /* GL_MODELVIEW4_ARB */
@@ -4230,17 +4230,17 @@ static const unsigned reduced_enums[1232] =
        838, /* GL_MODULATE_ADD_ATI */
        839, /* GL_MODULATE_SIGNED_ADD_ATI */
        840, /* GL_MODULATE_SUBTRACT_ATI */
-       1608, /* GL_YCBCR_MESA */
+      1608, /* GL_YCBCR_MESA */
        929, /* GL_PACK_INVERT_MESA */
         97, /* GL_BUFFER_SIZE */
         99, /* GL_BUFFER_USAGE */
        432, /* GL_FRAGMENT_PROGRAM_ARB */
-       1062, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
-       1090, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
-       1089, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
-       1074, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
-       1080, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
-       1079, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
+      1062, /* GL_PROGRAM_ALU_INSTRUCTIONS_ARB */
+      1090, /* GL_PROGRAM_TEX_INSTRUCTIONS_ARB */
+      1089, /* GL_PROGRAM_TEX_INDIRECTIONS_ARB */
+      1074, /* GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB */
+      1080, /* GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB */
+      1079, /* GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB */
        739, /* GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB */
        762, /* GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB */
        761, /* GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB */
@@ -4275,71 +4275,71 @@ static const unsigned reduced_enums[1232] =
        704, /* GL_MATRIX_INDEX_ARRAY_TYPE_ARB */
        703, /* GL_MATRIX_INDEX_ARRAY_STRIDE_ARB */
        701, /* GL_MATRIX_INDEX_ARRAY_POINTER_ARB */
-       1452, /* GL_TEXTURE_DEPTH_SIZE */
+      1452, /* GL_TEXTURE_DEPTH_SIZE */
        310, /* GL_DEPTH_TEXTURE_MODE */
-       1418, /* GL_TEXTURE_COMPARE_MODE */
-       1416, /* GL_TEXTURE_COMPARE_FUNC */
+      1418, /* GL_TEXTURE_COMPARE_MODE */
+      1416, /* GL_TEXTURE_COMPARE_FUNC */
        196, /* GL_COMPARE_R_TO_TEXTURE */
        997, /* GL_POINT_SPRITE_ARB */
        244, /* GL_COORD_REPLACE_ARB */
-       1000, /* GL_POINT_SPRITE_R_MODE_NV */
-       1115, /* GL_QUERY_COUNTER_BITS */
+      1000, /* GL_POINT_SPRITE_R_MODE_NV */
+      1115, /* GL_QUERY_COUNTER_BITS */
        267, /* GL_CURRENT_QUERY */
-       1117, /* GL_QUERY_RESULT */
-       1119, /* GL_QUERY_RESULT_AVAILABLE */
+      1117, /* GL_QUERY_RESULT */
+      1119, /* GL_QUERY_RESULT_AVAILABLE */
        780, /* GL_MAX_VERTEX_ATTRIBS_ARB */
-       1578, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */
+      1578, /* GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB */
        308, /* GL_DEPTH_STENCIL_TO_RGBA_NV */
        307, /* GL_DEPTH_STENCIL_TO_BGRA_NV */
        769, /* GL_MAX_TEXTURE_COORDS_ARB */
        770, /* GL_MAX_TEXTURE_IMAGE_UNITS_ARB */
-       1067, /* GL_PROGRAM_ERROR_STRING_ARB */
-       1069, /* GL_PROGRAM_FORMAT_ASCII_ARB */
-       1068, /* GL_PROGRAM_FORMAT_ARB */
-       1497, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
+      1067, /* GL_PROGRAM_ERROR_STRING_ARB */
+      1069, /* GL_PROGRAM_FORMAT_ASCII_ARB */
+      1068, /* GL_PROGRAM_FORMAT_ARB */
+      1497, /* GL_TEXTURE_UNSIGNED_REMAP_MODE_NV */
        289, /* GL_DEPTH_BOUNDS_TEST_EXT */
        288, /* GL_DEPTH_BOUNDS_EXT */
         48, /* GL_ARRAY_BUFFER */
        373, /* GL_ELEMENT_ARRAY_BUFFER */
         50, /* GL_ARRAY_BUFFER_BINDING */
        375, /* GL_ELEMENT_ARRAY_BUFFER_BINDING */
-       1553, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
+      1553, /* GL_VERTEX_ARRAY_BUFFER_BINDING */
        864, /* GL_NORMAL_ARRAY_BUFFER_BINDING */
        130, /* GL_COLOR_ARRAY_BUFFER_BINDING */
        499, /* GL_INDEX_ARRAY_BUFFER_BINDING */
-       1431, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
+      1431, /* GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING */
        369, /* GL_EDGE_FLAG_ARRAY_BUFFER_BINDING */
-       1216, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
+      1216, /* GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING */
        410, /* GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING */
-       1596, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
-       1575, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
-       1070, /* GL_PROGRAM_INSTRUCTIONS_ARB */
+      1596, /* GL_WEIGHT_ARRAY_BUFFER_BINDING */
+      1575, /* GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING */
+      1070, /* GL_PROGRAM_INSTRUCTIONS_ARB */
        745, /* GL_MAX_PROGRAM_INSTRUCTIONS_ARB */
-       1076, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
+      1076, /* GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
        754, /* GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB */
-       1088, /* GL_PROGRAM_TEMPORARIES_ARB */
+      1088, /* GL_PROGRAM_TEMPORARIES_ARB */
        760, /* GL_MAX_PROGRAM_TEMPORARIES_ARB */
-       1078, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
+      1078, /* GL_PROGRAM_NATIVE_TEMPORARIES_ARB */
        756, /* GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB */
-       1082, /* GL_PROGRAM_PARAMETERS_ARB */
+      1082, /* GL_PROGRAM_PARAMETERS_ARB */
        759, /* GL_MAX_PROGRAM_PARAMETERS_ARB */
-       1077, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
+      1077, /* GL_PROGRAM_NATIVE_PARAMETERS_ARB */
        755, /* GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB */
-       1063, /* GL_PROGRAM_ATTRIBS_ARB */
+      1063, /* GL_PROGRAM_ATTRIBS_ARB */
        740, /* GL_MAX_PROGRAM_ATTRIBS_ARB */
-       1075, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
+      1075, /* GL_PROGRAM_NATIVE_ATTRIBS_ARB */
        753, /* GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB */
-       1061, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
+      1061, /* GL_PROGRAM_ADDRESS_REGISTERS_ARB */
        738, /* GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB */
-       1073, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
+      1073, /* GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
        751, /* GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB */
        746, /* GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB */
        742, /* GL_MAX_PROGRAM_ENV_PARAMETERS_ARB */
-       1091, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
-       1507, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
-       1125, /* GL_READ_ONLY */
-       1604, /* GL_WRITE_ONLY */
-       1127, /* GL_READ_WRITE */
+      1091, /* GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB */
+      1507, /* GL_TRANSPOSE_CURRENT_MATRIX_ARB */
+      1125, /* GL_READ_ONLY */
+      1604, /* GL_WRITE_ONLY */
+      1127, /* GL_READ_WRITE */
         91, /* GL_BUFFER_ACCESS */
         93, /* GL_BUFFER_MAPPED */
         95, /* GL_BUFFER_MAP_POINTER */
@@ -4375,12 +4375,12 @@ static const unsigned reduced_enums[1232] =
        683, /* GL_MATRIX29_ARB */
        686, /* GL_MATRIX30_ARB */
        687, /* GL_MATRIX31_ARB */
-       1308, /* GL_STREAM_DRAW */
-       1310, /* GL_STREAM_READ */
-       1306, /* GL_STREAM_COPY */
-       1281, /* GL_STATIC_DRAW */
-       1283, /* GL_STATIC_READ */
-       1279, /* GL_STATIC_COPY */
+      1308, /* GL_STREAM_DRAW */
+      1310, /* GL_STREAM_READ */
+      1306, /* GL_STREAM_COPY */
+      1281, /* GL_STATIC_DRAW */
+      1283, /* GL_STATIC_READ */
+      1279, /* GL_STATIC_COPY */
        363, /* GL_DYNAMIC_DRAW */
        365, /* GL_DYNAMIC_READ */
        361, /* GL_DYNAMIC_COPY */
@@ -4393,14 +4393,14 @@ static const unsigned reduced_enums[1232] =
        744, /* GL_MAX_PROGRAM_IF_DEPTH_NV */
        748, /* GL_MAX_PROGRAM_LOOP_DEPTH_NV */
        747, /* GL_MAX_PROGRAM_LOOP_COUNT_NV */
-       1302, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
+      1302, /* GL_STENCIL_TEST_TWO_SIDE_EXT */
         15, /* GL_ACTIVE_STENCIL_FACE_EXT */
        798, /* GL_MIRROR_CLAMP_TO_BORDER_EXT */
-       1197, /* GL_SAMPLES_PASSED */
+      1197, /* GL_SAMPLES_PASSED */
        433, /* GL_FRAGMENT_SHADER_ARB */
-       1591, /* GL_VERTEX_SHADER_ARB */
-       1081, /* GL_PROGRAM_OBJECT_ARB */
-       1229, /* GL_SHADER_OBJECT_ARB */
+      1591, /* GL_VERTEX_SHADER_ARB */
+      1081, /* GL_PROGRAM_OBJECT_ARB */
+      1229, /* GL_SHADER_OBJECT_ARB */
        730, /* GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB */
        782, /* GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB */
        779, /* GL_MAX_VARYING_FLOATS_ARB */
@@ -4446,7 +4446,7 @@ static const unsigned reduced_enums[1232] =
        493, /* GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES */
        998, /* GL_POINT_SPRITE_COORD_ORIGIN */
        439, /* GL_FRAMEBUFFER_BINDING_EXT */
-       1139, /* GL_RENDERBUFFER_BINDING_EXT */
+      1139, /* GL_RENDERBUFFER_BINDING_EXT */
        435, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT */
        434, /* GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT */
        438, /* GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT */
@@ -4480,22 +4480,22 @@ static const unsigned reduced_enums[1232] =
        141, /* GL_COLOR_ATTACHMENT14_EXT */
        142, /* GL_COLOR_ATTACHMENT15_EXT */
        285, /* GL_DEPTH_ATTACHMENT_EXT */
-       1286, /* GL_STENCIL_ATTACHMENT_EXT */
+      1286, /* GL_STENCIL_ATTACHMENT_EXT */
        441, /* GL_FRAMEBUFFER_EXT */
-       1140, /* GL_RENDERBUFFER_EXT */
-       1143, /* GL_RENDERBUFFER_WIDTH_EXT */
-       1141, /* GL_RENDERBUFFER_HEIGHT_EXT */
-       1142, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
-       1297, /* GL_STENCIL_INDEX_EXT */
-       1294, /* GL_STENCIL_INDEX1_EXT */
-       1295, /* GL_STENCIL_INDEX4_EXT */
-       1296, /* GL_STENCIL_INDEX8_EXT */
-       1293, /* GL_STENCIL_INDEX16_EXT */
+      1140, /* GL_RENDERBUFFER_EXT */
+      1143, /* GL_RENDERBUFFER_WIDTH_EXT */
+      1141, /* GL_RENDERBUFFER_HEIGHT_EXT */
+      1142, /* GL_RENDERBUFFER_INTERNAL_FORMAT_EXT */
+      1297, /* GL_STENCIL_INDEX_EXT */
+      1294, /* GL_STENCIL_INDEX1_EXT */
+      1295, /* GL_STENCIL_INDEX4_EXT */
+      1296, /* GL_STENCIL_INDEX8_EXT */
+      1293, /* GL_STENCIL_INDEX16_EXT */
        381, /* GL_EVAL_BIT */
-       1123, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
+      1123, /* GL_RASTER_POSITION_UNCLIPPED_IBM */
        576, /* GL_LIST_BIT */
-       1402, /* GL_TEXTURE_BIT */
-       1212, /* GL_SCISSOR_BIT */
+      1402, /* GL_TEXTURE_BIT */
+      1212, /* GL_SCISSOR_BIT */
         25, /* GL_ALL_ATTRIB_BITS */
        845, /* GL_MULTISAMPLE_BIT */
         26, /* GL_ALL_CLIENT_ATTRIB_BITS */
diff --git a/src/mesa/x86/glapi_x86.S b/src/mesa/x86/glapi_x86.S
index c0a971bd53b..42e61e261e9 100644
--- a/src/mesa/x86/glapi_x86.S
+++ b/src/mesa/x86/glapi_x86.S
@@ -969,6 +969,44 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB(StencilFuncSeparate, _gloffset_StencilFuncSeparate, StencilFuncSeparate@16)
 	GL_STUB(StencilOpSeparate, _gloffset_StencilOpSeparate, StencilOpSeparate@16)
 	GL_STUB(StencilMaskSeparate, _gloffset_StencilMaskSeparate, StencilMaskSeparate@8)
+	GL_STUB_ALIAS(ArrayElementEXT, _gloffset_ArrayElement, ArrayElementEXT@4, ArrayElement, ArrayElement@4)
+	GL_STUB_ALIAS(BindTextureEXT, _gloffset_BindTexture, BindTextureEXT@8, BindTexture, BindTexture@8)
+	GL_STUB_ALIAS(DrawArraysEXT, _gloffset_DrawArrays, DrawArraysEXT@12, DrawArrays, DrawArrays@12)
+	GL_STUB_ALIAS(CopyTexImage1DEXT, _gloffset_CopyTexImage1D, CopyTexImage1DEXT@28, CopyTexImage1D, CopyTexImage1D@28)
+	GL_STUB_ALIAS(CopyTexImage2DEXT, _gloffset_CopyTexImage2D, CopyTexImage2DEXT@32, CopyTexImage2D, CopyTexImage2D@32)
+	GL_STUB_ALIAS(CopyTexSubImage1DEXT, _gloffset_CopyTexSubImage1D, CopyTexSubImage1DEXT@24, CopyTexSubImage1D, CopyTexSubImage1D@24)
+	GL_STUB_ALIAS(CopyTexSubImage2DEXT, _gloffset_CopyTexSubImage2D, CopyTexSubImage2DEXT@32, CopyTexSubImage2D, CopyTexSubImage2D@32)
+	GL_STUB_ALIAS(DeleteTexturesEXT, _gloffset_DeleteTextures, DeleteTexturesEXT@8, DeleteTextures, DeleteTextures@8)
+	GL_STUB_ALIAS(GetPointervEXT, _gloffset_GetPointerv, GetPointervEXT@8, GetPointerv, GetPointerv@8)
+	GL_STUB_ALIAS(PrioritizeTexturesEXT, _gloffset_PrioritizeTextures, PrioritizeTexturesEXT@12, PrioritizeTextures, PrioritizeTextures@12)
+	GL_STUB_ALIAS(TexSubImage1DEXT, _gloffset_TexSubImage1D, TexSubImage1DEXT@28, TexSubImage1D, TexSubImage1D@28)
+	GL_STUB_ALIAS(TexSubImage2DEXT, _gloffset_TexSubImage2D, TexSubImage2DEXT@36, TexSubImage2D, TexSubImage2D@36)
+	GL_STUB_ALIAS(BlendColorEXT, _gloffset_BlendColor, BlendColorEXT@16, BlendColor, BlendColor@16)
+	GL_STUB_ALIAS(BlendEquationEXT, _gloffset_BlendEquation, BlendEquationEXT@4, BlendEquation, BlendEquation@4)
+	GL_STUB_ALIAS(DrawRangeElementsEXT, _gloffset_DrawRangeElements, DrawRangeElementsEXT@24, DrawRangeElements, DrawRangeElements@24)
+	GL_STUB_ALIAS(ColorTableSGI, _gloffset_ColorTable, ColorTableSGI@24, ColorTable, ColorTable@24)
+	GL_STUB_ALIAS(ColorTableEXT, _gloffset_ColorTable, ColorTableEXT@24, ColorTable, ColorTable@24)
+	GL_STUB_ALIAS(ColorTableParameterfvSGI, _gloffset_ColorTableParameterfv, ColorTableParameterfvSGI@12, ColorTableParameterfv, ColorTableParameterfv@12)
+	GL_STUB_ALIAS(ColorTableParameterivSGI, _gloffset_ColorTableParameteriv, ColorTableParameterivSGI@12, ColorTableParameteriv, ColorTableParameteriv@12)
+	GL_STUB_ALIAS(CopyColorTableSGI, _gloffset_CopyColorTable, CopyColorTableSGI@20, CopyColorTable, CopyColorTable@20)
+	GL_STUB_ALIAS(ColorSubTableEXT, _gloffset_ColorSubTable, ColorSubTableEXT@24, ColorSubTable, ColorSubTable@24)
+	GL_STUB_ALIAS(CopyColorSubTableEXT, _gloffset_CopyColorSubTable, CopyColorSubTableEXT@20, CopyColorSubTable, CopyColorSubTable@20)
+	GL_STUB_ALIAS(ConvolutionFilter1DEXT, _gloffset_ConvolutionFilter1D, ConvolutionFilter1DEXT@24, ConvolutionFilter1D, ConvolutionFilter1D@24)
+	GL_STUB_ALIAS(ConvolutionFilter2DEXT, _gloffset_ConvolutionFilter2D, ConvolutionFilter2DEXT@28, ConvolutionFilter2D, ConvolutionFilter2D@28)
+	GL_STUB_ALIAS(ConvolutionParameterfEXT, _gloffset_ConvolutionParameterf, ConvolutionParameterfEXT@12, ConvolutionParameterf, ConvolutionParameterf@12)
+	GL_STUB_ALIAS(ConvolutionParameterfvEXT, _gloffset_ConvolutionParameterfv, ConvolutionParameterfvEXT@12, ConvolutionParameterfv, ConvolutionParameterfv@12)
+	GL_STUB_ALIAS(ConvolutionParameteriEXT, _gloffset_ConvolutionParameteri, ConvolutionParameteriEXT@12, ConvolutionParameteri, ConvolutionParameteri@12)
+	GL_STUB_ALIAS(ConvolutionParameterivEXT, _gloffset_ConvolutionParameteriv, ConvolutionParameterivEXT@12, ConvolutionParameteriv, ConvolutionParameteriv@12)
+	GL_STUB_ALIAS(CopyConvolutionFilter1DEXT, _gloffset_CopyConvolutionFilter1D, CopyConvolutionFilter1DEXT@20, CopyConvolutionFilter1D, CopyConvolutionFilter1D@20)
+	GL_STUB_ALIAS(CopyConvolutionFilter2DEXT, _gloffset_CopyConvolutionFilter2D, CopyConvolutionFilter2DEXT@24, CopyConvolutionFilter2D, CopyConvolutionFilter2D@24)
+	GL_STUB_ALIAS(SeparableFilter2DEXT, _gloffset_SeparableFilter2D, SeparableFilter2DEXT@32, SeparableFilter2D, SeparableFilter2D@32)
+	GL_STUB_ALIAS(HistogramEXT, _gloffset_Histogram, HistogramEXT@16, Histogram, Histogram@16)
+	GL_STUB_ALIAS(MinmaxEXT, _gloffset_Minmax, MinmaxEXT@12, Minmax, Minmax@12)
+	GL_STUB_ALIAS(ResetHistogramEXT, _gloffset_ResetHistogram, ResetHistogramEXT@4, ResetHistogram, ResetHistogram@4)
+	GL_STUB_ALIAS(ResetMinmaxEXT, _gloffset_ResetMinmax, ResetMinmaxEXT@4, ResetMinmax, ResetMinmax@4)
+	GL_STUB_ALIAS(TexImage3DEXT, _gloffset_TexImage3D, TexImage3DEXT@40, TexImage3D, TexImage3D@40)
+	GL_STUB_ALIAS(TexSubImage3DEXT, _gloffset_TexSubImage3D, TexSubImage3DEXT@44, TexSubImage3D, TexSubImage3D@44)
+	GL_STUB_ALIAS(CopyTexSubImage3DEXT, _gloffset_CopyTexSubImage3D, CopyTexSubImage3DEXT@36, CopyTexSubImage3D, CopyTexSubImage3D@36)
 	GL_STUB_ALIAS(ActiveTexture, _gloffset_ActiveTextureARB, ActiveTexture@4, ActiveTextureARB, ActiveTextureARB@4)
 	GL_STUB_ALIAS(ClientActiveTexture, _gloffset_ClientActiveTextureARB, ClientActiveTexture@4, ClientActiveTextureARB, ClientActiveTextureARB@4)
 	GL_STUB_ALIAS(MultiTexCoord1d, _gloffset_MultiTexCoord1dARB, MultiTexCoord1d@12, MultiTexCoord1dARB, MultiTexCoord1dARB@12)
@@ -1008,6 +1046,54 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB_ALIAS(MultTransposeMatrixf, _gloffset_MultTransposeMatrixfARB, MultTransposeMatrixf@4, MultTransposeMatrixfARB, MultTransposeMatrixfARB@4)
 	GL_STUB_ALIAS(MultTransposeMatrixd, _gloffset_MultTransposeMatrixdARB, MultTransposeMatrixd@4, MultTransposeMatrixdARB, MultTransposeMatrixdARB@4)
 	GL_STUB_ALIAS(SampleCoverage, _gloffset_SampleCoverageARB, SampleCoverage@8, SampleCoverageARB, SampleCoverageARB@8)
+	GL_STUB_ALIAS(DrawBuffersATI, _gloffset_DrawBuffersARB, DrawBuffersATI@8, DrawBuffersARB, DrawBuffersARB@8)
+	GL_STUB_ALIAS(SampleMaskEXT, _gloffset_SampleMaskSGIS, SampleMaskEXT@8, SampleMaskSGIS, SampleMaskSGIS@8)
+	GL_STUB_ALIAS(SamplePatternEXT, _gloffset_SamplePatternSGIS, SamplePatternEXT@4, SamplePatternSGIS, SamplePatternSGIS@4)
+	GL_STUB_ALIAS(PointParameterf, _gloffset_PointParameterfEXT, PointParameterf@8, PointParameterfEXT, PointParameterfEXT@8)
+	GL_STUB_ALIAS(PointParameterfARB, _gloffset_PointParameterfEXT, PointParameterfARB@8, PointParameterfEXT, PointParameterfEXT@8)
+	GL_STUB_ALIAS(PointParameterfSGIS, _gloffset_PointParameterfEXT, PointParameterfSGIS@8, PointParameterfEXT, PointParameterfEXT@8)
+	GL_STUB_ALIAS(PointParameterfv, _gloffset_PointParameterfvEXT, PointParameterfv@8, PointParameterfvEXT, PointParameterfvEXT@8)
+	GL_STUB_ALIAS(PointParameterfvARB, _gloffset_PointParameterfvEXT, PointParameterfvARB@8, PointParameterfvEXT, PointParameterfvEXT@8)
+	GL_STUB_ALIAS(PointParameterfvSGIS, _gloffset_PointParameterfvEXT, PointParameterfvSGIS@8, PointParameterfvEXT, PointParameterfvEXT@8)
+	GL_STUB_ALIAS(WindowPos2d, _gloffset_WindowPos2dMESA, WindowPos2d@16, WindowPos2dMESA, WindowPos2dMESA@16)
+	GL_STUB_ALIAS(WindowPos2dARB, _gloffset_WindowPos2dMESA, WindowPos2dARB@16, WindowPos2dMESA, WindowPos2dMESA@16)
+	GL_STUB_ALIAS(WindowPos2dv, _gloffset_WindowPos2dvMESA, WindowPos2dv@4, WindowPos2dvMESA, WindowPos2dvMESA@4)
+	GL_STUB_ALIAS(WindowPos2dvARB, _gloffset_WindowPos2dvMESA, WindowPos2dvARB@4, WindowPos2dvMESA, WindowPos2dvMESA@4)
+	GL_STUB_ALIAS(WindowPos2f, _gloffset_WindowPos2fMESA, WindowPos2f@8, WindowPos2fMESA, WindowPos2fMESA@8)
+	GL_STUB_ALIAS(WindowPos2fARB, _gloffset_WindowPos2fMESA, WindowPos2fARB@8, WindowPos2fMESA, WindowPos2fMESA@8)
+	GL_STUB_ALIAS(WindowPos2fv, _gloffset_WindowPos2fvMESA, WindowPos2fv@4, WindowPos2fvMESA, WindowPos2fvMESA@4)
+	GL_STUB_ALIAS(WindowPos2fvARB, _gloffset_WindowPos2fvMESA, WindowPos2fvARB@4, WindowPos2fvMESA, WindowPos2fvMESA@4)
+	GL_STUB_ALIAS(WindowPos2i, _gloffset_WindowPos2iMESA, WindowPos2i@8, WindowPos2iMESA, WindowPos2iMESA@8)
+	GL_STUB_ALIAS(WindowPos2iARB, _gloffset_WindowPos2iMESA, WindowPos2iARB@8, WindowPos2iMESA, WindowPos2iMESA@8)
+	GL_STUB_ALIAS(WindowPos2iv, _gloffset_WindowPos2ivMESA, WindowPos2iv@4, WindowPos2ivMESA, WindowPos2ivMESA@4)
+	GL_STUB_ALIAS(WindowPos2ivARB, _gloffset_WindowPos2ivMESA, WindowPos2ivARB@4, WindowPos2ivMESA, WindowPos2ivMESA@4)
+	GL_STUB_ALIAS(WindowPos2s, _gloffset_WindowPos2sMESA, WindowPos2s@8, WindowPos2sMESA, WindowPos2sMESA@8)
+	GL_STUB_ALIAS(WindowPos2sARB, _gloffset_WindowPos2sMESA, WindowPos2sARB@8, WindowPos2sMESA, WindowPos2sMESA@8)
+	GL_STUB_ALIAS(WindowPos2sv, _gloffset_WindowPos2svMESA, WindowPos2sv@4, WindowPos2svMESA, WindowPos2svMESA@4)
+	GL_STUB_ALIAS(WindowPos2svARB, _gloffset_WindowPos2svMESA, WindowPos2svARB@4, WindowPos2svMESA, WindowPos2svMESA@4)
+	GL_STUB_ALIAS(WindowPos3d, _gloffset_WindowPos3dMESA, WindowPos3d@24, WindowPos3dMESA, WindowPos3dMESA@24)
+	GL_STUB_ALIAS(WindowPos3dARB, _gloffset_WindowPos3dMESA, WindowPos3dARB@24, WindowPos3dMESA, WindowPos3dMESA@24)
+	GL_STUB_ALIAS(WindowPos3dv, _gloffset_WindowPos3dvMESA, WindowPos3dv@4, WindowPos3dvMESA, WindowPos3dvMESA@4)
+	GL_STUB_ALIAS(WindowPos3dvARB, _gloffset_WindowPos3dvMESA, WindowPos3dvARB@4, WindowPos3dvMESA, WindowPos3dvMESA@4)
+	GL_STUB_ALIAS(WindowPos3f, _gloffset_WindowPos3fMESA, WindowPos3f@12, WindowPos3fMESA, WindowPos3fMESA@12)
+	GL_STUB_ALIAS(WindowPos3fARB, _gloffset_WindowPos3fMESA, WindowPos3fARB@12, WindowPos3fMESA, WindowPos3fMESA@12)
+	GL_STUB_ALIAS(WindowPos3fv, _gloffset_WindowPos3fvMESA, WindowPos3fv@4, WindowPos3fvMESA, WindowPos3fvMESA@4)
+	GL_STUB_ALIAS(WindowPos3fvARB, _gloffset_WindowPos3fvMESA, WindowPos3fvARB@4, WindowPos3fvMESA, WindowPos3fvMESA@4)
+	GL_STUB_ALIAS(WindowPos3i, _gloffset_WindowPos3iMESA, WindowPos3i@12, WindowPos3iMESA, WindowPos3iMESA@12)
+	GL_STUB_ALIAS(WindowPos3iARB, _gloffset_WindowPos3iMESA, WindowPos3iARB@12, WindowPos3iMESA, WindowPos3iMESA@12)
+	GL_STUB_ALIAS(WindowPos3iv, _gloffset_WindowPos3ivMESA, WindowPos3iv@4, WindowPos3ivMESA, WindowPos3ivMESA@4)
+	GL_STUB_ALIAS(WindowPos3ivARB, _gloffset_WindowPos3ivMESA, WindowPos3ivARB@4, WindowPos3ivMESA, WindowPos3ivMESA@4)
+	GL_STUB_ALIAS(WindowPos3s, _gloffset_WindowPos3sMESA, WindowPos3s@12, WindowPos3sMESA, WindowPos3sMESA@12)
+	GL_STUB_ALIAS(WindowPos3sARB, _gloffset_WindowPos3sMESA, WindowPos3sARB@12, WindowPos3sMESA, WindowPos3sMESA@12)
+	GL_STUB_ALIAS(WindowPos3sv, _gloffset_WindowPos3svMESA, WindowPos3sv@4, WindowPos3svMESA, WindowPos3svMESA@4)
+	GL_STUB_ALIAS(WindowPos3svARB, _gloffset_WindowPos3svMESA, WindowPos3svARB@4, WindowPos3svMESA, WindowPos3svMESA@4)
+	GL_STUB_ALIAS(BlendFuncSeparate, _gloffset_BlendFuncSeparateEXT, BlendFuncSeparate@16, BlendFuncSeparateEXT, BlendFuncSeparateEXT@16)
+	GL_STUB_ALIAS(BlendFuncSeparateINGR, _gloffset_BlendFuncSeparateEXT, BlendFuncSeparateINGR@16, BlendFuncSeparateEXT, BlendFuncSeparateEXT@16)
+	GL_STUB_ALIAS(FogCoordf, _gloffset_FogCoordfEXT, FogCoordf@4, FogCoordfEXT, FogCoordfEXT@4)
+	GL_STUB_ALIAS(FogCoordfv, _gloffset_FogCoordfvEXT, FogCoordfv@4, FogCoordfvEXT, FogCoordfvEXT@4)
+	GL_STUB_ALIAS(FogCoordd, _gloffset_FogCoorddEXT, FogCoordd@8, FogCoorddEXT, FogCoorddEXT@8)
+	GL_STUB_ALIAS(FogCoorddv, _gloffset_FogCoorddvEXT, FogCoorddv@4, FogCoorddvEXT, FogCoorddvEXT@4)
+	GL_STUB_ALIAS(FogCoordPointer, _gloffset_FogCoordPointerEXT, FogCoordPointer@12, FogCoordPointerEXT, FogCoordPointerEXT@12)
 	GL_STUB_ALIAS(CompressedTexImage3D, _gloffset_CompressedTexImage3DARB, CompressedTexImage3D@36, CompressedTexImage3DARB, CompressedTexImage3DARB@36)
 	GL_STUB_ALIAS(CompressedTexImage2D, _gloffset_CompressedTexImage2DARB, CompressedTexImage2D@32, CompressedTexImage2DARB, CompressedTexImage2DARB@32)
 	GL_STUB_ALIAS(CompressedTexImage1D, _gloffset_CompressedTexImage1DARB, CompressedTexImage1D@28, CompressedTexImage1DARB, CompressedTexImage1DARB@28)
@@ -1015,18 +1101,6 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB_ALIAS(CompressedTexSubImage2D, _gloffset_CompressedTexSubImage2DARB, CompressedTexSubImage2D@36, CompressedTexSubImage2DARB, CompressedTexSubImage2DARB@36)
 	GL_STUB_ALIAS(CompressedTexSubImage1D, _gloffset_CompressedTexSubImage1DARB, CompressedTexSubImage1D@28, CompressedTexSubImage1DARB, CompressedTexSubImage1DARB@28)
 	GL_STUB_ALIAS(GetCompressedTexImage, _gloffset_GetCompressedTexImageARB, GetCompressedTexImage@12, GetCompressedTexImageARB, GetCompressedTexImageARB@12)
-	GL_STUB_ALIAS(BlendFuncSeparate, _gloffset_BlendFuncSeparateEXT, BlendFuncSeparate@16, BlendFuncSeparateEXT, BlendFuncSeparateEXT@16)
-	GL_STUB_ALIAS(FogCoordf, _gloffset_FogCoordfEXT, FogCoordf@4, FogCoordfEXT, FogCoordfEXT@4)
-	GL_STUB_ALIAS(FogCoordfv, _gloffset_FogCoordfvEXT, FogCoordfv@4, FogCoordfvEXT, FogCoordfvEXT@4)
-	GL_STUB_ALIAS(FogCoordd, _gloffset_FogCoorddEXT, FogCoordd@8, FogCoorddEXT, FogCoorddEXT@8)
-	GL_STUB_ALIAS(FogCoorddv, _gloffset_FogCoorddvEXT, FogCoorddv@4, FogCoorddvEXT, FogCoorddvEXT@4)
-	GL_STUB_ALIAS(FogCoordPointer, _gloffset_FogCoordPointerEXT, FogCoordPointer@12, FogCoordPointerEXT, FogCoordPointerEXT@12)
-	GL_STUB_ALIAS(MultiDrawArrays, _gloffset_MultiDrawArraysEXT, MultiDrawArrays@16, MultiDrawArraysEXT, MultiDrawArraysEXT@16)
-	GL_STUB_ALIAS(MultiDrawElements, _gloffset_MultiDrawElementsEXT, MultiDrawElements@20, MultiDrawElementsEXT, MultiDrawElementsEXT@20)
-	GL_STUB_ALIAS(PointParameterf, _gloffset_PointParameterfEXT, PointParameterf@8, PointParameterfEXT, PointParameterfEXT@8)
-	GL_STUB_ALIAS(PointParameterfv, _gloffset_PointParameterfvEXT, PointParameterfv@8, PointParameterfvEXT, PointParameterfvEXT@8)
-	GL_STUB_ALIAS(PointParameteri, _gloffset_PointParameteriNV, PointParameteri@8, PointParameteriNV, PointParameteriNV@8)
-	GL_STUB_ALIAS(PointParameteriv, _gloffset_PointParameterivNV, PointParameteriv@8, PointParameterivNV, PointParameterivNV@8)
 	GL_STUB_ALIAS(SecondaryColor3b, _gloffset_SecondaryColor3bEXT, SecondaryColor3b@12, SecondaryColor3bEXT, SecondaryColor3bEXT@12)
 	GL_STUB_ALIAS(SecondaryColor3bv, _gloffset_SecondaryColor3bvEXT, SecondaryColor3bv@4, SecondaryColor3bvEXT, SecondaryColor3bvEXT@4)
 	GL_STUB_ALIAS(SecondaryColor3d, _gloffset_SecondaryColor3dEXT, SecondaryColor3d@24, SecondaryColor3dEXT, SecondaryColor3dEXT@24)
@@ -1044,22 +1118,15 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB_ALIAS(SecondaryColor3us, _gloffset_SecondaryColor3usEXT, SecondaryColor3us@12, SecondaryColor3usEXT, SecondaryColor3usEXT@12)
 	GL_STUB_ALIAS(SecondaryColor3usv, _gloffset_SecondaryColor3usvEXT, SecondaryColor3usv@4, SecondaryColor3usvEXT, SecondaryColor3usvEXT@4)
 	GL_STUB_ALIAS(SecondaryColorPointer, _gloffset_SecondaryColorPointerEXT, SecondaryColorPointer@16, SecondaryColorPointerEXT, SecondaryColorPointerEXT@16)
-	GL_STUB_ALIAS(WindowPos2d, _gloffset_WindowPos2dMESA, WindowPos2d@16, WindowPos2dMESA, WindowPos2dMESA@16)
-	GL_STUB_ALIAS(WindowPos2dv, _gloffset_WindowPos2dvMESA, WindowPos2dv@4, WindowPos2dvMESA, WindowPos2dvMESA@4)
-	GL_STUB_ALIAS(WindowPos2f, _gloffset_WindowPos2fMESA, WindowPos2f@8, WindowPos2fMESA, WindowPos2fMESA@8)
-	GL_STUB_ALIAS(WindowPos2fv, _gloffset_WindowPos2fvMESA, WindowPos2fv@4, WindowPos2fvMESA, WindowPos2fvMESA@4)
-	GL_STUB_ALIAS(WindowPos2i, _gloffset_WindowPos2iMESA, WindowPos2i@8, WindowPos2iMESA, WindowPos2iMESA@8)
-	GL_STUB_ALIAS(WindowPos2iv, _gloffset_WindowPos2ivMESA, WindowPos2iv@4, WindowPos2ivMESA, WindowPos2ivMESA@4)
-	GL_STUB_ALIAS(WindowPos2s, _gloffset_WindowPos2sMESA, WindowPos2s@8, WindowPos2sMESA, WindowPos2sMESA@8)
-	GL_STUB_ALIAS(WindowPos2sv, _gloffset_WindowPos2svMESA, WindowPos2sv@4, WindowPos2svMESA, WindowPos2svMESA@4)
-	GL_STUB_ALIAS(WindowPos3d, _gloffset_WindowPos3dMESA, WindowPos3d@24, WindowPos3dMESA, WindowPos3dMESA@24)
-	GL_STUB_ALIAS(WindowPos3dv, _gloffset_WindowPos3dvMESA, WindowPos3dv@4, WindowPos3dvMESA, WindowPos3dvMESA@4)
-	GL_STUB_ALIAS(WindowPos3f, _gloffset_WindowPos3fMESA, WindowPos3f@12, WindowPos3fMESA, WindowPos3fMESA@12)
-	GL_STUB_ALIAS(WindowPos3fv, _gloffset_WindowPos3fvMESA, WindowPos3fv@4, WindowPos3fvMESA, WindowPos3fvMESA@4)
-	GL_STUB_ALIAS(WindowPos3i, _gloffset_WindowPos3iMESA, WindowPos3i@12, WindowPos3iMESA, WindowPos3iMESA@12)
-	GL_STUB_ALIAS(WindowPos3iv, _gloffset_WindowPos3ivMESA, WindowPos3iv@4, WindowPos3ivMESA, WindowPos3ivMESA@4)
-	GL_STUB_ALIAS(WindowPos3s, _gloffset_WindowPos3sMESA, WindowPos3s@12, WindowPos3sMESA, WindowPos3sMESA@12)
-	GL_STUB_ALIAS(WindowPos3sv, _gloffset_WindowPos3svMESA, WindowPos3sv@4, WindowPos3svMESA, WindowPos3svMESA@4)
+	GL_STUB_ALIAS(BindProgramARB, _gloffset_BindProgramNV, BindProgramARB@8, BindProgramNV, BindProgramNV@8)
+	GL_STUB_ALIAS(DeleteProgramsARB, _gloffset_DeleteProgramsNV, DeleteProgramsARB@8, DeleteProgramsNV, DeleteProgramsNV@8)
+	GL_STUB_ALIAS(GenProgramsARB, _gloffset_GenProgramsNV, GenProgramsARB@8, GenProgramsNV, GenProgramsNV@8)
+	GL_STUB_ALIAS(GetVertexAttribPointervARB, _gloffset_GetVertexAttribPointervNV, GetVertexAttribPointervARB@12, GetVertexAttribPointervNV, GetVertexAttribPointervNV@12)
+	GL_STUB_ALIAS(IsProgramARB, _gloffset_IsProgramNV, IsProgramARB@4, IsProgramNV, IsProgramNV@4)
+	GL_STUB_ALIAS(PointParameteri, _gloffset_PointParameteriNV, PointParameteri@8, PointParameteriNV, PointParameteriNV@8)
+	GL_STUB_ALIAS(PointParameteriv, _gloffset_PointParameterivNV, PointParameteriv@8, PointParameterivNV, PointParameterivNV@8)
+	GL_STUB_ALIAS(MultiDrawArrays, _gloffset_MultiDrawArraysEXT, MultiDrawArrays@16, MultiDrawArraysEXT, MultiDrawArraysEXT@16)
+	GL_STUB_ALIAS(MultiDrawElements, _gloffset_MultiDrawElementsEXT, MultiDrawElements@20, MultiDrawElementsEXT, MultiDrawElementsEXT@20)
 	GL_STUB_ALIAS(BindBuffer, _gloffset_BindBufferARB, BindBuffer@8, BindBufferARB, BindBufferARB@8)
 	GL_STUB_ALIAS(BufferData, _gloffset_BufferDataARB, BufferData@16, BufferDataARB, BufferDataARB@16)
 	GL_STUB_ALIAS(BufferSubData, _gloffset_BufferSubDataARB, BufferSubData@16, BufferSubDataARB, BufferSubDataARB@16)
@@ -1079,74 +1146,7 @@ GLNAME(gl_dispatch_functions_start):
 	GL_STUB_ALIAS(GetQueryiv, _gloffset_GetQueryivARB, GetQueryiv@12, GetQueryivARB, GetQueryivARB@12)
 	GL_STUB_ALIAS(GetQueryObjectiv, _gloffset_GetQueryObjectivARB, GetQueryObjectiv@12, GetQueryObjectivARB, GetQueryObjectivARB@12)
 	GL_STUB_ALIAS(GetQueryObjectuiv, _gloffset_GetQueryObjectuivARB, GetQueryObjectuiv@12, GetQueryObjectuivARB, GetQueryObjectuivARB@12)
-	GL_STUB_ALIAS(PointParameterfARB, _gloffset_PointParameterfEXT, PointParameterfARB@8, PointParameterfEXT, PointParameterfEXT@8)
-	GL_STUB_ALIAS(PointParameterfvARB, _gloffset_PointParameterfvEXT, PointParameterfvARB@8, PointParameterfvEXT, PointParameterfvEXT@8)
-	GL_STUB_ALIAS(WindowPos2dARB, _gloffset_WindowPos2dMESA, WindowPos2dARB@16, WindowPos2dMESA, WindowPos2dMESA@16)
-	GL_STUB_ALIAS(WindowPos2fARB, _gloffset_WindowPos2fMESA, WindowPos2fARB@8, WindowPos2fMESA, WindowPos2fMESA@8)
-	GL_STUB_ALIAS(WindowPos2iARB, _gloffset_WindowPos2iMESA, WindowPos2iARB@8, WindowPos2iMESA, WindowPos2iMESA@8)
-	GL_STUB_ALIAS(WindowPos2sARB, _gloffset_WindowPos2sMESA, WindowPos2sARB@8, WindowPos2sMESA, WindowPos2sMESA@8)
-	GL_STUB_ALIAS(WindowPos2dvARB, _gloffset_WindowPos2dvMESA, WindowPos2dvARB@4, WindowPos2dvMESA, WindowPos2dvMESA@4)
-	GL_STUB_ALIAS(WindowPos2fvARB, _gloffset_WindowPos2fvMESA, WindowPos2fvARB@4, WindowPos2fvMESA, WindowPos2fvMESA@4)
-	GL_STUB_ALIAS(WindowPos2ivARB, _gloffset_WindowPos2ivMESA, WindowPos2ivARB@4, WindowPos2ivMESA, WindowPos2ivMESA@4)
-	GL_STUB_ALIAS(WindowPos2svARB, _gloffset_WindowPos2svMESA, WindowPos2svARB@4, WindowPos2svMESA, WindowPos2svMESA@4)
-	GL_STUB_ALIAS(WindowPos3dARB, _gloffset_WindowPos3dMESA, WindowPos3dARB@24, WindowPos3dMESA, WindowPos3dMESA@24)
-	GL_STUB_ALIAS(WindowPos3fARB, _gloffset_WindowPos3fMESA, WindowPos3fARB@12, WindowPos3fMESA, WindowPos3fMESA@12)
-	GL_STUB_ALIAS(WindowPos3iARB, _gloffset_WindowPos3iMESA, WindowPos3iARB@12, WindowPos3iMESA, WindowPos3iMESA@12)
-	GL_STUB_ALIAS(WindowPos3sARB, _gloffset_WindowPos3sMESA, WindowPos3sARB@12, WindowPos3sMESA, WindowPos3sMESA@12)
-	GL_STUB_ALIAS(WindowPos3dvARB, _gloffset_WindowPos3dvMESA, WindowPos3dvARB@4, WindowPos3dvMESA, WindowPos3dvMESA@4)
-	GL_STUB_ALIAS(WindowPos3fvARB, _gloffset_WindowPos3fvMESA, WindowPos3fvARB@4, WindowPos3fvMESA, WindowPos3fvMESA@4)
-	GL_STUB_ALIAS(WindowPos3ivARB, _gloffset_WindowPos3ivMESA, WindowPos3ivARB@4, WindowPos3ivMESA, WindowPos3ivMESA@4)
-	GL_STUB_ALIAS(WindowPos3svARB, _gloffset_WindowPos3svMESA, WindowPos3svARB@4, WindowPos3svMESA, WindowPos3svMESA@4)
-	GL_STUB_ALIAS(BindProgramARB, _gloffset_BindProgramNV, BindProgramARB@8, BindProgramNV, BindProgramNV@8)
-	GL_STUB_ALIAS(DeleteProgramsARB, _gloffset_DeleteProgramsNV, DeleteProgramsARB@8, DeleteProgramsNV, DeleteProgramsNV@8)
-	GL_STUB_ALIAS(GenProgramsARB, _gloffset_GenProgramsNV, GenProgramsARB@8, GenProgramsNV, GenProgramsNV@8)
-	GL_STUB_ALIAS(IsProgramARB, _gloffset_IsProgramNV, IsProgramARB@4, IsProgramNV, IsProgramNV@4)
-	GL_STUB_ALIAS(GetVertexAttribPointervARB, _gloffset_GetVertexAttribPointervNV, GetVertexAttribPointervARB@12, GetVertexAttribPointervNV, GetVertexAttribPointervNV@12)
-	GL_STUB_ALIAS(BlendColorEXT, _gloffset_BlendColor, BlendColorEXT@16, BlendColor, BlendColor@16)
-	GL_STUB_ALIAS(TexImage3DEXT, _gloffset_TexImage3D, TexImage3DEXT@40, TexImage3D, TexImage3D@40)
-	GL_STUB_ALIAS(TexSubImage3DEXT, _gloffset_TexSubImage3D, TexSubImage3DEXT@44, TexSubImage3D, TexSubImage3D@44)
-	GL_STUB_ALIAS(TexSubImage1DEXT, _gloffset_TexSubImage1D, TexSubImage1DEXT@28, TexSubImage1D, TexSubImage1D@28)
-	GL_STUB_ALIAS(TexSubImage2DEXT, _gloffset_TexSubImage2D, TexSubImage2DEXT@36, TexSubImage2D, TexSubImage2D@36)
-	GL_STUB_ALIAS(CopyTexImage1DEXT, _gloffset_CopyTexImage1D, CopyTexImage1DEXT@28, CopyTexImage1D, CopyTexImage1D@28)
-	GL_STUB_ALIAS(CopyTexImage2DEXT, _gloffset_CopyTexImage2D, CopyTexImage2DEXT@32, CopyTexImage2D, CopyTexImage2D@32)
-	GL_STUB_ALIAS(CopyTexSubImage1DEXT, _gloffset_CopyTexSubImage1D, CopyTexSubImage1DEXT@24, CopyTexSubImage1D, CopyTexSubImage1D@24)
-	GL_STUB_ALIAS(CopyTexSubImage2DEXT, _gloffset_CopyTexSubImage2D, CopyTexSubImage2DEXT@32, CopyTexSubImage2D, CopyTexSubImage2D@32)
-	GL_STUB_ALIAS(CopyTexSubImage3DEXT, _gloffset_CopyTexSubImage3D, CopyTexSubImage3DEXT@36, CopyTexSubImage3D, CopyTexSubImage3D@36)
-	GL_STUB_ALIAS(HistogramEXT, _gloffset_Histogram, HistogramEXT@16, Histogram, Histogram@16)
-	GL_STUB_ALIAS(MinmaxEXT, _gloffset_Minmax, MinmaxEXT@12, Minmax, Minmax@12)
-	GL_STUB_ALIAS(ResetHistogramEXT, _gloffset_ResetHistogram, ResetHistogramEXT@4, ResetHistogram, ResetHistogram@4)
-	GL_STUB_ALIAS(ResetMinmaxEXT, _gloffset_ResetMinmax, ResetMinmaxEXT@4, ResetMinmax, ResetMinmax@4)
-	GL_STUB_ALIAS(ConvolutionFilter1DEXT, _gloffset_ConvolutionFilter1D, ConvolutionFilter1DEXT@24, ConvolutionFilter1D, ConvolutionFilter1D@24)
-	GL_STUB_ALIAS(ConvolutionFilter2DEXT, _gloffset_ConvolutionFilter2D, ConvolutionFilter2DEXT@28, ConvolutionFilter2D, ConvolutionFilter2D@28)
-	GL_STUB_ALIAS(ConvolutionParameterfEXT, _gloffset_ConvolutionParameterf, ConvolutionParameterfEXT@12, ConvolutionParameterf, ConvolutionParameterf@12)
-	GL_STUB_ALIAS(ConvolutionParameterfvEXT, _gloffset_ConvolutionParameterfv, ConvolutionParameterfvEXT@12, ConvolutionParameterfv, ConvolutionParameterfv@12)
-	GL_STUB_ALIAS(ConvolutionParameteriEXT, _gloffset_ConvolutionParameteri, ConvolutionParameteriEXT@12, ConvolutionParameteri, ConvolutionParameteri@12)
-	GL_STUB_ALIAS(ConvolutionParameterivEXT, _gloffset_ConvolutionParameteriv, ConvolutionParameterivEXT@12, ConvolutionParameteriv, ConvolutionParameteriv@12)
-	GL_STUB_ALIAS(CopyConvolutionFilter1DEXT, _gloffset_CopyConvolutionFilter1D, CopyConvolutionFilter1DEXT@20, CopyConvolutionFilter1D, CopyConvolutionFilter1D@20)
-	GL_STUB_ALIAS(CopyConvolutionFilter2DEXT, _gloffset_CopyConvolutionFilter2D, CopyConvolutionFilter2DEXT@24, CopyConvolutionFilter2D, CopyConvolutionFilter2D@24)
-	GL_STUB_ALIAS(SeparableFilter2DEXT, _gloffset_SeparableFilter2D, SeparableFilter2DEXT@32, SeparableFilter2D, SeparableFilter2D@32)
-	GL_STUB_ALIAS(ColorTableSGI, _gloffset_ColorTable, ColorTableSGI@24, ColorTable, ColorTable@24)
-	GL_STUB_ALIAS(ColorTableParameterfvSGI, _gloffset_ColorTableParameterfv, ColorTableParameterfvSGI@12, ColorTableParameterfv, ColorTableParameterfv@12)
-	GL_STUB_ALIAS(ColorTableParameterivSGI, _gloffset_ColorTableParameteriv, ColorTableParameterivSGI@12, ColorTableParameteriv, ColorTableParameteriv@12)
-	GL_STUB_ALIAS(CopyColorTableSGI, _gloffset_CopyColorTable, CopyColorTableSGI@20, CopyColorTable, CopyColorTable@20)
-	GL_STUB_ALIAS(BindTextureEXT, _gloffset_BindTexture, BindTextureEXT@8, BindTexture, BindTexture@8)
-	GL_STUB_ALIAS(DeleteTexturesEXT, _gloffset_DeleteTextures, DeleteTexturesEXT@8, DeleteTextures, DeleteTextures@8)
-	GL_STUB_ALIAS(PrioritizeTexturesEXT, _gloffset_PrioritizeTextures, PrioritizeTexturesEXT@12, PrioritizeTextures, PrioritizeTextures@12)
-	GL_STUB_ALIAS(ArrayElementEXT, _gloffset_ArrayElement, ArrayElementEXT@4, ArrayElement, ArrayElement@4)
-	GL_STUB_ALIAS(DrawArraysEXT, _gloffset_DrawArrays, DrawArraysEXT@12, DrawArrays, DrawArrays@12)
-	GL_STUB_ALIAS(GetPointervEXT, _gloffset_GetPointerv, GetPointervEXT@8, GetPointerv, GetPointerv@8)
-	GL_STUB_ALIAS(BlendEquationEXT, _gloffset_BlendEquation, BlendEquationEXT@4, BlendEquation, BlendEquation@4)
-	GL_STUB_ALIAS(ColorSubTableEXT, _gloffset_ColorSubTable, ColorSubTableEXT@24, ColorSubTable, ColorSubTable@24)
-	GL_STUB_ALIAS(CopyColorSubTableEXT, _gloffset_CopyColorSubTable, CopyColorSubTableEXT@20, CopyColorSubTable, CopyColorSubTable@20)
-	GL_STUB_ALIAS(ColorTableEXT, _gloffset_ColorTable, ColorTableEXT@24, ColorTable, ColorTable@24)
-	GL_STUB_ALIAS(DrawRangeElementsEXT, _gloffset_DrawRangeElements, DrawRangeElementsEXT@24, DrawRangeElements, DrawRangeElements@24)
-	GL_STUB_ALIAS(SampleMaskEXT, _gloffset_SampleMaskSGIS, SampleMaskEXT@8, SampleMaskSGIS, SampleMaskSGIS@8)
-	GL_STUB_ALIAS(SamplePatternEXT, _gloffset_SamplePatternSGIS, SamplePatternEXT@4, SamplePatternSGIS, SamplePatternSGIS@4)
-	GL_STUB_ALIAS(DrawBuffersATI, _gloffset_DrawBuffersARB, DrawBuffersATI@8, DrawBuffersARB, DrawBuffersARB@8)
 	GL_STUB_ALIAS(BlendEquationSeparateATI, _gloffset_BlendEquationSeparateEXT, BlendEquationSeparateATI@8, BlendEquationSeparateEXT, BlendEquationSeparateEXT@8)
-	GL_STUB_ALIAS(BlendFuncSeparateINGR, _gloffset_BlendFuncSeparateEXT, BlendFuncSeparateINGR@16, BlendFuncSeparateEXT, BlendFuncSeparateEXT@16)
-	GL_STUB_ALIAS(PointParameterfSGIS, _gloffset_PointParameterfEXT, PointParameterfSGIS@8, PointParameterfEXT, PointParameterfEXT@8)
-	GL_STUB_ALIAS(PointParameterfvSGIS, _gloffset_PointParameterfvEXT, PointParameterfvSGIS@8, PointParameterfvEXT, PointParameterfvEXT@8)
 
 		GLOBL	GLNAME(gl_dispatch_functions_end)
 		HIDDEN(GLNAME(gl_dispatch_functions_end))