/*
 * Mesa 3-D graphics library
 * Version:  7.6
 *
 * Copyright (C) 2004-2008  Brian Paul   All Rights Reserved.
 * Copyright (C) 2009  VMware, Inc.  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
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * 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 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 NONINFRINGEMENT.  IN NO EVENT SHALL
 * BRIAN PAUL 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.
 */

/**
 * \file shader_api.c
 * Implementation of GLSL-related API functions
 * \author Brian Paul
 */

/**
 * XXX things to do:
 * 1. Check that the right error code is generated for all _mesa_error() calls.
 * 2. Insert FLUSH_VERTICES calls in various places
 */


#include "main/glheader.h"
#include "main/context.h"
#include "main/hash.h"
#include "main/macros.h"
#include "shader/program.h"
#include "shader/prog_parameter.h"
#include "shader/prog_print.h"
#include "shader/prog_statevars.h"
#include "shader/prog_uniform.h"
#include "shader/shader_api.h"
#include "shader/slang/slang_compile.h"
#include "shader/slang/slang_link.h"
#include "glapi/dispatch.h"


/**
 * Allocate a new gl_shader_program object, initialize it.
 */
static struct gl_shader_program *
_mesa_new_shader_program(GLcontext *ctx, GLuint name)
{
   struct gl_shader_program *shProg;
   shProg = CALLOC_STRUCT(gl_shader_program);
   if (shProg) {
      shProg->Type = GL_SHADER_PROGRAM_MESA;
      shProg->Name = name;
      shProg->RefCount = 1;
      shProg->Attributes = _mesa_new_parameter_list();
   }
   return shProg;
}


/**
 * Clear (free) the shader program state that gets produced by linking.
 */
void
_mesa_clear_shader_program_data(GLcontext *ctx,
                                struct gl_shader_program *shProg)
{
   _mesa_reference_vertprog(ctx, &shProg->VertexProgram, NULL);
   _mesa_reference_fragprog(ctx, &shProg->FragmentProgram, NULL);

   if (shProg->Uniforms) {
      _mesa_free_uniform_list(shProg->Uniforms);
      shProg->Uniforms = NULL;
   }

   if (shProg->Varying) {
      _mesa_free_parameter_list(shProg->Varying);
      shProg->Varying = NULL;
   }
}


/**
 * Free all the data that hangs off a shader program object, but not the
 * object itself.
 */
void
_mesa_free_shader_program_data(GLcontext *ctx,
                               struct gl_shader_program *shProg)
{
   GLuint i;

   assert(shProg->Type == GL_SHADER_PROGRAM_MESA);

   _mesa_clear_shader_program_data(ctx, shProg);

   if (shProg->Attributes) {
      _mesa_free_parameter_list(shProg->Attributes);
      shProg->Attributes = NULL;
   }

   /* detach shaders */
   for (i = 0; i < shProg->NumShaders; i++) {
      _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);
   }
   shProg->NumShaders = 0;

   if (shProg->Shaders) {
      _mesa_free(shProg->Shaders);
      shProg->Shaders = NULL;
   }

   if (shProg->InfoLog) {
      _mesa_free(shProg->InfoLog);
      shProg->InfoLog = NULL;
   }
}


/**
 * Free/delete a shader program object.
 */
void
_mesa_free_shader_program(GLcontext *ctx, struct gl_shader_program *shProg)
{
   _mesa_free_shader_program_data(ctx, shProg);

   _mesa_free(shProg);
}


/**
 * Set ptr to point to shProg.
 * If ptr is pointing to another object, decrement its refcount (and delete
 * if refcount hits zero).
 * Then set ptr to point to shProg, incrementing its refcount.
 */
/* XXX this could be static */
void
_mesa_reference_shader_program(GLcontext *ctx,
                               struct gl_shader_program **ptr,
                               struct gl_shader_program *shProg)
{
   assert(ptr);
   if (*ptr == shProg) {
      /* no-op */
      return;
   }
   if (*ptr) {
      /* Unreference the old shader program */
      GLboolean deleteFlag = GL_FALSE;
      struct gl_shader_program *old = *ptr;

      ASSERT(old->RefCount > 0);
      old->RefCount--;
#if 0
      printf("ShaderProgram %p ID=%u  RefCount-- to %d\n",
             (void *) old, old->Name, old->RefCount);
#endif
      deleteFlag = (old->RefCount == 0);

      if (deleteFlag) {
         _mesa_HashRemove(ctx->Shared->ShaderObjects, old->Name);
         _mesa_free_shader_program(ctx, old);
      }

      *ptr = NULL;
   }
   assert(!*ptr);

   if (shProg) {
      shProg->RefCount++;
#if 0
      printf("ShaderProgram %p ID=%u  RefCount++ to %d\n",
             (void *) shProg, shProg->Name, shProg->RefCount);
#endif
      *ptr = shProg;
   }
}


/**
 * Lookup a GLSL program object.
 */
struct gl_shader_program *
_mesa_lookup_shader_program(GLcontext *ctx, GLuint name)
{
   struct gl_shader_program *shProg;
   if (name) {
      shProg = (struct gl_shader_program *)
         _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
      /* Note that both gl_shader and gl_shader_program objects are kept
       * in the same hash table.  Check the object's type to be sure it's
       * what we're expecting.
       */
      if (shProg && shProg->Type != GL_SHADER_PROGRAM_MESA) {
         return NULL;
      }
      return shProg;
   }
   return NULL;
}


/**
 * As above, but record an error if program is not found.
 */
static struct gl_shader_program *
_mesa_lookup_shader_program_err(GLcontext *ctx, GLuint name,
                                const char *caller)
{
   if (!name) {
      _mesa_error(ctx, GL_INVALID_VALUE, caller);
      return NULL;
   }
   else {
      struct gl_shader_program *shProg = (struct gl_shader_program *)
         _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
      if (!shProg) {
         _mesa_error(ctx, GL_INVALID_VALUE, caller);
         return NULL;
      }
      if (shProg->Type != GL_SHADER_PROGRAM_MESA) {
         _mesa_error(ctx, GL_INVALID_OPERATION, caller);
         return NULL;
      }
      return shProg;
   }
}




/**
 * Allocate a new gl_shader object, initialize it.
 */
struct gl_shader *
_mesa_new_shader(GLcontext *ctx, GLuint name, GLenum type)
{
   struct gl_shader *shader;
   assert(type == GL_FRAGMENT_SHADER || type == GL_VERTEX_SHADER);
   shader = CALLOC_STRUCT(gl_shader);
   if (shader) {
      shader->Type = type;
      shader->Name = name;
      shader->RefCount = 1;
   }
   return shader;
}


void
_mesa_free_shader(GLcontext *ctx, struct gl_shader *sh)
{
   if (sh->Source)
      _mesa_free((void *) sh->Source);
   if (sh->InfoLog)
      _mesa_free(sh->InfoLog);
   _mesa_reference_program(ctx, &sh->Program, NULL);
   _mesa_free(sh);
}


/**
 * Set ptr to point to sh.
 * If ptr is pointing to another shader, decrement its refcount (and delete
 * if refcount hits zero).
 * Then set ptr to point to sh, incrementing its refcount.
 */
/* XXX this could be static */
void
_mesa_reference_shader(GLcontext *ctx, struct gl_shader **ptr,
                       struct gl_shader *sh)
{
   assert(ptr);
   if (*ptr == sh) {
      /* no-op */
      return;
   }
   if (*ptr) {
      /* Unreference the old shader */
      GLboolean deleteFlag = GL_FALSE;
      struct gl_shader *old = *ptr;

      ASSERT(old->RefCount > 0);
      old->RefCount--;
      /*printf("SHADER DECR %p (%d) to %d\n",
        (void*) old, old->Name, old->RefCount);*/
      deleteFlag = (old->RefCount == 0);

      if (deleteFlag) {
         _mesa_HashRemove(ctx->Shared->ShaderObjects, old->Name);
         _mesa_free_shader(ctx, old);
      }

      *ptr = NULL;
   }
   assert(!*ptr);

   if (sh) {
      /* reference new */
      sh->RefCount++;
      /*printf("SHADER INCR %p (%d) to %d\n",
        (void*) sh, sh->Name, sh->RefCount);*/
      *ptr = sh;
   }
}


/**
 * Lookup a GLSL shader object.
 */
struct gl_shader *
_mesa_lookup_shader(GLcontext *ctx, GLuint name)
{
   if (name) {
      struct gl_shader *sh = (struct gl_shader *)
         _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
      /* Note that both gl_shader and gl_shader_program objects are kept
       * in the same hash table.  Check the object's type to be sure it's
       * what we're expecting.
       */
      if (sh && sh->Type == GL_SHADER_PROGRAM_MESA) {
         return NULL;
      }
      return sh;
   }
   return NULL;
}


/**
 * As above, but record an error if shader is not found.
 */
static struct gl_shader *
_mesa_lookup_shader_err(GLcontext *ctx, GLuint name, const char *caller)
{
   if (!name) {
      _mesa_error(ctx, GL_INVALID_VALUE, caller);
      return NULL;
   }
   else {
      struct gl_shader *sh = (struct gl_shader *)
         _mesa_HashLookup(ctx->Shared->ShaderObjects, name);
      if (!sh) {
         _mesa_error(ctx, GL_INVALID_VALUE, caller);
         return NULL;
      }
      if (sh->Type == GL_SHADER_PROGRAM_MESA) {
         _mesa_error(ctx, GL_INVALID_OPERATION, caller);
         return NULL;
      }
      return sh;
   }
}


/**
 * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
 */
static GLbitfield
get_shader_flags(void)
{
   GLbitfield flags = 0x0;
   const char *env = _mesa_getenv("MESA_GLSL");

   if (env) {
      if (_mesa_strstr(env, "dump"))
         flags |= GLSL_DUMP;
      if (_mesa_strstr(env, "log"))
         flags |= GLSL_LOG;
      if (_mesa_strstr(env, "nopt"))
         flags |= GLSL_NO_OPT;
      else if (_mesa_strstr(env, "opt"))
         flags |= GLSL_OPT;
      if (_mesa_strstr(env, "uniform"))
         flags |= GLSL_UNIFORMS;
   }

   return flags;
}


/**
 * Initialize context's shader state.
 */
void
_mesa_init_shader_state(GLcontext * ctx)
{
   /* Device drivers may override these to control what kind of instructions
    * are generated by the GLSL compiler.
    */
   ctx->Shader.EmitHighLevelInstructions = GL_TRUE;
   ctx->Shader.EmitContReturn = GL_TRUE;
   ctx->Shader.EmitCondCodes = GL_FALSE;
   ctx->Shader.EmitComments = GL_FALSE;
   ctx->Shader.Flags = get_shader_flags();

   /* Default pragma settings */
   ctx->Shader.DefaultPragmas.IgnoreOptimize = GL_FALSE;
   ctx->Shader.DefaultPragmas.IgnoreDebug = GL_FALSE;
   ctx->Shader.DefaultPragmas.Optimize = GL_TRUE;
   ctx->Shader.DefaultPragmas.Debug = GL_FALSE;
}


/**
 * Free the per-context shader-related state.
 */
void
_mesa_free_shader_state(GLcontext *ctx)
{
   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentProgram, NULL);
}


/**
 * Copy string from <src> to <dst>, up to maxLength characters, returning
 * length of <dst> in <length>.
 * \param src  the strings source
 * \param maxLength  max chars to copy
 * \param length  returns number of chars copied
 * \param dst  the string destination
 */
static void
copy_string(GLchar *dst, GLsizei maxLength, GLsizei *length, const GLchar *src)
{
   GLsizei len;
   for (len = 0; len < maxLength - 1 && src && src[len]; len++)
      dst[len] = src[len];
   if (maxLength > 0)
      dst[len] = 0;
   if (length)
      *length = len;
}


static GLboolean
_mesa_is_program(GLcontext *ctx, GLuint name)
{
   struct gl_shader_program *shProg = _mesa_lookup_shader_program(ctx, name);
   return shProg ? GL_TRUE : GL_FALSE;
}


static GLboolean
_mesa_is_shader(GLcontext *ctx, GLuint name)
{
   struct gl_shader *shader = _mesa_lookup_shader(ctx, name);
   return shader ? GL_TRUE : GL_FALSE;
}


/**
 * Called via ctx->Driver.AttachShader()
 */
static void
_mesa_attach_shader(GLcontext *ctx, GLuint program, GLuint shader)
{
   struct gl_shader_program *shProg;
   struct gl_shader *sh;
   GLuint i, n;

   shProg = _mesa_lookup_shader_program_err(ctx, program, "glAttachShader");
   if (!shProg)
      return;

   sh = _mesa_lookup_shader_err(ctx, shader, "glAttachShader");
   if (!sh) {
      return;
   }

   n = shProg->NumShaders;
   for (i = 0; i < n; i++) {
      if (shProg->Shaders[i] == sh) {
         /* The shader is already attched to this program.  The
          * GL_ARB_shader_objects spec says:
          *
          *     "The error INVALID_OPERATION is generated by AttachObjectARB
          *     if <obj> is already attached to <containerObj>."
          */
         _mesa_error(ctx, GL_INVALID_OPERATION, "glAttachShader");
         return;
      }
   }

   /* grow list */
   shProg->Shaders = (struct gl_shader **)
      _mesa_realloc(shProg->Shaders,
                    n * sizeof(struct gl_shader *),
                    (n + 1) * sizeof(struct gl_shader *));
   if (!shProg->Shaders) {
      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glAttachShader");
      return;
   }

   /* append */
   shProg->Shaders[n] = NULL; /* since realloc() didn't zero the new space */
   _mesa_reference_shader(ctx, &shProg->Shaders[n], sh);
   shProg->NumShaders++;
}


static GLint
_mesa_get_attrib_location(GLcontext *ctx, GLuint program,
                          const GLchar *name)
{
   struct gl_shader_program *shProg
      = _mesa_lookup_shader_program_err(ctx, program, "glGetAttribLocation");

   if (!shProg) {
      return -1;
   }

   if (!shProg->LinkStatus) {
      _mesa_error(ctx, GL_INVALID_OPERATION,
                  "glGetAttribLocation(program not linked)");
      return -1;
   }

   if (!name)
      return -1;

   if (shProg->VertexProgram) {
      const struct gl_program_parameter_list *attribs =
         shProg->VertexProgram->Base.Attributes;
      if (attribs) {
         GLint i = _mesa_lookup_parameter_index(attribs, -1, name);
         if (i >= 0) {
            return attribs->Parameters[i].StateIndexes[0];
         }
      }
   }
   return -1;
}


static void
_mesa_bind_attrib_location(GLcontext *ctx, GLuint program, GLuint index,
                           const GLchar *name)
{
   struct gl_shader_program *shProg;
   const GLint size = -1; /* unknown size */
   GLint i, oldIndex;
   GLenum datatype = GL_FLOAT_VEC4;

   shProg = _mesa_lookup_shader_program_err(ctx, program,
                                            "glBindAttribLocation");
   if (!shProg) {
      return;
   }

   if (!name)
      return;

   if (strncmp(name, "gl_", 3) == 0) {
      _mesa_error(ctx, GL_INVALID_OPERATION,
                  "glBindAttribLocation(illegal name)");
      return;
   }

   if (index >= ctx->Const.VertexProgram.MaxAttribs) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glBindAttribLocation(index)");
      return;
   }

   if (shProg->LinkStatus) {
      /* get current index/location for the attribute */
      oldIndex = _mesa_get_attrib_location(ctx, program, name);
   }
   else {
      oldIndex = -1;
   }

   /* this will replace the current value if it's already in the list */
   i = _mesa_add_attribute(shProg->Attributes, name, size, datatype, index);
   if (i < 0) {
      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindAttribLocation");
      return;
   }

   /*
    * Note that this attribute binding won't go into effect until
    * glLinkProgram is called again.
    */
}


static GLuint
_mesa_create_shader(GLcontext *ctx, GLenum type)
{
   struct gl_shader *sh;
   GLuint name;

   name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);

   switch (type) {
   case GL_FRAGMENT_SHADER:
   case GL_VERTEX_SHADER:
      sh = _mesa_new_shader(ctx, name, type);
      break;
   default:
      _mesa_error(ctx, GL_INVALID_ENUM, "CreateShader(type)");
      return 0;
   }

   _mesa_HashInsert(ctx->Shared->ShaderObjects, name, sh);

   return name;
}


static GLuint 
_mesa_create_program(GLcontext *ctx)
{
   GLuint name;
   struct gl_shader_program *shProg;

   name = _mesa_HashFindFreeKeyBlock(ctx->Shared->ShaderObjects, 1);
   shProg = _mesa_new_shader_program(ctx, name);

   _mesa_HashInsert(ctx->Shared->ShaderObjects, name, shProg);

   assert(shProg->RefCount == 1);

   return name;
}


/**
 * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
 * DeleteProgramARB.
 */
static void
_mesa_delete_program2(GLcontext *ctx, GLuint name)
{
   /*
    * NOTE: deleting shaders/programs works a bit differently than
    * texture objects (and buffer objects, etc).  Shader/program
    * handles/IDs exist in the hash table until the object is really
    * deleted (refcount==0).  With texture objects, the handle/ID is
    * removed from the hash table in glDeleteTextures() while the tex
    * object itself might linger until its refcount goes to zero.
    */
   struct gl_shader_program *shProg;

   shProg = _mesa_lookup_shader_program_err(ctx, name, "glDeleteProgram");
   if (!shProg)
      return;

   shProg->DeletePending = GL_TRUE;

   /* effectively, decr shProg's refcount */
   _mesa_reference_shader_program(ctx, &shProg, NULL);
}


static void
_mesa_delete_shader(GLcontext *ctx, GLuint shader)
{
   struct gl_shader *sh;

   sh = _mesa_lookup_shader_err(ctx, shader, "glDeleteShader");
   if (!sh)
      return;

   sh->DeletePending = GL_TRUE;

   /* effectively, decr sh's refcount */
   _mesa_reference_shader(ctx, &sh, NULL);
}


static void
_mesa_detach_shader(GLcontext *ctx, GLuint program, GLuint shader)
{
   struct gl_shader_program *shProg;
   GLuint n;
   GLuint i, j;

   shProg = _mesa_lookup_shader_program_err(ctx, program, "glDetachShader");
   if (!shProg)
      return;

   n = shProg->NumShaders;

   for (i = 0; i < n; i++) {
      if (shProg->Shaders[i]->Name == shader) {
         /* found it */
         struct gl_shader **newList;

         /* release */
         _mesa_reference_shader(ctx, &shProg->Shaders[i], NULL);

         /* alloc new, smaller array */
         newList = (struct gl_shader **)
            _mesa_malloc((n - 1) * sizeof(struct gl_shader *));
         if (!newList) {
            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glDetachShader");
            return;
         }
         for (j = 0; j < i; j++) {
            newList[j] = shProg->Shaders[j];
         }
         while (++i < n)
            newList[j++] = shProg->Shaders[i];
         _mesa_free(shProg->Shaders);

         shProg->Shaders = newList;
         shProg->NumShaders = n - 1;

#ifdef DEBUG
         /* sanity check */
         {
            for (j = 0; j < shProg->NumShaders; j++) {
               assert(shProg->Shaders[j]->Type == GL_VERTEX_SHADER ||
                      shProg->Shaders[j]->Type == GL_FRAGMENT_SHADER);
               assert(shProg->Shaders[j]->RefCount > 0);
            }
         }
#endif

         return;
      }
   }

   /* not found */
   {
      GLenum err;
      if (_mesa_is_shader(ctx, shader))
         err = GL_INVALID_OPERATION;
      else if (_mesa_is_program(ctx, shader))
         err = GL_INVALID_OPERATION;
      else
         err = GL_INVALID_VALUE;
      _mesa_error(ctx, err, "glDetachProgram(shader)");
      return;
   }
}


static GLint
sizeof_glsl_type(GLenum type)
{
   switch (type) {
   case GL_FLOAT:
   case GL_INT:
   case GL_BOOL:
   case GL_SAMPLER_1D:
   case GL_SAMPLER_2D:
   case GL_SAMPLER_3D:
   case GL_SAMPLER_CUBE:
   case GL_SAMPLER_1D_SHADOW:
   case GL_SAMPLER_2D_SHADOW:
   case GL_SAMPLER_2D_RECT_ARB:
   case GL_SAMPLER_2D_RECT_SHADOW_ARB:
   case GL_SAMPLER_1D_ARRAY_SHADOW_EXT:
   case GL_SAMPLER_2D_ARRAY_SHADOW_EXT:
   case GL_SAMPLER_CUBE_SHADOW_EXT:
      return 1;
   case GL_FLOAT_VEC2:
   case GL_INT_VEC2:
   case GL_BOOL_VEC2:
      return 2;
   case GL_FLOAT_VEC3:
   case GL_INT_VEC3:
   case GL_BOOL_VEC3:
      return 3;
   case GL_FLOAT_VEC4:
   case GL_INT_VEC4:
   case GL_BOOL_VEC4:
      return 4;
   case GL_FLOAT_MAT2:
   case GL_FLOAT_MAT2x3:
   case GL_FLOAT_MAT2x4:
      return 8; /* two float[4] vectors */
   case GL_FLOAT_MAT3:
   case GL_FLOAT_MAT3x2:
   case GL_FLOAT_MAT3x4:
      return 12; /* three float[4] vectors */
   case GL_FLOAT_MAT4:
   case GL_FLOAT_MAT4x2:
   case GL_FLOAT_MAT4x3:
      return 16;  /* four float[4] vectors */
   default:
      _mesa_problem(NULL, "Invalid type in sizeof_glsl_type()");
      return 1;
   }
}


static GLboolean
is_boolean_type(GLenum type)
{
   switch (type) {
   case GL_BOOL:
   case GL_BOOL_VEC2:
   case GL_BOOL_VEC3:
   case GL_BOOL_VEC4:
      return GL_TRUE;
   default:
      return GL_FALSE;
   }
}


static GLboolean
is_integer_type(GLenum type)
{
   switch (type) {
   case GL_INT:
   case GL_INT_VEC2:
   case GL_INT_VEC3:
   case GL_INT_VEC4:
      return GL_TRUE;
   default:
      return GL_FALSE;
   }
}


static GLboolean
is_sampler_type(GLenum type)
{
   switch (type) {
   case GL_SAMPLER_1D:
   case GL_SAMPLER_2D:
   case GL_SAMPLER_3D:
   case GL_SAMPLER_CUBE:
   case GL_SAMPLER_1D_SHADOW:
   case GL_SAMPLER_2D_SHADOW:
   case GL_SAMPLER_2D_RECT_ARB:
   case GL_SAMPLER_2D_RECT_SHADOW_ARB:
   case GL_SAMPLER_1D_ARRAY_EXT:
   case GL_SAMPLER_2D_ARRAY_EXT:
      return GL_TRUE;
   default:
      return GL_FALSE;
   }
}


static void
_mesa_get_active_attrib(GLcontext *ctx, GLuint program, GLuint index,
                        GLsizei maxLength, GLsizei *length, GLint *size,
                        GLenum *type, GLchar *nameOut)
{
   const struct gl_program_parameter_list *attribs = NULL;
   struct gl_shader_program *shProg;

   shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveAttrib");
   if (!shProg)
      return;

   if (shProg->VertexProgram)
      attribs = shProg->VertexProgram->Base.Attributes;

   if (!attribs || index >= attribs->NumParameters) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveAttrib(index)");
      return;
   }

   copy_string(nameOut, maxLength, length, attribs->Parameters[index].Name);

   if (size)
      *size = attribs->Parameters[index].Size
         / sizeof_glsl_type(attribs->Parameters[index].DataType);

   if (type)
      *type = attribs->Parameters[index].DataType;
}


static struct gl_program_parameter *
get_uniform_parameter(const struct gl_shader_program *shProg, GLuint index)
{
   const struct gl_program *prog = NULL;
   GLint progPos;

   progPos = shProg->Uniforms->Uniforms[index].VertPos;
   if (progPos >= 0) {
      prog = &shProg->VertexProgram->Base;
   }
   else {
      progPos = shProg->Uniforms->Uniforms[index].FragPos;
      if (progPos >= 0) {
         prog = &shProg->FragmentProgram->Base;
      }
   }

   if (!prog || progPos < 0)
      return NULL; /* should never happen */

   return &prog->Parameters->Parameters[progPos];
}


/**
 * Called via ctx->Driver.GetActiveUniform().
 */
static void
_mesa_get_active_uniform(GLcontext *ctx, GLuint program, GLuint index,
                         GLsizei maxLength, GLsizei *length, GLint *size,
                         GLenum *type, GLchar *nameOut)
{
   const struct gl_shader_program *shProg;
   const struct gl_program *prog = NULL;
   const struct gl_program_parameter *param;
   GLint progPos;

   shProg = _mesa_lookup_shader_program_err(ctx, program, "glGetActiveUniform");
   if (!shProg)
      return;

   if (!shProg->Uniforms || index >= shProg->Uniforms->NumUniforms) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glGetActiveUniform(index)");
      return;
   }

   progPos = shProg->Uniforms->Uniforms[index].VertPos;
   if (progPos >= 0) {
      prog = &shProg->VertexProgram->Base;
   }
   else {
      progPos = shProg->Uniforms->Uniforms[index].FragPos;
      if (progPos >= 0) {
         prog = &shProg->FragmentProgram->Base;
      }
   }

   if (!prog || progPos < 0)
      return; /* should never happen */

   ASSERT(progPos < prog->Parameters->NumParameters);
   param = &prog->Parameters->Parameters[progPos];

   if (nameOut) {
      copy_string(nameOut, maxLength, length, param->Name);
   }

   if (size) {
      GLint typeSize = sizeof_glsl_type(param->DataType);
      if (param->Size > typeSize) {
         /* This is an array.
          * Array elements are placed on vector[4] boundaries so they're
          * a multiple of four floats.  We round typeSize up to next multiple
          * of four to get the right size below.
          */
         typeSize = (typeSize + 3) & ~3;
      }
      /* Note that the returned size is in units of the <type>, not bytes */
      *size = param->Size / typeSize;
   }

   if (type) {
      *type = param->DataType;
   }
}


/**
 * Called via ctx->Driver.GetAttachedShaders().
 */
static void
_mesa_get_attached_shaders(GLcontext *ctx, GLuint program, GLsizei maxCount,
                           GLsizei *count, GLuint *obj)
{
   struct gl_shader_program *shProg =
      _mesa_lookup_shader_program_err(ctx, program, "glGetAttachedShaders");
   if (shProg) {
      GLuint i;
      for (i = 0; i < (GLuint) maxCount && i < shProg->NumShaders; i++) {
         obj[i] = shProg->Shaders[i]->Name;
      }
      if (count)
         *count = i;
   }
}


static GLuint
_mesa_get_handle(GLcontext *ctx, GLenum pname)
{
   GLint handle = 0;
   
   if (pname == GL_PROGRAM_OBJECT_ARB) {
      CALL_GetIntegerv(ctx->Exec, (GL_CURRENT_PROGRAM, &handle));
   } else {
      _mesa_error(ctx, GL_INVALID_ENUM, "glGetHandleARB");
   }

   return handle;
}


static void
_mesa_get_programiv(GLcontext *ctx, GLuint program,
                    GLenum pname, GLint *params)
{
   const struct gl_program_parameter_list *attribs;
   struct gl_shader_program *shProg
      = _mesa_lookup_shader_program(ctx, program);

   if (!shProg) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramiv(program)");
      return;
   }

   if (shProg->VertexProgram)
      attribs = shProg->VertexProgram->Base.Attributes;
   else
      attribs = NULL;

   switch (pname) {
   case GL_DELETE_STATUS:
      *params = shProg->DeletePending;
      break; 
   case GL_LINK_STATUS:
      *params = shProg->LinkStatus;
      break;
   case GL_VALIDATE_STATUS:
      *params = shProg->Validated;
      break;
   case GL_INFO_LOG_LENGTH:
      *params = shProg->InfoLog ? strlen(shProg->InfoLog) + 1 : 0;
      break;
   case GL_ATTACHED_SHADERS:
      *params = shProg->NumShaders;
      break;
   case GL_ACTIVE_ATTRIBUTES:
      *params = attribs ? attribs->NumParameters : 0;
      break;
   case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
      *params = _mesa_longest_parameter_name(attribs, PROGRAM_INPUT) + 1;
      break;
   case GL_ACTIVE_UNIFORMS:
      *params = shProg->Uniforms ? shProg->Uniforms->NumUniforms : 0;
      break;
   case GL_ACTIVE_UNIFORM_MAX_LENGTH:
      *params = _mesa_longest_uniform_name(shProg->Uniforms);
      if (*params > 0)
         (*params)++;  /* add one for terminating zero */
      break;
   case GL_PROGRAM_BINARY_LENGTH_OES:
      *params = 0;
      break;
   default:
      _mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramiv(pname)");
      return;
   }
}


static void
_mesa_get_shaderiv(GLcontext *ctx, GLuint name, GLenum pname, GLint *params)
{
   struct gl_shader *shader = _mesa_lookup_shader_err(ctx, name, "glGetShaderiv");

   if (!shader) {
      return;
   }

   switch (pname) {
   case GL_SHADER_TYPE:
      *params = shader->Type;
      break;
   case GL_DELETE_STATUS:
      *params = shader->DeletePending;
      break;
   case GL_COMPILE_STATUS:
      *params = shader->CompileStatus;
      break;
   case GL_INFO_LOG_LENGTH:
      *params = shader->InfoLog ? strlen(shader->InfoLog) + 1 : 0;
      break;
   case GL_SHADER_SOURCE_LENGTH:
      *params = shader->Source ? strlen((char *) shader->Source) + 1 : 0;
      break;
   default:
      _mesa_error(ctx, GL_INVALID_ENUM, "glGetShaderiv(pname)");
      return;
   }
}


static void
_mesa_get_program_info_log(GLcontext *ctx, GLuint program, GLsizei bufSize,
                           GLsizei *length, GLchar *infoLog)
{
   struct gl_shader_program *shProg
      = _mesa_lookup_shader_program(ctx, program);
   if (!shProg) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glGetProgramInfoLog(program)");
      return;
   }
   copy_string(infoLog, bufSize, length, shProg->InfoLog);
}


static void
_mesa_get_shader_info_log(GLcontext *ctx, GLuint shader, GLsizei bufSize,
                          GLsizei *length, GLchar *infoLog)
{
   struct gl_shader *sh = _mesa_lookup_shader(ctx, shader);
   if (!sh) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glGetShaderInfoLog(shader)");
      return;
   }
   copy_string(infoLog, bufSize, length, sh->InfoLog);
}


/**
 * Called via ctx->Driver.GetShaderSource().
 */
static void
_mesa_get_shader_source(GLcontext *ctx, GLuint shader, GLsizei maxLength,
                        GLsizei *length, GLchar *sourceOut)
{
   struct gl_shader *sh;
   sh = _mesa_lookup_shader_err(ctx, shader, "glGetShaderSource");
   if (!sh) {
      return;
   }
   copy_string(sourceOut, maxLength, length, sh->Source);
}


static void
get_matrix_dims(GLenum type, GLint *rows, GLint *cols)
{
   switch (type) {
   case GL_FLOAT_MAT2:
      *rows = *cols = 2;
      break;
   case GL_FLOAT_MAT2x3:
      *rows = 3;
      *cols = 2;
      break;
   case GL_FLOAT_MAT2x4:
      *rows = 4;
      *cols = 2;
      break;
   case GL_FLOAT_MAT3:
      *rows = 3;
      *cols = 3;
      break;
   case GL_FLOAT_MAT3x2:
      *rows = 2;
      *cols = 3;
      break;
   case GL_FLOAT_MAT3x4:
      *rows = 4;
      *cols = 3;
      break;
   case GL_FLOAT_MAT4:
      *rows = 4;
      *cols = 4;
      break;
   case GL_FLOAT_MAT4x2:
      *rows = 2;
      *cols = 4;
      break;
   case GL_FLOAT_MAT4x3:
      *rows = 3;
      *cols = 4;
      break;
   default:
      *rows = *cols = 0;
   }
}


/**
 * Determine the number of rows and columns occupied by a uniform
 * according to its datatype.  For non-matrix types (such as GL_FLOAT_VEC4),
 * the number of rows = 1 and cols = number of elements in the vector.
 */
static void
get_uniform_rows_cols(const struct gl_program_parameter *p,
                      GLint *rows, GLint *cols)
{
   get_matrix_dims(p->DataType, rows, cols);
   if (*rows == 0 && *cols == 0) {
      /* not a matrix type, probably a float or vector */
      if (p->Size <= 4) {
         *rows = 1;
         *cols = p->Size;
      }
      else {
         *rows = p->Size / 4 + 1;
         if (p->Size % 4 == 0)
            *cols = 4;
         else
            *cols = p->Size % 4;
      }
   }
}


/**
 * Helper for get_uniform[fi]v() functions.
 * Given a shader program name and uniform location, return a pointer
 * to the shader program and return the program parameter position.
 */
static void
lookup_uniform_parameter(GLcontext *ctx, GLuint program, GLint location,
                         struct gl_program **progOut, GLint *paramPosOut)
{
   struct gl_shader_program *shProg
      = _mesa_lookup_shader_program_err(ctx, program, "glGetUniform[if]v");
   struct gl_program *prog = NULL;
   GLint progPos = -1;

   /* if shProg is NULL, we'll have already recorded an error */

   if (shProg) {
      if (!shProg->Uniforms ||
          location < 0 ||
          location >= (GLint) shProg->Uniforms->NumUniforms) {
         _mesa_error(ctx, GL_INVALID_OPERATION,  "glGetUniformfv(location)");
      }
      else {
         /* OK, find the gl_program and program parameter location */
         progPos = shProg->Uniforms->Uniforms[location].VertPos;
         if (progPos >= 0) {
            prog = &shProg->VertexProgram->Base;
         }
         else {
            progPos = shProg->Uniforms->Uniforms[location].FragPos;
            if (progPos >= 0) {
               prog = &shProg->FragmentProgram->Base;
            }
         }
      }
   }

   *progOut = prog;
   *paramPosOut = progPos;
}


/**
 * Called via ctx->Driver.GetUniformfv().
 */
static void
_mesa_get_uniformfv(GLcontext *ctx, GLuint program, GLint location,
                    GLfloat *params)
{
   struct gl_program *prog;
   GLint paramPos;

   lookup_uniform_parameter(ctx, program, location, &prog, &paramPos);

   if (prog) {
      const struct gl_program_parameter *p =
         &prog->Parameters->Parameters[paramPos];
      GLint rows, cols, i, j, k;

      get_uniform_rows_cols(p, &rows, &cols);

      k = 0;
      for (i = 0; i < rows; i++) {
         for (j = 0; j < cols; j++ ) {
            params[k++] = prog->Parameters->ParameterValues[paramPos+i][j];
         }
      }
   }
}


/**
 * Called via ctx->Driver.GetUniformiv().
 * \sa _mesa_get_uniformfv, only difference is a cast.
 */
static void
_mesa_get_uniformiv(GLcontext *ctx, GLuint program, GLint location,
                    GLint *params)
{
   struct gl_program *prog;
   GLint paramPos;

   lookup_uniform_parameter(ctx, program, location, &prog, &paramPos);

   if (prog) {
      const struct gl_program_parameter *p =
         &prog->Parameters->Parameters[paramPos];
      GLint rows, cols, i, j, k;

      get_uniform_rows_cols(p, &rows, &cols);

      k = 0;
      for (i = 0; i < rows; i++) {
         for (j = 0; j < cols; j++ ) {
            params[k++] = (GLint) prog->Parameters->ParameterValues[paramPos+i][j];
         }
      }
   }
}


/**
 * The value returned by GetUniformLocation actually encodes two things:
 * 1. the index into the prog->Uniforms[] array for the uniform
 * 2. an offset in the prog->ParameterValues[] array for specifying array
 *    elements or structure fields.
 * This function merges those two values.
 */
static void
merge_location_offset(GLint *location, GLint offset)
{
   *location = *location | (offset << 16);
}


/**
 * Seperate the uniform location and parameter offset.  See above.
 */
static void
split_location_offset(GLint *location, GLint *offset)
{
   *offset = (*location >> 16);
   *location = *location & 0xffff;
}


/**
 * Called via ctx->Driver.GetUniformLocation().
 *
 * The return value will encode two values, the uniform location and an
 * offset (used for arrays, structs).
 */
static GLint
_mesa_get_uniform_location(GLcontext *ctx, GLuint program, const GLchar *name)
{
   GLint offset = 0, location = -1;

   struct gl_shader_program *shProg =
      _mesa_lookup_shader_program_err(ctx, program, "glGetUniformLocation");

   if (!shProg)
      return -1;

   if (shProg->LinkStatus == GL_FALSE) {
      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetUniformfv(program)");
      return -1;
   }

   /* XXX we should return -1 if the uniform was declared, but not
    * actually used.
    */

   /* XXX we need to be able to parse uniform names for structs and arrays
    * such as:
    *   mymatrix[1]
    *   mystruct.field1
    */

   {
      /* handle 1-dimension arrays here... */
      char *c = strchr(name, '[');
      if (c) {
         /* truncate name at [ */
         const GLint len = c - name;
         GLchar *newName = _mesa_malloc(len + 1);
         if (!newName)
            return -1; /* out of mem */
         _mesa_memcpy(newName, name, len);
         newName[len] = 0;

         location = _mesa_lookup_uniform(shProg->Uniforms, newName);
         if (location >= 0) {
            const GLint element = _mesa_atoi(c + 1);
            if (element > 0) {
               /* get type of the uniform array element */
               struct gl_program_parameter *p;
               p = get_uniform_parameter(shProg, location);
               if (p) {
                  GLint rows, cols;
                  get_matrix_dims(p->DataType, &rows, &cols);
                  if (rows < 1)
                     rows = 1;
                  offset = element * rows;
               }
            }
         }

         _mesa_free(newName);
      }
   }

   if (location < 0) {
      location = _mesa_lookup_uniform(shProg->Uniforms, name);
   }

   if (location >= 0) {
      merge_location_offset(&location, offset);
   }

   return location;
}



/**
 * Called via ctx->Driver.ShaderSource()
 */
static void
_mesa_shader_source(GLcontext *ctx, GLuint shader, const GLchar *source)
{
   struct gl_shader *sh;

   sh = _mesa_lookup_shader_err(ctx, shader, "glShaderSource");
   if (!sh)
      return;

   /* free old shader source string and install new one */
   if (sh->Source) {
      _mesa_free((void *) sh->Source);
   }
   sh->Source = source;
   sh->CompileStatus = GL_FALSE;
#ifdef DEBUG
   sh->SourceChecksum = _mesa_str_checksum(sh->Source);
#endif
}


/**
 * Called via ctx->Driver.CompileShader()
 */
static void
_mesa_compile_shader(GLcontext *ctx, GLuint shaderObj)
{
   struct gl_shader *sh;

   sh = _mesa_lookup_shader_err(ctx, shaderObj, "glCompileShader");
   if (!sh)
      return;

   /* set default pragma state for shader */
   sh->Pragmas = ctx->Shader.DefaultPragmas;

   /* this call will set the sh->CompileStatus field to indicate if
    * compilation was successful.
    */
   (void) _slang_compile(ctx, sh);
}


/**
 * Called via ctx->Driver.LinkProgram()
 */
static void
_mesa_link_program(GLcontext *ctx, GLuint program)
{
   struct gl_shader_program *shProg;

   shProg = _mesa_lookup_shader_program_err(ctx, program, "glLinkProgram");
   if (!shProg)
      return;

   FLUSH_VERTICES(ctx, _NEW_PROGRAM);

   _slang_link(ctx, program, shProg);

   /* debug code */
   if (0) {
      GLuint i;

      _mesa_printf("Link %u shaders in program %u: %s\n",
                   shProg->NumShaders, shProg->Name,
                   shProg->LinkStatus ? "Success" : "Failed");

      for (i = 0; i < shProg->NumShaders; i++) {
         _mesa_printf(" shader %u, type 0x%x\n",
                      shProg->Shaders[i]->Name,
                      shProg->Shaders[i]->Type);
      }
   }
}


/**
 * Called via ctx->Driver.UseProgram()
 */
void
_mesa_use_program(GLcontext *ctx, GLuint program)
{
   struct gl_shader_program *shProg;

   if (ctx->Shader.CurrentProgram &&
       ctx->Shader.CurrentProgram->Name == program) {
      /* no-op */
      return;
   }

   FLUSH_VERTICES(ctx, _NEW_PROGRAM | _NEW_PROGRAM_CONSTANTS);

   if (program) {
      shProg = _mesa_lookup_shader_program_err(ctx, program, "glUseProgram");
      if (!shProg) {
         return;
      }
      if (!shProg->LinkStatus) {
         _mesa_error(ctx, GL_INVALID_OPERATION,
                     "glUseProgram(program %u not linked)", program);
         return;
      }

      /* debug code */
      if (0) {
         GLuint i;
         _mesa_printf("Use Shader %u\n", shProg->Name);
         for (i = 0; i < shProg->NumShaders; i++) {
            _mesa_printf(" shader %u, type 0x%x, checksum %u\n",
                         shProg->Shaders[i]->Name,
                         shProg->Shaders[i]->Type,
                         shProg->Shaders[i]->SourceChecksum);
         }
         if (shProg->VertexProgram)
            printf(" vert prog %u\n", shProg->VertexProgram->Base.Id);
         if (shProg->FragmentProgram)
            printf(" frag prog %u\n", shProg->FragmentProgram->Base.Id);
      }
   }
   else {
      shProg = NULL;
   }

   _mesa_reference_shader_program(ctx, &ctx->Shader.CurrentProgram, shProg);
}



/**
 * Update the vertex/fragment program's TexturesUsed array.
 *
 * This needs to be called after glUniform(set sampler var) is called.
 * A call to glUniform(samplerVar, value) causes a sampler to point to a
 * particular texture unit.  We know the sampler's texture target
 * (1D/2D/3D/etc) from compile time but the sampler's texture unit is
 * set by glUniform() calls.
 *
 * So, scan the program->SamplerUnits[] and program->SamplerTargets[]
 * information to update the prog->TexturesUsed[] values.
 * Each value of TexturesUsed[unit] is one of zero, TEXTURE_1D_INDEX,
 * TEXTURE_2D_INDEX, TEXTURE_3D_INDEX, etc.
 * We'll use that info for state validation before rendering.
 */
void
_mesa_update_shader_textures_used(struct gl_program *prog)
{
   GLuint s;

   memset(prog->TexturesUsed, 0, sizeof(prog->TexturesUsed));

   for (s = 0; s < MAX_SAMPLERS; s++) {
      if (prog->SamplersUsed & (1 << s)) {
         GLuint unit = prog->SamplerUnits[s];
         GLuint tgt = prog->SamplerTargets[s];
         assert(unit < MAX_TEXTURE_IMAGE_UNITS);
         assert(tgt < NUM_TEXTURE_TARGETS);
         prog->TexturesUsed[unit] |= (1 << tgt);
      }
   }
}


/**
 * Check if the type given by userType is allowed to set a uniform of the
 * target type.  Generally, equivalence is required, but setting Boolean
 * uniforms can be done with glUniformiv or glUniformfv.
 */
static GLboolean
compatible_types(GLenum userType, GLenum targetType)
{
   if (userType == targetType)
      return GL_TRUE;

   if (targetType == GL_BOOL && (userType == GL_FLOAT || userType == GL_INT))
      return GL_TRUE;

   if (targetType == GL_BOOL_VEC2 && (userType == GL_FLOAT_VEC2 ||
                                      userType == GL_INT_VEC2))
      return GL_TRUE;

   if (targetType == GL_BOOL_VEC3 && (userType == GL_FLOAT_VEC3 ||
                                      userType == GL_INT_VEC3))
      return GL_TRUE;

   if (targetType == GL_BOOL_VEC4 && (userType == GL_FLOAT_VEC4 ||
                                      userType == GL_INT_VEC4))
      return GL_TRUE;

   if (is_sampler_type(targetType) && userType == GL_INT)
      return GL_TRUE;

   return GL_FALSE;
}


/**
 * Set the value of a program's uniform variable.
 * \param program  the program whose uniform to update
 * \param index  the index of the program parameter for the uniform
 * \param offset  additional parameter slot offset (for arrays)
 * \param type  the incoming datatype of 'values'
 * \param count  the number of uniforms to set
 * \param elems  number of elements per uniform (1, 2, 3 or 4)
 * \param values  the new values, of datatype 'type'
 */
static void
set_program_uniform(GLcontext *ctx, struct gl_program *program,
                    GLint index, GLint offset,
                    GLenum type, GLsizei count, GLint elems,
                    const void *values)
{
   const struct gl_program_parameter *param =
      &program->Parameters->Parameters[index];

   assert(offset >= 0);
   assert(elems >= 1);
   assert(elems <= 4);

   if (!compatible_types(type, param->DataType)) {
      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(type mismatch)");
      return;
   }

   if (index + offset > (GLint) program->Parameters->Size) {
      /* out of bounds! */
      return;
   }

   if (param->Type == PROGRAM_SAMPLER) {
      /* This controls which texture unit which is used by a sampler */
      GLboolean changed = GL_FALSE;
      GLint i;

      /* this should have been caught by the compatible_types() check */
      ASSERT(type == GL_INT);

      /* loop over number of samplers to change */
      for (i = 0; i < count; i++) {
         GLuint sampler =
            (GLuint) program->Parameters->ParameterValues[index + offset + i][0];
         GLuint texUnit = ((GLuint *) values)[i];

         /* check that the sampler (tex unit index) is legal */
         if (texUnit >= ctx->Const.MaxTextureImageUnits) {
            _mesa_error(ctx, GL_INVALID_VALUE,
                        "glUniform1(invalid sampler/tex unit index)");
            return;
         }

         /* This maps a sampler to a texture unit: */
         if (sampler < MAX_SAMPLERS) {
#if 0
            _mesa_printf("Set program %p sampler %d '%s' to unit %u\n",
                         program, sampler, param->Name, texUnit);
#endif
            if (program->SamplerUnits[sampler] != texUnit) {
               program->SamplerUnits[sampler] = texUnit;
               changed = GL_TRUE;
            }
         }
      }

      if (changed) {
         /* When a sampler's value changes it usually requires rewriting
          * a GPU program's TEX instructions since there may not be a
          * sampler->texture lookup table.  We signal this with the
          * ProgramStringNotify() callback.
          */
         FLUSH_VERTICES(ctx, _NEW_TEXTURE | _NEW_PROGRAM);
         _mesa_update_shader_textures_used(program);
         ctx->Driver.ProgramStringNotify(ctx, program->Target, program);
      }
   }
   else {
      /* ordinary uniform variable */
      const GLboolean isUniformBool = is_boolean_type(param->DataType);
      const GLboolean areIntValues = is_integer_type(type);
      const GLint slots = (param->Size + 3) / 4;
      const GLint typeSize = sizeof_glsl_type(param->DataType);
      GLsizei k, i;

      if (param->Size > typeSize) {
         /* an array */
         /* we'll ignore extra data below */
      }
      else {
         /* non-array: count must be one */
         if (count != 1) {
            _mesa_error(ctx, GL_INVALID_OPERATION,
                        "glUniform(uniform is not an array)");
            return;
         }
      }

      /* loop over number of array elements */
      for (k = 0; k < count; k++) {
         GLfloat *uniformVal;

         if (offset + k >= slots) {
            /* Extra array data is ignored */
            break;
         }

         /* uniformVal (the destination) is always float[4] */
         uniformVal = program->Parameters->ParameterValues[index + offset + k];

         if (areIntValues) {
            /* convert user's ints to floats */
            const GLint *iValues = ((const GLint *) values) + k * elems;
            for (i = 0; i < elems; i++) {
               uniformVal[i] = (GLfloat) iValues[i];
            }
         }
         else {
            const GLfloat *fValues = ((const GLfloat *) values) + k * elems;
            for (i = 0; i < elems; i++) {
               uniformVal[i] = fValues[i];
            }
         }

         /* if the uniform is bool-valued, convert to 1.0 or 0.0 */
         if (isUniformBool) {
            for (i = 0; i < elems; i++) {
               uniformVal[i] = uniformVal[i] ? 1.0f : 0.0f;
            }
         }
      }
   }
}


/**
 * Called via ctx->Driver.Uniform().
 */
static void
_mesa_uniform(GLcontext *ctx, GLint location, GLsizei count,
              const GLvoid *values, GLenum type)
{
   struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
   struct gl_uniform *uniform;
   GLint elems, offset;
   GLenum basicType;

   if (!shProg || !shProg->LinkStatus) {
      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(program not linked)");
      return;
   }

   if (location == -1)
      return;   /* The standard specifies this as a no-op */

   if (location < -1) {
      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniform(location)");
      return;
   }

   split_location_offset(&location, &offset);

   if (location < 0 || location >= (GLint) shProg->Uniforms->NumUniforms) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(location)");
      return;
   }

   if (count < 0) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glUniform(count < 0)");
      return;
   }

   switch (type) {
   case GL_FLOAT:
      basicType = GL_FLOAT;
      elems = 1;
      break;
   case GL_INT:
      basicType = GL_INT;
      elems = 1;
      break;
   case GL_FLOAT_VEC2:
      basicType = GL_FLOAT;
      elems = 2;
      break;
   case GL_INT_VEC2:
      basicType = GL_INT;
      elems = 2;
      break;
   case GL_FLOAT_VEC3:
      basicType = GL_FLOAT;
      elems = 3;
      break;
   case GL_INT_VEC3:
      basicType = GL_INT;
      elems = 3;
      break;
   case GL_FLOAT_VEC4:
      basicType = GL_FLOAT;
      elems = 4;
      break;
   case GL_INT_VEC4:
      basicType = GL_INT;
      elems = 4;
      break;
   default:
      _mesa_problem(ctx, "Invalid type in _mesa_uniform");
      return;
   }

   FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);

   uniform = &shProg->Uniforms->Uniforms[location];

   if (ctx->Shader.Flags & GLSL_UNIFORMS) {
      GLint i;
      _mesa_printf("Mesa: set program %u uniform %s (loc %d) to: ",
                   shProg->Name, uniform->Name, location);
      if (basicType == GL_INT) {
         const GLint *v = (const GLint *) values;
         for (i = 0; i < count * elems; i++) {
            _mesa_printf("%d ", v[i]);
         }
      }
      else {
         const GLfloat *v = (const GLfloat *) values;
         for (i = 0; i < count * elems; i++) {
            _mesa_printf("%g ", v[i]);
         }
      }
      _mesa_printf("\n");
   }

   /* A uniform var may be used by both a vertex shader and a fragment
    * shader.  We may need to update one or both shader's uniform here:
    */
   if (shProg->VertexProgram) {
      /* convert uniform location to program parameter index */
      GLint index = uniform->VertPos;
      if (index >= 0) {
         set_program_uniform(ctx, &shProg->VertexProgram->Base,
                             index, offset, type, count, elems, values);
      }
   }

   if (shProg->FragmentProgram) {
      /* convert uniform location to program parameter index */
      GLint index = uniform->FragPos;
      if (index >= 0) {
         set_program_uniform(ctx, &shProg->FragmentProgram->Base,
                             index, offset, type, count, elems, values);
      }
   }

   uniform->Initialized = GL_TRUE;
}


/**
 * Set a matrix-valued program parameter.
 */
static void
set_program_uniform_matrix(GLcontext *ctx, struct gl_program *program,
                           GLuint index, GLuint offset,
                           GLuint count, GLuint rows, GLuint cols,
                           GLboolean transpose, const GLfloat *values)
{
   GLuint mat, row, col;
   GLuint dst = index + offset, src = 0;
   GLint nr, nc;

   /* check that the number of rows, columns is correct */
   get_matrix_dims(program->Parameters->Parameters[index].DataType, &nr, &nc);
   if (rows != nr || cols != nc) {
      _mesa_error(ctx, GL_INVALID_OPERATION,
                  "glUniformMatrix(matrix size mismatch)");
      return;
   }

   if (index + offset > program->Parameters->Size) {
      /* out of bounds! */
      return;
   }

   /*
    * Note: the _columns_ of a matrix are stored in program registers, not
    * the rows.  So, the loops below look a little funny.
    * XXX could optimize this a bit...
    */

   /* loop over matrices */
   for (mat = 0; mat < count; mat++) {

      /* each matrix: */
      for (col = 0; col < cols; col++) {
         GLfloat *v = program->Parameters->ParameterValues[dst];
         for (row = 0; row < rows; row++) {
            if (transpose) {
               v[row] = values[src + row * cols + col];
            }
            else {
               v[row] = values[src + col * rows + row];
            }
         }
         dst++;
      }

      src += rows * cols;  /* next matrix */
   }
}


/**
 * Called by ctx->Driver.UniformMatrix().
 * Note: cols=2, rows=4  ==>  array[2] of vec4
 */
static void
_mesa_uniform_matrix(GLcontext *ctx, GLint cols, GLint rows,
                     GLint location, GLsizei count,
                     GLboolean transpose, const GLfloat *values)
{
   struct gl_shader_program *shProg = ctx->Shader.CurrentProgram;
   struct gl_uniform *uniform;
   GLint offset;

   if (!shProg || !shProg->LinkStatus) {
      _mesa_error(ctx, GL_INVALID_OPERATION,
         "glUniformMatrix(program not linked)");
      return;
   }

   if (location == -1)
      return;   /* The standard specifies this as a no-op */

   if (location < -1) {
      _mesa_error(ctx, GL_INVALID_OPERATION, "glUniformMatrix(location)");
      return;
   }

   split_location_offset(&location, &offset);

   if (location < 0 || location >= (GLint) shProg->Uniforms->NumUniforms) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glUniformMatrix(location)");
      return;
   }
   if (values == NULL) {
      _mesa_error(ctx, GL_INVALID_VALUE, "glUniformMatrix");
      return;
   }

   FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);

   uniform = &shProg->Uniforms->Uniforms[location];

   if (shProg->VertexProgram) {
      /* convert uniform location to program parameter index */
      GLint index = uniform->VertPos;
      if (index >= 0) {
         set_program_uniform_matrix(ctx, &shProg->VertexProgram->Base,
                                    index, offset,
                                    count, rows, cols, transpose, values);
      }
   }

   if (shProg->FragmentProgram) {
      /* convert uniform location to program parameter index */
      GLint index = uniform->FragPos;
      if (index >= 0) {
         set_program_uniform_matrix(ctx, &shProg->FragmentProgram->Base,
                                    index, offset,
                                    count, rows, cols, transpose, values);
      }
   }

   uniform->Initialized = GL_TRUE;
}


/**
 * Validate a program's samplers.
 * Specifically, check that there aren't two samplers of different types
 * pointing to the same texture unit.
 * \return GL_TRUE if valid, GL_FALSE if invalid
 */
static GLboolean
validate_samplers(GLcontext *ctx, const struct gl_program *prog, char *errMsg)
{
   static const char *targetName[] = {
      "TEXTURE_2D_ARRAY",
      "TEXTURE_1D_ARRAY",
      "TEXTURE_CUBE",
      "TEXTURE_3D",
      "TEXTURE_RECT",
      "TEXTURE_2D",
      "TEXTURE_1D",
   };
   GLint targetUsed[MAX_TEXTURE_IMAGE_UNITS];
   GLbitfield samplersUsed = prog->SamplersUsed;
   GLuint i;

   assert(Elements(targetName) == NUM_TEXTURE_TARGETS);

   if (samplersUsed == 0x0)
      return GL_TRUE;

   for (i = 0; i < Elements(targetUsed); i++)
      targetUsed[i] = -1;

   /* walk over bits which are set in 'samplers' */
   while (samplersUsed) {
      GLuint unit;
      gl_texture_index target;
      GLint sampler = _mesa_ffs(samplersUsed) - 1;
      assert(sampler >= 0);
      assert(sampler < MAX_TEXTURE_IMAGE_UNITS);
      unit = prog->SamplerUnits[sampler];
      target = prog->SamplerTargets[sampler];
      if (targetUsed[unit] != -1 && targetUsed[unit] != target) {
         _mesa_snprintf(errMsg, 100,
                       "Texture unit %d is accessed both as %s and %s",
                       unit, targetName[targetUsed[unit]], targetName[target]);
         return GL_FALSE;
      }
      targetUsed[unit] = target;
      samplersUsed ^= (1 << sampler);
   }

   return GL_TRUE;
}


/**
 * Do validation of the given shader program.
 * \param errMsg  returns error message if validation fails.
 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
 */
GLboolean
_mesa_validate_shader_program(GLcontext *ctx,
                              const struct gl_shader_program *shProg,
                              char *errMsg)
{
   const struct gl_vertex_program *vp = shProg->VertexProgram;
   const struct gl_fragment_program *fp = shProg->FragmentProgram;

   if (!shProg->LinkStatus) {
      return GL_FALSE;
   }

   /* From the GL spec, a program is invalid if any of these are true:

     any two active samplers in the current program object are of
     different types, but refer to the same texture image unit,

     any active sampler in the current program object refers to a texture
     image unit where fixed-function fragment processing accesses a
     texture target that does not match the sampler type, or 

     the sum of the number of active samplers in the program and the
     number of texture image units enabled for fixed-function fragment
     processing exceeds the combined limit on the total number of texture
     image units allowed.
   */


   /*
    * Check: any two active samplers in the current program object are of
    * different types, but refer to the same texture image unit,
    */
   if (vp && !validate_samplers(ctx, &vp->Base, errMsg)) {
      return GL_FALSE;
   }
   if (fp && !validate_samplers(ctx, &fp->Base, errMsg)) {
      return GL_FALSE;
   }

   return GL_TRUE;
}


/**
 * Called via glValidateProgram()
 */
static void
_mesa_validate_program(GLcontext *ctx, GLuint program)
{
   struct gl_shader_program *shProg;
   char errMsg[100];

   shProg = _mesa_lookup_shader_program_err(ctx, program, "glValidateProgram");
   if (!shProg) {
      return;
   }

   shProg->Validated = _mesa_validate_shader_program(ctx, shProg, errMsg);
   if (!shProg->Validated) {
      /* update info log */
      if (shProg->InfoLog) {
         _mesa_free(shProg->InfoLog);
      }
      shProg->InfoLog = _mesa_strdup(errMsg);
   }
}


/**
 * Plug in Mesa's GLSL functions into the device driver function table.
 */
void
_mesa_init_glsl_driver_functions(struct dd_function_table *driver)
{
   driver->AttachShader = _mesa_attach_shader;
   driver->BindAttribLocation = _mesa_bind_attrib_location;
   driver->CompileShader = _mesa_compile_shader;
   driver->CreateProgram = _mesa_create_program;
   driver->CreateShader = _mesa_create_shader;
   driver->DeleteProgram2 = _mesa_delete_program2;
   driver->DeleteShader = _mesa_delete_shader;
   driver->DetachShader = _mesa_detach_shader;
   driver->GetActiveAttrib = _mesa_get_active_attrib;
   driver->GetActiveUniform = _mesa_get_active_uniform;
   driver->GetAttachedShaders = _mesa_get_attached_shaders;
   driver->GetAttribLocation = _mesa_get_attrib_location;
   driver->GetHandle = _mesa_get_handle;
   driver->GetProgramiv = _mesa_get_programiv;
   driver->GetProgramInfoLog = _mesa_get_program_info_log;
   driver->GetShaderiv = _mesa_get_shaderiv;
   driver->GetShaderInfoLog = _mesa_get_shader_info_log;
   driver->GetShaderSource = _mesa_get_shader_source;
   driver->GetUniformfv = _mesa_get_uniformfv;
   driver->GetUniformiv = _mesa_get_uniformiv;
   driver->GetUniformLocation = _mesa_get_uniform_location;
   driver->IsProgram = _mesa_is_program;
   driver->IsShader = _mesa_is_shader;
   driver->LinkProgram = _mesa_link_program;
   driver->ShaderSource = _mesa_shader_source;
   driver->Uniform = _mesa_uniform;
   driver->UniformMatrix = _mesa_uniform_matrix;
   driver->UseProgram = _mesa_use_program;
   driver->ValidateProgram = _mesa_validate_program;
}
a id='n1558' href='#n1558'>1558</a>
<a id='n1559' href='#n1559'>1559</a>
<a id='n1560' href='#n1560'>1560</a>
<a id='n1561' href='#n1561'>1561</a>
<a id='n1562' href='#n1562'>1562</a>
<a id='n1563' href='#n1563'>1563</a>
<a id='n1564' href='#n1564'>1564</a>
<a id='n1565' href='#n1565'>1565</a>
<a id='n1566' href='#n1566'>1566</a>
<a id='n1567' href='#n1567'>1567</a>
<a id='n1568' href='#n1568'>1568</a>
<a id='n1569' href='#n1569'>1569</a>
<a id='n1570' href='#n1570'>1570</a>
<a id='n1571' href='#n1571'>1571</a>
<a id='n1572' href='#n1572'>1572</a>
<a id='n1573' href='#n1573'>1573</a>
<a id='n1574' href='#n1574'>1574</a>
<a id='n1575' href='#n1575'>1575</a>
<a id='n1576' href='#n1576'>1576</a>
<a id='n1577' href='#n1577'>1577</a>
<a id='n1578' href='#n1578'>1578</a>
<a id='n1579' href='#n1579'>1579</a>
<a id='n1580' href='#n1580'>1580</a>
<a id='n1581' href='#n1581'>1581</a>
<a id='n1582' href='#n1582'>1582</a>
<a id='n1583' href='#n1583'>1583</a>
<a id='n1584' href='#n1584'>1584</a>
<a id='n1585' href='#n1585'>1585</a>
<a id='n1586' href='#n1586'>1586</a>
<a id='n1587' href='#n1587'>1587</a>
<a id='n1588' href='#n1588'>1588</a>
<a id='n1589' href='#n1589'>1589</a>
<a id='n1590' href='#n1590'>1590</a>
<a id='n1591' href='#n1591'>1591</a>
<a id='n1592' href='#n1592'>1592</a>
<a id='n1593' href='#n1593'>1593</a>
<a id='n1594' href='#n1594'>1594</a>
<a id='n1595' href='#n1595'>1595</a>
<a id='n1596' href='#n1596'>1596</a>
<a id='n1597' href='#n1597'>1597</a>
<a id='n1598' href='#n1598'>1598</a>
<a id='n1599' href='#n1599'>1599</a>
<a id='n1600' href='#n1600'>1600</a>
<a id='n1601' href='#n1601'>1601</a>
<a id='n1602' href='#n1602'>1602</a>
<a id='n1603' href='#n1603'>1603</a>
<a id='n1604' href='#n1604'>1604</a>
<a id='n1605' href='#n1605'>1605</a>
<a id='n1606' href='#n1606'>1606</a>
<a id='n1607' href='#n1607'>1607</a>
<a id='n1608' href='#n1608'>1608</a>
<a id='n1609' href='#n1609'>1609</a>
<a id='n1610' href='#n1610'>1610</a>
<a id='n1611' href='#n1611'>1611</a>
<a id='n1612' href='#n1612'>1612</a>
<a id='n1613' href='#n1613'>1613</a>
<a id='n1614' href='#n1614'>1614</a>
<a id='n1615' href='#n1615'>1615</a>
<a id='n1616' href='#n1616'>1616</a>
<a id='n1617' href='#n1617'>1617</a>
<a id='n1618' href='#n1618'>1618</a>
<a id='n1619' href='#n1619'>1619</a>
<a id='n1620' href='#n1620'>1620</a>
<a id='n1621' href='#n1621'>1621</a>
<a id='n1622' href='#n1622'>1622</a>
<a id='n1623' href='#n1623'>1623</a>
<a id='n1624' href='#n1624'>1624</a>
<a id='n1625' href='#n1625'>1625</a>
<a id='n1626' href='#n1626'>1626</a>
<a id='n1627' href='#n1627'>1627</a>
<a id='n1628' href='#n1628'>1628</a>
<a id='n1629' href='#n1629'>1629</a>
<a id='n1630' href='#n1630'>1630</a>
<a id='n1631' href='#n1631'>1631</a>
<a id='n1632' href='#n1632'>1632</a>
<a id='n1633' href='#n1633'>1633</a>
<a id='n1634' href='#n1634'>1634</a>
<a id='n1635' href='#n1635'>1635</a>
<a id='n1636' href='#n1636'>1636</a>
<a id='n1637' href='#n1637'>1637</a>
<a id='n1638' href='#n1638'>1638</a>
<a id='n1639' href='#n1639'>1639</a>
<a id='n1640' href='#n1640'>1640</a>
<a id='n1641' href='#n1641'>1641</a>
<a id='n1642' href='#n1642'>1642</a>
<a id='n1643' href='#n1643'>1643</a>
<a id='n1644' href='#n1644'>1644</a>
<a id='n1645' href='#n1645'>1645</a>
<a id='n1646' href='#n1646'>1646</a>
<a id='n1647' href='#n1647'>1647</a>
<a id='n1648' href='#n1648'>1648</a>
<a id='n1649' href='#n1649'>1649</a>
<a id='n1650' href='#n1650'>1650</a>
<a id='n1651' href='#n1651'>1651</a>
<a id='n1652' href='#n1652'>1652</a>
<a id='n1653' href='#n1653'>1653</a>
<a id='n1654' href='#n1654'>1654</a>
<a id='n1655' href='#n1655'>1655</a>
<a id='n1656' href='#n1656'>1656</a>
<a id='n1657' href='#n1657'>1657</a>
<a id='n1658' href='#n1658'>1658</a>
<a id='n1659' href='#n1659'>1659</a>
<a id='n1660' href='#n1660'>1660</a>
<a id='n1661' href='#n1661'>1661</a>
<a id='n1662' href='#n1662'>1662</a>
<a id='n1663' href='#n1663'>1663</a>
<a id='n1664' href='#n1664'>1664</a>
<a id='n1665' href='#n1665'>1665</a>
<a id='n1666' href='#n1666'>1666</a>
<a id='n1667' href='#n1667'>1667</a>
<a id='n1668' href='#n1668'>1668</a>
<a id='n1669' href='#n1669'>1669</a>
<a id='n1670' href='#n1670'>1670</a>
<a id='n1671' href='#n1671'>1671</a>
<a id='n1672' href='#n1672'>1672</a>
<a id='n1673' href='#n1673'>1673</a>
<a id='n1674' href='#n1674'>1674</a>
<a id='n1675' href='#n1675'>1675</a>
<a id='n1676' href='#n1676'>1676</a>
<a id='n1677' href='#n1677'>1677</a>
<a id='n1678' href='#n1678'>1678</a>
<a id='n1679' href='#n1679'>1679</a>
<a id='n1680' href='#n1680'>1680</a>
<a id='n1681' href='#n1681'>1681</a>
<a id='n1682' href='#n1682'>1682</a>
<a id='n1683' href='#n1683'>1683</a>
<a id='n1684' href='#n1684'>1684</a>
<a id='n1685' href='#n1685'>1685</a>
<a id='n1686' href='#n1686'>1686</a>
<a id='n1687' href='#n1687'>1687</a>
<a id='n1688' href='#n1688'>1688</a>
<a id='n1689' href='#n1689'>1689</a>
<a id='n1690' href='#n1690'>1690</a>
<a id='n1691' href='#n1691'>1691</a>
<a id='n1692' href='#n1692'>1692</a>
<a id='n1693' href='#n1693'>1693</a>
<a id='n1694' href='#n1694'>1694</a>
<a id='n1695' href='#n1695'>1695</a>
<a id='n1696' href='#n1696'>1696</a>
<a id='n1697' href='#n1697'>1697</a>
<a id='n1698' href='#n1698'>1698</a>
<a id='n1699' href='#n1699'>1699</a>
<a id='n1700' href='#n1700'>1700</a>
<a id='n1701' href='#n1701'>1701</a>
<a id='n1702' href='#n1702'>1702</a>
<a id='n1703' href='#n1703'>1703</a>
<a id='n1704' href='#n1704'>1704</a>
<a id='n1705' href='#n1705'>1705</a>
<a id='n1706' href='#n1706'>1706</a>
<a id='n1707' href='#n1707'>1707</a>
<a id='n1708' href='#n1708'>1708</a>
<a id='n1709' href='#n1709'>1709</a>
<a id='n1710' href='#n1710'>1710</a>
<a id='n1711' href='#n1711'>1711</a>
<a id='n1712' href='#n1712'>1712</a>
<a id='n1713' href='#n1713'>1713</a>
<a id='n1714' href='#n1714'>1714</a>
<a id='n1715' href='#n1715'>1715</a>
<a id='n1716' href='#n1716'>1716</a>
<a id='n1717' href='#n1717'>1717</a>
<a id='n1718' href='#n1718'>1718</a>
<a id='n1719' href='#n1719'>1719</a>
<a id='n1720' href='#n1720'>1720</a>
<a id='n1721' href='#n1721'>1721</a>
<a id='n1722' href='#n1722'>1722</a>
<a id='n1723' href='#n1723'>1723</a>
<a id='n1724' href='#n1724'>1724</a>
<a id='n1725' href='#n1725'>1725</a>
<a id='n1726' href='#n1726'>1726</a>
<a id='n1727' href='#n1727'>1727</a>
<a id='n1728' href='#n1728'>1728</a>
<a id='n1729' href='#n1729'>1729</a>
<a id='n1730' href='#n1730'>1730</a>
<a id='n1731' href='#n1731'>1731</a>
<a id='n1732' href='#n1732'>1732</a>
<a id='n1733' href='#n1733'>1733</a>
<a id='n1734' href='#n1734'>1734</a>
<a id='n1735' href='#n1735'>1735</a>
<a id='n1736' href='#n1736'>1736</a>
<a id='n1737' href='#n1737'>1737</a>
<a id='n1738' href='#n1738'>1738</a>
<a id='n1739' href='#n1739'>1739</a>
<a id='n1740' href='#n1740'>1740</a>
<a id='n1741' href='#n1741'>1741</a>
<a id='n1742' href='#n1742'>1742</a>
<a id='n1743' href='#n1743'>1743</a>
<a id='n1744' href='#n1744'>1744</a>
<a id='n1745' href='#n1745'>1745</a>
<a id='n1746' href='#n1746'>1746</a>
<a id='n1747' href='#n1747'>1747</a>
<a id='n1748' href='#n1748'>1748</a>
<a id='n1749' href='#n1749'>1749</a>
<a id='n1750' href='#n1750'>1750</a>
<a id='n1751' href='#n1751'>1751</a>
<a id='n1752' href='#n1752'>1752</a>
<a id='n1753' href='#n1753'>1753</a>
<a id='n1754' href='#n1754'>1754</a>
<a id='n1755' href='#n1755'>1755</a>
<a id='n1756' href='#n1756'>1756</a>
<a id='n1757' href='#n1757'>1757</a>
<a id='n1758' href='#n1758'>1758</a>
<a id='n1759' href='#n1759'>1759</a>
<a id='n1760' href='#n1760'>1760</a>
<a id='n1761' href='#n1761'>1761</a>
<a id='n1762' href='#n1762'>1762</a>
<a id='n1763' href='#n1763'>1763</a>
<a id='n1764' href='#n1764'>1764</a>
<a id='n1765' href='#n1765'>1765</a>
<a id='n1766' href='#n1766'>1766</a>
<a id='n1767' href='#n1767'>1767</a>
<a id='n1768' href='#n1768'>1768</a>
<a id='n1769' href='#n1769'>1769</a>
<a id='n1770' href='#n1770'>1770</a>
<a id='n1771' href='#n1771'>1771</a>
<a id='n1772' href='#n1772'>1772</a>
<a id='n1773' href='#n1773'>1773</a>
<a id='n1774' href='#n1774'>1774</a>
<a id='n1775' href='#n1775'>1775</a>
<a id='n1776' href='#n1776'>1776</a>
<a id='n1777' href='#n1777'>1777</a>
<a id='n1778' href='#n1778'>1778</a>
<a id='n1779' href='#n1779'>1779</a>
<a id='n1780' href='#n1780'>1780</a>
<a id='n1781' href='#n1781'>1781</a>
<a id='n1782' href='#n1782'>1782</a>
<a id='n1783' href='#n1783'>1783</a>
<a id='n1784' href='#n1784'>1784</a>
<a id='n1785' href='#n1785'>1785</a>
<a id='n1786' href='#n1786'>1786</a>
<a id='n1787' href='#n1787'>1787</a>
<a id='n1788' href='#n1788'>1788</a>
<a id='n1789' href='#n1789'>1789</a>
<a id='n1790' href='#n1790'>1790</a>
<a id='n1791' href='#n1791'>1791</a>
<a id='n1792' href='#n1792'>1792</a>
<a id='n1793' href='#n1793'>1793</a>
<a id='n1794' href='#n1794'>1794</a>
<a id='n1795' href='#n1795'>1795</a>
<a id='n1796' href='#n1796'>1796</a>
<a id='n1797' href='#n1797'>1797</a>
<a id='n1798' href='#n1798'>1798</a>
<a id='n1799' href='#n1799'>1799</a>
<a id='n1800' href='#n1800'>1800</a>
<a id='n1801' href='#n1801'>1801</a>
<a id='n1802' href='#n1802'>1802</a>
<a id='n1803' href='#n1803'>1803</a>
<a id='n1804' href='#n1804'>1804</a>
<a id='n1805' href='#n1805'>1805</a>
<a id='n1806' href='#n1806'>1806</a>
<a id='n1807' href='#n1807'>1807</a>
<a id='n1808' href='#n1808'>1808</a>
<a id='n1809' href='#n1809'>1809</a>
<a id='n1810' href='#n1810'>1810</a>
<a id='n1811' href='#n1811'>1811</a>
<a id='n1812' href='#n1812'>1812</a>
<a id='n1813' href='#n1813'>1813</a>
<a id='n1814' href='#n1814'>1814</a>
<a id='n1815' href='#n1815'>1815</a>
<a id='n1816' href='#n1816'>1816</a>
<a id='n1817' href='#n1817'>1817</a>
<a id='n1818' href='#n1818'>1818</a>
<a id='n1819' href='#n1819'>1819</a>
<a id='n1820' href='#n1820'>1820</a>
<a id='n1821' href='#n1821'>1821</a>
<a id='n1822' href='#n1822'>1822</a>
<a id='n1823' href='#n1823'>1823</a>
<a id='n1824' href='#n1824'>1824</a>
<a id='n1825' href='#n1825'>1825</a>
<a id='n1826' href='#n1826'>1826</a>
<a id='n1827' href='#n1827'>1827</a>
<a id='n1828' href='#n1828'>1828</a>
<a id='n1829' href='#n1829'>1829</a>
<a id='n1830' href='#n1830'>1830</a>
<a id='n1831' href='#n1831'>1831</a>
<a id='n1832' href='#n1832'>1832</a>
<a id='n1833' href='#n1833'>1833</a>
<a id='n1834' href='#n1834'>1834</a>
<a id='n1835' href='#n1835'>1835</a>
<a id='n1836' href='#n1836'>1836</a>
<a id='n1837' href='#n1837'>1837</a>
<a id='n1838' href='#n1838'>1838</a>
<a id='n1839' href='#n1839'>1839</a>
<a id='n1840' href='#n1840'>1840</a>
<a id='n1841' href='#n1841'>1841</a>
<a id='n1842' href='#n1842'>1842</a>
<a id='n1843' href='#n1843'>1843</a>
<a id='n1844' href='#n1844'>1844</a>
<a id='n1845' href='#n1845'>1845</a>
<a id='n1846' href='#n1846'>1846</a>
<a id='n1847' href='#n1847'>1847</a>
<a id='n1848' href='#n1848'>1848</a>
<a id='n1849' href='#n1849'>1849</a>
<a id='n1850' href='#n1850'>1850</a>
<a id='n1851' href='#n1851'>1851</a>
<a id='n1852' href='#n1852'>1852</a>
<a id='n1853' href='#n1853'>1853</a>
<a id='n1854' href='#n1854'>1854</a>
<a id='n1855' href='#n1855'>1855</a>
<a id='n1856' href='#n1856'>1856</a>
<a id='n1857' href='#n1857'>1857</a>
<a id='n1858' href='#n1858'>1858</a>
<a id='n1859' href='#n1859'>1859</a>
<a id='n1860' href='#n1860'>1860</a>
<a id='n1861' href='#n1861'>1861</a>
<a id='n1862' href='#n1862'>1862</a>
<a id='n1863' href='#n1863'>1863</a>
<a id='n1864' href='#n1864'>1864</a>
<a id='n1865' href='#n1865'>1865</a>
<a id='n1866' href='#n1866'>1866</a>
<a id='n1867' href='#n1867'>1867</a>
<a id='n1868' href='#n1868'>1868</a>
<a id='n1869' href='#n1869'>1869</a>
<a id='n1870' href='#n1870'>1870</a>
<a id='n1871' href='#n1871'>1871</a>
<a id='n1872' href='#n1872'>1872</a>
<a id='n1873' href='#n1873'>1873</a>
<a id='n1874' href='#n1874'>1874</a>
<a id='n1875' href='#n1875'>1875</a>
<a id='n1876' href='#n1876'>1876</a>
<a id='n1877' href='#n1877'>1877</a>
<a id='n1878' href='#n1878'>1878</a>
<a id='n1879' href='#n1879'>1879</a>
<a id='n1880' href='#n1880'>1880</a>
<a id='n1881' href='#n1881'>1881</a>
<a id='n1882' href='#n1882'>1882</a>
<a id='n1883' href='#n1883'>1883</a>
<a id='n1884' href='#n1884'>1884</a>
<a id='n1885' href='#n1885'>1885</a>
<a id='n1886' href='#n1886'>1886</a>
<a id='n1887' href='#n1887'>1887</a>
<a id='n1888' href='#n1888'>1888</a>
<a id='n1889' href='#n1889'>1889</a>
<a id='n1890' href='#n1890'>1890</a>
<a id='n1891' href='#n1891'>1891</a>
<a id='n1892' href='#n1892'>1892</a>
<a id='n1893' href='#n1893'>1893</a>
<a id='n1894' href='#n1894'>1894</a>
<a id='n1895' href='#n1895'>1895</a>
<a id='n1896' href='#n1896'>1896</a>
<a id='n1897' href='#n1897'>1897</a>
<a id='n1898' href='#n1898'>1898</a>
<a id='n1899' href='#n1899'>1899</a>
<a id='n1900' href='#n1900'>1900</a>
<a id='n1901' href='#n1901'>1901</a>
<a id='n1902' href='#n1902'>1902</a>
<a id='n1903' href='#n1903'>1903</a>
<a id='n1904' href='#n1904'>1904</a>
<a id='n1905' href='#n1905'>1905</a>
<a id='n1906' href='#n1906'>1906</a>
<a id='n1907' href='#n1907'>1907</a>
<a id='n1908' href='#n1908'>1908</a>
<a id='n1909' href='#n1909'>1909</a>
<a id='n1910' href='#n1910'>1910</a>
<a id='n1911' href='#n1911'>1911</a>
<a id='n1912' href='#n1912'>1912</a>
<a id='n1913' href='#n1913'>1913</a>
<a id='n1914' href='#n1914'>1914</a>
<a id='n1915' href='#n1915'>1915</a>
<a id='n1916' href='#n1916'>1916</a>
<a id='n1917' href='#n1917'>1917</a>
<a id='n1918' href='#n1918'>1918</a>
<a id='n1919' href='#n1919'>1919</a>
<a id='n1920' href='#n1920'>1920</a>
<a id='n1921' href='#n1921'>1921</a>
<a id='n1922' href='#n1922'>1922</a>
<a id='n1923' href='#n1923'>1923</a>
<a id='n1924' href='#n1924'>1924</a>
<a id='n1925' href='#n1925'>1925</a>
<a id='n1926' href='#n1926'>1926</a>
<a id='n1927' href='#n1927'>1927</a>
<a id='n1928' href='#n1928'>1928</a>
<a id='n1929' href='#n1929'>1929</a>
<a id='n1930' href='#n1930'>1930</a>
<a id='n1931' href='#n1931'>1931</a>
<a id='n1932' href='#n1932'>1932</a>
<a id='n1933' href='#n1933'>1933</a>
<a id='n1934' href='#n1934'>1934</a>
<a id='n1935' href='#n1935'>1935</a>
<a id='n1936' href='#n1936'>1936</a>
<a id='n1937' href='#n1937'>1937</a>
<a id='n1938' href='#n1938'>1938</a>
<a id='n1939' href='#n1939'>1939</a>
<a id='n1940' href='#n1940'>1940</a>
<a id='n1941' href='#n1941'>1941</a>
<a id='n1942' href='#n1942'>1942</a>
<a id='n1943' href='#n1943'>1943</a>
<a id='n1944' href='#n1944'>1944</a>
<a id='n1945' href='#n1945'>1945</a>
<a id='n1946' href='#n1946'>1946</a>
<a id='n1947' href='#n1947'>1947</a>
<a id='n1948' href='#n1948'>1948</a>
<a id='n1949' href='#n1949'>1949</a>
<a id='n1950' href='#n1950'>1950</a>
<a id='n1951' href='#n1951'>1951</a>
<a id='n1952' href='#n1952'>1952</a>
<a id='n1953' href='#n1953'>1953</a>
<a id='n1954' href='#n1954'>1954</a>
<a id='n1955' href='#n1955'>1955</a>
<a id='n1956' href='#n1956'>1956</a>
<a id='n1957' href='#n1957'>1957</a>
<a id='n1958' href='#n1958'>1958</a>
<a id='n1959' href='#n1959'>1959</a>
<a id='n1960' href='#n1960'>1960</a>
<a id='n1961' href='#n1961'>1961</a>
<a id='n1962' href='#n1962'>1962</a>
<a id='n1963' href='#n1963'>1963</a>
<a id='n1964' href='#n1964'>1964</a>
<a id='n1965' href='#n1965'>1965</a>
<a id='n1966' href='#n1966'>1966</a>
<a id='n1967' href='#n1967'>1967</a>
<a id='n1968' href='#n1968'>1968</a>
<a id='n1969' href='#n1969'>1969</a>
<a id='n1970' href='#n1970'>1970</a>
<a id='n1971' href='#n1971'>1971</a>
<a id='n1972' href='#n1972'>1972</a>
<a id='n1973' href='#n1973'>1973</a>
<a id='n1974' href='#n1974'>1974</a>
<a id='n1975' href='#n1975'>1975</a>
<a id='n1976' href='#n1976'>1976</a>
<a id='n1977' href='#n1977'>1977</a>
<a id='n1978' href='#n1978'>1978</a>
<a id='n1979' href='#n1979'>1979</a>
<a id='n1980' href='#n1980'>1980</a>
<a id='n1981' href='#n1981'>1981</a>
<a id='n1982' href='#n1982'>1982</a>
<a id='n1983' href='#n1983'>1983</a>
<a id='n1984' href='#n1984'>1984</a>
<a id='n1985' href='#n1985'>1985</a>
<a id='n1986' href='#n1986'>1986</a>
<a id='n1987' href='#n1987'>1987</a>
<a id='n1988' href='#n1988'>1988</a>
<a id='n1989' href='#n1989'>1989</a>
<a id='n1990' href='#n1990'>1990</a>
<a id='n1991' href='#n1991'>1991</a>
<a id='n1992' href='#n1992'>1992</a>
<a id='n1993' href='#n1993'>1993</a>
<a id='n1994' href='#n1994'>1994</a>
<a id='n1995' href='#n1995'>1995</a>
<a id='n1996' href='#n1996'>1996</a>
<a id='n1997' href='#n1997'>1997</a>
<a id='n1998' href='#n1998'>1998</a>
<a id='n1999' href='#n1999'>1999</a>
<a id='n2000' href='#n2000'>2000</a>
<a id='n2001' href='#n2001'>2001</a>
<a id='n2002' href='#n2002'>2002</a>
<a id='n2003' href='#n2003'>2003</a>
<a id='n2004' href='#n2004'>2004</a>
<a id='n2005' href='#n2005'>2005</a>
<a id='n2006' href='#n2006'>2006</a>
<a id='n2007' href='#n2007'>2007</a>
<a id='n2008' href='#n2008'>2008</a>
<a id='n2009' href='#n2009'>2009</a>
<a id='n2010' href='#n2010'>2010</a>
<a id='n2011' href='#n2011'>2011</a>
<a id='n2012' href='#n2012'>2012</a>
<a id='n2013' href='#n2013'>2013</a>
<a id='n2014' href='#n2014'>2014</a>
<a id='n2015' href='#n2015'>2015</a>
<a id='n2016' href='#n2016'>2016</a>
<a id='n2017' href='#n2017'>2017</a>
<a id='n2018' href='#n2018'>2018</a>
<a id='n2019' href='#n2019'>2019</a>
<a id='n2020' href='#n2020'>2020</a>
<a id='n2021' href='#n2021'>2021</a>
<a id='n2022' href='#n2022'>2022</a>
<a id='n2023' href='#n2023'>2023</a>
<a id='n2024' href='#n2024'>2024</a>
<a id='n2025' href='#n2025'>2025</a>
<a id='n2026' href='#n2026'>2026</a>
<a id='n2027' href='#n2027'>2027</a>
<a id='n2028' href='#n2028'>2028</a>
<a id='n2029' href='#n2029'>2029</a>
<a id='n2030' href='#n2030'>2030</a>
<a id='n2031' href='#n2031'>2031</a>
<a id='n2032' href='#n2032'>2032</a>
<a id='n2033' href='#n2033'>2033</a>
<a id='n2034' href='#n2034'>2034</a>
<a id='n2035' href='#n2035'>2035</a>
<a id='n2036' href='#n2036'>2036</a>
<a id='n2037' href='#n2037'>2037</a>
<a id='n2038' href='#n2038'>2038</a>
<a id='n2039' href='#n2039'>2039</a>
<a id='n2040' href='#n2040'>2040</a>
<a id='n2041' href='#n2041'>2041</a>
<a id='n2042' href='#n2042'>2042</a>
<a id='n2043' href='#n2043'>2043</a>
<a id='n2044' href='#n2044'>2044</a>
<a id='n2045' href='#n2045'>2045</a>
<a id='n2046' href='#n2046'>2046</a>
<a id='n2047' href='#n2047'>2047</a>
<a id='n2048' href='#n2048'>2048</a>
<a id='n2049' href='#n2049'>2049</a>
<a id='n2050' href='#n2050'>2050</a>
<a id='n2051' href='#n2051'>2051</a>
<a id='n2052' href='#n2052'>2052</a>
<a id='n2053' href='#n2053'>2053</a>
<a id='n2054' href='#n2054'>2054</a>
<a id='n2055' href='#n2055'>2055</a>
<a id='n2056' href='#n2056'>2056</a>
<a id='n2057' href='#n2057'>2057</a>
<a id='n2058' href='#n2058'>2058</a>
<a id='n2059' href='#n2059'>2059</a>
<a id='n2060' href='#n2060'>2060</a>
<a id='n2061' href='#n2061'>2061</a>
<a id='n2062' href='#n2062'>2062</a>
<a id='n2063' href='#n2063'>2063</a>
<a id='n2064' href='#n2064'>2064</a>
<a id='n2065' href='#n2065'>2065</a>
<a id='n2066' href='#n2066'>2066</a>
<a id='n2067' href='#n2067'>2067</a>
<a id='n2068' href='#n2068'>2068</a>
<a id='n2069' href='#n2069'>2069</a>
<a id='n2070' href='#n2070'>2070</a>
<a id='n2071' href='#n2071'>2071</a>
<a id='n2072' href='#n2072'>2072</a>
<a id='n2073' href='#n2073'>2073</a>
<a id='n2074' href='#n2074'>2074</a>
<a id='n2075' href='#n2075'>2075</a>
<a id='n2076' href='#n2076'>2076</a>
<a id='n2077' href='#n2077'>2077</a>
<a id='n2078' href='#n2078'>2078</a>
<a id='n2079' href='#n2079'>2079</a>
<a id='n2080' href='#n2080'>2080</a>
<a id='n2081' href='#n2081'>2081</a>
<a id='n2082' href='#n2082'>2082</a>
<a id='n2083' href='#n2083'>2083</a>
<a id='n2084' href='#n2084'>2084</a>
<a id='n2085' href='#n2085'>2085</a>
<a id='n2086' href='#n2086'>2086</a>
<a id='n2087' href='#n2087'>2087</a>
<a id='n2088' href='#n2088'>2088</a>
<a id='n2089' href='#n2089'>2089</a>
<a id='n2090' href='#n2090'>2090</a>
<a id='n2091' href='#n2091'>2091</a>
<a id='n2092' href='#n2092'>2092</a>
<a id='n2093' href='#n2093'>2093</a>
<a id='n2094' href='#n2094'>2094</a>
<a id='n2095' href='#n2095'>2095</a>
<a id='n2096' href='#n2096'>2096</a>
<a id='n2097' href='#n2097'>2097</a>
<a id='n2098' href='#n2098'>2098</a>
<a id='n2099' href='#n2099'>2099</a>
<a id='n2100' href='#n2100'>2100</a>
<a id='n2101' href='#n2101'>2101</a>
<a id='n2102' href='#n2102'>2102</a>
<a id='n2103' href='#n2103'>2103</a>
<a id='n2104' href='#n2104'>2104</a>
<a id='n2105' href='#n2105'>2105</a>
<a id='n2106' href='#n2106'>2106</a>
<a id='n2107' href='#n2107'>2107</a>
<a id='n2108' href='#n2108'>2108</a>
<a id='n2109' href='#n2109'>2109</a>
<a id='n2110' href='#n2110'>2110</a>
<a id='n2111' href='#n2111'>2111</a>
<a id='n2112' href='#n2112'>2112</a>
<a id='n2113' href='#n2113'>2113</a>
<a id='n2114' href='#n2114'>2114</a>
<a id='n2115' href='#n2115'>2115</a>
<a id='n2116' href='#n2116'>2116</a>
<a id='n2117' href='#n2117'>2117</a>
<a id='n2118' href='#n2118'>2118</a>
<a id='n2119' href='#n2119'>2119</a>
<a id='n2120' href='#n2120'>2120</a>
<a id='n2121' href='#n2121'>2121</a>
<a id='n2122' href='#n2122'>2122</a>
<a id='n2123' href='#n2123'>2123</a>
<a id='n2124' href='#n2124'>2124</a>
<a id='n2125' href='#n2125'>2125</a>
<a id='n2126' href='#n2126'>2126</a>
<a id='n2127' href='#n2127'>2127</a>
<a id='n2128' href='#n2128'>2128</a>
<a id='n2129' href='#n2129'>2129</a>
<a id='n2130' href='#n2130'>2130</a>
<a id='n2131' href='#n2131'>2131</a>
<a id='n2132' href='#n2132'>2132</a>
<a id='n2133' href='#n2133'>2133</a>
<a id='n2134' href='#n2134'>2134</a>
<a id='n2135' href='#n2135'>2135</a>
<a id='n2136' href='#n2136'>2136</a>
<a id='n2137' href='#n2137'>2137</a>
<a id='n2138' href='#n2138'>2138</a>
<a id='n2139' href='#n2139'>2139</a>
<a id='n2140' href='#n2140'>2140</a>
<a id='n2141' href='#n2141'>2141</a>
<a id='n2142' href='#n2142'>2142</a>
<a id='n2143' href='#n2143'>2143</a>
<a id='n2144' href='#n2144'>2144</a>
<a id='n2145' href='#n2145'>2145</a>
<a id='n2146' href='#n2146'>2146</a>
<a id='n2147' href='#n2147'>2147</a>
<a id='n2148' href='#n2148'>2148</a>
<a id='n2149' href='#n2149'>2149</a>
<a id='n2150' href='#n2150'>2150</a>
<a id='n2151' href='#n2151'>2151</a>
<a id='n2152' href='#n2152'>2152</a>
<a id='n2153' href='#n2153'>2153</a>
<a id='n2154' href='#n2154'>2154</a>
<a id='n2155' href='#n2155'>2155</a>
<a id='n2156' href='#n2156'>2156</a>
<a id='n2157' href='#n2157'>2157</a>
<a id='n2158' href='#n2158'>2158</a>
<a id='n2159' href='#n2159'>2159</a>
<a id='n2160' href='#n2160'>2160</a>
<a id='n2161' href='#n2161'>2161</a>
<a id='n2162' href='#n2162'>2162</a>
<a id='n2163' href='#n2163'>2163</a>
<a id='n2164' href='#n2164'>2164</a>
<a id='n2165' href='#n2165'>2165</a>
<a id='n2166' href='#n2166'>2166</a>
<a id='n2167' href='#n2167'>2167</a>
<a id='n2168' href='#n2168'>2168</a>
<a id='n2169' href='#n2169'>2169</a>
<a id='n2170' href='#n2170'>2170</a>
<a id='n2171' href='#n2171'>2171</a>
<a id='n2172' href='#n2172'>2172</a>
<a id='n2173' href='#n2173'>2173</a>
<a id='n2174' href='#n2174'>2174</a>
<a id='n2175' href='#n2175'>2175</a>
<a id='n2176' href='#n2176'>2176</a>
<a id='n2177' href='#n2177'>2177</a>
<a id='n2178' href='#n2178'>2178</a>
<a id='n2179' href='#n2179'>2179</a>
<a id='n2180' href='#n2180'>2180</a>
<a id='n2181' href='#n2181'>2181</a>
<a id='n2182' href='#n2182'>2182</a>
<a id='n2183' href='#n2183'>2183</a>
<a id='n2184' href='#n2184'>2184</a>
<a id='n2185' href='#n2185'>2185</a>
<a id='n2186' href='#n2186'>2186</a>
<a id='n2187' href='#n2187'>2187</a>
<a id='n2188' href='#n2188'>2188</a>
<a id='n2189' href='#n2189'>2189</a>
<a id='n2190' href='#n2190'>2190</a>
<a id='n2191' href='#n2191'>2191</a>
<a id='n2192' href='#n2192'>2192</a>
<a id='n2193' href='#n2193'>2193</a>
<a id='n2194' href='#n2194'>2194</a>
<a id='n2195' href='#n2195'>2195</a>
<a id='n2196' href='#n2196'>2196</a>
<a id='n2197' href='#n2197'>2197</a>
<a id='n2198' href='#n2198'>2198</a>
<a id='n2199' href='#n2199'>2199</a>
<a id='n2200' href='#n2200'>2200</a>
<a id='n2201' href='#n2201'>2201</a>
<a id='n2202' href='#n2202'>2202</a>
<a id='n2203' href='#n2203'>2203</a>
<a id='n2204' href='#n2204'>2204</a>
<a id='n2205' href='#n2205'>2205</a>
<a id='n2206' href='#n2206'>2206</a>
<a id='n2207' href='#n2207'>2207</a>
<a id='n2208' href='#n2208'>2208</a>
<a id='n2209' href='#n2209'>2209</a>
<a id='n2210' href='#n2210'>2210</a>
<a id='n2211' href='#n2211'>2211</a>
<a id='n2212' href='#n2212'>2212</a>
<a id='n2213' href='#n2213'>2213</a>
<a id='n2214' href='#n2214'>2214</a>
<a id='n2215' href='#n2215'>2215</a>
<a id='n2216' href='#n2216'>2216</a>
<a id='n2217' href='#n2217'>2217</a>
<a id='n2218' href='#n2218'>2218</a>
<a id='n2219' href='#n2219'>2219</a>
<a id='n2220' href='#n2220'>2220</a>
<a id='n2221' href='#n2221'>2221</a>
<a id='n2222' href='#n2222'>2222</a>
<a id='n2223' href='#n2223'>2223</a>
<a id='n2224' href='#n2224'>2224</a>
<a id='n2225' href='#n2225'>2225</a>
<a id='n2226' href='#n2226'>2226</a>
<a id='n2227' href='#n2227'>2227</a>
<a id='n2228' href='#n2228'>2228</a>
<a id='n2229' href='#n2229'>2229</a>
<a id='n2230' href='#n2230'>2230</a>
<a id='n2231' href='#n2231'>2231</a>
<a id='n2232' href='#n2232'>2232</a>
<a id='n2233' href='#n2233'>2233</a>
<a id='n2234' href='#n2234'>2234</a>
<a id='n2235' href='#n2235'>2235</a>
<a id='n2236' href='#n2236'>2236</a>
<a id='n2237' href='#n2237'>2237</a>
<a id='n2238' href='#n2238'>2238</a>
<a id='n2239' href='#n2239'>2239</a>
<a id='n2240' href='#n2240'>2240</a>
<a id='n2241' href='#n2241'>2241</a>
<a id='n2242' href='#n2242'>2242</a>
<a id='n2243' href='#n2243'>2243</a>
<a id='n2244' href='#n2244'>2244</a>
<a id='n2245' href='#n2245'>2245</a>
<a id='n2246' href='#n2246'>2246</a>
<a id='n2247' href='#n2247'>2247</a>
<a id='n2248' href='#n2248'>2248</a>
<a id='n2249' href='#n2249'>2249</a>
<a id='n2250' href='#n2250'>2250</a>
<a id='n2251' href='#n2251'>2251</a>
<a id='n2252' href='#n2252'>2252</a>
<a id='n2253' href='#n2253'>2253</a>
<a id='n2254' href='#n2254'>2254</a>
<a id='n2255' href='#n2255'>2255</a>
<a id='n2256' href='#n2256'>2256</a>
<a id='n2257' href='#n2257'>2257</a>
<a id='n2258' href='#n2258'>2258</a>
<a id='n2259' href='#n2259'>2259</a>
<a id='n2260' href='#n2260'>2260</a>
<a id='n2261' href='#n2261'>2261</a>
<a id='n2262' href='#n2262'>2262</a>
<a id='n2263' href='#n2263'>2263</a>
<a id='n2264' href='#n2264'>2264</a>
<a id='n2265' href='#n2265'>2265</a>
<a id='n2266' href='#n2266'>2266</a>
<a id='n2267' href='#n2267'>2267</a>
<a id='n2268' href='#n2268'>2268</a>
<a id='n2269' href='#n2269'>2269</a>
<a id='n2270' href='#n2270'>2270</a>
<a id='n2271' href='#n2271'>2271</a>
<a id='n2272' href='#n2272'>2272</a>
<a id='n2273' href='#n2273'>2273</a>
<a id='n2274' href='#n2274'>2274</a>
<a id='n2275' href='#n2275'>2275</a>
<a id='n2276' href='#n2276'>2276</a>
<a id='n2277' href='#n2277'>2277</a>
<a id='n2278' href='#n2278'>2278</a>
<a id='n2279' href='#n2279'>2279</a>
<a id='n2280' href='#n2280'>2280</a>
<a id='n2281' href='#n2281'>2281</a>
<a id='n2282' href='#n2282'>2282</a>
<a id='n2283' href='#n2283'>2283</a>
<a id='n2284' href='#n2284'>2284</a>
<a id='n2285' href='#n2285'>2285</a>
<a id='n2286' href='#n2286'>2286</a>
<a id='n2287' href='#n2287'>2287</a>
<a id='n2288' href='#n2288'>2288</a>
<a id='n2289' href='#n2289'>2289</a>
<a id='n2290' href='#n2290'>2290</a>
<a id='n2291' href='#n2291'>2291</a>
<a id='n2292' href='#n2292'>2292</a>
<a id='n2293' href='#n2293'>2293</a>
<a id='n2294' href='#n2294'>2294</a>
<a id='n2295' href='#n2295'>2295</a>
<a id='n2296' href='#n2296'>2296</a>
<a id='n2297' href='#n2297'>2297</a>
<a id='n2298' href='#n2298'>2298</a>
<a id='n2299' href='#n2299'>2299</a>
<a id='n2300' href='#n2300'>2300</a>
<a id='n2301' href='#n2301'>2301</a>
<a id='n2302' href='#n2302'>2302</a>
<a id='n2303' href='#n2303'>2303</a>
<a id='n2304' href='#n2304'>2304</a>
<a id='n2305' href='#n2305'>2305</a>
<a id='n2306' href='#n2306'>2306</a>
<a id='n2307' href='#n2307'>2307</a>
<a id='n2308' href='#n2308'>2308</a>
<a id='n2309' href='#n2309'>2309</a>
<a id='n2310' href='#n2310'>2310</a>
<a id='n2311' href='#n2311'>2311</a>
<a id='n2312' href='#n2312'>2312</a>
<a id='n2313' href='#n2313'>2313</a>
<a id='n2314' href='#n2314'>2314</a>
<a id='n2315' href='#n2315'>2315</a>
<a id='n2316' href='#n2316'>2316</a>
<a id='n2317' href='#n2317'>2317</a>
<a id='n2318' href='#n2318'>2318</a>
<a id='n2319' href='#n2319'>2319</a>
<a id='n2320' href='#n2320'>2320</a>
<a id='n2321' href='#n2321'>2321</a>
<a id='n2322' href='#n2322'>2322</a>
<a id='n2323' href='#n2323'>2323</a>
<a id='n2324' href='#n2324'>2324</a>
<a id='n2325' href='#n2325'>2325</a>
<a id='n2326' href='#n2326'>2326</a>
<a id='n2327' href='#n2327'>2327</a>
<a id='n2328' href='#n2328'>2328</a>
<a id='n2329' href='#n2329'>2329</a>
<a id='n2330' href='#n2330'>2330</a>
<a id='n2331' href='#n2331'>2331</a>
<a id='n2332' href='#n2332'>2332</a>
<a id='n2333' href='#n2333'>2333</a>
<a id='n2334' href='#n2334'>2334</a>
<a id='n2335' href='#n2335'>2335</a>
<a id='n2336' href='#n2336'>2336</a>
<a id='n2337' href='#n2337'>2337</a>
<a id='n2338' href='#n2338'>2338</a>
<a id='n2339' href='#n2339'>2339</a>
<a id='n2340' href='#n2340'>2340</a>
<a id='n2341' href='#n2341'>2341</a>
<a id='n2342' href='#n2342'>2342</a>
<a id='n2343' href='#n2343'>2343</a>
<a id='n2344' href='#n2344'>2344</a>
<a id='n2345' href='#n2345'>2345</a>
<a id='n2346' href='#n2346'>2346</a>
<a id='n2347' href='#n2347'>2347</a>
<a id='n2348' href='#n2348'>2348</a>
<a id='n2349' href='#n2349'>2349</a>
<a id='n2350' href='#n2350'>2350</a>
<a id='n2351' href='#n2351'>2351</a>
<a id='n2352' href='#n2352'>2352</a>
<a id='n2353' href='#n2353'>2353</a>
<a id='n2354' href='#n2354'>2354</a>
<a id='n2355' href='#n2355'>2355</a>
<a id='n2356' href='#n2356'>2356</a>
<a id='n2357' href='#n2357'>2357</a>
<a id='n2358' href='#n2358'>2358</a>
<a id='n2359' href='#n2359'>2359</a>
<a id='n2360' href='#n2360'>2360</a>
<a id='n2361' href='#n2361'>2361</a>
<a id='n2362' href='#n2362'>2362</a>
<a id='n2363' href='#n2363'>2363</a>
<a id='n2364' href='#n2364'>2364</a>
<a id='n2365' href='#n2365'>2365</a>
<a id='n2366' href='#n2366'>2366</a>
<a id='n2367' href='#n2367'>2367</a>
<a id='n2368' href='#n2368'>2368</a>
<a id='n2369' href='#n2369'>2369</a>
<a id='n2370' href='#n2370'>2370</a>
<a id='n2371' href='#n2371'>2371</a>
<a id='n2372' href='#n2372'>2372</a>
<a id='n2373' href='#n2373'>2373</a>
<a id='n2374' href='#n2374'>2374</a>
<a id='n2375' href='#n2375'>2375</a>
<a id='n2376' href='#n2376'>2376</a>
<a id='n2377' href='#n2377'>2377</a>
<a id='n2378' href='#n2378'>2378</a>
<a id='n2379' href='#n2379'>2379</a>
<a id='n2380' href='#n2380'>2380</a>
<a id='n2381' href='#n2381'>2381</a>
<a id='n2382' href='#n2382'>2382</a>
<a id='n2383' href='#n2383'>2383</a>
<a id='n2384' href='#n2384'>2384</a>
<a id='n2385' href='#n2385'>2385</a>
<a id='n2386' href='#n2386'>2386</a>
<a id='n2387' href='#n2387'>2387</a>
<a id='n2388' href='#n2388'>2388</a>
<a id='n2389' href='#n2389'>2389</a>
<a id='n2390' href='#n2390'>2390</a>
<a id='n2391' href='#n2391'>2391</a>
<a id='n2392' href='#n2392'>2392</a>
<a id='n2393' href='#n2393'>2393</a>
<a id='n2394' href='#n2394'>2394</a>
<a id='n2395' href='#n2395'>2395</a>
<a id='n2396' href='#n2396'>2396</a>
<a id='n2397' href='#n2397'>2397</a>
<a id='n2398' href='#n2398'>2398</a>
<a id='n2399' href='#n2399'>2399</a>
<a id='n2400' href='#n2400'>2400</a>
<a id='n2401' href='#n2401'>2401</a>
<a id='n2402' href='#n2402'>2402</a>
<a id='n2403' href='#n2403'>2403</a>
<a id='n2404' href='#n2404'>2404</a>
<a id='n2405' href='#n2405'>2405</a>
<a id='n2406' href='#n2406'>2406</a>
<a id='n2407' href='#n2407'>2407</a>
<a id='n2408' href='#n2408'>2408</a>
<a id='n2409' href='#n2409'>2409</a>
<a id='n2410' href='#n2410'>2410</a>
<a id='n2411' href='#n2411'>2411</a>
<a id='n2412' href='#n2412'>2412</a>
<a id='n2413' href='#n2413'>2413</a>
<a id='n2414' href='#n2414'>2414</a>
<a id='n2415' href='#n2415'>2415</a>
<a id='n2416' href='#n2416'>2416</a>
<a id='n2417' href='#n2417'>2417</a>
<a id='n2418' href='#n2418'>2418</a>
<a id='n2419' href='#n2419'>2419</a>
<a id='n2420' href='#n2420'>2420</a>
<a id='n2421' href='#n2421'>2421</a>
<a id='n2422' href='#n2422'>2422</a>
<a id='n2423' href='#n2423'>2423</a>
<a id='n2424' href='#n2424'>2424</a>
<a id='n2425' href='#n2425'>2425</a>
<a id='n2426' href='#n2426'>2426</a>
<a id='n2427' href='#n2427'>2427</a>
<a id='n2428' href='#n2428'>2428</a>
<a id='n2429' href='#n2429'>2429</a>
<a id='n2430' href='#n2430'>2430</a>
<a id='n2431' href='#n2431'>2431</a>
<a id='n2432' href='#n2432'>2432</a>
<a id='n2433' href='#n2433'>2433</a>
<a id='n2434' href='#n2434'>2434</a>
<a id='n2435' href='#n2435'>2435</a>
<a id='n2436' href='#n2436'>2436</a>
<a id='n2437' href='#n2437'>2437</a>
<a id='n2438' href='#n2438'>2438</a>
<a id='n2439' href='#n2439'>2439</a>
<a id='n2440' href='#n2440'>2440</a>
<a id='n2441' href='#n2441'>2441</a>
<a id='n2442' href='#n2442'>2442</a>
<a id='n2443' href='#n2443'>2443</a>
<a id='n2444' href='#n2444'>2444</a>
<a id='n2445' href='#n2445'>2445</a>
<a id='n2446' href='#n2446'>2446</a>
<a id='n2447' href='#n2447'>2447</a>
<a id='n2448' href='#n2448'>2448</a>
<a id='n2449' href='#n2449'>2449</a>
<a id='n2450' href='#n2450'>2450</a>
<a id='n2451' href='#n2451'>2451</a>
<a id='n2452' href='#n2452'>2452</a>
<a id='n2453' href='#n2453'>2453</a>
<a id='n2454' href='#n2454'>2454</a>
<a id='n2455' href='#n2455'>2455</a>
<a id='n2456' href='#n2456'>2456</a>
<a id='n2457' href='#n2457'>2457</a>
<a id='n2458' href='#n2458'>2458</a>
<a id='n2459' href='#n2459'>2459</a>
<a id='n2460' href='#n2460'>2460</a>
<a id='n2461' href='#n2461'>2461</a>
<a id='n2462' href='#n2462'>2462</a>
<a id='n2463' href='#n2463'>2463</a>
<a id='n2464' href='#n2464'>2464</a>
<a id='n2465' href='#n2465'>2465</a>
<a id='n2466' href='#n2466'>2466</a>
<a id='n2467' href='#n2467'>2467</a>
<a id='n2468' href='#n2468'>2468</a>
<a id='n2469' href='#n2469'>2469</a>
<a id='n2470' href='#n2470'>2470</a>
<a id='n2471' href='#n2471'>2471</a>
<a id='n2472' href='#n2472'>2472</a>
<a id='n2473' href='#n2473'>2473</a>
<a id='n2474' href='#n2474'>2474</a>
<a id='n2475' href='#n2475'>2475</a>
<a id='n2476' href='#n2476'>2476</a>
<a id='n2477' href='#n2477'>2477</a>
<a id='n2478' href='#n2478'>2478</a>
<a id='n2479' href='#n2479'>2479</a>
<a id='n2480' href='#n2480'>2480</a>
<a id='n2481' href='#n2481'>2481</a>
<a id='n2482' href='#n2482'>2482</a>
<a id='n2483' href='#n2483'>2483</a>
<a id='n2484' href='#n2484'>2484</a>
<a id='n2485' href='#n2485'>2485</a>
<a id='n2486' href='#n2486'>2486</a>
<a id='n2487' href='#n2487'>2487</a>
<a id='n2488' href='#n2488'>2488</a>
<a id='n2489' href='#n2489'>2489</a>
<a id='n2490' href='#n2490'>2490</a>
<a id='n2491' href='#n2491'>2491</a>
<a id='n2492' href='#n2492'>2492</a>
<a id='n2493' href='#n2493'>2493</a>
<a id='n2494' href='#n2494'>2494</a>
<a id='n2495' href='#n2495'>2495</a>
<a id='n2496' href='#n2496'>2496</a>
<a id='n2497' href='#n2497'>2497</a>
<a id='n2498' href='#n2498'>2498</a>
<a id='n2499' href='#n2499'>2499</a>
<a id='n2500' href='#n2500'>2500</a>
<a id='n2501' href='#n2501'>2501</a>
<a id='n2502' href='#n2502'>2502</a>
<a id='n2503' href='#n2503'>2503</a>
<a id='n2504' href='#n2504'>2504</a>
<a id='n2505' href='#n2505'>2505</a>
<a id='n2506' href='#n2506'>2506</a>
<a id='n2507' href='#n2507'>2507</a>
<a id='n2508' href='#n2508'>2508</a>
<a id='n2509' href='#n2509'>2509</a>
<a id='n2510' href='#n2510'>2510</a>
<a id='n2511' href='#n2511'>2511</a>
<a id='n2512' href='#n2512'>2512</a>
<a id='n2513' href='#n2513'>2513</a>
<a id='n2514' href='#n2514'>2514</a>
<a id='n2515' href='#n2515'>2515</a>
<a id='n2516' href='#n2516'>2516</a>
<a id='n2517' href='#n2517'>2517</a>
<a id='n2518' href='#n2518'>2518</a>
<a id='n2519' href='#n2519'>2519</a>
<a id='n2520' href='#n2520'>2520</a>
<a id='n2521' href='#n2521'>2521</a>
<a id='n2522' href='#n2522'>2522</a>
<a id='n2523' href='#n2523'>2523</a>
<a id='n2524' href='#n2524'>2524</a>
<a id='n2525' href='#n2525'>2525</a>
<a id='n2526' href='#n2526'>2526</a>
<a id='n2527' href='#n2527'>2527</a>
<a id='n2528' href='#n2528'>2528</a>
<a id='n2529' href='#n2529'>2529</a>
<a id='n2530' href='#n2530'>2530</a>
<a id='n2531' href='#n2531'>2531</a>
<a id='n2532' href='#n2532'>2532</a>
<a id='n2533' href='#n2533'>2533</a>
<a id='n2534' href='#n2534'>2534</a>
<a id='n2535' href='#n2535'>2535</a>
<a id='n2536' href='#n2536'>2536</a>
<a id='n2537' href='#n2537'>2537</a>
<a id='n2538' href='#n2538'>2538</a>
<a id='n2539' href='#n2539'>2539</a>
<a id='n2540' href='#n2540'>2540</a>
<a id='n2541' href='#n2541'>2541</a>
<a id='n2542' href='#n2542'>2542</a>
<a id='n2543' href='#n2543'>2543</a>
<a id='n2544' href='#n2544'>2544</a>
<a id='n2545' href='#n2545'>2545</a>
<a id='n2546' href='#n2546'>2546</a>
<a id='n2547' href='#n2547'>2547</a>
<a id='n2548' href='#n2548'>2548</a>
<a id='n2549' href='#n2549'>2549</a>
<a id='n2550' href='#n2550'>2550</a>
<a id='n2551' href='#n2551'>2551</a>
<a id='n2552' href='#n2552'>2552</a>
<a id='n2553' href='#n2553'>2553</a>
<a id='n2554' href='#n2554'>2554</a>
<a id='n2555' href='#n2555'>2555</a>
<a id='n2556' href='#n2556'>2556</a>
<a id='n2557' href='#n2557'>2557</a>
<a id='n2558' href='#n2558'>2558</a>
<a id='n2559' href='#n2559'>2559</a>
<a id='n2560' href='#n2560'>2560</a>
<a id='n2561' href='#n2561'>2561</a>
<a id='n2562' href='#n2562'>2562</a>
<a id='n2563' href='#n2563'>2563</a>
<a id='n2564' href='#n2564'>2564</a>
<a id='n2565' href='#n2565'>2565</a>
<a id='n2566' href='#n2566'>2566</a>
<a id='n2567' href='#n2567'>2567</a>
<a id='n2568' href='#n2568'>2568</a>
<a id='n2569' href='#n2569'>2569</a>
<a id='n2570' href='#n2570'>2570</a>
<a id='n2571' href='#n2571'>2571</a>
<a id='n2572' href='#n2572'>2572</a>
<a id='n2573' href='#n2573'>2573</a>
<a id='n2574' href='#n2574'>2574</a>
<a id='n2575' href='#n2575'>2575</a>
<a id='n2576' href='#n2576'>2576</a>
<a id='n2577' href='#n2577'>2577</a>
<a id='n2578' href='#n2578'>2578</a>
<a id='n2579' href='#n2579'>2579</a>
<a id='n2580' href='#n2580'>2580</a>
<a id='n2581' href='#n2581'>2581</a>
<a id='n2582' href='#n2582'>2582</a>
<a id='n2583' href='#n2583'>2583</a>
<a id='n2584' href='#n2584'>2584</a>
<a id='n2585' href='#n2585'>2585</a>
<a id='n2586' href='#n2586'>2586</a>
<a id='n2587' href='#n2587'>2587</a>
<a id='n2588' href='#n2588'>2588</a>
<a id='n2589' href='#n2589'>2589</a>
<a id='n2590' href='#n2590'>2590</a>
<a id='n2591' href='#n2591'>2591</a>
<a id='n2592' href='#n2592'>2592</a>
<a id='n2593' href='#n2593'>2593</a>
<a id='n2594' href='#n2594'>2594</a>
<a id='n2595' href='#n2595'>2595</a>
<a id='n2596' href='#n2596'>2596</a>
<a id='n2597' href='#n2597'>2597</a>
<a id='n2598' href='#n2598'>2598</a>
<a id='n2599' href='#n2599'>2599</a>
<a id='n2600' href='#n2600'>2600</a>
<a id='n2601' href='#n2601'>2601</a>
<a id='n2602' href='#n2602'>2602</a>
<a id='n2603' href='#n2603'>2603</a>
<a id='n2604' href='#n2604'>2604</a>
<a id='n2605' href='#n2605'>2605</a>
<a id='n2606' href='#n2606'>2606</a>
<a id='n2607' href='#n2607'>2607</a>
<a id='n2608' href='#n2608'>2608</a>
<a id='n2609' href='#n2609'>2609</a>
<a id='n2610' href='#n2610'>2610</a>
<a id='n2611' href='#n2611'>2611</a>
<a id='n2612' href='#n2612'>2612</a>
<a id='n2613' href='#n2613'>2613</a>
<a id='n2614' href='#n2614'>2614</a>
<a id='n2615' href='#n2615'>2615</a>
<a id='n2616' href='#n2616'>2616</a>
<a id='n2617' href='#n2617'>2617</a>
<a id='n2618' href='#n2618'>2618</a>
<a id='n2619' href='#n2619'>2619</a>
<a id='n2620' href='#n2620'>2620</a>
<a id='n2621' href='#n2621'>2621</a>
<a id='n2622' href='#n2622'>2622</a>
<a id='n2623' href='#n2623'>2623</a>
<a id='n2624' href='#n2624'>2624</a>
<a id='n2625' href='#n2625'>2625</a>
<a id='n2626' href='#n2626'>2626</a>
<a id='n2627' href='#n2627'>2627</a>
<a id='n2628' href='#n2628'>2628</a>
<a id='n2629' href='#n2629'>2629</a>
<a id='n2630' href='#n2630'>2630</a>
<a id='n2631' href='#n2631'>2631</a>
<a id='n2632' href='#n2632'>2632</a>
<a id='n2633' href='#n2633'>2633</a>
<a id='n2634' href='#n2634'>2634</a>
<a id='n2635' href='#n2635'>2635</a>
<a id='n2636' href='#n2636'>2636</a>
<a id='n2637' href='#n2637'>2637</a>
<a id='n2638' href='#n2638'>2638</a>
<a id='n2639' href='#n2639'>2639</a>
<a id='n2640' href='#n2640'>2640</a>
<a id='n2641' href='#n2641'>2641</a>
<a id='n2642' href='#n2642'>2642</a>
<a id='n2643' href='#n2643'>2643</a>
<a id='n2644' href='#n2644'>2644</a>
<a id='n2645' href='#n2645'>2645</a>
<a id='n2646' href='#n2646'>2646</a>
<a id='n2647' href='#n2647'>2647</a>
<a id='n2648' href='#n2648'>2648</a>
<a id='n2649' href='#n2649'>2649</a>
<a id='n2650' href='#n2650'>2650</a>
<a id='n2651' href='#n2651'>2651</a>
<a id='n2652' href='#n2652'>2652</a>
<a id='n2653' href='#n2653'>2653</a>
<a id='n2654' href='#n2654'>2654</a>
<a id='n2655' href='#n2655'>2655</a>
<a id='n2656' href='#n2656'>2656</a>
<a id='n2657' href='#n2657'>2657</a>
<a id='n2658' href='#n2658'>2658</a>
<a id='n2659' href='#n2659'>2659</a>
<a id='n2660' href='#n2660'>2660</a>
<a id='n2661' href='#n2661'>2661</a>
<a id='n2662' href='#n2662'>2662</a>
<a id='n2663' href='#n2663'>2663</a>
<a id='n2664' href='#n2664'>2664</a>
<a id='n2665' href='#n2665'>2665</a>
<a id='n2666' href='#n2666'>2666</a>
<a id='n2667' href='#n2667'>2667</a>
<a id='n2668' href='#n2668'>2668</a>
<a id='n2669' href='#n2669'>2669</a>
<a id='n2670' href='#n2670'>2670</a>
<a id='n2671' href='#n2671'>2671</a>
<a id='n2672' href='#n2672'>2672</a>
<a id='n2673' href='#n2673'>2673</a>
<a id='n2674' href='#n2674'>2674</a>
<a id='n2675' href='#n2675'>2675</a>
<a id='n2676' href='#n2676'>2676</a>
<a id='n2677' href='#n2677'>2677</a>
<a id='n2678' href='#n2678'>2678</a>
<a id='n2679' href='#n2679'>2679</a>
<a id='n2680' href='#n2680'>2680</a>
<a id='n2681' href='#n2681'>2681</a>
<a id='n2682' href='#n2682'>2682</a>
<a id='n2683' href='#n2683'>2683</a>
<a id='n2684' href='#n2684'>2684</a>
<a id='n2685' href='#n2685'>2685</a>
<a id='n2686' href='#n2686'>2686</a>
<a id='n2687' href='#n2687'>2687</a>
<a id='n2688' href='#n2688'>2688</a>
<a id='n2689' href='#n2689'>2689</a>
<a id='n2690' href='#n2690'>2690</a>
<a id='n2691' href='#n2691'>2691</a>
<a id='n2692' href='#n2692'>2692</a>
<a id='n2693' href='#n2693'>2693</a>
<a id='n2694' href='#n2694'>2694</a>
<a id='n2695' href='#n2695'>2695</a>
<a id='n2696' href='#n2696'>2696</a>
<a id='n2697' href='#n2697'>2697</a>
<a id='n2698' href='#n2698'>2698</a>
<a id='n2699' href='#n2699'>2699</a>
<a id='n2700' href='#n2700'>2700</a>
<a id='n2701' href='#n2701'>2701</a>
<a id='n2702' href='#n2702'>2702</a>
<a id='n2703' href='#n2703'>2703</a>
<a id='n2704' href='#n2704'>2704</a>
<a id='n2705' href='#n2705'>2705</a>
<a id='n2706' href='#n2706'>2706</a>
<a id='n2707' href='#n2707'>2707</a>
<a id='n2708' href='#n2708'>2708</a>
<a id='n2709' href='#n2709'>2709</a>
<a id='n2710' href='#n2710'>2710</a>
<a id='n2711' href='#n2711'>2711</a>
<a id='n2712' href='#n2712'>2712</a>
<a id='n2713' href='#n2713'>2713</a>
<a id='n2714' href='#n2714'>2714</a>
<a id='n2715' href='#n2715'>2715</a>
<a id='n2716' href='#n2716'>2716</a>
<a id='n2717' href='#n2717'>2717</a>
<a id='n2718' href='#n2718'>2718</a>
<a id='n2719' href='#n2719'>2719</a>
<a id='n2720' href='#n2720'>2720</a>
<a id='n2721' href='#n2721'>2721</a>
<a id='n2722' href='#n2722'>2722</a>
<a id='n2723' href='#n2723'>2723</a>
<a id='n2724' href='#n2724'>2724</a>
<a id='n2725' href='#n2725'>2725</a>
<a id='n2726' href='#n2726'>2726</a>
<a id='n2727' href='#n2727'>2727</a>
<a id='n2728' href='#n2728'>2728</a>
<a id='n2729' href='#n2729'>2729</a>
<a id='n2730' href='#n2730'>2730</a>
<a id='n2731' href='#n2731'>2731</a>
<a id='n2732' href='#n2732'>2732</a>
<a id='n2733' href='#n2733'>2733</a>
<a id='n2734' href='#n2734'>2734</a>
<a id='n2735' href='#n2735'>2735</a>
<a id='n2736' href='#n2736'>2736</a>
<a id='n2737' href='#n2737'>2737</a>
<a id='n2738' href='#n2738'>2738</a>
<a id='n2739' href='#n2739'>2739</a>
<a id='n2740' href='#n2740'>2740</a>
<a id='n2741' href='#n2741'>2741</a>
<a id='n2742' href='#n2742'>2742</a>
<a id='n2743' href='#n2743'>2743</a>
<a id='n2744' href='#n2744'>2744</a>
<a id='n2745' href='#n2745'>2745</a>
<a id='n2746' href='#n2746'>2746</a>
<a id='n2747' href='#n2747'>2747</a>
<a id='n2748' href='#n2748'>2748</a>
<a id='n2749' href='#n2749'>2749</a>
<a id='n2750' href='#n2750'>2750</a>
<a id='n2751' href='#n2751'>2751</a>
<a id='n2752' href='#n2752'>2752</a>
<a id='n2753' href='#n2753'>2753</a>
<a id='n2754' href='#n2754'>2754</a>
<a id='n2755' href='#n2755'>2755</a>
<a id='n2756' href='#n2756'>2756</a>
<a id='n2757' href='#n2757'>2757</a>
<a id='n2758' href='#n2758'>2758</a>
<a id='n2759' href='#n2759'>2759</a>
<a id='n2760' href='#n2760'>2760</a>
<a id='n2761' href='#n2761'>2761</a>
<a id='n2762' href='#n2762'>2762</a>
<a id='n2763' href='#n2763'>2763</a>
<a id='n2764' href='#n2764'>2764</a>
<a id='n2765' href='#n2765'>2765</a>
<a id='n2766' href='#n2766'>2766</a>
<a id='n2767' href='#n2767'>2767</a>
<a id='n2768' href='#n2768'>2768</a>
<a id='n2769' href='#n2769'>2769</a>
<a id='n2770' href='#n2770'>2770</a>
<a id='n2771' href='#n2771'>2771</a>
<a id='n2772' href='#n2772'>2772</a>
<a id='n2773' href='#n2773'>2773</a>
<a id='n2774' href='#n2774'>2774</a>
<a id='n2775' href='#n2775'>2775</a>
<a id='n2776' href='#n2776'>2776</a>
<a id='n2777' href='#n2777'>2777</a>
<a id='n2778' href='#n2778'>2778</a>
<a id='n2779' href='#n2779'>2779</a>
<a id='n2780' href='#n2780'>2780</a>
<a id='n2781' href='#n2781'>2781</a>
<a id='n2782' href='#n2782'>2782</a>
<a id='n2783' href='#n2783'>2783</a>
<a id='n2784' href='#n2784'>2784</a>
<a id='n2785' href='#n2785'>2785</a>
<a id='n2786' href='#n2786'>2786</a>
<a id='n2787' href='#n2787'>2787</a>
<a id='n2788' href='#n2788'>2788</a>
<a id='n2789' href='#n2789'>2789</a>
<a id='n2790' href='#n2790'>2790</a>
<a id='n2791' href='#n2791'>2791</a>
<a id='n2792' href='#n2792'>2792</a>
<a id='n2793' href='#n2793'>2793</a>
<a id='n2794' href='#n2794'>2794</a>
<a id='n2795' href='#n2795'>2795</a>
<a id='n2796' href='#n2796'>2796</a>
<a id='n2797' href='#n2797'>2797</a>
<a id='n2798' href='#n2798'>2798</a>
<a id='n2799' href='#n2799'>2799</a>
<a id='n2800' href='#n2800'>2800</a>
<a id='n2801' href='#n2801'>2801</a>
<a id='n2802' href='#n2802'>2802</a>
<a id='n2803' href='#n2803'>2803</a>
<a id='n2804' href='#n2804'>2804</a>
<a id='n2805' href='#n2805'>2805</a>
<a id='n2806' href='#n2806'>2806</a>
<a id='n2807' href='#n2807'>2807</a>
<a id='n2808' href='#n2808'>2808</a>
<a id='n2809' href='#n2809'>2809</a>
<a id='n2810' href='#n2810'>2810</a>
<a id='n2811' href='#n2811'>2811</a>
<a id='n2812' href='#n2812'>2812</a>
<a id='n2813' href='#n2813'>2813</a>
<a id='n2814' href='#n2814'>2814</a>
<a id='n2815' href='#n2815'>2815</a>
<a id='n2816' href='#n2816'>2816</a>
<a id='n2817' href='#n2817'>2817</a>
<a id='n2818' href='#n2818'>2818</a>
<a id='n2819' href='#n2819'>2819</a>
<a id='n2820' href='#n2820'>2820</a>
<a id='n2821' href='#n2821'>2821</a>
<a id='n2822' href='#n2822'>2822</a>
<a id='n2823' href='#n2823'>2823</a>
<a id='n2824' href='#n2824'>2824</a>
<a id='n2825' href='#n2825'>2825</a>
<a id='n2826' href='#n2826'>2826</a>
<a id='n2827' href='#n2827'>2827</a>
<a id='n2828' href='#n2828'>2828</a>
<a id='n2829' href='#n2829'>2829</a>
<a id='n2830' href='#n2830'>2830</a>
<a id='n2831' href='#n2831'>2831</a>
<a id='n2832' href='#n2832'>2832</a>
<a id='n2833' href='#n2833'>2833</a>
<a id='n2834' href='#n2834'>2834</a>
<a id='n2835' href='#n2835'>2835</a>
<a id='n2836' href='#n2836'>2836</a>
<a id='n2837' href='#n2837'>2837</a>
<a id='n2838' href='#n2838'>2838</a>
<a id='n2839' href='#n2839'>2839</a>
<a id='n2840' href='#n2840'>2840</a>
<a id='n2841' href='#n2841'>2841</a>
<a id='n2842' href='#n2842'>2842</a>
<a id='n2843' href='#n2843'>2843</a>
<a id='n2844' href='#n2844'>2844</a>
<a id='n2845' href='#n2845'>2845</a>
<a id='n2846' href='#n2846'>2846</a>
<a id='n2847' href='#n2847'>2847</a>
<a id='n2848' href='#n2848'>2848</a>
<a id='n2849' href='#n2849'>2849</a>
<a id='n2850' href='#n2850'>2850</a>
<a id='n2851' href='#n2851'>2851</a>
<a id='n2852' href='#n2852'>2852</a>
<a id='n2853' href='#n2853'>2853</a>
<a id='n2854' href='#n2854'>2854</a>
<a id='n2855' href='#n2855'>2855</a>
<a id='n2856' href='#n2856'>2856</a>
<a id='n2857' href='#n2857'>2857</a>
<a id='n2858' href='#n2858'>2858</a>
<a id='n2859' href='#n2859'>2859</a>
<a id='n2860' href='#n2860'>2860</a>
<a id='n2861' href='#n2861'>2861</a>
<a id='n2862' href='#n2862'>2862</a>
<a id='n2863' href='#n2863'>2863</a>
<a id='n2864' href='#n2864'>2864</a>
<a id='n2865' href='#n2865'>2865</a>
<a id='n2866' href='#n2866'>2866</a>
<a id='n2867' href='#n2867'>2867</a>
<a id='n2868' href='#n2868'>2868</a>
<a id='n2869' href='#n2869'>2869</a>
<a id='n2870' href='#n2870'>2870</a>
<a id='n2871' href='#n2871'>2871</a>
<a id='n2872' href='#n2872'>2872</a>
<a id='n2873' href='#n2873'>2873</a>
<a id='n2874' href='#n2874'>2874</a>
<a id='n2875' href='#n2875'>2875</a>
<a id='n2876' href='#n2876'>2876</a>
<a id='n2877' href='#n2877'>2877</a>
<a id='n2878' href='#n2878'>2878</a>
<a id='n2879' href='#n2879'>2879</a>
<a id='n2880' href='#n2880'>2880</a>
<a id='n2881' href='#n2881'>2881</a>
<a id='n2882' href='#n2882'>2882</a>
<a id='n2883' href='#n2883'>2883</a>
<a id='n2884' href='#n2884'>2884</a>
<a id='n2885' href='#n2885'>2885</a>
<a id='n2886' href='#n2886'>2886</a>
<a id='n2887' href='#n2887'>2887</a>
<a id='n2888' href='#n2888'>2888</a>
<a id='n2889' href='#n2889'>2889</a>
<a id='n2890' href='#n2890'>2890</a>
<a id='n2891' href='#n2891'>2891</a>
<a id='n2892' href='#n2892'>2892</a>
<a id='n2893' href='#n2893'>2893</a>
<a id='n2894' href='#n2894'>2894</a>
<a id='n2895' href='#n2895'>2895</a>
<a id='n2896' href='#n2896'>2896</a>
<a id='n2897' href='#n2897'>2897</a>
<a id='n2898' href='#n2898'>2898</a>
<a id='n2899' href='#n2899'>2899</a>
<a id='n2900' href='#n2900'>2900</a>
<a id='n2901' href='#n2901'>2901</a>
<a id='n2902' href='#n2902'>2902</a>
<a id='n2903' href='#n2903'>2903</a>
<a id='n2904' href='#n2904'>2904</a>
<a id='n2905' href='#n2905'>2905</a>
<a id='n2906' href='#n2906'>2906</a>
<a id='n2907' href='#n2907'>2907</a>
<a id='n2908' href='#n2908'>2908</a>
<a id='n2909' href='#n2909'>2909</a>
<a id='n2910' href='#n2910'>2910</a>
<a id='n2911' href='#n2911'>2911</a>
<a id='n2912' href='#n2912'>2912</a>
<a id='n2913' href='#n2913'>2913</a>
<a id='n2914' href='#n2914'>2914</a>
<a id='n2915' href='#n2915'>2915</a>
<a id='n2916' href='#n2916'>2916</a>
<a id='n2917' href='#n2917'>2917</a>
<a id='n2918' href='#n2918'>2918</a>
<a id='n2919' href='#n2919'>2919</a>
<a id='n2920' href='#n2920'>2920</a>
<a id='n2921' href='#n2921'>2921</a>
<a id='n2922' href='#n2922'>2922</a>
<a id='n2923' href='#n2923'>2923</a>
<a id='n2924' href='#n2924'>2924</a>
<a id='n2925' href='#n2925'>2925</a>
<a id='n2926' href='#n2926'>2926</a>
<a id='n2927' href='#n2927'>2927</a>
<a id='n2928' href='#n2928'>2928</a>
<a id='n2929' href='#n2929'>2929</a>
<a id='n2930' href='#n2930'>2930</a>
<a id='n2931' href='#n2931'>2931</a>
<a id='n2932' href='#n2932'>2932</a>
<a id='n2933' href='#n2933'>2933</a>
<a id='n2934' href='#n2934'>2934</a>
<a id='n2935' href='#n2935'>2935</a>
<a id='n2936' href='#n2936'>2936</a>
<a id='n2937' href='#n2937'>2937</a>
<a id='n2938' href='#n2938'>2938</a>
<a id='n2939' href='#n2939'>2939</a>
<a id='n2940' href='#n2940'>2940</a>
<a id='n2941' href='#n2941'>2941</a>
<a id='n2942' href='#n2942'>2942</a>
<a id='n2943' href='#n2943'>2943</a>
<a id='n2944' href='#n2944'>2944</a>
<a id='n2945' href='#n2945'>2945</a>
<a id='n2946' href='#n2946'>2946</a>
<a id='n2947' href='#n2947'>2947</a>
<a id='n2948' href='#n2948'>2948</a>
<a id='n2949' href='#n2949'>2949</a>
<a id='n2950' href='#n2950'>2950</a>
<a id='n2951' href='#n2951'>2951</a>
<a id='n2952' href='#n2952'>2952</a>
<a id='n2953' href='#n2953'>2953</a>
<a id='n2954' href='#n2954'>2954</a>
<a id='n2955' href='#n2955'>2955</a>
<a id='n2956' href='#n2956'>2956</a>
<a id='n2957' href='#n2957'>2957</a>
<a id='n2958' href='#n2958'>2958</a>
<a id='n2959' href='#n2959'>2959</a>
<a id='n2960' href='#n2960'>2960</a>
<a id='n2961' href='#n2961'>2961</a>
<a id='n2962' href='#n2962'>2962</a>
<a id='n2963' href='#n2963'>2963</a>
<a id='n2964' href='#n2964'>2964</a>
<a id='n2965' href='#n2965'>2965</a>
<a id='n2966' href='#n2966'>2966</a>
<a id='n2967' href='#n2967'>2967</a>
<a id='n2968' href='#n2968'>2968</a>
<a id='n2969' href='#n2969'>2969</a>
<a id='n2970' href='#n2970'>2970</a>
<a id='n2971' href='#n2971'>2971</a>
<a id='n2972' href='#n2972'>2972</a>
<a id='n2973' href='#n2973'>2973</a>
<a id='n2974' href='#n2974'>2974</a>
<a id='n2975' href='#n2975'>2975</a>
<a id='n2976' href='#n2976'>2976</a>
<a id='n2977' href='#n2977'>2977</a>
<a id='n2978' href='#n2978'>2978</a>
<a id='n2979' href='#n2979'>2979</a>
<a id='n2980' href='#n2980'>2980</a>
<a id='n2981' href='#n2981'>2981</a>
<a id='n2982' href='#n2982'>2982</a>
<a id='n2983' href='#n2983'>2983</a>
<a id='n2984' href='#n2984'>2984</a>
<a id='n2985' href='#n2985'>2985</a>
<a id='n2986' href='#n2986'>2986</a>
<a id='n2987' href='#n2987'>2987</a>
<a id='n2988' href='#n2988'>2988</a>
<a id='n2989' href='#n2989'>2989</a>
<a id='n2990' href='#n2990'>2990</a>
<a id='n2991' href='#n2991'>2991</a>
<a id='n2992' href='#n2992'>2992</a>
<a id='n2993' href='#n2993'>2993</a>
<a id='n2994' href='#n2994'>2994</a>
<a id='n2995' href='#n2995'>2995</a>
<a id='n2996' href='#n2996'>2996</a>
<a id='n2997' href='#n2997'>2997</a>
<a id='n2998' href='#n2998'>2998</a>
<a id='n2999' href='#n2999'>2999</a>
<a id='n3000' href='#n3000'>3000</a>
<a id='n3001' href='#n3001'>3001</a>
<a id='n3002' href='#n3002'>3002</a>
<a id='n3003' href='#n3003'>3003</a>
<a id='n3004' href='#n3004'>3004</a>
<a id='n3005' href='#n3005'>3005</a>
<a id='n3006' href='#n3006'>3006</a>
<a id='n3007' href='#n3007'>3007</a>
<a id='n3008' href='#n3008'>3008</a>
<a id='n3009' href='#n3009'>3009</a>
<a id='n3010' href='#n3010'>3010</a>
<a id='n3011' href='#n3011'>3011</a>
<a id='n3012' href='#n3012'>3012</a>
<a id='n3013' href='#n3013'>3013</a>
<a id='n3014' href='#n3014'>3014</a>
<a id='n3015' href='#n3015'>3015</a>
<a id='n3016' href='#n3016'>3016</a>
<a id='n3017' href='#n3017'>3017</a>
<a id='n3018' href='#n3018'>3018</a>
<a id='n3019' href='#n3019'>3019</a>
<a id='n3020' href='#n3020'>3020</a>
<a id='n3021' href='#n3021'>3021</a>
<a id='n3022' href='#n3022'>3022</a>
<a id='n3023' href='#n3023'>3023</a>
<a id='n3024' href='#n3024'>3024</a>
<a id='n3025' href='#n3025'>3025</a>
<a id='n3026' href='#n3026'>3026</a>
<a id='n3027' href='#n3027'>3027</a>
<a id='n3028' href='#n3028'>3028</a>
<a id='n3029' href='#n3029'>3029</a>
<a id='n3030' href='#n3030'>3030</a>
<a id='n3031' href='#n3031'>3031</a>
<a id='n3032' href='#n3032'>3032</a>
<a id='n3033' href='#n3033'>3033</a>
<a id='n3034' href='#n3034'>3034</a>
<a id='n3035' href='#n3035'>3035</a>
<a id='n3036' href='#n3036'>3036</a>
<a id='n3037' href='#n3037'>3037</a>
<a id='n3038' href='#n3038'>3038</a>
<a id='n3039' href='#n3039'>3039</a>
<a id='n3040' href='#n3040'>3040</a>
<a id='n3041' href='#n3041'>3041</a>
<a id='n3042' href='#n3042'>3042</a>
<a id='n3043' href='#n3043'>3043</a>
<a id='n3044' href='#n3044'>3044</a>
<a id='n3045' href='#n3045'>3045</a>
<a id='n3046' href='#n3046'>3046</a>
<a id='n3047' href='#n3047'>3047</a>
<a id='n3048' href='#n3048'>3048</a>
<a id='n3049' href='#n3049'>3049</a>
<a id='n3050' href='#n3050'>3050</a>
<a id='n3051' href='#n3051'>3051</a>
<a id='n3052' href='#n3052'>3052</a>
<a id='n3053' href='#n3053'>3053</a>
<a id='n3054' href='#n3054'>3054</a>
<a id='n3055' href='#n3055'>3055</a>
<a id='n3056' href='#n3056'>3056</a>
<a id='n3057' href='#n3057'>3057</a>
<a id='n3058' href='#n3058'>3058</a>
<a id='n3059' href='#n3059'>3059</a>
<a id='n3060' href='#n3060'>3060</a>
<a id='n3061' href='#n3061'>3061</a>
<a id='n3062' href='#n3062'>3062</a>
<a id='n3063' href='#n3063'>3063</a>
<a id='n3064' href='#n3064'>3064</a>
<a id='n3065' href='#n3065'>3065</a>
<a id='n3066' href='#n3066'>3066</a>
<a id='n3067' href='#n3067'>3067</a>
<a id='n3068' href='#n3068'>3068</a>
<a id='n3069' href='#n3069'>3069</a>
<a id='n3070' href='#n3070'>3070</a>
<a id='n3071' href='#n3071'>3071</a>
<a id='n3072' href='#n3072'>3072</a>
<a id='n3073' href='#n3073'>3073</a>
<a id='n3074' href='#n3074'>3074</a>
<a id='n3075' href='#n3075'>3075</a>
<a id='n3076' href='#n3076'>3076</a>
<a id='n3077' href='#n3077'>3077</a>
<a id='n3078' href='#n3078'>3078</a>
<a id='n3079' href='#n3079'>3079</a>
<a id='n3080' href='#n3080'>3080</a>
<a id='n3081' href='#n3081'>3081</a>
<a id='n3082' href='#n3082'>3082</a>
<a id='n3083' href='#n3083'>3083</a>
<a id='n3084' href='#n3084'>3084</a>
<a id='n3085' href='#n3085'>3085</a>
<a id='n3086' href='#n3086'>3086</a>
<a id='n3087' href='#n3087'>3087</a>
<a id='n3088' href='#n3088'>3088</a>
<a id='n3089' href='#n3089'>3089</a>
<a id='n3090' href='#n3090'>3090</a>
<a id='n3091' href='#n3091'>3091</a>
<a id='n3092' href='#n3092'>3092</a>
<a id='n3093' href='#n3093'>3093</a>
<a id='n3094' href='#n3094'>3094</a>
<a id='n3095' href='#n3095'>3095</a>
<a id='n3096' href='#n3096'>3096</a>
<a id='n3097' href='#n3097'>3097</a>
<a id='n3098' href='#n3098'>3098</a>
<a id='n3099' href='#n3099'>3099</a>
<a id='n3100' href='#n3100'>3100</a>
<a id='n3101' href='#n3101'>3101</a>
<a id='n3102' href='#n3102'>3102</a>
<a id='n3103' href='#n3103'>3103</a>
<a id='n3104' href='#n3104'>3104</a>
<a id='n3105' href='#n3105'>3105</a>
<a id='n3106' href='#n3106'>3106</a>
<a id='n3107' href='#n3107'>3107</a>
<a id='n3108' href='#n3108'>3108</a>
<a id='n3109' href='#n3109'>3109</a>
<a id='n3110' href='#n3110'>3110</a>
<a id='n3111' href='#n3111'>3111</a>
<a id='n3112' href='#n3112'>3112</a>
<a id='n3113' href='#n3113'>3113</a>
<a id='n3114' href='#n3114'>3114</a>
<a id='n3115' href='#n3115'>3115</a>
<a id='n3116' href='#n3116'>3116</a>
<a id='n3117' href='#n3117'>3117</a>
<a id='n3118' href='#n3118'>3118</a>
<a id='n3119' href='#n3119'>3119</a>
<a id='n3120' href='#n3120'>3120</a>
<a id='n3121' href='#n3121'>3121</a>
<a id='n3122' href='#n3122'>3122</a>
<a id='n3123' href='#n3123'>3123</a>
<a id='n3124' href='#n3124'>3124</a>
<a id='n3125' href='#n3125'>3125</a>
<a id='n3126' href='#n3126'>3126</a>
<a id='n3127' href='#n3127'>3127</a>
<a id='n3128' href='#n3128'>3128</a>
<a id='n3129' href='#n3129'>3129</a>
<a id='n3130' href='#n3130'>3130</a>
<a id='n3131' href='#n3131'>3131</a>
<a id='n3132' href='#n3132'>3132</a>
<a id='n3133' href='#n3133'>3133</a>
<a id='n3134' href='#n3134'>3134</a>
<a id='n3135' href='#n3135'>3135</a>
<a id='n3136' href='#n3136'>3136</a>
<a id='n3137' href='#n3137'>3137</a>
<a id='n3138' href='#n3138'>3138</a>
<a id='n3139' href='#n3139'>3139</a>
<a id='n3140' href='#n3140'>3140</a>
<a id='n3141' href='#n3141'>3141</a>
<a id='n3142' href='#n3142'>3142</a>
<a id='n3143' href='#n3143'>3143</a>
<a id='n3144' href='#n3144'>3144</a>
<a id='n3145' href='#n3145'>3145</a>
<a id='n3146' href='#n3146'>3146</a>
<a id='n3147' href='#n3147'>3147</a>
<a id='n3148' href='#n3148'>3148</a>
<a id='n3149' href='#n3149'>3149</a>
<a id='n3150' href='#n3150'>3150</a>
<a id='n3151' href='#n3151'>3151</a>
<a id='n3152' href='#n3152'>3152</a>
<a id='n3153' href='#n3153'>3153</a>
<a id='n3154' href='#n3154'>3154</a>
<a id='n3155' href='#n3155'>3155</a>
<a id='n3156' href='#n3156'>3156</a>
<a id='n3157' href='#n3157'>3157</a>
<a id='n3158' href='#n3158'>3158</a>
<a id='n3159' href='#n3159'>3159</a>
<a id='n3160' href='#n3160'>3160</a>
<a id='n3161' href='#n3161'>3161</a>
<a id='n3162' href='#n3162'>3162</a>
<a id='n3163' href='#n3163'>3163</a>
<a id='n3164' href='#n3164'>3164</a>
<a id='n3165' href='#n3165'>3165</a>
<a id='n3166' href='#n3166'>3166</a>
<a id='n3167' href='#n3167'>3167</a>
<a id='n3168' href='#n3168'>3168</a>
<a id='n3169' href='#n3169'>3169</a>
<a id='n3170' href='#n3170'>3170</a>
<a id='n3171' href='#n3171'>3171</a>
<a id='n3172' href='#n3172'>3172</a>
<a id='n3173' href='#n3173'>3173</a>
<a id='n3174' href='#n3174'>3174</a>
<a id='n3175' href='#n3175'>3175</a>
<a id='n3176' href='#n3176'>3176</a>
<a id='n3177' href='#n3177'>3177</a>
<a id='n3178' href='#n3178'>3178</a>
<a id='n3179' href='#n3179'>3179</a>
<a id='n3180' href='#n3180'>3180</a>
<a id='n3181' href='#n3181'>3181</a>
<a id='n3182' href='#n3182'>3182</a>
<a id='n3183' href='#n3183'>3183</a>
<a id='n3184' href='#n3184'>3184</a>
<a id='n3185' href='#n3185'>3185</a>
<a id='n3186' href='#n3186'>3186</a>
<a id='n3187' href='#n3187'>3187</a>
<a id='n3188' href='#n3188'>3188</a>
<a id='n3189' href='#n3189'>3189</a>
<a id='n3190' href='#n3190'>3190</a>
<a id='n3191' href='#n3191'>3191</a>
<a id='n3192' href='#n3192'>3192</a>
<a id='n3193' href='#n3193'>3193</a>
<a id='n3194' href='#n3194'>3194</a>
<a id='n3195' href='#n3195'>3195</a>
<a id='n3196' href='#n3196'>3196</a>
<a id='n3197' href='#n3197'>3197</a>
<a id='n3198' href='#n3198'>3198</a>
<a id='n3199' href='#n3199'>3199</a>
<a id='n3200' href='#n3200'>3200</a>
<a id='n3201' href='#n3201'>3201</a>
<a id='n3202' href='#n3202'>3202</a>
<a id='n3203' href='#n3203'>3203</a>
<a id='n3204' href='#n3204'>3204</a>
<a id='n3205' href='#n3205'>3205</a>
<a id='n3206' href='#n3206'>3206</a>
<a id='n3207' href='#n3207'>3207</a>
<a id='n3208' href='#n3208'>3208</a>
<a id='n3209' href='#n3209'>3209</a>
<a id='n3210' href='#n3210'>3210</a>
<a id='n3211' href='#n3211'>3211</a>
<a id='n3212' href='#n3212'>3212</a>
<a id='n3213' href='#n3213'>3213</a>
<a id='n3214' href='#n3214'>3214</a>
<a id='n3215' href='#n3215'>3215</a>
<a id='n3216' href='#n3216'>3216</a>
<a id='n3217' href='#n3217'>3217</a>
<a id='n3218' href='#n3218'>3218</a>
<a id='n3219' href='#n3219'>3219</a>
<a id='n3220' href='#n3220'>3220</a>
<a id='n3221' href='#n3221'>3221</a>
<a id='n3222' href='#n3222'>3222</a>
<a id='n3223' href='#n3223'>3223</a>
<a id='n3224' href='#n3224'>3224</a>
<a id='n3225' href='#n3225'>3225</a>
<a id='n3226' href='#n3226'>3226</a>
<a id='n3227' href='#n3227'>3227</a>
<a id='n3228' href='#n3228'>3228</a>
<a id='n3229' href='#n3229'>3229</a>
<a id='n3230' href='#n3230'>3230</a>
<a id='n3231' href='#n3231'>3231</a>
<a id='n3232' href='#n3232'>3232</a>
<a id='n3233' href='#n3233'>3233</a>
<a id='n3234' href='#n3234'>3234</a>
<a id='n3235' href='#n3235'>3235</a>
<a id='n3236' href='#n3236'>3236</a>
<a id='n3237' href='#n3237'>3237</a>
<a id='n3238' href='#n3238'>3238</a>
<a id='n3239' href='#n3239'>3239</a>
<a id='n3240' href='#n3240'>3240</a>
<a id='n3241' href='#n3241'>3241</a>
<a id='n3242' href='#n3242'>3242</a>
<a id='n3243' href='#n3243'>3243</a>
<a id='n3244' href='#n3244'>3244</a>
<a id='n3245' href='#n3245'>3245</a>
<a id='n3246' href='#n3246'>3246</a>
<a id='n3247' href='#n3247'>3247</a>
<a id='n3248' href='#n3248'>3248</a>
<a id='n3249' href='#n3249'>3249</a>
<a id='n3250' href='#n3250'>3250</a>
<a id='n3251' href='#n3251'>3251</a>
<a id='n3252' href='#n3252'>3252</a>
<a id='n3253' href='#n3253'>3253</a>
<a id='n3254' href='#n3254'>3254</a>
<a id='n3255' href='#n3255'>3255</a>
<a id='n3256' href='#n3256'>3256</a>
<a id='n3257' href='#n3257'>3257</a>
<a id='n3258' href='#n3258'>3258</a>
<a id='n3259' href='#n3259'>3259</a>
<a id='n3260' href='#n3260'>3260</a>
<a id='n3261' href='#n3261'>3261</a>
<a id='n3262' href='#n3262'>3262</a>
<a id='n3263' href='#n3263'>3263</a>
<a id='n3264' href='#n3264'>3264</a>
<a id='n3265' href='#n3265'>3265</a>
<a id='n3266' href='#n3266'>3266</a>
<a id='n3267' href='#n3267'>3267</a>
<a id='n3268' href='#n3268'>3268</a>
<a id='n3269' href='#n3269'>3269</a>
<a id='n3270' href='#n3270'>3270</a>
<a id='n3271' href='#n3271'>3271</a>
<a id='n3272' href='#n3272'>3272</a>
<a id='n3273' href='#n3273'>3273</a>
<a id='n3274' href='#n3274'>3274</a>
<a id='n3275' href='#n3275'>3275</a>
<a id='n3276' href='#n3276'>3276</a>
<a id='n3277' href='#n3277'>3277</a>
<a id='n3278' href='#n3278'>3278</a>
<a id='n3279' href='#n3279'>3279</a>
<a id='n3280' href='#n3280'>3280</a>
<a id='n3281' href='#n3281'>3281</a>
<a id='n3282' href='#n3282'>3282</a>
<a id='n3283' href='#n3283'>3283</a>
<a id='n3284' href='#n3284'>3284</a>
<a id='n3285' href='#n3285'>3285</a>
<a id='n3286' href='#n3286'>3286</a>
<a id='n3287' href='#n3287'>3287</a>
<a id='n3288' href='#n3288'>3288</a>
<a id='n3289' href='#n3289'>3289</a>
<a id='n3290' href='#n3290'>3290</a>
<a id='n3291' href='#n3291'>3291</a>
<a id='n3292' href='#n3292'>3292</a>
<a id='n3293' href='#n3293'>3293</a>
<a id='n3294' href='#n3294'>3294</a>
<a id='n3295' href='#n3295'>3295</a>
<a id='n3296' href='#n3296'>3296</a>
<a id='n3297' href='#n3297'>3297</a>
<a id='n3298' href='#n3298'>3298</a>
<a id='n3299' href='#n3299'>3299</a>
<a id='n3300' href='#n3300'>3300</a>
<a id='n3301' href='#n3301'>3301</a>
<a id='n3302' href='#n3302'>3302</a>
<a id='n3303' href='#n3303'>3303</a>
<a id='n3304' href='#n3304'>3304</a>
<a id='n3305' href='#n3305'>3305</a>
<a id='n3306' href='#n3306'>3306</a>
<a id='n3307' href='#n3307'>3307</a>
<a id='n3308' href='#n3308'>3308</a>
<a id='n3309' href='#n3309'>3309</a>
<a id='n3310' href='#n3310'>3310</a>
<a id='n3311' href='#n3311'>3311</a>
<a id='n3312' href='#n3312'>3312</a>
<a id='n3313' href='#n3313'>3313</a>
<a id='n3314' href='#n3314'>3314</a>
<a id='n3315' href='#n3315'>3315</a>
<a id='n3316' href='#n3316'>3316</a>
<a id='n3317' href='#n3317'>3317</a>
<a id='n3318' href='#n3318'>3318</a>
<a id='n3319' href='#n3319'>3319</a>
<a id='n3320' href='#n3320'>3320</a>
<a id='n3321' href='#n3321'>3321</a>
<a id='n3322' href='#n3322'>3322</a>
<a id='n3323' href='#n3323'>3323</a>
<a id='n3324' href='#n3324'>3324</a>
<a id='n3325' href='#n3325'>3325</a>
<a id='n3326' href='#n3326'>3326</a>
<a id='n3327' href='#n3327'>3327</a>
<a id='n3328' href='#n3328'>3328</a>
<a id='n3329' href='#n3329'>3329</a>
<a id='n3330' href='#n3330'>3330</a>
<a id='n3331' href='#n3331'>3331</a>
<a id='n3332' href='#n3332'>3332</a>
<a id='n3333' href='#n3333'>3333</a>
<a id='n3334' href='#n3334'>3334</a>
<a id='n3335' href='#n3335'>3335</a>
<a id='n3336' href='#n3336'>3336</a>
<a id='n3337' href='#n3337'>3337</a>
<a id='n3338' href='#n3338'>3338</a>
<a id='n3339' href='#n3339'>3339</a>
<a id='n3340' href='#n3340'>3340</a>
<a id='n3341' href='#n3341'>3341</a>
<a id='n3342' href='#n3342'>3342</a>
<a id='n3343' href='#n3343'>3343</a>
<a id='n3344' href='#n3344'>3344</a>
<a id='n3345' href='#n3345'>3345</a>
<a id='n3346' href='#n3346'>3346</a>
<a id='n3347' href='#n3347'>3347</a>
<a id='n3348' href='#n3348'>3348</a>
<a id='n3349' href='#n3349'>3349</a>
<a id='n3350' href='#n3350'>3350</a>
<a id='n3351' href='#n3351'>3351</a>
<a id='n3352' href='#n3352'>3352</a>
<a id='n3353' href='#n3353'>3353</a>
<a id='n3354' href='#n3354'>3354</a>
<a id='n3355' href='#n3355'>3355</a>
<a id='n3356' href='#n3356'>3356</a>
<a id='n3357' href='#n3357'>3357</a>
<a id='n3358' href='#n3358'>3358</a>
<a id='n3359' href='#n3359'>3359</a>
<a id='n3360' href='#n3360'>3360</a>
<a id='n3361' href='#n3361'>3361</a>
<a id='n3362' href='#n3362'>3362</a>
<a id='n3363' href='#n3363'>3363</a>
<a id='n3364' href='#n3364'>3364</a>
<a id='n3365' href='#n3365'>3365</a>
<a id='n3366' href='#n3366'>3366</a>
<a id='n3367' href='#n3367'>3367</a>
<a id='n3368' href='#n3368'>3368</a>
<a id='n3369' href='#n3369'>3369</a>
<a id='n3370' href='#n3370'>3370</a>
<a id='n3371' href='#n3371'>3371</a>
<a id='n3372' href='#n3372'>3372</a>
<a id='n3373' href='#n3373'>3373</a>
<a id='n3374' href='#n3374'>3374</a>
<a id='n3375' href='#n3375'>3375</a>
<a id='n3376' href='#n3376'>3376</a>
<a id='n3377' href='#n3377'>3377</a>
<a id='n3378' href='#n3378'>3378</a>
<a id='n3379' href='#n3379'>3379</a>
<a id='n3380' href='#n3380'>3380</a>
<a id='n3381' href='#n3381'>3381</a>
<a id='n3382' href='#n3382'>3382</a>
<a id='n3383' href='#n3383'>3383</a>
<a id='n3384' href='#n3384'>3384</a>
<a id='n3385' href='#n3385'>3385</a>
<a id='n3386' href='#n3386'>3386</a>
<a id='n3387' href='#n3387'>3387</a>
<a id='n3388' href='#n3388'>3388</a>
<a id='n3389' href='#n3389'>3389</a>
<a id='n3390' href='#n3390'>3390</a>
<a id='n3391' href='#n3391'>3391</a>
<a id='n3392' href='#n3392'>3392</a>
<a id='n3393' href='#n3393'>3393</a>
<a id='n3394' href='#n3394'>3394</a>
<a id='n3395' href='#n3395'>3395</a>
<a id='n3396' href='#n3396'>3396</a>
<a id='n3397' href='#n3397'>3397</a>
<a id='n3398' href='#n3398'>3398</a>
<a id='n3399' href='#n3399'>3399</a>
<a id='n3400' href='#n3400'>3400</a>
<a id='n3401' href='#n3401'>3401</a>
<a id='n3402' href='#n3402'>3402</a>
<a id='n3403' href='#n3403'>3403</a>
<a id='n3404' href='#n3404'>3404</a>
<a id='n3405' href='#n3405'>3405</a>
<a id='n3406' href='#n3406'>3406</a>
<a id='n3407' href='#n3407'>3407</a>
<a id='n3408' href='#n3408'>3408</a>
<a id='n3409' href='#n3409'>3409</a>
<a id='n3410' href='#n3410'>3410</a>
<a id='n3411' href='#n3411'>3411</a>
<a id='n3412' href='#n3412'>3412</a>
<a id='n3413' href='#n3413'>3413</a>
<a id='n3414' href='#n3414'>3414</a>
<a id='n3415' href='#n3415'>3415</a>
<a id='n3416' href='#n3416'>3416</a>
<a id='n3417' href='#n3417'>3417</a>
<a id='n3418' href='#n3418'>3418</a>
<a id='n3419' href='#n3419'>3419</a>
<a id='n3420' href='#n3420'>3420</a>
<a id='n3421' href='#n3421'>3421</a>
<a id='n3422' href='#n3422'>3422</a>
<a id='n3423' href='#n3423'>3423</a>
<a id='n3424' href='#n3424'>3424</a>
<a id='n3425' href='#n3425'>3425</a>
<a id='n3426' href='#n3426'>3426</a>
<a id='n3427' href='#n3427'>3427</a>
<a id='n3428' href='#n3428'>3428</a>
<a id='n3429' href='#n3429'>3429</a>
<a id='n3430' href='#n3430'>3430</a>
<a id='n3431' href='#n3431'>3431</a>
<a id='n3432' href='#n3432'>3432</a>
<a id='n3433' href='#n3433'>3433</a>
<a id='n3434' href='#n3434'>3434</a>
<a id='n3435' href='#n3435'>3435</a>
<a id='n3436' href='#n3436'>3436</a>
<a id='n3437' href='#n3437'>3437</a>
<a id='n3438' href='#n3438'>3438</a>
<a id='n3439' href='#n3439'>3439</a>
<a id='n3440' href='#n3440'>3440</a>
<a id='n3441' href='#n3441'>3441</a>
<a id='n3442' href='#n3442'>3442</a>
<a id='n3443' href='#n3443'>3443</a>
<a id='n3444' href='#n3444'>3444</a>
<a id='n3445' href='#n3445'>3445</a>
<a id='n3446' href='#n3446'>3446</a>
<a id='n3447' href='#n3447'>3447</a>
<a id='n3448' href='#n3448'>3448</a>
<a id='n3449' href='#n3449'>3449</a>
<a id='n3450' href='#n3450'>3450</a>
<a id='n3451' href='#n3451'>3451</a>
<a id='n3452' href='#n3452'>3452</a>
<a id='n3453' href='#n3453'>3453</a>
<a id='n3454' href='#n3454'>3454</a>
<a id='n3455' href='#n3455'>3455</a>
<a id='n3456' href='#n3456'>3456</a>
<a id='n3457' href='#n3457'>3457</a>
<a id='n3458' href='#n3458'>3458</a>
<a id='n3459' href='#n3459'>3459</a>
<a id='n3460' href='#n3460'>3460</a>
<a id='n3461' href='#n3461'>3461</a>
<a id='n3462' href='#n3462'>3462</a>
<a id='n3463' href='#n3463'>3463</a>
<a id='n3464' href='#n3464'>3464</a>
<a id='n3465' href='#n3465'>3465</a>
<a id='n3466' href='#n3466'>3466</a>
<a id='n3467' href='#n3467'>3467</a>
<a id='n3468' href='#n3468'>3468</a>
<a id='n3469' href='#n3469'>3469</a>
<a id='n3470' href='#n3470'>3470</a>
<a id='n3471' href='#n3471'>3471</a>
<a id='n3472' href='#n3472'>3472</a>
<a id='n3473' href='#n3473'>3473</a>
<a id='n3474' href='#n3474'>3474</a>
<a id='n3475' href='#n3475'>3475</a>
<a id='n3476' href='#n3476'>3476</a>
<a id='n3477' href='#n3477'>3477</a>
<a id='n3478' href='#n3478'>3478</a>
<a id='n3479' href='#n3479'>3479</a>
<a id='n3480' href='#n3480'>3480</a>
<a id='n3481' href='#n3481'>3481</a>
<a id='n3482' href='#n3482'>3482</a>
<a id='n3483' href='#n3483'>3483</a>
<a id='n3484' href='#n3484'>3484</a>
<a id='n3485' href='#n3485'>3485</a>
<a id='n3486' href='#n3486'>3486</a>
<a id='n3487' href='#n3487'>3487</a>
<a id='n3488' href='#n3488'>3488</a>
<a id='n3489' href='#n3489'>3489</a>
<a id='n3490' href='#n3490'>3490</a>
<a id='n3491' href='#n3491'>3491</a>
<a id='n3492' href='#n3492'>3492</a>
<a id='n3493' href='#n3493'>3493</a>
<a id='n3494' href='#n3494'>3494</a>
<a id='n3495' href='#n3495'>3495</a>
<a id='n3496' href='#n3496'>3496</a>
<a id='n3497' href='#n3497'>3497</a>
<a id='n3498' href='#n3498'>3498</a>
<a id='n3499' href='#n3499'>3499</a>
<a id='n3500' href='#n3500'>3500</a>
<a id='n3501' href='#n3501'>3501</a>
<a id='n3502' href='#n3502'>3502</a>
<a id='n3503' href='#n3503'>3503</a>
<a id='n3504' href='#n3504'>3504</a>
<a id='n3505' href='#n3505'>3505</a>
<a id='n3506' href='#n3506'>3506</a>
<a id='n3507' href='#n3507'>3507</a>
<a id='n3508' href='#n3508'>3508</a>
<a id='n3509' href='#n3509'>3509</a>
<a id='n3510' href='#n3510'>3510</a>
<a id='n3511' href='#n3511'>3511</a>
<a id='n3512' href='#n3512'>3512</a>
<a id='n3513' href='#n3513'>3513</a>
<a id='n3514' href='#n3514'>3514</a>
<a id='n3515' href='#n3515'>3515</a>
<a id='n3516' href='#n3516'>3516</a>
<a id='n3517' href='#n3517'>3517</a>
<a id='n3518' href='#n3518'>3518</a>
<a id='n3519' href='#n3519'>3519</a>
<a id='n3520' href='#n3520'>3520</a>
<a id='n3521' href='#n3521'>3521</a>
<a id='n3522' href='#n3522'>3522</a>
<a id='n3523' href='#n3523'>3523</a>
<a id='n3524' href='#n3524'>3524</a>
<a id='n3525' href='#n3525'>3525</a>
<a id='n3526' href='#n3526'>3526</a>
<a id='n3527' href='#n3527'>3527</a>
<a id='n3528' href='#n3528'>3528</a>
<a id='n3529' href='#n3529'>3529</a>
<a id='n3530' href='#n3530'>3530</a>
<a id='n3531' href='#n3531'>3531</a>
<a id='n3532' href='#n3532'>3532</a>
<a id='n3533' href='#n3533'>3533</a>
<a id='n3534' href='#n3534'>3534</a>
<a id='n3535' href='#n3535'>3535</a>
<a id='n3536' href='#n3536'>3536</a>
<a id='n3537' href='#n3537'>3537</a>
<a id='n3538' href='#n3538'>3538</a>
<a id='n3539' href='#n3539'>3539</a>
<a id='n3540' href='#n3540'>3540</a>
<a id='n3541' href='#n3541'>3541</a>
<a id='n3542' href='#n3542'>3542</a>
<a id='n3543' href='#n3543'>3543</a>
<a id='n3544' href='#n3544'>3544</a>
<a id='n3545' href='#n3545'>3545</a>
<a id='n3546' href='#n3546'>3546</a>
<a id='n3547' href='#n3547'>3547</a>
<a id='n3548' href='#n3548'>3548</a>
<a id='n3549' href='#n3549'>3549</a>
<a id='n3550' href='#n3550'>3550</a>
<a id='n3551' href='#n3551'>3551</a>
<a id='n3552' href='#n3552'>3552</a>
<a id='n3553' href='#n3553'>3553</a>
<a id='n3554' href='#n3554'>3554</a>
<a id='n3555' href='#n3555'>3555</a>
<a id='n3556' href='#n3556'>3556</a>
<a id='n3557' href='#n3557'>3557</a>
<a id='n3558' href='#n3558'>3558</a>
<a id='n3559' href='#n3559'>3559</a>
<a id='n3560' href='#n3560'>3560</a>
<a id='n3561' href='#n3561'>3561</a>
<a id='n3562' href='#n3562'>3562</a>
<a id='n3563' href='#n3563'>3563</a>
<a id='n3564' href='#n3564'>3564</a>
<a id='n3565' href='#n3565'>3565</a>
<a id='n3566' href='#n3566'>3566</a>
<a id='n3567' href='#n3567'>3567</a>
<a id='n3568' href='#n3568'>3568</a>
<a id='n3569' href='#n3569'>3569</a>
<a id='n3570' href='#n3570'>3570</a>
<a id='n3571' href='#n3571'>3571</a>
<a id='n3572' href='#n3572'>3572</a>
<a id='n3573' href='#n3573'>3573</a>
<a id='n3574' href='#n3574'>3574</a>
<a id='n3575' href='#n3575'>3575</a>
<a id='n3576' href='#n3576'>3576</a>
<a id='n3577' href='#n3577'>3577</a>
<a id='n3578' href='#n3578'>3578</a>
<a id='n3579' href='#n3579'>3579</a>
<a id='n3580' href='#n3580'>3580</a>
<a id='n3581' href='#n3581'>3581</a>
<a id='n3582' href='#n3582'>3582</a>
<a id='n3583' href='#n3583'>3583</a>
<a id='n3584' href='#n3584'>3584</a>
<a id='n3585' href='#n3585'>3585</a>
<a id='n3586' href='#n3586'>3586</a>
<a id='n3587' href='#n3587'>3587</a>
<a id='n3588' href='#n3588'>3588</a>
<a id='n3589' href='#n3589'>3589</a>
<a id='n3590' href='#n3590'>3590</a>
<a id='n3591' href='#n3591'>3591</a>
<a id='n3592' href='#n3592'>3592</a>
<a id='n3593' href='#n3593'>3593</a>
<a id='n3594' href='#n3594'>3594</a>
<a id='n3595' href='#n3595'>3595</a>
<a id='n3596' href='#n3596'>3596</a>
<a id='n3597' href='#n3597'>3597</a>
<a id='n3598' href='#n3598'>3598</a>
<a id='n3599' href='#n3599'>3599</a>
<a id='n3600' href='#n3600'>3600</a>
<a id='n3601' href='#n3601'>3601</a>
<a id='n3602' href='#n3602'>3602</a>
<a id='n3603' href='#n3603'>3603</a>
<a id='n3604' href='#n3604'>3604</a>
<a id='n3605' href='#n3605'>3605</a>
<a id='n3606' href='#n3606'>3606</a>
<a id='n3607' href='#n3607'>3607</a>
<a id='n3608' href='#n3608'>3608</a>
<a id='n3609' href='#n3609'>3609</a>
<a id='n3610' href='#n3610'>3610</a>
<a id='n3611' href='#n3611'>3611</a>
<a id='n3612' href='#n3612'>3612</a>
<a id='n3613' href='#n3613'>3613</a>
<a id='n3614' href='#n3614'>3614</a>
<a id='n3615' href='#n3615'>3615</a>
<a id='n3616' href='#n3616'>3616</a>
<a id='n3617' href='#n3617'>3617</a>
<a id='n3618' href='#n3618'>3618</a>
<a id='n3619' href='#n3619'>3619</a>
<a id='n3620' href='#n3620'>3620</a>
<a id='n3621' href='#n3621'>3621</a>
<a id='n3622' href='#n3622'>3622</a>
<a id='n3623' href='#n3623'>3623</a>
<a id='n3624' href='#n3624'>3624</a>
<a id='n3625' href='#n3625'>3625</a>
<a id='n3626' href='#n3626'>3626</a>
<a id='n3627' href='#n3627'>3627</a>
<a id='n3628' href='#n3628'>3628</a>
<a id='n3629' href='#n3629'>3629</a>
<a id='n3630' href='#n3630'>3630</a>
<a id='n3631' href='#n3631'>3631</a>
<a id='n3632' href='#n3632'>3632</a>
<a id='n3633' href='#n3633'>3633</a>
<a id='n3634' href='#n3634'>3634</a>
<a id='n3635' href='#n3635'>3635</a>
<a id='n3636' href='#n3636'>3636</a>
<a id='n3637' href='#n3637'>3637</a>
<a id='n3638' href='#n3638'>3638</a>
<a id='n3639' href='#n3639'>3639</a>
<a id='n3640' href='#n3640'>3640</a>
<a id='n3641' href='#n3641'>3641</a>
<a id='n3642' href='#n3642'>3642</a>
<a id='n3643' href='#n3643'>3643</a>
<a id='n3644' href='#n3644'>3644</a>
<a id='n3645' href='#n3645'>3645</a>
<a id='n3646' href='#n3646'>3646</a>
<a id='n3647' href='#n3647'>3647</a>
<a id='n3648' href='#n3648'>3648</a>
<a id='n3649' href='#n3649'>3649</a>
<a id='n3650' href='#n3650'>3650</a>
<a id='n3651' href='#n3651'>3651</a>
<a id='n3652' href='#n3652'>3652</a>
<a id='n3653' href='#n3653'>3653</a>
<a id='n3654' href='#n3654'>3654</a>
<a id='n3655' href='#n3655'>3655</a>
<a id='n3656' href='#n3656'>3656</a>
<a id='n3657' href='#n3657'>3657</a>
<a id='n3658' href='#n3658'>3658</a>
<a id='n3659' href='#n3659'>3659</a>
<a id='n3660' href='#n3660'>3660</a>
<a id='n3661' href='#n3661'>3661</a>
<a id='n3662' href='#n3662'>3662</a>
<a id='n3663' href='#n3663'>3663</a>
<a id='n3664' href='#n3664'>3664</a>
<a id='n3665' href='#n3665'>3665</a>
<a id='n3666' href='#n3666'>3666</a>
<a id='n3667' href='#n3667'>3667</a>
<a id='n3668' href='#n3668'>3668</a>
<a id='n3669' href='#n3669'>3669</a>
<a id='n3670' href='#n3670'>3670</a>
<a id='n3671' href='#n3671'>3671</a>
<a id='n3672' href='#n3672'>3672</a>
<a id='n3673' href='#n3673'>3673</a>
<a id='n3674' href='#n3674'>3674</a>
<a id='n3675' href='#n3675'>3675</a>
<a id='n3676' href='#n3676'>3676</a>
<a id='n3677' href='#n3677'>3677</a>
<a id='n3678' href='#n3678'>3678</a>
<a id='n3679' href='#n3679'>3679</a>
<a id='n3680' href='#n3680'>3680</a>
<a id='n3681' href='#n3681'>3681</a>
<a id='n3682' href='#n3682'>3682</a>
<a id='n3683' href='#n3683'>3683</a>
<a id='n3684' href='#n3684'>3684</a>
<a id='n3685' href='#n3685'>3685</a>
<a id='n3686' href='#n3686'>3686</a>
<a id='n3687' href='#n3687'>3687</a>
<a id='n3688' href='#n3688'>3688</a>
<a id='n3689' href='#n3689'>3689</a>
<a id='n3690' href='#n3690'>3690</a>
<a id='n3691' href='#n3691'>3691</a>
<a id='n3692' href='#n3692'>3692</a>
<a id='n3693' href='#n3693'>3693</a>
<a id='n3694' href='#n3694'>3694</a>
<a id='n3695' href='#n3695'>3695</a>
<a id='n3696' href='#n3696'>3696</a>
<a id='n3697' href='#n3697'>3697</a>
<a id='n3698' href='#n3698'>3698</a>
<a id='n3699' href='#n3699'>3699</a>
<a id='n3700' href='#n3700'>3700</a>
<a id='n3701' href='#n3701'>3701</a>
<a id='n3702' href='#n3702'>3702</a>
<a id='n3703' href='#n3703'>3703</a>
<a id='n3704' href='#n3704'>3704</a>
<a id='n3705' href='#n3705'>3705</a>
<a id='n3706' href='#n3706'>3706</a>
<a id='n3707' href='#n3707'>3707</a>
<a id='n3708' href='#n3708'>3708</a>
<a id='n3709' href='#n3709'>3709</a>
<a id='n3710' href='#n3710'>3710</a>
<a id='n3711' href='#n3711'>3711</a>
<a id='n3712' href='#n3712'>3712</a>
<a id='n3713' href='#n3713'>3713</a>
<a id='n3714' href='#n3714'>3714</a>
<a id='n3715' href='#n3715'>3715</a>
<a id='n3716' href='#n3716'>3716</a>
<a id='n3717' href='#n3717'>3717</a>
<a id='n3718' href='#n3718'>3718</a>
<a id='n3719' href='#n3719'>3719</a>
<a id='n3720' href='#n3720'>3720</a>
<a id='n3721' href='#n3721'>3721</a>
<a id='n3722' href='#n3722'>3722</a>
<a id='n3723' href='#n3723'>3723</a>
<a id='n3724' href='#n3724'>3724</a>
<a id='n3725' href='#n3725'>3725</a>
<a id='n3726' href='#n3726'>3726</a>
<a id='n3727' href='#n3727'>3727</a>
<a id='n3728' href='#n3728'>3728</a>
<a id='n3729' href='#n3729'>3729</a>
<a id='n3730' href='#n3730'>3730</a>
<a id='n3731' href='#n3731'>3731</a>
<a id='n3732' href='#n3732'>3732</a>
<a id='n3733' href='#n3733'>3733</a>
<a id='n3734' href='#n3734'>3734</a>
<a id='n3735' href='#n3735'>3735</a>
<a id='n3736' href='#n3736'>3736</a>
<a id='n3737' href='#n3737'>3737</a>
<a id='n3738' href='#n3738'>3738</a>
<a id='n3739' href='#n3739'>3739</a>
<a id='n3740' href='#n3740'>3740</a>
<a id='n3741' href='#n3741'>3741</a>
<a id='n3742' href='#n3742'>3742</a>
<a id='n3743' href='#n3743'>3743</a>
<a id='n3744' href='#n3744'>3744</a>
<a id='n3745' href='#n3745'>3745</a>
<a id='n3746' href='#n3746'>3746</a>
<a id='n3747' href='#n3747'>3747</a>
<a id='n3748' href='#n3748'>3748</a>
<a id='n3749' href='#n3749'>3749</a>
<a id='n3750' href='#n3750'>3750</a>
<a id='n3751' href='#n3751'>3751</a>
<a id='n3752' href='#n3752'>3752</a>
<a id='n3753' href='#n3753'>3753</a>
<a id='n3754' href='#n3754'>3754</a>
<a id='n3755' href='#n3755'>3755</a>
<a id='n3756' href='#n3756'>3756</a>
<a id='n3757' href='#n3757'>3757</a>
<a id='n3758' href='#n3758'>3758</a>
<a id='n3759' href='#n3759'>3759</a>
<a id='n3760' href='#n3760'>3760</a>
<a id='n3761' href='#n3761'>3761</a>
<a id='n3762' href='#n3762'>3762</a>
<a id='n3763' href='#n3763'>3763</a>
<a id='n3764' href='#n3764'>3764</a>
<a id='n3765' href='#n3765'>3765</a>
<a id='n3766' href='#n3766'>3766</a>
<a id='n3767' href='#n3767'>3767</a>
<a id='n3768' href='#n3768'>3768</a>
<a id='n3769' href='#n3769'>3769</a>
<a id='n3770' href='#n3770'>3770</a>
<a id='n3771' href='#n3771'>3771</a>
<a id='n3772' href='#n3772'>3772</a>
<a id='n3773' href='#n3773'>3773</a>
<a id='n3774' href='#n3774'>3774</a>
<a id='n3775' href='#n3775'>3775</a>
<a id='n3776' href='#n3776'>3776</a>
<a id='n3777' href='#n3777'>3777</a>
<a id='n3778' href='#n3778'>3778</a>
<a id='n3779' href='#n3779'>3779</a>
<a id='n3780' href='#n3780'>3780</a>
<a id='n3781' href='#n3781'>3781</a>
<a id='n3782' href='#n3782'>3782</a>
<a id='n3783' href='#n3783'>3783</a>
<a id='n3784' href='#n3784'>3784</a>
<a id='n3785' href='#n3785'>3785</a>
<a id='n3786' href='#n3786'>3786</a>
<a id='n3787' href='#n3787'>3787</a>
<a id='n3788' href='#n3788'>3788</a>
<a id='n3789' href='#n3789'>3789</a>
<a id='n3790' href='#n3790'>3790</a>
<a id='n3791' href='#n3791'>3791</a>
<a id='n3792' href='#n3792'>3792</a>
<a id='n3793' href='#n3793'>3793</a>
<a id='n3794' href='#n3794'>3794</a>
<a id='n3795' href='#n3795'>3795</a>
<a id='n3796' href='#n3796'>3796</a>
<a id='n3797' href='#n3797'>3797</a>
<a id='n3798' href='#n3798'>3798</a>
<a id='n3799' href='#n3799'>3799</a>
<a id='n3800' href='#n3800'>3800</a>
<a id='n3801' href='#n3801'>3801</a>
<a id='n3802' href='#n3802'>3802</a>
<a id='n3803' href='#n3803'>3803</a>
<a id='n3804' href='#n3804'>3804</a>
<a id='n3805' href='#n3805'>3805</a>
<a id='n3806' href='#n3806'>3806</a>
<a id='n3807' href='#n3807'>3807</a>
<a id='n3808' href='#n3808'>3808</a>
<a id='n3809' href='#n3809'>3809</a>
<a id='n3810' href='#n3810'>3810</a>
<a id='n3811' href='#n3811'>3811</a>
<a id='n3812' href='#n3812'>3812</a>
<a id='n3813' href='#n3813'>3813</a>
<a id='n3814' href='#n3814'>3814</a>
<a id='n3815' href='#n3815'>3815</a>
<a id='n3816' href='#n3816'>3816</a>
<a id='n3817' href='#n3817'>3817</a>
<a id='n3818' href='#n3818'>3818</a>
<a id='n3819' href='#n3819'>3819</a>
<a id='n3820' href='#n3820'>3820</a>
<a id='n3821' href='#n3821'>3821</a>
<a id='n3822' href='#n3822'>3822</a>
<a id='n3823' href='#n3823'>3823</a>
<a id='n3824' href='#n3824'>3824</a>
<a id='n3825' href='#n3825'>3825</a>
<a id='n3826' href='#n3826'>3826</a>
<a id='n3827' href='#n3827'>3827</a>
<a id='n3828' href='#n3828'>3828</a>
<a id='n3829' href='#n3829'>3829</a>
<a id='n3830' href='#n3830'>3830</a>
<a id='n3831' href='#n3831'>3831</a>
<a id='n3832' href='#n3832'>3832</a>
<a id='n3833' href='#n3833'>3833</a>
<a id='n3834' href='#n3834'>3834</a>
<a id='n3835' href='#n3835'>3835</a>
<a id='n3836' href='#n3836'>3836</a>
<a id='n3837' href='#n3837'>3837</a>
<a id='n3838' href='#n3838'>3838</a>
<a id='n3839' href='#n3839'>3839</a>
<a id='n3840' href='#n3840'>3840</a>
<a id='n3841' href='#n3841'>3841</a>
<a id='n3842' href='#n3842'>3842</a>
<a id='n3843' href='#n3843'>3843</a>
<a id='n3844' href='#n3844'>3844</a>
<a id='n3845' href='#n3845'>3845</a>
<a id='n3846' href='#n3846'>3846</a>
<a id='n3847' href='#n3847'>3847</a>
<a id='n3848' href='#n3848'>3848</a>
<a id='n3849' href='#n3849'>3849</a>
<a id='n3850' href='#n3850'>3850</a>
<a id='n3851' href='#n3851'>3851</a>
<a id='n3852' href='#n3852'>3852</a>
<a id='n3853' href='#n3853'>3853</a>
<a id='n3854' href='#n3854'>3854</a>
<a id='n3855' href='#n3855'>3855</a>
<a id='n3856' href='#n3856'>3856</a>
<a id='n3857' href='#n3857'>3857</a>
<a id='n3858' href='#n3858'>3858</a>
<a id='n3859' href='#n3859'>3859</a>
<a id='n3860' href='#n3860'>3860</a>
<a id='n3861' href='#n3861'>3861</a>
<a id='n3862' href='#n3862'>3862</a>
<a id='n3863' href='#n3863'>3863</a>
<a id='n3864' href='#n3864'>3864</a>
<a id='n3865' href='#n3865'>3865</a>
<a id='n3866' href='#n3866'>3866</a>
<a id='n3867' href='#n3867'>3867</a>
<a id='n3868' href='#n3868'>3868</a>
<a id='n3869' href='#n3869'>3869</a>
<a id='n3870' href='#n3870'>3870</a>
<a id='n3871' href='#n3871'>3871</a>
<a id='n3872' href='#n3872'>3872</a>
<a id='n3873' href='#n3873'>3873</a>
<a id='n3874' href='#n3874'>3874</a>
<a id='n3875' href='#n3875'>3875</a>
<a id='n3876' href='#n3876'>3876</a>
<a id='n3877' href='#n3877'>3877</a>
<a id='n3878' href='#n3878'>3878</a>
<a id='n3879' href='#n3879'>3879</a>
<a id='n3880' href='#n3880'>3880</a>
<a id='n3881' href='#n3881'>3881</a>
<a id='n3882' href='#n3882'>3882</a>
<a id='n3883' href='#n3883'>3883</a>
<a id='n3884' href='#n3884'>3884</a>
<a id='n3885' href='#n3885'>3885</a>
<a id='n3886' href='#n3886'>3886</a>
<a id='n3887' href='#n3887'>3887</a>
<a id='n3888' href='#n3888'>3888</a>
<a id='n3889' href='#n3889'>3889</a>
<a id='n3890' href='#n3890'>3890</a>
<a id='n3891' href='#n3891'>3891</a>
<a id='n3892' href='#n3892'>3892</a>
<a id='n3893' href='#n3893'>3893</a>
<a id='n3894' href='#n3894'>3894</a>
<a id='n3895' href='#n3895'>3895</a>
<a id='n3896' href='#n3896'>3896</a>
<a id='n3897' href='#n3897'>3897</a>
<a id='n3898' href='#n3898'>3898</a>
<a id='n3899' href='#n3899'>3899</a>
<a id='n3900' href='#n3900'>3900</a>
<a id='n3901' href='#n3901'>3901</a>
<a id='n3902' href='#n3902'>3902</a>
<a id='n3903' href='#n3903'>3903</a>
<a id='n3904' href='#n3904'>3904</a>
<a id='n3905' href='#n3905'>3905</a>
<a id='n3906' href='#n3906'>3906</a>
<a id='n3907' href='#n3907'>3907</a>
<a id='n3908' href='#n3908'>3908</a>
<a id='n3909' href='#n3909'>3909</a>
<a id='n3910' href='#n3910'>3910</a>
<a id='n3911' href='#n3911'>3911</a>
<a id='n3912' href='#n3912'>3912</a>
<a id='n3913' href='#n3913'>3913</a>
<a id='n3914' href='#n3914'>3914</a>
<a id='n3915' href='#n3915'>3915</a>
<a id='n3916' href='#n3916'>3916</a>
<a id='n3917' href='#n3917'>3917</a>
<a id='n3918' href='#n3918'>3918</a>
<a id='n3919' href='#n3919'>3919</a>
<a id='n3920' href='#n3920'>3920</a>
<a id='n3921' href='#n3921'>3921</a>
<a id='n3922' href='#n3922'>3922</a>
<a id='n3923' href='#n3923'>3923</a>
<a id='n3924' href='#n3924'>3924</a>
<a id='n3925' href='#n3925'>3925</a>
<a id='n3926' href='#n3926'>3926</a>
<a id='n3927' href='#n3927'>3927</a>
<a id='n3928' href='#n3928'>3928</a>
<a id='n3929' href='#n3929'>3929</a>
<a id='n3930' href='#n3930'>3930</a>
<a id='n3931' href='#n3931'>3931</a>
<a id='n3932' href='#n3932'>3932</a>
<a id='n3933' href='#n3933'>3933</a>
<a id='n3934' href='#n3934'>3934</a>
<a id='n3935' href='#n3935'>3935</a>
<a id='n3936' href='#n3936'>3936</a>
<a id='n3937' href='#n3937'>3937</a>
<a id='n3938' href='#n3938'>3938</a>
<a id='n3939' href='#n3939'>3939</a>
<a id='n3940' href='#n3940'>3940</a>
<a id='n3941' href='#n3941'>3941</a>
<a id='n3942' href='#n3942'>3942</a>
<a id='n3943' href='#n3943'>3943</a>
<a id='n3944' href='#n3944'>3944</a>
<a id='n3945' href='#n3945'>3945</a>
<a id='n3946' href='#n3946'>3946</a>
<a id='n3947' href='#n3947'>3947</a>
<a id='n3948' href='#n3948'>3948</a>
<a id='n3949' href='#n3949'>3949</a>
<a id='n3950' href='#n3950'>3950</a>
<a id='n3951' href='#n3951'>3951</a>
<a id='n3952' href='#n3952'>3952</a>
<a id='n3953' href='#n3953'>3953</a>
<a id='n3954' href='#n3954'>3954</a>
<a id='n3955' href='#n3955'>3955</a>
<a id='n3956' href='#n3956'>3956</a>
<a id='n3957' href='#n3957'>3957</a>
<a id='n3958' href='#n3958'>3958</a>
<a id='n3959' href='#n3959'>3959</a>
<a id='n3960' href='#n3960'>3960</a>
<a id='n3961' href='#n3961'>3961</a>
<a id='n3962' href='#n3962'>3962</a>
<a id='n3963' href='#n3963'>3963</a>
<a id='n3964' href='#n3964'>3964</a>
<a id='n3965' href='#n3965'>3965</a>
<a id='n3966' href='#n3966'>3966</a>
<a id='n3967' href='#n3967'>3967</a>
<a id='n3968' href='#n3968'>3968</a>
<a id='n3969' href='#n3969'>3969</a>
<a id='n3970' href='#n3970'>3970</a>
<a id='n3971' href='#n3971'>3971</a>
<a id='n3972' href='#n3972'>3972</a>
<a id='n3973' href='#n3973'>3973</a>
<a id='n3974' href='#n3974'>3974</a>
<a id='n3975' href='#n3975'>3975</a>
<a id='n3976' href='#n3976'>3976</a>
<a id='n3977' href='#n3977'>3977</a>
<a id='n3978' href='#n3978'>3978</a>
<a id='n3979' href='#n3979'>3979</a>
<a id='n3980' href='#n3980'>3980</a>
<a id='n3981' href='#n3981'>3981</a>
<a id='n3982' href='#n3982'>3982</a>
<a id='n3983' href='#n3983'>3983</a>
<a id='n3984' href='#n3984'>3984</a>
<a id='n3985' href='#n3985'>3985</a>
<a id='n3986' href='#n3986'>3986</a>
<a id='n3987' href='#n3987'>3987</a>
<a id='n3988' href='#n3988'>3988</a>
<a id='n3989' href='#n3989'>3989</a>
<a id='n3990' href='#n3990'>3990</a>
<a id='n3991' href='#n3991'>3991</a>
<a id='n3992' href='#n3992'>3992</a>
<a id='n3993' href='#n3993'>3993</a>
<a id='n3994' href='#n3994'>3994</a>
<a id='n3995' href='#n3995'>3995</a>
<a id='n3996' href='#n3996'>3996</a>
<a id='n3997' href='#n3997'>3997</a>
<a id='n3998' href='#n3998'>3998</a>
<a id='n3999' href='#n3999'>3999</a>
<a id='n4000' href='#n4000'>4000</a>
<a id='n4001' href='#n4001'>4001</a>
<a id='n4002' href='#n4002'>4002</a>
<a id='n4003' href='#n4003'>4003</a>
<a id='n4004' href='#n4004'>4004</a>
<a id='n4005' href='#n4005'>4005</a>
<a id='n4006' href='#n4006'>4006</a>
<a id='n4007' href='#n4007'>4007</a>
<a id='n4008' href='#n4008'>4008</a>
<a id='n4009' href='#n4009'>4009</a>
<a id='n4010' href='#n4010'>4010</a>
<a id='n4011' href='#n4011'>4011</a>
<a id='n4012' href='#n4012'>4012</a>
<a id='n4013' href='#n4013'>4013</a>
<a id='n4014' href='#n4014'>4014</a>
<a id='n4015' href='#n4015'>4015</a>
<a id='n4016' href='#n4016'>4016</a>
<a id='n4017' href='#n4017'>4017</a>
<a id='n4018' href='#n4018'>4018</a>
<a id='n4019' href='#n4019'>4019</a>
<a id='n4020' href='#n4020'>4020</a>
<a id='n4021' href='#n4021'>4021</a>
<a id='n4022' href='#n4022'>4022</a>
<a id='n4023' href='#n4023'>4023</a>
<a id='n4024' href='#n4024'>4024</a>
<a id='n4025' href='#n4025'>4025</a>
<a id='n4026' href='#n4026'>4026</a>
<a id='n4027' href='#n4027'>4027</a>
<a id='n4028' href='#n4028'>4028</a>
<a id='n4029' href='#n4029'>4029</a>
<a id='n4030' href='#n4030'>4030</a>
<a id='n4031' href='#n4031'>4031</a>
<a id='n4032' href='#n4032'>4032</a>
<a id='n4033' href='#n4033'>4033</a>
<a id='n4034' href='#n4034'>4034</a>
<a id='n4035' href='#n4035'>4035</a>
<a id='n4036' href='#n4036'>4036</a>
<a id='n4037' href='#n4037'>4037</a>
<a id='n4038' href='#n4038'>4038</a>
<a id='n4039' href='#n4039'>4039</a>
<a id='n4040' href='#n4040'>4040</a>
<a id='n4041' href='#n4041'>4041</a>
<a id='n4042' href='#n4042'>4042</a>
<a id='n4043' href='#n4043'>4043</a>
<a id='n4044' href='#n4044'>4044</a>
<a id='n4045' href='#n4045'>4045</a>
<a id='n4046' href='#n4046'>4046</a>
<a id='n4047' href='#n4047'>4047</a>
<a id='n4048' href='#n4048'>4048</a>
<a id='n4049' href='#n4049'>4049</a>
<a id='n4050' href='#n4050'>4050</a>
<a id='n4051' href='#n4051'>4051</a>
<a id='n4052' href='#n4052'>4052</a>
<a id='n4053' href='#n4053'>4053</a>
<a id='n4054' href='#n4054'>4054</a>
<a id='n4055' href='#n4055'>4055</a>
<a id='n4056' href='#n4056'>4056</a>
<a id='n4057' href='#n4057'>4057</a>
<a id='n4058' href='#n4058'>4058</a>
<a id='n4059' href='#n4059'>4059</a>
<a id='n4060' href='#n4060'>4060</a>
<a id='n4061' href='#n4061'>4061</a>
<a id='n4062' href='#n4062'>4062</a>
<a id='n4063' href='#n4063'>4063</a>
<a id='n4064' href='#n4064'>4064</a>
<a id='n4065' href='#n4065'>4065</a>
<a id='n4066' href='#n4066'>4066</a>
<a id='n4067' href='#n4067'>4067</a>
<a id='n4068' href='#n4068'>4068</a>
<a id='n4069' href='#n4069'>4069</a>
<a id='n4070' href='#n4070'>4070</a>
<a id='n4071' href='#n4071'>4071</a>
<a id='n4072' href='#n4072'>4072</a>
<a id='n4073' href='#n4073'>4073</a>
<a id='n4074' href='#n4074'>4074</a>
<a id='n4075' href='#n4075'>4075</a>
<a id='n4076' href='#n4076'>4076</a>
<a id='n4077' href='#n4077'>4077</a>
<a id='n4078' href='#n4078'>4078</a>
<a id='n4079' href='#n4079'>4079</a>
<a id='n4080' href='#n4080'>4080</a>
<a id='n4081' href='#n4081'>4081</a>
<a id='n4082' href='#n4082'>4082</a>
<a id='n4083' href='#n4083'>4083</a>
<a id='n4084' href='#n4084'>4084</a>
<a id='n4085' href='#n4085'>4085</a>
<a id='n4086' href='#n4086'>4086</a>
<a id='n4087' href='#n4087'>4087</a>
<a id='n4088' href='#n4088'>4088</a>
<a id='n4089' href='#n4089'>4089</a>
<a id='n4090' href='#n4090'>4090</a>
<a id='n4091' href='#n4091'>4091</a>
<a id='n4092' href='#n4092'>4092</a>
<a id='n4093' href='#n4093'>4093</a>
<a id='n4094' href='#n4094'>4094</a>
<a id='n4095' href='#n4095'>4095</a>
<a id='n4096' href='#n4096'>4096</a>
<a id='n4097' href='#n4097'>4097</a>
<a id='n4098' href='#n4098'>4098</a>
<a id='n4099' href='#n4099'>4099</a>
<a id='n4100' href='#n4100'>4100</a>
<a id='n4101' href='#n4101'>4101</a>
<a id='n4102' href='#n4102'>4102</a>
<a id='n4103' href='#n4103'>4103</a>
<a id='n4104' href='#n4104'>4104</a>
<a id='n4105' href='#n4105'>4105</a>
<a id='n4106' href='#n4106'>4106</a>
<a id='n4107' href='#n4107'>4107</a>
<a id='n4108' href='#n4108'>4108</a>
<a id='n4109' href='#n4109'>4109</a>
<a id='n4110' href='#n4110'>4110</a>
<a id='n4111' href='#n4111'>4111</a>
<a id='n4112' href='#n4112'>4112</a>
<a id='n4113' href='#n4113'>4113</a>
<a id='n4114' href='#n4114'>4114</a>
<a id='n4115' href='#n4115'>4115</a>
<a id='n4116' href='#n4116'>4116</a>
<a id='n4117' href='#n4117'>4117</a>
<a id='n4118' href='#n4118'>4118</a>
<a id='n4119' href='#n4119'>4119</a>
<a id='n4120' href='#n4120'>4120</a>
<a id='n4121' href='#n4121'>4121</a>
<a id='n4122' href='#n4122'>4122</a>
<a id='n4123' href='#n4123'>4123</a>
<a id='n4124' href='#n4124'>4124</a>
<a id='n4125' href='#n4125'>4125</a>
<a id='n4126' href='#n4126'>4126</a>
<a id='n4127' href='#n4127'>4127</a>
<a id='n4128' href='#n4128'>4128</a>
<a id='n4129' href='#n4129'>4129</a>
<a id='n4130' href='#n4130'>4130</a>
<a id='n4131' href='#n4131'>4131</a>
<a id='n4132' href='#n4132'>4132</a>
<a id='n4133' href='#n4133'>4133</a>
<a id='n4134' href='#n4134'>4134</a>
<a id='n4135' href='#n4135'>4135</a>
<a id='n4136' href='#n4136'>4136</a>
<a id='n4137' href='#n4137'>4137</a>
<a id='n4138' href='#n4138'>4138</a>
<a id='n4139' href='#n4139'>4139</a>
<a id='n4140' href='#n4140'>4140</a>
<a id='n4141' href='#n4141'>4141</a>
<a id='n4142' href='#n4142'>4142</a>
<a id='n4143' href='#n4143'>4143</a>
<a id='n4144' href='#n4144'>4144</a>
<a id='n4145' href='#n4145'>4145</a>
<a id='n4146' href='#n4146'>4146</a>
<a id='n4147' href='#n4147'>4147</a>
<a id='n4148' href='#n4148'>4148</a>
<a id='n4149' href='#n4149'>4149</a>
<a id='n4150' href='#n4150'>4150</a>
<a id='n4151' href='#n4151'>4151</a>
<a id='n4152' href='#n4152'>4152</a>
<a id='n4153' href='#n4153'>4153</a>
<a id='n4154' href='#n4154'>4154</a>
<a id='n4155' href='#n4155'>4155</a>
<a id='n4156' href='#n4156'>4156</a>
<a id='n4157' href='#n4157'>4157</a>
<a id='n4158' href='#n4158'>4158</a>
<a id='n4159' href='#n4159'>4159</a>
<a id='n4160' href='#n4160'>4160</a>
<a id='n4161' href='#n4161'>4161</a>
<a id='n4162' href='#n4162'>4162</a>
<a id='n4163' href='#n4163'>4163</a>
<a id='n4164' href='#n4164'>4164</a>
<a id='n4165' href='#n4165'>4165</a>
<a id='n4166' href='#n4166'>4166</a>
<a id='n4167' href='#n4167'>4167</a>
<a id='n4168' href='#n4168'>4168</a>
<a id='n4169' href='#n4169'>4169</a>
<a id='n4170' href='#n4170'>4170</a>
<a id='n4171' href='#n4171'>4171</a>
<a id='n4172' href='#n4172'>4172</a>
<a id='n4173' href='#n4173'>4173</a>
<a id='n4174' href='#n4174'>4174</a>
<a id='n4175' href='#n4175'>4175</a>
<a id='n4176' href='#n4176'>4176</a>
<a id='n4177' href='#n4177'>4177</a>
<a id='n4178' href='#n4178'>4178</a>
<a id='n4179' href='#n4179'>4179</a>
<a id='n4180' href='#n4180'>4180</a>
<a id='n4181' href='#n4181'>4181</a>
<a id='n4182' href='#n4182'>4182</a>
<a id='n4183' href='#n4183'>4183</a>
<a id='n4184' href='#n4184'>4184</a>
<a id='n4185' href='#n4185'>4185</a>
<a id='n4186' href='#n4186'>4186</a>
<a id='n4187' href='#n4187'>4187</a>
<a id='n4188' href='#n4188'>4188</a>
<a id='n4189' href='#n4189'>4189</a>
<a id='n4190' href='#n4190'>4190</a>
<a id='n4191' href='#n4191'>4191</a>
<a id='n4192' href='#n4192'>4192</a>
<a id='n4193' href='#n4193'>4193</a>
<a id='n4194' href='#n4194'>4194</a>
<a id='n4195' href='#n4195'>4195</a>
<a id='n4196' href='#n4196'>4196</a>
<a id='n4197' href='#n4197'>4197</a>
<a id='n4198' href='#n4198'>4198</a>
<a id='n4199' href='#n4199'>4199</a>
<a id='n4200' href='#n4200'>4200</a>
<a id='n4201' href='#n4201'>4201</a>
<a id='n4202' href='#n4202'>4202</a>
<a id='n4203' href='#n4203'>4203</a>
<a id='n4204' href='#n4204'>4204</a>
<a id='n4205' href='#n4205'>4205</a>
<a id='n4206' href='#n4206'>4206</a>
<a id='n4207' href='#n4207'>4207</a>
<a id='n4208' href='#n4208'>4208</a>
<a id='n4209' href='#n4209'>4209</a>
<a id='n4210' href='#n4210'>4210</a>
<a id='n4211' href='#n4211'>4211</a>
<a id='n4212' href='#n4212'>4212</a>
<a id='n4213' href='#n4213'>4213</a>
<a id='n4214' href='#n4214'>4214</a>
<a id='n4215' href='#n4215'>4215</a>
<a id='n4216' href='#n4216'>4216</a>
<a id='n4217' href='#n4217'>4217</a>
<a id='n4218' href='#n4218'>4218</a>
<a id='n4219' href='#n4219'>4219</a>
<a id='n4220' href='#n4220'>4220</a>
<a id='n4221' href='#n4221'>4221</a>
<a id='n4222' href='#n4222'>4222</a>
<a id='n4223' href='#n4223'>4223</a>
<a id='n4224' href='#n4224'>4224</a>
<a id='n4225' href='#n4225'>4225</a>
<a id='n4226' href='#n4226'>4226</a>
<a id='n4227' href='#n4227'>4227</a>
<a id='n4228' href='#n4228'>4228</a>
<a id='n4229' href='#n4229'>4229</a>
<a id='n4230' href='#n4230'>4230</a>
<a id='n4231' href='#n4231'>4231</a>
<a id='n4232' href='#n4232'>4232</a>
<a id='n4233' href='#n4233'>4233</a>
<a id='n4234' href='#n4234'>4234</a>
<a id='n4235' href='#n4235'>4235</a>
<a id='n4236' href='#n4236'>4236</a>
<a id='n4237' href='#n4237'>4237</a>
<a id='n4238' href='#n4238'>4238</a>
<a id='n4239' href='#n4239'>4239</a>
<a id='n4240' href='#n4240'>4240</a>
<a id='n4241' href='#n4241'>4241</a>
<a id='n4242' href='#n4242'>4242</a>
<a id='n4243' href='#n4243'>4243</a>
<a id='n4244' href='#n4244'>4244</a>
<a id='n4245' href='#n4245'>4245</a>
<a id='n4246' href='#n4246'>4246</a>
<a id='n4247' href='#n4247'>4247</a>
<a id='n4248' href='#n4248'>4248</a>
<a id='n4249' href='#n4249'>4249</a>
<a id='n4250' href='#n4250'>4250</a>
<a id='n4251' href='#n4251'>4251</a>
<a id='n4252' href='#n4252'>4252</a>
<a id='n4253' href='#n4253'>4253</a>
<a id='n4254' href='#n4254'>4254</a>
<a id='n4255' href='#n4255'>4255</a>
<a id='n4256' href='#n4256'>4256</a>
<a id='n4257' href='#n4257'>4257</a>
<a id='n4258' href='#n4258'>4258</a>
<a id='n4259' href='#n4259'>4259</a>
<a id='n4260' href='#n4260'>4260</a>
<a id='n4261' href='#n4261'>4261</a>
<a id='n4262' href='#n4262'>4262</a>
<a id='n4263' href='#n4263'>4263</a>
<a id='n4264' href='#n4264'>4264</a>
<a id='n4265' href='#n4265'>4265</a>
<a id='n4266' href='#n4266'>4266</a>
<a id='n4267' href='#n4267'>4267</a>
<a id='n4268' href='#n4268'>4268</a>
<a id='n4269' href='#n4269'>4269</a>
<a id='n4270' href='#n4270'>4270</a>
<a id='n4271' href='#n4271'>4271</a>
<a id='n4272' href='#n4272'>4272</a>
<a id='n4273' href='#n4273'>4273</a>
<a id='n4274' href='#n4274'>4274</a>
<a id='n4275' href='#n4275'>4275</a>
<a id='n4276' href='#n4276'>4276</a>
<a id='n4277' href='#n4277'>4277</a>
<a id='n4278' href='#n4278'>4278</a>
<a id='n4279' href='#n4279'>4279</a>
<a id='n4280' href='#n4280'>4280</a>
<a id='n4281' href='#n4281'>4281</a>
<a id='n4282' href='#n4282'>4282</a>
<a id='n4283' href='#n4283'>4283</a>
<a id='n4284' href='#n4284'>4284</a>
<a id='n4285' href='#n4285'>4285</a>
<a id='n4286' href='#n4286'>4286</a>
<a id='n4287' href='#n4287'>4287</a>
<a id='n4288' href='#n4288'>4288</a>
<a id='n4289' href='#n4289'>4289</a>
<a id='n4290' href='#n4290'>4290</a>
<a id='n4291' href='#n4291'>4291</a>
<a id='n4292' href='#n4292'>4292</a>
<a id='n4293' href='#n4293'>4293</a>
<a id='n4294' href='#n4294'>4294</a>
<a id='n4295' href='#n4295'>4295</a>
<a id='n4296' href='#n4296'>4296</a>
<a id='n4297' href='#n4297'>4297</a>
<a id='n4298' href='#n4298'>4298</a>
<a id='n4299' href='#n4299'>4299</a>
<a id='n4300' href='#n4300'>4300</a>
<a id='n4301' href='#n4301'>4301</a>
<a id='n4302' href='#n4302'>4302</a>
<a id='n4303' href='#n4303'>4303</a>
<a id='n4304' href='#n4304'>4304</a>
<a id='n4305' href='#n4305'>4305</a>
<a id='n4306' href='#n4306'>4306</a>
<a id='n4307' href='#n4307'>4307</a>
<a id='n4308' href='#n4308'>4308</a>
<a id='n4309' href='#n4309'>4309</a>
<a id='n4310' href='#n4310'>4310</a>
<a id='n4311' href='#n4311'>4311</a>
<a id='n4312' href='#n4312'>4312</a>
<a id='n4313' href='#n4313'>4313</a>
<a id='n4314' href='#n4314'>4314</a>
<a id='n4315' href='#n4315'>4315</a>
<a id='n4316' href='#n4316'>4316</a>
<a id='n4317' href='#n4317'>4317</a>
<a id='n4318' href='#n4318'>4318</a>
<a id='n4319' href='#n4319'>4319</a>
<a id='n4320' href='#n4320'>4320</a>
<a id='n4321' href='#n4321'>4321</a>
<a id='n4322' href='#n4322'>4322</a>
<a id='n4323' href='#n4323'>4323</a>
<a id='n4324' href='#n4324'>4324</a>
<a id='n4325' href='#n4325'>4325</a>
<a id='n4326' href='#n4326'>4326</a>
<a id='n4327' href='#n4327'>4327</a>
<a id='n4328' href='#n4328'>4328</a>
<a id='n4329' href='#n4329'>4329</a>
<a id='n4330' href='#n4330'>4330</a>
<a id='n4331' href='#n4331'>4331</a>
<a id='n4332' href='#n4332'>4332</a>
<a id='n4333' href='#n4333'>4333</a>
<a id='n4334' href='#n4334'>4334</a>
<a id='n4335' href='#n4335'>4335</a>
<a id='n4336' href='#n4336'>4336</a>
<a id='n4337' href='#n4337'>4337</a>
<a id='n4338' href='#n4338'>4338</a>
<a id='n4339' href='#n4339'>4339</a>
<a id='n4340' href='#n4340'>4340</a>
<a id='n4341' href='#n4341'>4341</a>
<a id='n4342' href='#n4342'>4342</a>
<a id='n4343' href='#n4343'>4343</a>
<a id='n4344' href='#n4344'>4344</a>
<a id='n4345' href='#n4345'>4345</a>
<a id='n4346' href='#n4346'>4346</a>
<a id='n4347' href='#n4347'>4347</a>
<a id='n4348' href='#n4348'>4348</a>
<a id='n4349' href='#n4349'>4349</a>
<a id='n4350' href='#n4350'>4350</a>
<a id='n4351' href='#n4351'>4351</a>
<a id='n4352' href='#n4352'>4352</a>
<a id='n4353' href='#n4353'>4353</a>
<a id='n4354' href='#n4354'>4354</a>
<a id='n4355' href='#n4355'>4355</a>
<a id='n4356' href='#n4356'>4356</a>
<a id='n4357' href='#n4357'>4357</a>
<a id='n4358' href='#n4358'>4358</a>
<a id='n4359' href='#n4359'>4359</a>
<a id='n4360' href='#n4360'>4360</a>
<a id='n4361' href='#n4361'>4361</a>
<a id='n4362' href='#n4362'>4362</a>
<a id='n4363' href='#n4363'>4363</a>
<a id='n4364' href='#n4364'>4364</a>
<a id='n4365' href='#n4365'>4365</a>
<a id='n4366' href='#n4366'>4366</a>
<a id='n4367' href='#n4367'>4367</a>
<a id='n4368' href='#n4368'>4368</a>
<a id='n4369' href='#n4369'>4369</a>
<a id='n4370' href='#n4370'>4370</a>
<a id='n4371' href='#n4371'>4371</a>
<a id='n4372' href='#n4372'>4372</a>
<a id='n4373' href='#n4373'>4373</a>
<a id='n4374' href='#n4374'>4374</a>
<a id='n4375' href='#n4375'>4375</a>
<a id='n4376' href='#n4376'>4376</a>
<a id='n4377' href='#n4377'>4377</a>
<a id='n4378' href='#n4378'>4378</a>
<a id='n4379' href='#n4379'>4379</a>
<a id='n4380' href='#n4380'>4380</a>
<a id='n4381' href='#n4381'>4381</a>
<a id='n4382' href='#n4382'>4382</a>
<a id='n4383' href='#n4383'>4383</a>
<a id='n4384' href='#n4384'>4384</a>
<a id='n4385' href='#n4385'>4385</a>
<a id='n4386' href='#n4386'>4386</a>
<a id='n4387' href='#n4387'>4387</a>
<a id='n4388' href='#n4388'>4388</a>
<a id='n4389' href='#n4389'>4389</a>
<a id='n4390' href='#n4390'>4390</a>
<a id='n4391' href='#n4391'>4391</a>
<a id='n4392' href='#n4392'>4392</a>
<a id='n4393' href='#n4393'>4393</a>
<a id='n4394' href='#n4394'>4394</a>
<a id='n4395' href='#n4395'>4395</a>
<a id='n4396' href='#n4396'>4396</a>
<a id='n4397' href='#n4397'>4397</a>
<a id='n4398' href='#n4398'>4398</a>
<a id='n4399' href='#n4399'>4399</a>
<a id='n4400' href='#n4400'>4400</a>
<a id='n4401' href='#n4401'>4401</a>
<a id='n4402' href='#n4402'>4402</a>
<a id='n4403' href='#n4403'>4403</a>
<a id='n4404' href='#n4404'>4404</a>
<a id='n4405' href='#n4405'>4405</a>
<a id='n4406' href='#n4406'>4406</a>
<a id='n4407' href='#n4407'>4407</a>
<a id='n4408' href='#n4408'>4408</a>
<a id='n4409' href='#n4409'>4409</a>
<a id='n4410' href='#n4410'>4410</a>
<a id='n4411' href='#n4411'>4411</a>
<a id='n4412' href='#n4412'>4412</a>
<a id='n4413' href='#n4413'>4413</a>
<a id='n4414' href='#n4414'>4414</a>
<a id='n4415' href='#n4415'>4415</a>
<a id='n4416' href='#n4416'>4416</a>
<a id='n4417' href='#n4417'>4417</a>
<a id='n4418' href='#n4418'>4418</a>
<a id='n4419' href='#n4419'>4419</a>
<a id='n4420' href='#n4420'>4420</a>
<a id='n4421' href='#n4421'>4421</a>
<a id='n4422' href='#n4422'>4422</a>
<a id='n4423' href='#n4423'>4423</a>
<a id='n4424' href='#n4424'>4424</a>
<a id='n4425' href='#n4425'>4425</a>
<a id='n4426' href='#n4426'>4426</a>
<a id='n4427' href='#n4427'>4427</a>
<a id='n4428' href='#n4428'>4428</a>
<a id='n4429' href='#n4429'>4429</a>
<a id='n4430' href='#n4430'>4430</a>
<a id='n4431' href='#n4431'>4431</a>
<a id='n4432' href='#n4432'>4432</a>
<a id='n4433' href='#n4433'>4433</a>
<a id='n4434' href='#n4434'>4434</a>
<a id='n4435' href='#n4435'>4435</a>
<a id='n4436' href='#n4436'>4436</a>
<a id='n4437' href='#n4437'>4437</a>
<a id='n4438' href='#n4438'>4438</a>
<a id='n4439' href='#n4439'>4439</a>
<a id='n4440' href='#n4440'>4440</a>
<a id='n4441' href='#n4441'>4441</a>
<a id='n4442' href='#n4442'>4442</a>
<a id='n4443' href='#n4443'>4443</a>
<a id='n4444' href='#n4444'>4444</a>
<a id='n4445' href='#n4445'>4445</a>
<a id='n4446' href='#n4446'>4446</a>
<a id='n4447' href='#n4447'>4447</a>
<a id='n4448' href='#n4448'>4448</a>
<a id='n4449' href='#n4449'>4449</a>
<a id='n4450' href='#n4450'>4450</a>
<a id='n4451' href='#n4451'>4451</a>
<a id='n4452' href='#n4452'>4452</a>
<a id='n4453' href='#n4453'>4453</a>
<a id='n4454' href='#n4454'>4454</a>
<a id='n4455' href='#n4455'>4455</a>
<a id='n4456' href='#n4456'>4456</a>
<a id='n4457' href='#n4457'>4457</a>
<a id='n4458' href='#n4458'>4458</a>
<a id='n4459' href='#n4459'>4459</a>
<a id='n4460' href='#n4460'>4460</a>
<a id='n4461' href='#n4461'>4461</a>
<a id='n4462' href='#n4462'>4462</a>
<a id='n4463' href='#n4463'>4463</a>
<a id='n4464' href='#n4464'>4464</a>
<a id='n4465' href='#n4465'>4465</a>
<a id='n4466' href='#n4466'>4466</a>
<a id='n4467' href='#n4467'>4467</a>
<a id='n4468' href='#n4468'>4468</a>
<a id='n4469' href='#n4469'>4469</a>
<a id='n4470' href='#n4470'>4470</a>
<a id='n4471' href='#n4471'>4471</a>
<a id='n4472' href='#n4472'>4472</a>
<a id='n4473' href='#n4473'>4473</a>
<a id='n4474' href='#n4474'>4474</a>
<a id='n4475' href='#n4475'>4475</a>
<a id='n4476' href='#n4476'>4476</a>
<a id='n4477' href='#n4477'>4477</a>
<a id='n4478' href='#n4478'>4478</a>
<a id='n4479' href='#n4479'>4479</a>
<a id='n4480' href='#n4480'>4480</a>
<a id='n4481' href='#n4481'>4481</a>
<a id='n4482' href='#n4482'>4482</a>
<a id='n4483' href='#n4483'>4483</a>
<a id='n4484' href='#n4484'>4484</a>
<a id='n4485' href='#n4485'>4485</a>
<a id='n4486' href='#n4486'>4486</a>
<a id='n4487' href='#n4487'>4487</a>
<a id='n4488' href='#n4488'>4488</a>
<a id='n4489' href='#n4489'>4489</a>
<a id='n4490' href='#n4490'>4490</a>
<a id='n4491' href='#n4491'>4491</a>
<a id='n4492' href='#n4492'>4492</a>
<a id='n4493' href='#n4493'>4493</a>
<a id='n4494' href='#n4494'>4494</a>
<a id='n4495' href='#n4495'>4495</a>
<a id='n4496' href='#n4496'>4496</a>
<a id='n4497' href='#n4497'>4497</a>
<a id='n4498' href='#n4498'>4498</a>
<a id='n4499' href='#n4499'>4499</a>
<a id='n4500' href='#n4500'>4500</a>
<a id='n4501' href='#n4501'>4501</a>
<a id='n4502' href='#n4502'>4502</a>
<a id='n4503' href='#n4503'>4503</a>
<a id='n4504' href='#n4504'>4504</a>
<a id='n4505' href='#n4505'>4505</a>
<a id='n4506' href='#n4506'>4506</a>
<a id='n4507' href='#n4507'>4507</a>
<a id='n4508' href='#n4508'>4508</a>
<a id='n4509' href='#n4509'>4509</a>
<a id='n4510' href='#n4510'>4510</a>
<a id='n4511' href='#n4511'>4511</a>
<a id='n4512' href='#n4512'>4512</a>
<a id='n4513' href='#n4513'>4513</a>
<a id='n4514' href='#n4514'>4514</a>
<a id='n4515' href='#n4515'>4515</a>
<a id='n4516' href='#n4516'>4516</a>
<a id='n4517' href='#n4517'>4517</a>
<a id='n4518' href='#n4518'>4518</a>
<a id='n4519' href='#n4519'>4519</a>
<a id='n4520' href='#n4520'>4520</a>
<a id='n4521' href='#n4521'>4521</a>
<a id='n4522' href='#n4522'>4522</a>
<a id='n4523' href='#n4523'>4523</a>
<a id='n4524' href='#n4524'>4524</a>
<a id='n4525' href='#n4525'>4525</a>
<a id='n4526' href='#n4526'>4526</a>
<a id='n4527' href='#n4527'>4527</a>
<a id='n4528' href='#n4528'>4528</a>
<a id='n4529' href='#n4529'>4529</a>
<a id='n4530' href='#n4530'>4530</a>
<a id='n4531' href='#n4531'>4531</a>
<a id='n4532' href='#n4532'>4532</a>
<a id='n4533' href='#n4533'>4533</a>
<a id='n4534' href='#n4534'>4534</a>
<a id='n4535' href='#n4535'>4535</a>
<a id='n4536' href='#n4536'>4536</a>
<a id='n4537' href='#n4537'>4537</a>
<a id='n4538' href='#n4538'>4538</a>
<a id='n4539' href='#n4539'>4539</a>
<a id='n4540' href='#n4540'>4540</a>
<a id='n4541' href='#n4541'>4541</a>
<a id='n4542' href='#n4542'>4542</a>
<a id='n4543' href='#n4543'>4543</a>
<a id='n4544' href='#n4544'>4544</a>
<a id='n4545' href='#n4545'>4545</a>
<a id='n4546' href='#n4546'>4546</a>
<a id='n4547' href='#n4547'>4547</a>
<a id='n4548' href='#n4548'>4548</a>
<a id='n4549' href='#n4549'>4549</a>
<a id='n4550' href='#n4550'>4550</a>
<a id='n4551' href='#n4551'>4551</a>
<a id='n4552' href='#n4552'>4552</a>
<a id='n4553' href='#n4553'>4553</a>
<a id='n4554' href='#n4554'>4554</a>
<a id='n4555' href='#n4555'>4555</a>
<a id='n4556' href='#n4556'>4556</a>
<a id='n4557' href='#n4557'>4557</a>
<a id='n4558' href='#n4558'>4558</a>
<a id='n4559' href='#n4559'>4559</a>
<a id='n4560' href='#n4560'>4560</a>
<a id='n4561' href='#n4561'>4561</a>
<a id='n4562' href='#n4562'>4562</a>
<a id='n4563' href='#n4563'>4563</a>
<a id='n4564' href='#n4564'>4564</a>
<a id='n4565' href='#n4565'>4565</a>
<a id='n4566' href='#n4566'>4566</a>
<a id='n4567' href='#n4567'>4567</a>
<a id='n4568' href='#n4568'>4568</a>
<a id='n4569' href='#n4569'>4569</a>
<a id='n4570' href='#n4570'>4570</a>
<a id='n4571' href='#n4571'>4571</a>
<a id='n4572' href='#n4572'>4572</a>
<a id='n4573' href='#n4573'>4573</a>
<a id='n4574' href='#n4574'>4574</a>
<a id='n4575' href='#n4575'>4575</a>
<a id='n4576' href='#n4576'>4576</a>
<a id='n4577' href='#n4577'>4577</a>
<a id='n4578' href='#n4578'>4578</a>
<a id='n4579' href='#n4579'>4579</a>
<a id='n4580' href='#n4580'>4580</a>
<a id='n4581' href='#n4581'>4581</a>
<a id='n4582' href='#n4582'>4582</a>
<a id='n4583' href='#n4583'>4583</a>
<a id='n4584' href='#n4584'>4584</a>
<a id='n4585' href='#n4585'>4585</a>
<a id='n4586' href='#n4586'>4586</a>
<a id='n4587' href='#n4587'>4587</a>
<a id='n4588' href='#n4588'>4588</a>
<a id='n4589' href='#n4589'>4589</a>
<a id='n4590' href='#n4590'>4590</a>
<a id='n4591' href='#n4591'>4591</a>
<a id='n4592' href='#n4592'>4592</a>
<a id='n4593' href='#n4593'>4593</a>
<a id='n4594' href='#n4594'>4594</a>
<a id='n4595' href='#n4595'>4595</a>
<a id='n4596' href='#n4596'>4596</a>
<a id='n4597' href='#n4597'>4597</a>
<a id='n4598' href='#n4598'>4598</a>
<a id='n4599' href='#n4599'>4599</a>
<a id='n4600' href='#n4600'>4600</a>
<a id='n4601' href='#n4601'>4601</a>
<a id='n4602' href='#n4602'>4602</a>
<a id='n4603' href='#n4603'>4603</a>
<a id='n4604' href='#n4604'>4604</a>
<a id='n4605' href='#n4605'>4605</a>
<a id='n4606' href='#n4606'>4606</a>
<a id='n4607' href='#n4607'>4607</a>
<a id='n4608' href='#n4608'>4608</a>
<a id='n4609' href='#n4609'>4609</a>
<a id='n4610' href='#n4610'>4610</a>
<a id='n4611' href='#n4611'>4611</a>
<a id='n4612' href='#n4612'>4612</a>
<a id='n4613' href='#n4613'>4613</a>
<a id='n4614' href='#n4614'>4614</a>
<a id='n4615' href='#n4615'>4615</a>
<a id='n4616' href='#n4616'>4616</a>
<a id='n4617' href='#n4617'>4617</a>
<a id='n4618' href='#n4618'>4618</a>
<a id='n4619' href='#n4619'>4619</a>
<a id='n4620' href='#n4620'>4620</a>
<a id='n4621' href='#n4621'>4621</a>
<a id='n4622' href='#n4622'>4622</a>
<a id='n4623' href='#n4623'>4623</a>
<a id='n4624' href='#n4624'>4624</a>
<a id='n4625' href='#n4625'>4625</a>
<a id='n4626' href='#n4626'>4626</a>
<a id='n4627' href='#n4627'>4627</a>
<a id='n4628' href='#n4628'>4628</a>
<a id='n4629' href='#n4629'>4629</a>
<a id='n4630' href='#n4630'>4630</a>
<a id='n4631' href='#n4631'>4631</a>
<a id='n4632' href='#n4632'>4632</a>
<a id='n4633' href='#n4633'>4633</a>
<a id='n4634' href='#n4634'>4634</a>
<a id='n4635' href='#n4635'>4635</a>
<a id='n4636' href='#n4636'>4636</a>
<a id='n4637' href='#n4637'>4637</a>
<a id='n4638' href='#n4638'>4638</a>
<a id='n4639' href='#n4639'>4639</a>
<a id='n4640' href='#n4640'>4640</a>
<a id='n4641' href='#n4641'>4641</a>
<a id='n4642' href='#n4642'>4642</a>
<a id='n4643' href='#n4643'>4643</a>
<a id='n4644' href='#n4644'>4644</a>
<a id='n4645' href='#n4645'>4645</a>
<a id='n4646' href='#n4646'>4646</a>
<a id='n4647' href='#n4647'>4647</a>
<a id='n4648' href='#n4648'>4648</a>
<a id='n4649' href='#n4649'>4649</a>
<a id='n4650' href='#n4650'>4650</a>
<a id='n4651' href='#n4651'>4651</a>
<a id='n4652' href='#n4652'>4652</a>
<a id='n4653' href='#n4653'>4653</a>
<a id='n4654' href='#n4654'>4654</a>
<a id='n4655' href='#n4655'>4655</a>
<a id='n4656' href='#n4656'>4656</a>
<a id='n4657' href='#n4657'>4657</a>
<a id='n4658' href='#n4658'>4658</a>
<a id='n4659' href='#n4659'>4659</a>
<a id='n4660' href='#n4660'>4660</a>
<a id='n4661' href='#n4661'>4661</a>
<a id='n4662' href='#n4662'>4662</a>
<a id='n4663' href='#n4663'>4663</a>
<a id='n4664' href='#n4664'>4664</a>
<a id='n4665' href='#n4665'>4665</a>
<a id='n4666' href='#n4666'>4666</a>
<a id='n4667' href='#n4667'>4667</a>
<a id='n4668' href='#n4668'>4668</a>
<a id='n4669' href='#n4669'>4669</a>
<a id='n4670' href='#n4670'>4670</a>
<a id='n4671' href='#n4671'>4671</a>
<a id='n4672' href='#n4672'>4672</a>
<a id='n4673' href='#n4673'>4673</a>
<a id='n4674' href='#n4674'>4674</a>
<a id='n4675' href='#n4675'>4675</a>
<a id='n4676' href='#n4676'>4676</a>
<a id='n4677' href='#n4677'>4677</a>
<a id='n4678' href='#n4678'>4678</a>
<a id='n4679' href='#n4679'>4679</a>
<a id='n4680' href='#n4680'>4680</a>
<a id='n4681' href='#n4681'>4681</a>
<a id='n4682' href='#n4682'>4682</a>
<a id='n4683' href='#n4683'>4683</a>
<a id='n4684' href='#n4684'>4684</a>
<a id='n4685' href='#n4685'>4685</a>
<a id='n4686' href='#n4686'>4686</a>
<a id='n4687' href='#n4687'>4687</a>
<a id='n4688' href='#n4688'>4688</a>
<a id='n4689' href='#n4689'>4689</a>
<a id='n4690' href='#n4690'>4690</a>
<a id='n4691' href='#n4691'>4691</a>
<a id='n4692' href='#n4692'>4692</a>
<a id='n4693' href='#n4693'>4693</a>
<a id='n4694' href='#n4694'>4694</a>
<a id='n4695' href='#n4695'>4695</a>
<a id='n4696' href='#n4696'>4696</a>
<a id='n4697' href='#n4697'>4697</a>
<a id='n4698' href='#n4698'>4698</a>
<a id='n4699' href='#n4699'>4699</a>
<a id='n4700' href='#n4700'>4700</a>
<a id='n4701' href='#n4701'>4701</a>
<a id='n4702' href='#n4702'>4702</a>
<a id='n4703' href='#n4703'>4703</a>
<a id='n4704' href='#n4704'>4704</a>
<a id='n4705' href='#n4705'>4705</a>
<a id='n4706' href='#n4706'>4706</a>
<a id='n4707' href='#n4707'>4707</a>
<a id='n4708' href='#n4708'>4708</a>
<a id='n4709' href='#n4709'>4709</a>
<a id='n4710' href='#n4710'>4710</a>
<a id='n4711' href='#n4711'>4711</a>
<a id='n4712' href='#n4712'>4712</a>
<a id='n4713' href='#n4713'>4713</a>
<a id='n4714' href='#n4714'>4714</a>
<a id='n4715' href='#n4715'>4715</a>
<a id='n4716' href='#n4716'>4716</a>
<a id='n4717' href='#n4717'>4717</a>
<a id='n4718' href='#n4718'>4718</a>
<a id='n4719' href='#n4719'>4719</a>
<a id='n4720' href='#n4720'>4720</a>
<a id='n4721' href='#n4721'>4721</a>
<a id='n4722' href='#n4722'>4722</a>
<a id='n4723' href='#n4723'>4723</a>
<a id='n4724' href='#n4724'>4724</a>
<a id='n4725' href='#n4725'>4725</a>
<a id='n4726' href='#n4726'>4726</a>
<a id='n4727' href='#n4727'>4727</a>
<a id='n4728' href='#n4728'>4728</a>
<a id='n4729' href='#n4729'>4729</a>
<a id='n4730' href='#n4730'>4730</a>
<a id='n4731' href='#n4731'>4731</a>
<a id='n4732' href='#n4732'>4732</a>
<a id='n4733' href='#n4733'>4733</a>
<a id='n4734' href='#n4734'>4734</a>
<a id='n4735' href='#n4735'>4735</a>
<a id='n4736' href='#n4736'>4736</a>
<a id='n4737' href='#n4737'>4737</a>
<a id='n4738' href='#n4738'>4738</a>
<a id='n4739' href='#n4739'>4739</a>
<a id='n4740' href='#n4740'>4740</a>
<a id='n4741' href='#n4741'>4741</a>
<a id='n4742' href='#n4742'>4742</a>
<a id='n4743' href='#n4743'>4743</a>
<a id='n4744' href='#n4744'>4744</a>
<a id='n4745' href='#n4745'>4745</a>
<a id='n4746' href='#n4746'>4746</a>
<a id='n4747' href='#n4747'>4747</a>
<a id='n4748' href='#n4748'>4748</a>
<a id='n4749' href='#n4749'>4749</a>
<a id='n4750' href='#n4750'>4750</a>
<a id='n4751' href='#n4751'>4751</a>
<a id='n4752' href='#n4752'>4752</a>
<a id='n4753' href='#n4753'>4753</a>
<a id='n4754' href='#n4754'>4754</a>
<a id='n4755' href='#n4755'>4755</a>
<a id='n4756' href='#n4756'>4756</a>
<a id='n4757' href='#n4757'>4757</a>
<a id='n4758' href='#n4758'>4758</a>
<a id='n4759' href='#n4759'>4759</a>
<a id='n4760' href='#n4760'>4760</a>
<a id='n4761' href='#n4761'>4761</a>
<a id='n4762' href='#n4762'>4762</a>
<a id='n4763' href='#n4763'>4763</a>
<a id='n4764' href='#n4764'>4764</a>
<a id='n4765' href='#n4765'>4765</a>
<a id='n4766' href='#n4766'>4766</a>
<a id='n4767' href='#n4767'>4767</a>
<a id='n4768' href='#n4768'>4768</a>
<a id='n4769' href='#n4769'>4769</a>
<a id='n4770' href='#n4770'>4770</a>
<a id='n4771' href='#n4771'>4771</a>
<a id='n4772' href='#n4772'>4772</a>
<a id='n4773' href='#n4773'>4773</a>
<a id='n4774' href='#n4774'>4774</a>
<a id='n4775' href='#n4775'>4775</a>
<a id='n4776' href='#n4776'>4776</a>
<a id='n4777' href='#n4777'>4777</a>
<a id='n4778' href='#n4778'>4778</a>
<a id='n4779' href='#n4779'>4779</a>
<a id='n4780' href='#n4780'>4780</a>
<a id='n4781' href='#n4781'>4781</a>
<a id='n4782' href='#n4782'>4782</a>
<a id='n4783' href='#n4783'>4783</a>
<a id='n4784' href='#n4784'>4784</a>
<a id='n4785' href='#n4785'>4785</a>
<a id='n4786' href='#n4786'>4786</a>
<a id='n4787' href='#n4787'>4787</a>
<a id='n4788' href='#n4788'>4788</a>
<a id='n4789' href='#n4789'>4789</a>
<a id='n4790' href='#n4790'>4790</a>
<a id='n4791' href='#n4791'>4791</a>
<a id='n4792' href='#n4792'>4792</a>
<a id='n4793' href='#n4793'>4793</a>
<a id='n4794' href='#n4794'>4794</a>
<a id='n4795' href='#n4795'>4795</a>
<a id='n4796' href='#n4796'>4796</a>
<a id='n4797' href='#n4797'>4797</a>
<a id='n4798' href='#n4798'>4798</a>
<a id='n4799' href='#n4799'>4799</a>
<a id='n4800' href='#n4800'>4800</a>
<a id='n4801' href='#n4801'>4801</a>
<a id='n4802' href='#n4802'>4802</a>
<a id='n4803' href='#n4803'>4803</a>
<a id='n4804' href='#n4804'>4804</a>
<a id='n4805' href='#n4805'>4805</a>
<a id='n4806' href='#n4806'>4806</a>
<a id='n4807' href='#n4807'>4807</a>
<a id='n4808' href='#n4808'>4808</a>
<a id='n4809' href='#n4809'>4809</a>
<a id='n4810' href='#n4810'>4810</a>
<a id='n4811' href='#n4811'>4811</a>
<a id='n4812' href='#n4812'>4812</a>
<a id='n4813' href='#n4813'>4813</a>
<a id='n4814' href='#n4814'>4814</a>
<a id='n4815' href='#n4815'>4815</a>
<a id='n4816' href='#n4816'>4816</a>
<a id='n4817' href='#n4817'>4817</a>
<a id='n4818' href='#n4818'>4818</a>
<a id='n4819' href='#n4819'>4819</a>
<a id='n4820' href='#n4820'>4820</a>
<a id='n4821' href='#n4821'>4821</a>
<a id='n4822' href='#n4822'>4822</a>
<a id='n4823' href='#n4823'>4823</a>
<a id='n4824' href='#n4824'>4824</a>
<a id='n4825' href='#n4825'>4825</a>
<a id='n4826' href='#n4826'>4826</a>
<a id='n4827' href='#n4827'>4827</a>
<a id='n4828' href='#n4828'>4828</a>
<a id='n4829' href='#n4829'>4829</a>
<a id='n4830' href='#n4830'>4830</a>
<a id='n4831' href='#n4831'>4831</a>
<a id='n4832' href='#n4832'>4832</a>
<a id='n4833' href='#n4833'>4833</a>
<a id='n4834' href='#n4834'>4834</a>
<a id='n4835' href='#n4835'>4835</a>
<a id='n4836' href='#n4836'>4836</a>
<a id='n4837' href='#n4837'>4837</a>
<a id='n4838' href='#n4838'>4838</a>
<a id='n4839' href='#n4839'>4839</a>
<a id='n4840' href='#n4840'>4840</a>
<a id='n4841' href='#n4841'>4841</a>
<a id='n4842' href='#n4842'>4842</a>
<a id='n4843' href='#n4843'>4843</a>
<a id='n4844' href='#n4844'>4844</a>
<a id='n4845' href='#n4845'>4845</a>
<a id='n4846' href='#n4846'>4846</a>
<a id='n4847' href='#n4847'>4847</a>
<a id='n4848' href='#n4848'>4848</a>
<a id='n4849' href='#n4849'>4849</a>
<a id='n4850' href='#n4850'>4850</a>
<a id='n4851' href='#n4851'>4851</a>
<a id='n4852' href='#n4852'>4852</a>
<a id='n4853' href='#n4853'>4853</a>
<a id='n4854' href='#n4854'>4854</a>
<a id='n4855' href='#n4855'>4855</a>
<a id='n4856' href='#n4856'>4856</a>
<a id='n4857' href='#n4857'>4857</a>
<a id='n4858' href='#n4858'>4858</a>
<a id='n4859' href='#n4859'>4859</a>
<a id='n4860' href='#n4860'>4860</a>
<a id='n4861' href='#n4861'>4861</a>
<a id='n4862' href='#n4862'>4862</a>
<a id='n4863' href='#n4863'>4863</a>
<a id='n4864' href='#n4864'>4864</a>
<a id='n4865' href='#n4865'>4865</a>
<a id='n4866' href='#n4866'>4866</a>
<a id='n4867' href='#n4867'>4867</a>
<a id='n4868' href='#n4868'>4868</a>
<a id='n4869' href='#n4869'>4869</a>
<a id='n4870' href='#n4870'>4870</a>
<a id='n4871' href='#n4871'>4871</a>
<a id='n4872' href='#n4872'>4872</a>
<a id='n4873' href='#n4873'>4873</a>
<a id='n4874' href='#n4874'>4874</a>
<a id='n4875' href='#n4875'>4875</a>
<a id='n4876' href='#n4876'>4876</a>
<a id='n4877' href='#n4877'>4877</a>
<a id='n4878' href='#n4878'>4878</a>
<a id='n4879' href='#n4879'>4879</a>
<a id='n4880' href='#n4880'>4880</a>
<a id='n4881' href='#n4881'>4881</a>
<a id='n4882' href='#n4882'>4882</a>
<a id='n4883' href='#n4883'>4883</a>
<a id='n4884' href='#n4884'>4884</a>
<a id='n4885' href='#n4885'>4885</a>
<a id='n4886' href='#n4886'>4886</a>
<a id='n4887' href='#n4887'>4887</a>
<a id='n4888' href='#n4888'>4888</a>
<a id='n4889' href='#n4889'>4889</a>
<a id='n4890' href='#n4890'>4890</a>
<a id='n4891' href='#n4891'>4891</a>
<a id='n4892' href='#n4892'>4892</a>
<a id='n4893' href='#n4893'>4893</a>
<a id='n4894' href='#n4894'>4894</a>
<a id='n4895' href='#n4895'>4895</a>
<a id='n4896' href='#n4896'>4896</a>
<a id='n4897' href='#n4897'>4897</a>
<a id='n4898' href='#n4898'>4898</a>
<a id='n4899' href='#n4899'>4899</a>
<a id='n4900' href='#n4900'>4900</a>
<a id='n4901' href='#n4901'>4901</a>
<a id='n4902' href='#n4902'>4902</a>
<a id='n4903' href='#n4903'>4903</a>
<a id='n4904' href='#n4904'>4904</a>
<a id='n4905' href='#n4905'>4905</a>
<a id='n4906' href='#n4906'>4906</a>
<a id='n4907' href='#n4907'>4907</a>
<a id='n4908' href='#n4908'>4908</a>
<a id='n4909' href='#n4909'>4909</a>
<a id='n4910' href='#n4910'>4910</a>
<a id='n4911' href='#n4911'>4911</a>
<a id='n4912' href='#n4912'>4912</a>
<a id='n4913' href='#n4913'>4913</a>
<a id='n4914' href='#n4914'>4914</a>
<a id='n4915' href='#n4915'>4915</a>
<a id='n4916' href='#n4916'>4916</a>
<a id='n4917' href='#n4917'>4917</a>
<a id='n4918' href='#n4918'>4918</a>
<a id='n4919' href='#n4919'>4919</a>
<a id='n4920' href='#n4920'>4920</a>
<a id='n4921' href='#n4921'>4921</a>
<a id='n4922' href='#n4922'>4922</a>
<a id='n4923' href='#n4923'>4923</a>
<a id='n4924' href='#n4924'>4924</a>
<a id='n4925' href='#n4925'>4925</a>
<a id='n4926' href='#n4926'>4926</a>
<a id='n4927' href='#n4927'>4927</a>
<a id='n4928' href='#n4928'>4928</a>
<a id='n4929' href='#n4929'>4929</a>
<a id='n4930' href='#n4930'>4930</a>
<a id='n4931' href='#n4931'>4931</a>
<a id='n4932' href='#n4932'>4932</a>
<a id='n4933' href='#n4933'>4933</a>
<a id='n4934' href='#n4934'>4934</a>
<a id='n4935' href='#n4935'>4935</a>
<a id='n4936' href='#n4936'>4936</a>
<a id='n4937' href='#n4937'>4937</a>
<a id='n4938' href='#n4938'>4938</a>
<a id='n4939' href='#n4939'>4939</a>
<a id='n4940' href='#n4940'>4940</a>
<a id='n4941' href='#n4941'>4941</a>
<a id='n4942' href='#n4942'>4942</a>
<a id='n4943' href='#n4943'>4943</a>
<a id='n4944' href='#n4944'>4944</a>
<a id='n4945' href='#n4945'>4945</a>
<a id='n4946' href='#n4946'>4946</a>
<a id='n4947' href='#n4947'>4947</a>
<a id='n4948' href='#n4948'>4948</a>
<a id='n4949' href='#n4949'>4949</a>
<a id='n4950' href='#n4950'>4950</a>
<a id='n4951' href='#n4951'>4951</a>
<a id='n4952' href='#n4952'>4952</a>
<a id='n4953' href='#n4953'>4953</a>
<a id='n4954' href='#n4954'>4954</a>
<a id='n4955' href='#n4955'>4955</a>
<a id='n4956' href='#n4956'>4956</a>
<a id='n4957' href='#n4957'>4957</a>
<a id='n4958' href='#n4958'>4958</a>
<a id='n4959' href='#n4959'>4959</a>
<a id='n4960' href='#n4960'>4960</a>
<a id='n4961' href='#n4961'>4961</a>
<a id='n4962' href='#n4962'>4962</a>
<a id='n4963' href='#n4963'>4963</a>
<a id='n4964' href='#n4964'>4964</a>
<a id='n4965' href='#n4965'>4965</a>
<a id='n4966' href='#n4966'>4966</a>
<a id='n4967' href='#n4967'>4967</a>
<a id='n4968' href='#n4968'>4968</a>
<a id='n4969' href='#n4969'>4969</a>
<a id='n4970' href='#n4970'>4970</a>
<a id='n4971' href='#n4971'>4971</a>
<a id='n4972' href='#n4972'>4972</a>
<a id='n4973' href='#n4973'>4973</a>
<a id='n4974' href='#n4974'>4974</a>
<a id='n4975' href='#n4975'>4975</a>
<a id='n4976' href='#n4976'>4976</a>
<a id='n4977' href='#n4977'>4977</a>
<a id='n4978' href='#n4978'>4978</a>
<a id='n4979' href='#n4979'>4979</a>
<a id='n4980' href='#n4980'>4980</a>
<a id='n4981' href='#n4981'>4981</a>
<a id='n4982' href='#n4982'>4982</a>
<a id='n4983' href='#n4983'>4983</a>
<a id='n4984' href='#n4984'>4984</a>
<a id='n4985' href='#n4985'>4985</a>
<a id='n4986' href='#n4986'>4986</a>
<a id='n4987' href='#n4987'>4987</a>
<a id='n4988' href='#n4988'>4988</a>
<a id='n4989' href='#n4989'>4989</a>
<a id='n4990' href='#n4990'>4990</a>
<a id='n4991' href='#n4991'>4991</a>
<a id='n4992' href='#n4992'>4992</a>
<a id='n4993' href='#n4993'>4993</a>
<a id='n4994' href='#n4994'>4994</a>
<a id='n4995' href='#n4995'>4995</a>
<a id='n4996' href='#n4996'>4996</a>
<a id='n4997' href='#n4997'>4997</a>
<a id='n4998' href='#n4998'>4998</a>
<a id='n4999' href='#n4999'>4999</a>
<a id='n5000' href='#n5000'>5000</a>
<a id='n5001' href='#n5001'>5001</a>
<a id='n5002' href='#n5002'>5002</a>
<a id='n5003' href='#n5003'>5003</a>
<a id='n5004' href='#n5004'>5004</a>
<a id='n5005' href='#n5005'>5005</a>
<a id='n5006' href='#n5006'>5006</a>
<a id='n5007' href='#n5007'>5007</a>
<a id='n5008' href='#n5008'>5008</a>
<a id='n5009' href='#n5009'>5009</a>
<a id='n5010' href='#n5010'>5010</a>
<a id='n5011' href='#n5011'>5011</a>
<a id='n5012' href='#n5012'>5012</a>
<a id='n5013' href='#n5013'>5013</a>
<a id='n5014' href='#n5014'>5014</a>
<a id='n5015' href='#n5015'>5015</a>
<a id='n5016' href='#n5016'>5016</a>
<a id='n5017' href='#n5017'>5017</a>
<a id='n5018' href='#n5018'>5018</a>
<a id='n5019' href='#n5019'>5019</a>
<a id='n5020' href='#n5020'>5020</a>
<a id='n5021' href='#n5021'>5021</a>
<a id='n5022' href='#n5022'>5022</a>
<a id='n5023' href='#n5023'>5023</a>
<a id='n5024' href='#n5024'>5024</a>
<a id='n5025' href='#n5025'>5025</a>
<a id='n5026' href='#n5026'>5026</a>
<a id='n5027' href='#n5027'>5027</a>
<a id='n5028' href='#n5028'>5028</a>
<a id='n5029' href='#n5029'>5029</a>
<a id='n5030' href='#n5030'>5030</a>
<a id='n5031' href='#n5031'>5031</a>
<a id='n5032' href='#n5032'>5032</a>
<a id='n5033' href='#n5033'>5033</a>
<a id='n5034' href='#n5034'>5034</a>
<a id='n5035' href='#n5035'>5035</a>
<a id='n5036' href='#n5036'>5036</a>
<a id='n5037' href='#n5037'>5037</a>
<a id='n5038' href='#n5038'>5038</a>
<a id='n5039' href='#n5039'>5039</a>
<a id='n5040' href='#n5040'>5040</a>
<a id='n5041' href='#n5041'>5041</a>
<a id='n5042' href='#n5042'>5042</a>
<a id='n5043' href='#n5043'>5043</a>
<a id='n5044' href='#n5044'>5044</a>
<a id='n5045' href='#n5045'>5045</a>
<a id='n5046' href='#n5046'>5046</a>
<a id='n5047' href='#n5047'>5047</a>
<a id='n5048' href='#n5048'>5048</a>
<a id='n5049' href='#n5049'>5049</a>
<a id='n5050' href='#n5050'>5050</a>
<a id='n5051' href='#n5051'>5051</a>
<a id='n5052' href='#n5052'>5052</a>
<a id='n5053' href='#n5053'>5053</a>
<a id='n5054' href='#n5054'>5054</a>
<a id='n5055' href='#n5055'>5055</a>
<a id='n5056' href='#n5056'>5056</a>
<a id='n5057' href='#n5057'>5057</a>
<a id='n5058' href='#n5058'>5058</a>
<a id='n5059' href='#n5059'>5059</a>
<a id='n5060' href='#n5060'>5060</a>
<a id='n5061' href='#n5061'>5061</a>
<a id='n5062' href='#n5062'>5062</a>
<a id='n5063' href='#n5063'>5063</a>
<a id='n5064' href='#n5064'>5064</a>
<a id='n5065' href='#n5065'>5065</a>
<a id='n5066' href='#n5066'>5066</a>
<a id='n5067' href='#n5067'>5067</a>
<a id='n5068' href='#n5068'>5068</a>
<a id='n5069' href='#n5069'>5069</a>
<a id='n5070' href='#n5070'>5070</a>
<a id='n5071' href='#n5071'>5071</a>
<a id='n5072' href='#n5072'>5072</a>
<a id='n5073' href='#n5073'>5073</a>
<a id='n5074' href='#n5074'>5074</a>
<a id='n5075' href='#n5075'>5075</a>
<a id='n5076' href='#n5076'>5076</a>
<a id='n5077' href='#n5077'>5077</a>
<a id='n5078' href='#n5078'>5078</a>
<a id='n5079' href='#n5079'>5079</a>
<a id='n5080' href='#n5080'>5080</a>
<a id='n5081' href='#n5081'>5081</a>
<a id='n5082' href='#n5082'>5082</a>
<a id='n5083' href='#n5083'>5083</a>
<a id='n5084' href='#n5084'>5084</a>
<a id='n5085' href='#n5085'>5085</a>
<a id='n5086' href='#n5086'>5086</a>
<a id='n5087' href='#n5087'>5087</a>
<a id='n5088' href='#n5088'>5088</a>
<a id='n5089' href='#n5089'>5089</a>
<a id='n5090' href='#n5090'>5090</a>
<a id='n5091' href='#n5091'>5091</a>
<a id='n5092' href='#n5092'>5092</a>
<a id='n5093' href='#n5093'>5093</a>
<a id='n5094' href='#n5094'>5094</a>
<a id='n5095' href='#n5095'>5095</a>
<a id='n5096' href='#n5096'>5096</a>
<a id='n5097' href='#n5097'>5097</a>
<a id='n5098' href='#n5098'>5098</a>
<a id='n5099' href='#n5099'>5099</a>
<a id='n5100' href='#n5100'>5100</a>
<a id='n5101' href='#n5101'>5101</a>
<a id='n5102' href='#n5102'>5102</a>
<a id='n5103' href='#n5103'>5103</a>
<a id='n5104' href='#n5104'>5104</a>
<a id='n5105' href='#n5105'>5105</a>
<a id='n5106' href='#n5106'>5106</a>
<a id='n5107' href='#n5107'>5107</a>
<a id='n5108' href='#n5108'>5108</a>
<a id='n5109' href='#n5109'>5109</a>
<a id='n5110' href='#n5110'>5110</a>
<a id='n5111' href='#n5111'>5111</a>
<a id='n5112' href='#n5112'>5112</a>
<a id='n5113' href='#n5113'>5113</a>
<a id='n5114' href='#n5114'>5114</a>
<a id='n5115' href='#n5115'>5115</a>
<a id='n5116' href='#n5116'>5116</a>
<a id='n5117' href='#n5117'>5117</a>
<a id='n5118' href='#n5118'>5118</a>
<a id='n5119' href='#n5119'>5119</a>
<a id='n5120' href='#n5120'>5120</a>
<a id='n5121' href='#n5121'>5121</a>
<a id='n5122' href='#n5122'>5122</a>
<a id='n5123' href='#n5123'>5123</a>
<a id='n5124' href='#n5124'>5124</a>
<a id='n5125' href='#n5125'>5125</a>
<a id='n5126' href='#n5126'>5126</a>
<a id='n5127' href='#n5127'>5127</a>
<a id='n5128' href='#n5128'>5128</a>
<a id='n5129' href='#n5129'>5129</a>
<a id='n5130' href='#n5130'>5130</a>
<a id='n5131' href='#n5131'>5131</a>
<a id='n5132' href='#n5132'>5132</a>
<a id='n5133' href='#n5133'>5133</a>
<a id='n5134' href='#n5134'>5134</a>
<a id='n5135' href='#n5135'>5135</a>
<a id='n5136' href='#n5136'>5136</a>
<a id='n5137' href='#n5137'>5137</a>
<a id='n5138' href='#n5138'>5138</a>
<a id='n5139' href='#n5139'>5139</a>
<a id='n5140' href='#n5140'>5140</a>
<a id='n5141' href='#n5141'>5141</a>
<a id='n5142' href='#n5142'>5142</a>
<a id='n5143' href='#n5143'>5143</a>
<a id='n5144' href='#n5144'>5144</a>
<a id='n5145' href='#n5145'>5145</a>
<a id='n5146' href='#n5146'>5146</a>
<a id='n5147' href='#n5147'>5147</a>
<a id='n5148' href='#n5148'>5148</a>
<a id='n5149' href='#n5149'>5149</a>
<a id='n5150' href='#n5150'>5150</a>
<a id='n5151' href='#n5151'>5151</a>
<a id='n5152' href='#n5152'>5152</a>
<a id='n5153' href='#n5153'>5153</a>
<a id='n5154' href='#n5154'>5154</a>
<a id='n5155' href='#n5155'>5155</a>
<a id='n5156' href='#n5156'>5156</a>
<a id='n5157' href='#n5157'>5157</a>
<a id='n5158' href='#n5158'>5158</a>
<a id='n5159' href='#n5159'>5159</a>
<a id='n5160' href='#n5160'>5160</a>
<a id='n5161' href='#n5161'>5161</a>
<a id='n5162' href='#n5162'>5162</a>
<a id='n5163' href='#n5163'>5163</a>
<a id='n5164' href='#n5164'>5164</a>
<a id='n5165' href='#n5165'>5165</a>
<a id='n5166' href='#n5166'>5166</a>
<a id='n5167' href='#n5167'>5167</a>
<a id='n5168' href='#n5168'>5168</a>
<a id='n5169' href='#n5169'>5169</a>
<a id='n5170' href='#n5170'>5170</a>
<a id='n5171' href='#n5171'>5171</a>
<a id='n5172' href='#n5172'>5172</a>
<a id='n5173' href='#n5173'>5173</a>
<a id='n5174' href='#n5174'>5174</a>
<a id='n5175' href='#n5175'>5175</a>
<a id='n5176' href='#n5176'>5176</a>
<a id='n5177' href='#n5177'>5177</a>
<a id='n5178' href='#n5178'>5178</a>
<a id='n5179' href='#n5179'>5179</a>
<a id='n5180' href='#n5180'>5180</a>
<a id='n5181' href='#n5181'>5181</a>
<a id='n5182' href='#n5182'>5182</a>
<a id='n5183' href='#n5183'>5183</a>
<a id='n5184' href='#n5184'>5184</a>
<a id='n5185' href='#n5185'>5185</a>
<a id='n5186' href='#n5186'>5186</a>
<a id='n5187' href='#n5187'>5187</a>
<a id='n5188' href='#n5188'>5188</a>
<a id='n5189' href='#n5189'>5189</a>
<a id='n5190' href='#n5190'>5190</a>
<a id='n5191' href='#n5191'>5191</a>
<a id='n5192' href='#n5192'>5192</a>
<a id='n5193' href='#n5193'>5193</a>
<a id='n5194' href='#n5194'>5194</a>
<a id='n5195' href='#n5195'>5195</a>
<a id='n5196' href='#n5196'>5196</a>
<a id='n5197' href='#n5197'>5197</a>
<a id='n5198' href='#n5198'>5198</a>
<a id='n5199' href='#n5199'>5199</a>
<a id='n5200' href='#n5200'>5200</a>
<a id='n5201' href='#n5201'>5201</a>
<a id='n5202' href='#n5202'>5202</a>
<a id='n5203' href='#n5203'>5203</a>
<a id='n5204' href='#n5204'>5204</a>
<a id='n5205' href='#n5205'>5205</a>
<a id='n5206' href='#n5206'>5206</a>
<a id='n5207' href='#n5207'>5207</a>
<a id='n5208' href='#n5208'>5208</a>
<a id='n5209' href='#n5209'>5209</a>
<a id='n5210' href='#n5210'>5210</a>
<a id='n5211' href='#n5211'>5211</a>
<a id='n5212' href='#n5212'>5212</a>
<a id='n5213' href='#n5213'>5213</a>
<a id='n5214' href='#n5214'>5214</a>
<a id='n5215' href='#n5215'>5215</a>
<a id='n5216' href='#n5216'>5216</a>
<a id='n5217' href='#n5217'>5217</a>
<a id='n5218' href='#n5218'>5218</a>
<a id='n5219' href='#n5219'>5219</a>
<a id='n5220' href='#n5220'>5220</a>
<a id='n5221' href='#n5221'>5221</a>
<a id='n5222' href='#n5222'>5222</a>
<a id='n5223' href='#n5223'>5223</a>
<a id='n5224' href='#n5224'>5224</a>
<a id='n5225' href='#n5225'>5225</a>
<a id='n5226' href='#n5226'>5226</a>
<a id='n5227' href='#n5227'>5227</a>
<a id='n5228' href='#n5228'>5228</a>
<a id='n5229' href='#n5229'>5229</a>
<a id='n5230' href='#n5230'>5230</a>
<a id='n5231' href='#n5231'>5231</a>
<a id='n5232' href='#n5232'>5232</a>
<a id='n5233' href='#n5233'>5233</a>
<a id='n5234' href='#n5234'>5234</a>
<a id='n5235' href='#n5235'>5235</a>
<a id='n5236' href='#n5236'>5236</a>
<a id='n5237' href='#n5237'>5237</a>
<a id='n5238' href='#n5238'>5238</a>
<a id='n5239' href='#n5239'>5239</a>
<a id='n5240' href='#n5240'>5240</a>
<a id='n5241' href='#n5241'>5241</a>
<a id='n5242' href='#n5242'>5242</a>
<a id='n5243' href='#n5243'>5243</a>
<a id='n5244' href='#n5244'>5244</a>
<a id='n5245' href='#n5245'>5245</a>
<a id='n5246' href='#n5246'>5246</a>
<a id='n5247' href='#n5247'>5247</a>
<a id='n5248' href='#n5248'>5248</a>
<a id='n5249' href='#n5249'>5249</a>
<a id='n5250' href='#n5250'>5250</a>
<a id='n5251' href='#n5251'>5251</a>
<a id='n5252' href='#n5252'>5252</a>
<a id='n5253' href='#n5253'>5253</a>
<a id='n5254' href='#n5254'>5254</a>
<a id='n5255' href='#n5255'>5255</a>
<a id='n5256' href='#n5256'>5256</a>
<a id='n5257' href='#n5257'>5257</a>
<a id='n5258' href='#n5258'>5258</a>
<a id='n5259' href='#n5259'>5259</a>
<a id='n5260' href='#n5260'>5260</a>
<a id='n5261' href='#n5261'>5261</a>
<a id='n5262' href='#n5262'>5262</a>
<a id='n5263' href='#n5263'>5263</a>
<a id='n5264' href='#n5264'>5264</a>
<a id='n5265' href='#n5265'>5265</a>
<a id='n5266' href='#n5266'>5266</a>
<a id='n5267' href='#n5267'>5267</a>
<a id='n5268' href='#n5268'>5268</a>
<a id='n5269' href='#n5269'>5269</a>
<a id='n5270' href='#n5270'>5270</a>
<a id='n5271' href='#n5271'>5271</a>
<a id='n5272' href='#n5272'>5272</a>
<a id='n5273' href='#n5273'>5273</a>
<a id='n5274' href='#n5274'>5274</a>
<a id='n5275' href='#n5275'>5275</a>
<a id='n5276' href='#n5276'>5276</a>
<a id='n5277' href='#n5277'>5277</a>
<a id='n5278' href='#n5278'>5278</a>
<a id='n5279' href='#n5279'>5279</a>
<a id='n5280' href='#n5280'>5280</a>
<a id='n5281' href='#n5281'>5281</a>
<a id='n5282' href='#n5282'>5282</a>
<a id='n5283' href='#n5283'>5283</a>
<a id='n5284' href='#n5284'>5284</a>
<a id='n5285' href='#n5285'>5285</a>
<a id='n5286' href='#n5286'>5286</a>
<a id='n5287' href='#n5287'>5287</a>
<a id='n5288' href='#n5288'>5288</a>
<a id='n5289' href='#n5289'>5289</a>
<a id='n5290' href='#n5290'>5290</a>
<a id='n5291' href='#n5291'>5291</a>
<a id='n5292' href='#n5292'>5292</a>
<a id='n5293' href='#n5293'>5293</a>
<a id='n5294' href='#n5294'>5294</a>
<a id='n5295' href='#n5295'>5295</a>
<a id='n5296' href='#n5296'>5296</a>
<a id='n5297' href='#n5297'>5297</a>
<a id='n5298' href='#n5298'>5298</a>
<a id='n5299' href='#n5299'>5299</a>
<a id='n5300' href='#n5300'>5300</a>
<a id='n5301' href='#n5301'>5301</a>
<a id='n5302' href='#n5302'>5302</a>
<a id='n5303' href='#n5303'>5303</a>
<a id='n5304' href='#n5304'>5304</a>
<a id='n5305' href='#n5305'>5305</a>
<a id='n5306' href='#n5306'>5306</a>
<a id='n5307' href='#n5307'>5307</a>
<a id='n5308' href='#n5308'>5308</a>
<a id='n5309' href='#n5309'>5309</a>
<a id='n5310' href='#n5310'>5310</a>
<a id='n5311' href='#n5311'>5311</a>
<a id='n5312' href='#n5312'>5312</a>
<a id='n5313' href='#n5313'>5313</a>
<a id='n5314' href='#n5314'>5314</a>
<a id='n5315' href='#n5315'>5315</a>
<a id='n5316' href='#n5316'>5316</a>
<a id='n5317' href='#n5317'>5317</a>
<a id='n5318' href='#n5318'>5318</a>
<a id='n5319' href='#n5319'>5319</a>
<a id='n5320' href='#n5320'>5320</a>
<a id='n5321' href='#n5321'>5321</a>
<a id='n5322' href='#n5322'>5322</a>
<a id='n5323' href='#n5323'>5323</a>
<a id='n5324' href='#n5324'>5324</a>
<a id='n5325' href='#n5325'>5325</a>
<a id='n5326' href='#n5326'>5326</a>
<a id='n5327' href='#n5327'>5327</a>
<a id='n5328' href='#n5328'>5328</a>
<a id='n5329' href='#n5329'>5329</a>
<a id='n5330' href='#n5330'>5330</a>
<a id='n5331' href='#n5331'>5331</a>
<a id='n5332' href='#n5332'>5332</a>
<a id='n5333' href='#n5333'>5333</a>
<a id='n5334' href='#n5334'>5334</a>
<a id='n5335' href='#n5335'>5335</a>
<a id='n5336' href='#n5336'>5336</a>
<a id='n5337' href='#n5337'>5337</a>
<a id='n5338' href='#n5338'>5338</a>
<a id='n5339' href='#n5339'>5339</a>
<a id='n5340' href='#n5340'>5340</a>
<a id='n5341' href='#n5341'>5341</a>
<a id='n5342' href='#n5342'>5342</a>
<a id='n5343' href='#n5343'>5343</a>
<a id='n5344' href='#n5344'>5344</a>
<a id='n5345' href='#n5345'>5345</a>
<a id='n5346' href='#n5346'>5346</a>
<a id='n5347' href='#n5347'>5347</a>
<a id='n5348' href='#n5348'>5348</a>
<a id='n5349' href='#n5349'>5349</a>
<a id='n5350' href='#n5350'>5350</a>
<a id='n5351' href='#n5351'>5351</a>
<a id='n5352' href='#n5352'>5352</a>
<a id='n5353' href='#n5353'>5353</a>
<a id='n5354' href='#n5354'>5354</a>
<a id='n5355' href='#n5355'>5355</a>
<a id='n5356' href='#n5356'>5356</a>
<a id='n5357' href='#n5357'>5357</a>
<a id='n5358' href='#n5358'>5358</a>
<a id='n5359' href='#n5359'>5359</a>
<a id='n5360' href='#n5360'>5360</a>
<a id='n5361' href='#n5361'>5361</a>
<a id='n5362' href='#n5362'>5362</a>
<a id='n5363' href='#n5363'>5363</a>
<a id='n5364' href='#n5364'>5364</a>
<a id='n5365' href='#n5365'>5365</a>
<a id='n5366' href='#n5366'>5366</a>
<a id='n5367' href='#n5367'>5367</a>
<a id='n5368' href='#n5368'>5368</a>
<a id='n5369' href='#n5369'>5369</a>
<a id='n5370' href='#n5370'>5370</a>
<a id='n5371' href='#n5371'>5371</a>
<a id='n5372' href='#n5372'>5372</a>
<a id='n5373' href='#n5373'>5373</a>
<a id='n5374' href='#n5374'>5374</a>
<a id='n5375' href='#n5375'>5375</a>
<a id='n5376' href='#n5376'>5376</a>
<a id='n5377' href='#n5377'>5377</a>
<a id='n5378' href='#n5378'>5378</a>
<a id='n5379' href='#n5379'>5379</a>
<a id='n5380' href='#n5380'>5380</a>
<a id='n5381' href='#n5381'>5381</a>
<a id='n5382' href='#n5382'>5382</a>
<a id='n5383' href='#n5383'>5383</a>
<a id='n5384' href='#n5384'>5384</a>
<a id='n5385' href='#n5385'>5385</a>
<a id='n5386' href='#n5386'>5386</a>
<a id='n5387' href='#n5387'>5387</a>
<a id='n5388' href='#n5388'>5388</a>
<a id='n5389' href='#n5389'>5389</a>
<a id='n5390' href='#n5390'>5390</a>
<a id='n5391' href='#n5391'>5391</a>
<a id='n5392' href='#n5392'>5392</a>
<a id='n5393' href='#n5393'>5393</a>
<a id='n5394' href='#n5394'>5394</a>
<a id='n5395' href='#n5395'>5395</a>
<a id='n5396' href='#n5396'>5396</a>
<a id='n5397' href='#n5397'>5397</a>
<a id='n5398' href='#n5398'>5398</a>
<a id='n5399' href='#n5399'>5399</a>
<a id='n5400' href='#n5400'>5400</a>
<a id='n5401' href='#n5401'>5401</a>
<a id='n5402' href='#n5402'>5402</a>
<a id='n5403' href='#n5403'>5403</a>
<a id='n5404' href='#n5404'>5404</a>
<a id='n5405' href='#n5405'>5405</a>
<a id='n5406' href='#n5406'>5406</a>
<a id='n5407' href='#n5407'>5407</a>
<a id='n5408' href='#n5408'>5408</a>
<a id='n5409' href='#n5409'>5409</a>
<a id='n5410' href='#n5410'>5410</a>
<a id='n5411' href='#n5411'>5411</a>
<a id='n5412' href='#n5412'>5412</a>
<a id='n5413' href='#n5413'>5413</a>
<a id='n5414' href='#n5414'>5414</a>
<a id='n5415' href='#n5415'>5415</a>
<a id='n5416' href='#n5416'>5416</a>
<a id='n5417' href='#n5417'>5417</a>
<a id='n5418' href='#n5418'>5418</a>
<a id='n5419' href='#n5419'>5419</a>
<a id='n5420' href='#n5420'>5420</a>
<a id='n5421' href='#n5421'>5421</a>
<a id='n5422' href='#n5422'>5422</a>
<a id='n5423' href='#n5423'>5423</a>
<a id='n5424' href='#n5424'>5424</a>
<a id='n5425' href='#n5425'>5425</a>
<a id='n5426' href='#n5426'>5426</a>
<a id='n5427' href='#n5427'>5427</a>
<a id='n5428' href='#n5428'>5428</a>
<a id='n5429' href='#n5429'>5429</a>
<a id='n5430' href='#n5430'>5430</a>
<a id='n5431' href='#n5431'>5431</a>
<a id='n5432' href='#n5432'>5432</a>
<a id='n5433' href='#n5433'>5433</a>
<a id='n5434' href='#n5434'>5434</a>
<a id='n5435' href='#n5435'>5435</a>
<a id='n5436' href='#n5436'>5436</a>
<a id='n5437' href='#n5437'>5437</a>
<a id='n5438' href='#n5438'>5438</a>
<a id='n5439' href='#n5439'>5439</a>
<a id='n5440' href='#n5440'>5440</a>
<a id='n5441' href='#n5441'>5441</a>
<a id='n5442' href='#n5442'>5442</a>
<a id='n5443' href='#n5443'>5443</a>
<a id='n5444' href='#n5444'>5444</a>
<a id='n5445' href='#n5445'>5445</a>
<a id='n5446' href='#n5446'>5446</a>
<a id='n5447' href='#n5447'>5447</a>
<a id='n5448' href='#n5448'>5448</a>
<a id='n5449' href='#n5449'>5449</a>
<a id='n5450' href='#n5450'>5450</a>
<a id='n5451' href='#n5451'>5451</a>
<a id='n5452' href='#n5452'>5452</a>
<a id='n5453' href='#n5453'>5453</a>
<a id='n5454' href='#n5454'>5454</a>
<a id='n5455' href='#n5455'>5455</a>
<a id='n5456' href='#n5456'>5456</a>
<a id='n5457' href='#n5457'>5457</a>
<a id='n5458' href='#n5458'>5458</a>
<a id='n5459' href='#n5459'>5459</a>
<a id='n5460' href='#n5460'>5460</a>
<a id='n5461' href='#n5461'>5461</a>
<a id='n5462' href='#n5462'>5462</a>
<a id='n5463' href='#n5463'>5463</a>
<a id='n5464' href='#n5464'>5464</a>
<a id='n5465' href='#n5465'>5465</a>
<a id='n5466' href='#n5466'>5466</a>
<a id='n5467' href='#n5467'>5467</a>
<a id='n5468' href='#n5468'>5468</a>
<a id='n5469' href='#n5469'>5469</a>
<a id='n5470' href='#n5470'>5470</a>
<a id='n5471' href='#n5471'>5471</a>
<a id='n5472' href='#n5472'>5472</a>
<a id='n5473' href='#n5473'>5473</a>
<a id='n5474' href='#n5474'>5474</a>
<a id='n5475' href='#n5475'>5475</a>
<a id='n5476' href='#n5476'>5476</a>
<a id='n5477' href='#n5477'>5477</a>
<a id='n5478' href='#n5478'>5478</a>
<a id='n5479' href='#n5479'>5479</a>
<a id='n5480' href='#n5480'>5480</a>
<a id='n5481' href='#n5481'>5481</a>
<a id='n5482' href='#n5482'>5482</a>
<a id='n5483' href='#n5483'>5483</a>
<a id='n5484' href='#n5484'>5484</a>
<a id='n5485' href='#n5485'>5485</a>
<a id='n5486' href='#n5486'>5486</a>
<a id='n5487' href='#n5487'>5487</a>
<a id='n5488' href='#n5488'>5488</a>
<a id='n5489' href='#n5489'>5489</a>
<a id='n5490' href='#n5490'>5490</a>
<a id='n5491' href='#n5491'>5491</a>
<a id='n5492' href='#n5492'>5492</a>
<a id='n5493' href='#n5493'>5493</a>
<a id='n5494' href='#n5494'>5494</a>
<a id='n5495' href='#n5495'>5495</a>
<a id='n5496' href='#n5496'>5496</a>
<a id='n5497' href='#n5497'>5497</a>
<a id='n5498' href='#n5498'>5498</a>
<a id='n5499' href='#n5499'>5499</a>
<a id='n5500' href='#n5500'>5500</a>
<a id='n5501' href='#n5501'>5501</a>
<a id='n5502' href='#n5502'>5502</a>
<a id='n5503' href='#n5503'>5503</a>
<a id='n5504' href='#n5504'>5504</a>
<a id='n5505' href='#n5505'>5505</a>
<a id='n5506' href='#n5506'>5506</a>
<a id='n5507' href='#n5507'>5507</a>
<a id='n5508' href='#n5508'>5508</a>
<a id='n5509' href='#n5509'>5509</a>
<a id='n5510' href='#n5510'>5510</a>
<a id='n5511' href='#n5511'>5511</a>
<a id='n5512' href='#n5512'>5512</a>
<a id='n5513' href='#n5513'>5513</a>
<a id='n5514' href='#n5514'>5514</a>
<a id='n5515' href='#n5515'>5515</a>
<a id='n5516' href='#n5516'>5516</a>
<a id='n5517' href='#n5517'>5517</a>
<a id='n5518' href='#n5518'>5518</a>
<a id='n5519' href='#n5519'>5519</a>
<a id='n5520' href='#n5520'>5520</a>
<a id='n5521' href='#n5521'>5521</a>
<a id='n5522' href='#n5522'>5522</a>
<a id='n5523' href='#n5523'>5523</a>
<a id='n5524' href='#n5524'>5524</a>
<a id='n5525' href='#n5525'>5525</a>
<a id='n5526' href='#n5526'>5526</a>
<a id='n5527' href='#n5527'>5527</a>
<a id='n5528' href='#n5528'>5528</a>
<a id='n5529' href='#n5529'>5529</a>
<a id='n5530' href='#n5530'>5530</a>
<a id='n5531' href='#n5531'>5531</a>
<a id='n5532' href='#n5532'>5532</a>
<a id='n5533' href='#n5533'>5533</a>
<a id='n5534' href='#n5534'>5534</a>
<a id='n5535' href='#n5535'>5535</a>
<a id='n5536' href='#n5536'>5536</a>
<a id='n5537' href='#n5537'>5537</a>
<a id='n5538' href='#n5538'>5538</a>
<a id='n5539' href='#n5539'>5539</a>
<a id='n5540' href='#n5540'>5540</a>
<a id='n5541' href='#n5541'>5541</a>
<a id='n5542' href='#n5542'>5542</a>
<a id='n5543' href='#n5543'>5543</a>
<a id='n5544' href='#n5544'>5544</a>
<a id='n5545' href='#n5545'>5545</a>
<a id='n5546' href='#n5546'>5546</a>
<a id='n5547' href='#n5547'>5547</a>
<a id='n5548' href='#n5548'>5548</a>
<a id='n5549' href='#n5549'>5549</a>
<a id='n5550' href='#n5550'>5550</a>
<a id='n5551' href='#n5551'>5551</a>
<a id='n5552' href='#n5552'>5552</a>
<a id='n5553' href='#n5553'>5553</a>
<a id='n5554' href='#n5554'>5554</a>
<a id='n5555' href='#n5555'>5555</a>
<a id='n5556' href='#n5556'>5556</a>
<a id='n5557' href='#n5557'>5557</a>
<a id='n5558' href='#n5558'>5558</a>
<a id='n5559' href='#n5559'>5559</a>
<a id='n5560' href='#n5560'>5560</a>
<a id='n5561' href='#n5561'>5561</a>
<a id='n5562' href='#n5562'>5562</a>
<a id='n5563' href='#n5563'>5563</a>
<a id='n5564' href='#n5564'>5564</a>
<a id='n5565' href='#n5565'>5565</a>
<a id='n5566' href='#n5566'>5566</a>
<a id='n5567' href='#n5567'>5567</a>
<a id='n5568' href='#n5568'>5568</a>
<a id='n5569' href='#n5569'>5569</a>
<a id='n5570' href='#n5570'>5570</a>
<a id='n5571' href='#n5571'>5571</a>
<a id='n5572' href='#n5572'>5572</a>
<a id='n5573' href='#n5573'>5573</a>
<a id='n5574' href='#n5574'>5574</a>
<a id='n5575' href='#n5575'>5575</a>
<a id='n5576' href='#n5576'>5576</a>
<a id='n5577' href='#n5577'>5577</a>
<a id='n5578' href='#n5578'>5578</a>
<a id='n5579' href='#n5579'>5579</a>
<a id='n5580' href='#n5580'>5580</a>
<a id='n5581' href='#n5581'>5581</a>
<a id='n5582' href='#n5582'>5582</a>
<a id='n5583' href='#n5583'>5583</a>
<a id='n5584' href='#n5584'>5584</a>
<a id='n5585' href='#n5585'>5585</a>
<a id='n5586' href='#n5586'>5586</a>
<a id='n5587' href='#n5587'>5587</a>
<a id='n5588' href='#n5588'>5588</a>
<a id='n5589' href='#n5589'>5589</a>
<a id='n5590' href='#n5590'>5590</a>
<a id='n5591' href='#n5591'>5591</a>
<a id='n5592' href='#n5592'>5592</a>
<a id='n5593' href='#n5593'>5593</a>
<a id='n5594' href='#n5594'>5594</a>
<a id='n5595' href='#n5595'>5595</a>
<a id='n5596' href='#n5596'>5596</a>
<a id='n5597' href='#n5597'>5597</a>
<a id='n5598' href='#n5598'>5598</a>
<a id='n5599' href='#n5599'>5599</a>
<a id='n5600' href='#n5600'>5600</a>
<a id='n5601' href='#n5601'>5601</a>
<a id='n5602' href='#n5602'>5602</a>
<a id='n5603' href='#n5603'>5603</a>
<a id='n5604' href='#n5604'>5604</a>
<a id='n5605' href='#n5605'>5605</a>
<a id='n5606' href='#n5606'>5606</a>
<a id='n5607' href='#n5607'>5607</a>
<a id='n5608' href='#n5608'>5608</a>
<a id='n5609' href='#n5609'>5609</a>
<a id='n5610' href='#n5610'>5610</a>
<a id='n5611' href='#n5611'>5611</a>
<a id='n5612' href='#n5612'>5612</a>
<a id='n5613' href='#n5613'>5613</a>
<a id='n5614' href='#n5614'>5614</a>
<a id='n5615' href='#n5615'>5615</a>
<a id='n5616' href='#n5616'>5616</a>
<a id='n5617' href='#n5617'>5617</a>
<a id='n5618' href='#n5618'>5618</a>
<a id='n5619' href='#n5619'>5619</a>
<a id='n5620' href='#n5620'>5620</a>
<a id='n5621' href='#n5621'>5621</a>
<a id='n5622' href='#n5622'>5622</a>
<a id='n5623' href='#n5623'>5623</a>
<a id='n5624' href='#n5624'>5624</a>
<a id='n5625' href='#n5625'>5625</a>
<a id='n5626' href='#n5626'>5626</a>
<a id='n5627' href='#n5627'>5627</a>
<a id='n5628' href='#n5628'>5628</a>
<a id='n5629' href='#n5629'>5629</a>
<a id='n5630' href='#n5630'>5630</a>
<a id='n5631' href='#n5631'>5631</a>
<a id='n5632' href='#n5632'>5632</a>
<a id='n5633' href='#n5633'>5633</a>
<a id='n5634' href='#n5634'>5634</a>
<a id='n5635' href='#n5635'>5635</a>
<a id='n5636' href='#n5636'>5636</a>
<a id='n5637' href='#n5637'>5637</a>
<a id='n5638' href='#n5638'>5638</a>
<a id='n5639' href='#n5639'>5639</a>
<a id='n5640' href='#n5640'>5640</a>
<a id='n5641' href='#n5641'>5641</a>
<a id='n5642' href='#n5642'>5642</a>
<a id='n5643' href='#n5643'>5643</a>
<a id='n5644' href='#n5644'>5644</a>
<a id='n5645' href='#n5645'>5645</a>
<a id='n5646' href='#n5646'>5646</a>
<a id='n5647' href='#n5647'>5647</a>
<a id='n5648' href='#n5648'>5648</a>
<a id='n5649' href='#n5649'>5649</a>
<a id='n5650' href='#n5650'>5650</a>
<a id='n5651' href='#n5651'>5651</a>
<a id='n5652' href='#n5652'>5652</a>
<a id='n5653' href='#n5653'>5653</a>
<a id='n5654' href='#n5654'>5654</a>
<a id='n5655' href='#n5655'>5655</a>
<a id='n5656' href='#n5656'>5656</a>
<a id='n5657' href='#n5657'>5657</a>
<a id='n5658' href='#n5658'>5658</a>
<a id='n5659' href='#n5659'>5659</a>
<a id='n5660' href='#n5660'>5660</a>
<a id='n5661' href='#n5661'>5661</a>
<a id='n5662' href='#n5662'>5662</a>
<a id='n5663' href='#n5663'>5663</a>
<a id='n5664' href='#n5664'>5664</a>
<a id='n5665' href='#n5665'>5665</a>
<a id='n5666' href='#n5666'>5666</a>
<a id='n5667' href='#n5667'>5667</a>
<a id='n5668' href='#n5668'>5668</a>
<a id='n5669' href='#n5669'>5669</a>
<a id='n5670' href='#n5670'>5670</a>
<a id='n5671' href='#n5671'>5671</a>
<a id='n5672' href='#n5672'>5672</a>
<a id='n5673' href='#n5673'>5673</a>
<a id='n5674' href='#n5674'>5674</a>
<a id='n5675' href='#n5675'>5675</a>
<a id='n5676' href='#n5676'>5676</a>
<a id='n5677' href='#n5677'>5677</a>
<a id='n5678' href='#n5678'>5678</a>
<a id='n5679' href='#n5679'>5679</a>
<a id='n5680' href='#n5680'>5680</a>
<a id='n5681' href='#n5681'>5681</a>
<a id='n5682' href='#n5682'>5682</a>
<a id='n5683' href='#n5683'>5683</a>
<a id='n5684' href='#n5684'>5684</a>
<a id='n5685' href='#n5685'>5685</a>
<a id='n5686' href='#n5686'>5686</a>
<a id='n5687' href='#n5687'>5687</a>
<a id='n5688' href='#n5688'>5688</a>
<a id='n5689' href='#n5689'>5689</a>
<a id='n5690' href='#n5690'>5690</a>
<a id='n5691' href='#n5691'>5691</a>
<a id='n5692' href='#n5692'>5692</a>
<a id='n5693' href='#n5693'>5693</a>
<a id='n5694' href='#n5694'>5694</a>
<a id='n5695' href='#n5695'>5695</a>
<a id='n5696' href='#n5696'>5696</a>
<a id='n5697' href='#n5697'>5697</a>
<a id='n5698' href='#n5698'>5698</a>
<a id='n5699' href='#n5699'>5699</a>
<a id='n5700' href='#n5700'>5700</a>
<a id='n5701' href='#n5701'>5701</a>
<a id='n5702' href='#n5702'>5702</a>
<a id='n5703' href='#n5703'>5703</a>
<a id='n5704' href='#n5704'>5704</a>
<a id='n5705' href='#n5705'>5705</a>
<a id='n5706' href='#n5706'>5706</a>
<a id='n5707' href='#n5707'>5707</a>
<a id='n5708' href='#n5708'>5708</a>
<a id='n5709' href='#n5709'>5709</a>
<a id='n5710' href='#n5710'>5710</a>
<a id='n5711' href='#n5711'>5711</a>
<a id='n5712' href='#n5712'>5712</a>
<a id='n5713' href='#n5713'>5713</a>
<a id='n5714' href='#n5714'>5714</a>
<a id='n5715' href='#n5715'>5715</a>
<a id='n5716' href='#n5716'>5716</a>
<a id='n5717' href='#n5717'>5717</a>
<a id='n5718' href='#n5718'>5718</a>
<a id='n5719' href='#n5719'>5719</a>
<a id='n5720' href='#n5720'>5720</a>
<a id='n5721' href='#n5721'>5721</a>
<a id='n5722' href='#n5722'>5722</a>
<a id='n5723' href='#n5723'>5723</a>
<a id='n5724' href='#n5724'>5724</a>
<a id='n5725' href='#n5725'>5725</a>
<a id='n5726' href='#n5726'>5726</a>
<a id='n5727' href='#n5727'>5727</a>
<a id='n5728' href='#n5728'>5728</a>
<a id='n5729' href='#n5729'>5729</a>
<a id='n5730' href='#n5730'>5730</a>
<a id='n5731' href='#n5731'>5731</a>
<a id='n5732' href='#n5732'>5732</a>
<a id='n5733' href='#n5733'>5733</a>
<a id='n5734' href='#n5734'>5734</a>
<a id='n5735' href='#n5735'>5735</a>
<a id='n5736' href='#n5736'>5736</a>
<a id='n5737' href='#n5737'>5737</a>
<a id='n5738' href='#n5738'>5738</a>
<a id='n5739' href='#n5739'>5739</a>
<a id='n5740' href='#n5740'>5740</a>
<a id='n5741' href='#n5741'>5741</a>
<a id='n5742' href='#n5742'>5742</a>
<a id='n5743' href='#n5743'>5743</a>
<a id='n5744' href='#n5744'>5744</a>
<a id='n5745' href='#n5745'>5745</a>
<a id='n5746' href='#n5746'>5746</a>
<a id='n5747' href='#n5747'>5747</a>
<a id='n5748' href='#n5748'>5748</a>
<a id='n5749' href='#n5749'>5749</a>
<a id='n5750' href='#n5750'>5750</a>
<a id='n5751' href='#n5751'>5751</a>
<a id='n5752' href='#n5752'>5752</a>
<a id='n5753' href='#n5753'>5753</a>
<a id='n5754' href='#n5754'>5754</a>
<a id='n5755' href='#n5755'>5755</a>
<a id='n5756' href='#n5756'>5756</a>
<a id='n5757' href='#n5757'>5757</a>
<a id='n5758' href='#n5758'>5758</a>
<a id='n5759' href='#n5759'>5759</a>
<a id='n5760' href='#n5760'>5760</a>
<a id='n5761' href='#n5761'>5761</a>
<a id='n5762' href='#n5762'>5762</a>
<a id='n5763' href='#n5763'>5763</a>
<a id='n5764' href='#n5764'>5764</a>
<a id='n5765' href='#n5765'>5765</a>
<a id='n5766' href='#n5766'>5766</a>
<a id='n5767' href='#n5767'>5767</a>
<a id='n5768' href='#n5768'>5768</a>
<a id='n5769' href='#n5769'>5769</a>
<a id='n5770' href='#n5770'>5770</a>
<a id='n5771' href='#n5771'>5771</a>
<a id='n5772' href='#n5772'>5772</a>
<a id='n5773' href='#n5773'>5773</a>
<a id='n5774' href='#n5774'>5774</a>
<a id='n5775' href='#n5775'>5775</a>
<a id='n5776' href='#n5776'>5776</a>
<a id='n5777' href='#n5777'>5777</a>
<a id='n5778' href='#n5778'>5778</a>
<a id='n5779' href='#n5779'>5779</a>
<a id='n5780' href='#n5780'>5780</a>
<a id='n5781' href='#n5781'>5781</a>
<a id='n5782' href='#n5782'>5782</a>
<a id='n5783' href='#n5783'>5783</a>
<a id='n5784' href='#n5784'>5784</a>
<a id='n5785' href='#n5785'>5785</a>
<a id='n5786' href='#n5786'>5786</a>
<a id='n5787' href='#n5787'>5787</a>
<a id='n5788' href='#n5788'>5788</a>
<a id='n5789' href='#n5789'>5789</a>
<a id='n5790' href='#n5790'>5790</a>
<a id='n5791' href='#n5791'>5791</a>
<a id='n5792' href='#n5792'>5792</a>
<a id='n5793' href='#n5793'>5793</a>
<a id='n5794' href='#n5794'>5794</a>
<a id='n5795' href='#n5795'>5795</a>
<a id='n5796' href='#n5796'>5796</a>
<a id='n5797' href='#n5797'>5797</a>
<a id='n5798' href='#n5798'>5798</a>
<a id='n5799' href='#n5799'>5799</a>
<a id='n5800' href='#n5800'>5800</a>
<a id='n5801' href='#n5801'>5801</a>
<a id='n5802' href='#n5802'>5802</a>
<a id='n5803' href='#n5803'>5803</a>
<a id='n5804' href='#n5804'>5804</a>
<a id='n5805' href='#n5805'>5805</a>
<a id='n5806' href='#n5806'>5806</a>
<a id='n5807' href='#n5807'>5807</a>
<a id='n5808' href='#n5808'>5808</a>
<a id='n5809' href='#n5809'>5809</a>
<a id='n5810' href='#n5810'>5810</a>
<a id='n5811' href='#n5811'>5811</a>
<a id='n5812' href='#n5812'>5812</a>
<a id='n5813' href='#n5813'>5813</a>
<a id='n5814' href='#n5814'>5814</a>
<a id='n5815' href='#n5815'>5815</a>
<a id='n5816' href='#n5816'>5816</a>
<a id='n5817' href='#n5817'>5817</a>
<a id='n5818' href='#n5818'>5818</a>
<a id='n5819' href='#n5819'>5819</a>
<a id='n5820' href='#n5820'>5820</a>
<a id='n5821' href='#n5821'>5821</a>
<a id='n5822' href='#n5822'>5822</a>
<a id='n5823' href='#n5823'>5823</a>
<a id='n5824' href='#n5824'>5824</a>
<a id='n5825' href='#n5825'>5825</a>
<a id='n5826' href='#n5826'>5826</a>
<a id='n5827' href='#n5827'>5827</a>
<a id='n5828' href='#n5828'>5828</a>
<a id='n5829' href='#n5829'>5829</a>
<a id='n5830' href='#n5830'>5830</a>
<a id='n5831' href='#n5831'>5831</a>
<a id='n5832' href='#n5832'>5832</a>
<a id='n5833' href='#n5833'>5833</a>
<a id='n5834' href='#n5834'>5834</a>
<a id='n5835' href='#n5835'>5835</a>
<a id='n5836' href='#n5836'>5836</a>
<a id='n5837' href='#n5837'>5837</a>
<a id='n5838' href='#n5838'>5838</a>
<a id='n5839' href='#n5839'>5839</a>
<a id='n5840' href='#n5840'>5840</a>
<a id='n5841' href='#n5841'>5841</a>
<a id='n5842' href='#n5842'>5842</a>
<a id='n5843' href='#n5843'>5843</a>
<a id='n5844' href='#n5844'>5844</a>
<a id='n5845' href='#n5845'>5845</a>
<a id='n5846' href='#n5846'>5846</a>
<a id='n5847' href='#n5847'>5847</a>
<a id='n5848' href='#n5848'>5848</a>
<a id='n5849' href='#n5849'>5849</a>
<a id='n5850' href='#n5850'>5850</a>
<a id='n5851' href='#n5851'>5851</a>
<a id='n5852' href='#n5852'>5852</a>
<a id='n5853' href='#n5853'>5853</a>
<a id='n5854' href='#n5854'>5854</a>
<a id='n5855' href='#n5855'>5855</a>
<a id='n5856' href='#n5856'>5856</a>
<a id='n5857' href='#n5857'>5857</a>
<a id='n5858' href='#n5858'>5858</a>
<a id='n5859' href='#n5859'>5859</a>
<a id='n5860' href='#n5860'>5860</a>
<a id='n5861' href='#n5861'>5861</a>
<a id='n5862' href='#n5862'>5862</a>
<a id='n5863' href='#n5863'>5863</a>
<a id='n5864' href='#n5864'>5864</a>
<a id='n5865' href='#n5865'>5865</a>
<a id='n5866' href='#n5866'>5866</a>
<a id='n5867' href='#n5867'>5867</a>
<a id='n5868' href='#n5868'>5868</a>
<a id='n5869' href='#n5869'>5869</a>
<a id='n5870' href='#n5870'>5870</a>
<a id='n5871' href='#n5871'>5871</a>
<a id='n5872' href='#n5872'>5872</a>
<a id='n5873' href='#n5873'>5873</a>
<a id='n5874' href='#n5874'>5874</a>
<a id='n5875' href='#n5875'>5875</a>
<a id='n5876' href='#n5876'>5876</a>
<a id='n5877' href='#n5877'>5877</a>
<a id='n5878' href='#n5878'>5878</a>
<a id='n5879' href='#n5879'>5879</a>
<a id='n5880' href='#n5880'>5880</a>
<a id='n5881' href='#n5881'>5881</a>
<a id='n5882' href='#n5882'>5882</a>
<a id='n5883' href='#n5883'>5883</a>
<a id='n5884' href='#n5884'>5884</a>
<a id='n5885' href='#n5885'>5885</a>
<a id='n5886' href='#n5886'>5886</a>
<a id='n5887' href='#n5887'>5887</a>
<a id='n5888' href='#n5888'>5888</a>
<a id='n5889' href='#n5889'>5889</a>
<a id='n5890' href='#n5890'>5890</a>
<a id='n5891' href='#n5891'>5891</a>
<a id='n5892' href='#n5892'>5892</a>
<a id='n5893' href='#n5893'>5893</a>
<a id='n5894' href='#n5894'>5894</a>
<a id='n5895' href='#n5895'>5895</a>
<a id='n5896' href='#n5896'>5896</a>
<a id='n5897' href='#n5897'>5897</a>
<a id='n5898' href='#n5898'>5898</a>
<a id='n5899' href='#n5899'>5899</a>
<a id='n5900' href='#n5900'>5900</a>
<a id='n5901' href='#n5901'>5901</a>
<a id='n5902' href='#n5902'>5902</a>
<a id='n5903' href='#n5903'>5903</a>
<a id='n5904' href='#n5904'>5904</a>
<a id='n5905' href='#n5905'>5905</a>
<a id='n5906' href='#n5906'>5906</a>
<a id='n5907' href='#n5907'>5907</a>
<a id='n5908' href='#n5908'>5908</a>
<a id='n5909' href='#n5909'>5909</a>
<a id='n5910' href='#n5910'>5910</a>
<a id='n5911' href='#n5911'>5911</a>
<a id='n5912' href='#n5912'>5912</a>
<a id='n5913' href='#n5913'>5913</a>
<a id='n5914' href='#n5914'>5914</a>
<a id='n5915' href='#n5915'>5915</a>
<a id='n5916' href='#n5916'>5916</a>
<a id='n5917' href='#n5917'>5917</a>
<a id='n5918' href='#n5918'>5918</a>
<a id='n5919' href='#n5919'>5919</a>
<a id='n5920' href='#n5920'>5920</a>
<a id='n5921' href='#n5921'>5921</a>
<a id='n5922' href='#n5922'>5922</a>
<a id='n5923' href='#n5923'>5923</a>
<a id='n5924' href='#n5924'>5924</a>
<a id='n5925' href='#n5925'>5925</a>
<a id='n5926' href='#n5926'>5926</a>
<a id='n5927' href='#n5927'>5927</a>
<a id='n5928' href='#n5928'>5928</a>
<a id='n5929' href='#n5929'>5929</a>
<a id='n5930' href='#n5930'>5930</a>
<a id='n5931' href='#n5931'>5931</a>
<a id='n5932' href='#n5932'>5932</a>
<a id='n5933' href='#n5933'>5933</a>
<a id='n5934' href='#n5934'>5934</a>
<a id='n5935' href='#n5935'>5935</a>
<a id='n5936' href='#n5936'>5936</a>
<a id='n5937' href='#n5937'>5937</a>
<a id='n5938' href='#n5938'>5938</a>
<a id='n5939' href='#n5939'>5939</a>
<a id='n5940' href='#n5940'>5940</a>
<a id='n5941' href='#n5941'>5941</a>
<a id='n5942' href='#n5942'>5942</a>
<a id='n5943' href='#n5943'>5943</a>
<a id='n5944' href='#n5944'>5944</a>
<a id='n5945' href='#n5945'>5945</a>
<a id='n5946' href='#n5946'>5946</a>
<a id='n5947' href='#n5947'>5947</a>
<a id='n5948' href='#n5948'>5948</a>
<a id='n5949' href='#n5949'>5949</a>
<a id='n5950' href='#n5950'>5950</a>
<a id='n5951' href='#n5951'>5951</a>
<a id='n5952' href='#n5952'>5952</a>
<a id='n5953' href='#n5953'>5953</a>
<a id='n5954' href='#n5954'>5954</a>
<a id='n5955' href='#n5955'>5955</a>
<a id='n5956' href='#n5956'>5956</a>
<a id='n5957' href='#n5957'>5957</a>
<a id='n5958' href='#n5958'>5958</a>
<a id='n5959' href='#n5959'>5959</a>
<a id='n5960' href='#n5960'>5960</a>
<a id='n5961' href='#n5961'>5961</a>
<a id='n5962' href='#n5962'>5962</a>
<a id='n5963' href='#n5963'>5963</a>
<a id='n5964' href='#n5964'>5964</a>
<a id='n5965' href='#n5965'>5965</a>
<a id='n5966' href='#n5966'>5966</a>
<a id='n5967' href='#n5967'>5967</a>
<a id='n5968' href='#n5968'>5968</a>
<a id='n5969' href='#n5969'>5969</a>
<a id='n5970' href='#n5970'>5970</a>
<a id='n5971' href='#n5971'>5971</a>
<a id='n5972' href='#n5972'>5972</a>
<a id='n5973' href='#n5973'>5973</a>
<a id='n5974' href='#n5974'>5974</a>
<a id='n5975' href='#n5975'>5975</a>
<a id='n5976' href='#n5976'>5976</a>
<a id='n5977' href='#n5977'>5977</a>
<a id='n5978' href='#n5978'>5978</a>
<a id='n5979' href='#n5979'>5979</a>
<a id='n5980' href='#n5980'>5980</a>
<a id='n5981' href='#n5981'>5981</a>
<a id='n5982' href='#n5982'>5982</a>
<a id='n5983' href='#n5983'>5983</a>
<a id='n5984' href='#n5984'>5984</a>
<a id='n5985' href='#n5985'>5985</a>
<a id='n5986' href='#n5986'>5986</a>
<a id='n5987' href='#n5987'>5987</a>
<a id='n5988' href='#n5988'>5988</a>
<a id='n5989' href='#n5989'>5989</a>
<a id='n5990' href='#n5990'>5990</a>
<a id='n5991' href='#n5991'>5991</a>
<a id='n5992' href='#n5992'>5992</a>
<a id='n5993' href='#n5993'>5993</a>
<a id='n5994' href='#n5994'>5994</a>
<a id='n5995' href='#n5995'>5995</a>
<a id='n5996' href='#n5996'>5996</a>
<a id='n5997' href='#n5997'>5997</a>
<a id='n5998' href='#n5998'>5998</a>
<a id='n5999' href='#n5999'>5999</a>
<a id='n6000' href='#n6000'>6000</a>
<a id='n6001' href='#n6001'>6001</a>
<a id='n6002' href='#n6002'>6002</a>
<a id='n6003' href='#n6003'>6003</a>
<a id='n6004' href='#n6004'>6004</a>
<a id='n6005' href='#n6005'>6005</a>
<a id='n6006' href='#n6006'>6006</a>
<a id='n6007' href='#n6007'>6007</a>
<a id='n6008' href='#n6008'>6008</a>
<a id='n6009' href='#n6009'>6009</a>
<a id='n6010' href='#n6010'>6010</a>
<a id='n6011' href='#n6011'>6011</a>
<a id='n6012' href='#n6012'>6012</a>
<a id='n6013' href='#n6013'>6013</a>
<a id='n6014' href='#n6014'>6014</a>
<a id='n6015' href='#n6015'>6015</a>
<a id='n6016' href='#n6016'>6016</a>
<a id='n6017' href='#n6017'>6017</a>
<a id='n6018' href='#n6018'>6018</a>
<a id='n6019' href='#n6019'>6019</a>
<a id='n6020' href='#n6020'>6020</a>
<a id='n6021' href='#n6021'>6021</a>
<a id='n6022' href='#n6022'>6022</a>
<a id='n6023' href='#n6023'>6023</a>
<a id='n6024' href='#n6024'>6024</a>
<a id='n6025' href='#n6025'>6025</a>
<a id='n6026' href='#n6026'>6026</a>
<a id='n6027' href='#n6027'>6027</a>
<a id='n6028' href='#n6028'>6028</a>
<a id='n6029' href='#n6029'>6029</a>
<a id='n6030' href='#n6030'>6030</a>
<a id='n6031' href='#n6031'>6031</a>
<a id='n6032' href='#n6032'>6032</a>
<a id='n6033' href='#n6033'>6033</a>
<a id='n6034' href='#n6034'>6034</a>
<a id='n6035' href='#n6035'>6035</a>
<a id='n6036' href='#n6036'>6036</a>
<a id='n6037' href='#n6037'>6037</a>
<a id='n6038' href='#n6038'>6038</a>
<a id='n6039' href='#n6039'>6039</a>
<a id='n6040' href='#n6040'>6040</a>
<a id='n6041' href='#n6041'>6041</a>
<a id='n6042' href='#n6042'>6042</a>
<a id='n6043' href='#n6043'>6043</a>
<a id='n6044' href='#n6044'>6044</a>
<a id='n6045' href='#n6045'>6045</a>
<a id='n6046' href='#n6046'>6046</a>
<a id='n6047' href='#n6047'>6047</a>
<a id='n6048' href='#n6048'>6048</a>
<a id='n6049' href='#n6049'>6049</a>
<a id='n6050' href='#n6050'>6050</a>
<a id='n6051' href='#n6051'>6051</a>
<a id='n6052' href='#n6052'>6052</a>
<a id='n6053' href='#n6053'>6053</a>
<a id='n6054' href='#n6054'>6054</a>
<a id='n6055' href='#n6055'>6055</a>
<a id='n6056' href='#n6056'>6056</a>
<a id='n6057' href='#n6057'>6057</a>
<a id='n6058' href='#n6058'>6058</a>
<a id='n6059' href='#n6059'>6059</a>
<a id='n6060' href='#n6060'>6060</a>
<a id='n6061' href='#n6061'>6061</a>
<a id='n6062' href='#n6062'>6062</a>
<a id='n6063' href='#n6063'>6063</a>
<a id='n6064' href='#n6064'>6064</a>
<a id='n6065' href='#n6065'>6065</a>
<a id='n6066' href='#n6066'>6066</a>
<a id='n6067' href='#n6067'>6067</a>
<a id='n6068' href='#n6068'>6068</a>
<a id='n6069' href='#n6069'>6069</a>
<a id='n6070' href='#n6070'>6070</a>
<a id='n6071' href='#n6071'>6071</a>
<a id='n6072' href='#n6072'>6072</a>
<a id='n6073' href='#n6073'>6073</a>
<a id='n6074' href='#n6074'>6074</a>
<a id='n6075' href='#n6075'>6075</a>
<a id='n6076' href='#n6076'>6076</a>
<a id='n6077' href='#n6077'>6077</a>
<a id='n6078' href='#n6078'>6078</a>
<a id='n6079' href='#n6079'>6079</a>
<a id='n6080' href='#n6080'>6080</a>
<a id='n6081' href='#n6081'>6081</a>
<a id='n6082' href='#n6082'>6082</a>
<a id='n6083' href='#n6083'>6083</a>
<a id='n6084' href='#n6084'>6084</a>
<a id='n6085' href='#n6085'>6085</a>
<a id='n6086' href='#n6086'>6086</a>
<a id='n6087' href='#n6087'>6087</a>
<a id='n6088' href='#n6088'>6088</a>
<a id='n6089' href='#n6089'>6089</a>
<a id='n6090' href='#n6090'>6090</a>
<a id='n6091' href='#n6091'>6091</a>
<a id='n6092' href='#n6092'>6092</a>
<a id='n6093' href='#n6093'>6093</a>
<a id='n6094' href='#n6094'>6094</a>
<a id='n6095' href='#n6095'>6095</a>
<a id='n6096' href='#n6096'>6096</a>
<a id='n6097' href='#n6097'>6097</a>
<a id='n6098' href='#n6098'>6098</a>
<a id='n6099' href='#n6099'>6099</a>
<a id='n6100' href='#n6100'>6100</a>
<a id='n6101' href='#n6101'>6101</a>
<a id='n6102' href='#n6102'>6102</a>
<a id='n6103' href='#n6103'>6103</a>
<a id='n6104' href='#n6104'>6104</a>
<a id='n6105' href='#n6105'>6105</a>
<a id='n6106' href='#n6106'>6106</a>
<a id='n6107' href='#n6107'>6107</a>
<a id='n6108' href='#n6108'>6108</a>
<a id='n6109' href='#n6109'>6109</a>
<a id='n6110' href='#n6110'>6110</a>
<a id='n6111' href='#n6111'>6111</a>
<a id='n6112' href='#n6112'>6112</a>
<a id='n6113' href='#n6113'>6113</a>
<a id='n6114' href='#n6114'>6114</a>
<a id='n6115' href='#n6115'>6115</a>
<a id='n6116' href='#n6116'>6116</a>
<a id='n6117' href='#n6117'>6117</a>
<a id='n6118' href='#n6118'>6118</a>
<a id='n6119' href='#n6119'>6119</a>
<a id='n6120' href='#n6120'>6120</a>
<a id='n6121' href='#n6121'>6121</a>
<a id='n6122' href='#n6122'>6122</a>
<a id='n6123' href='#n6123'>6123</a>
<a id='n6124' href='#n6124'>6124</a>
<a id='n6125' href='#n6125'>6125</a>
<a id='n6126' href='#n6126'>6126</a>
<a id='n6127' href='#n6127'>6127</a>
<a id='n6128' href='#n6128'>6128</a>
<a id='n6129' href='#n6129'>6129</a>
<a id='n6130' href='#n6130'>6130</a>
<a id='n6131' href='#n6131'>6131</a>
<a id='n6132' href='#n6132'>6132</a>
<a id='n6133' href='#n6133'>6133</a>
<a id='n6134' href='#n6134'>6134</a>
<a id='n6135' href='#n6135'>6135</a>
<a id='n6136' href='#n6136'>6136</a>
<a id='n6137' href='#n6137'>6137</a>
<a id='n6138' href='#n6138'>6138</a>
<a id='n6139' href='#n6139'>6139</a>
<a id='n6140' href='#n6140'>6140</a>
<a id='n6141' href='#n6141'>6141</a>
<a id='n6142' href='#n6142'>6142</a>
<a id='n6143' href='#n6143'>6143</a>
<a id='n6144' href='#n6144'>6144</a>
<a id='n6145' href='#n6145'>6145</a>
<a id='n6146' href='#n6146'>6146</a>
<a id='n6147' href='#n6147'>6147</a>
<a id='n6148' href='#n6148'>6148</a>
<a id='n6149' href='#n6149'>6149</a>
<a id='n6150' href='#n6150'>6150</a>
<a id='n6151' href='#n6151'>6151</a>
<a id='n6152' href='#n6152'>6152</a>
<a id='n6153' href='#n6153'>6153</a>
<a id='n6154' href='#n6154'>6154</a>
<a id='n6155' href='#n6155'>6155</a>
<a id='n6156' href='#n6156'>6156</a>
<a id='n6157' href='#n6157'>6157</a>
<a id='n6158' href='#n6158'>6158</a>
<a id='n6159' href='#n6159'>6159</a>
<a id='n6160' href='#n6160'>6160</a>
<a id='n6161' href='#n6161'>6161</a>
<a id='n6162' href='#n6162'>6162</a>
<a id='n6163' href='#n6163'>6163</a>
<a id='n6164' href='#n6164'>6164</a>
<a id='n6165' href='#n6165'>6165</a>
<a id='n6166' href='#n6166'>6166</a>
<a id='n6167' href='#n6167'>6167</a>
<a id='n6168' href='#n6168'>6168</a>
<a id='n6169' href='#n6169'>6169</a>
<a id='n6170' href='#n6170'>6170</a>
<a id='n6171' href='#n6171'>6171</a>
<a id='n6172' href='#n6172'>6172</a>
<a id='n6173' href='#n6173'>6173</a>
<a id='n6174' href='#n6174'>6174</a>
<a id='n6175' href='#n6175'>6175</a>
<a id='n6176' href='#n6176'>6176</a>
<a id='n6177' href='#n6177'>6177</a>
<a id='n6178' href='#n6178'>6178</a>
<a id='n6179' href='#n6179'>6179</a>
<a id='n6180' href='#n6180'>6180</a>
<a id='n6181' href='#n6181'>6181</a>
<a id='n6182' href='#n6182'>6182</a>
<a id='n6183' href='#n6183'>6183</a>
<a id='n6184' href='#n6184'>6184</a>
<a id='n6185' href='#n6185'>6185</a>
<a id='n6186' href='#n6186'>6186</a>
<a id='n6187' href='#n6187'>6187</a>
<a id='n6188' href='#n6188'>6188</a>
<a id='n6189' href='#n6189'>6189</a>
<a id='n6190' href='#n6190'>6190</a>
<a id='n6191' href='#n6191'>6191</a>
<a id='n6192' href='#n6192'>6192</a>
<a id='n6193' href='#n6193'>6193</a>
<a id='n6194' href='#n6194'>6194</a>
<a id='n6195' href='#n6195'>6195</a>
<a id='n6196' href='#n6196'>6196</a>
<a id='n6197' href='#n6197'>6197</a>
<a id='n6198' href='#n6198'>6198</a>
<a id='n6199' href='#n6199'>6199</a>
<a id='n6200' href='#n6200'>6200</a>
<a id='n6201' href='#n6201'>6201</a>
<a id='n6202' href='#n6202'>6202</a>
<a id='n6203' href='#n6203'>6203</a>
<a id='n6204' href='#n6204'>6204</a>
<a id='n6205' href='#n6205'>6205</a>
<a id='n6206' href='#n6206'>6206</a>
<a id='n6207' href='#n6207'>6207</a>
<a id='n6208' href='#n6208'>6208</a>
<a id='n6209' href='#n6209'>6209</a>
<a id='n6210' href='#n6210'>6210</a>
<a id='n6211' href='#n6211'>6211</a>
<a id='n6212' href='#n6212'>6212</a>
<a id='n6213' href='#n6213'>6213</a>
<a id='n6214' href='#n6214'>6214</a>
<a id='n6215' href='#n6215'>6215</a>
<a id='n6216' href='#n6216'>6216</a>
<a id='n6217' href='#n6217'>6217</a>
<a id='n6218' href='#n6218'>6218</a>
<a id='n6219' href='#n6219'>6219</a>
<a id='n6220' href='#n6220'>6220</a>
<a id='n6221' href='#n6221'>6221</a>
<a id='n6222' href='#n6222'>6222</a>
<a id='n6223' href='#n6223'>6223</a>
<a id='n6224' href='#n6224'>6224</a>
<a id='n6225' href='#n6225'>6225</a>
<a id='n6226' href='#n6226'>6226</a>
<a id='n6227' href='#n6227'>6227</a>
<a id='n6228' href='#n6228'>6228</a>
<a id='n6229' href='#n6229'>6229</a>
<a id='n6230' href='#n6230'>6230</a>
<a id='n6231' href='#n6231'>6231</a>
<a id='n6232' href='#n6232'>6232</a>
<a id='n6233' href='#n6233'>6233</a>
<a id='n6234' href='#n6234'>6234</a>
<a id='n6235' href='#n6235'>6235</a>
<a id='n6236' href='#n6236'>6236</a>
<a id='n6237' href='#n6237'>6237</a>
<a id='n6238' href='#n6238'>6238</a>
<a id='n6239' href='#n6239'>6239</a>
<a id='n6240' href='#n6240'>6240</a>
<a id='n6241' href='#n6241'>6241</a>
<a id='n6242' href='#n6242'>6242</a>
<a id='n6243' href='#n6243'>6243</a>
<a id='n6244' href='#n6244'>6244</a>
<a id='n6245' href='#n6245'>6245</a>
<a id='n6246' href='#n6246'>6246</a>
<a id='n6247' href='#n6247'>6247</a>
<a id='n6248' href='#n6248'>6248</a>
<a id='n6249' href='#n6249'>6249</a>
<a id='n6250' href='#n6250'>6250</a>
<a id='n6251' href='#n6251'>6251</a>
<a id='n6252' href='#n6252'>6252</a>
<a id='n6253' href='#n6253'>6253</a>
<a id='n6254' href='#n6254'>6254</a>
<a id='n6255' href='#n6255'>6255</a>
<a id='n6256' href='#n6256'>6256</a>
<a id='n6257' href='#n6257'>6257</a>
<a id='n6258' href='#n6258'>6258</a>
<a id='n6259' href='#n6259'>6259</a>
<a id='n6260' href='#n6260'>6260</a>
<a id='n6261' href='#n6261'>6261</a>
<a id='n6262' href='#n6262'>6262</a>
<a id='n6263' href='#n6263'>6263</a>
<a id='n6264' href='#n6264'>6264</a>
<a id='n6265' href='#n6265'>6265</a>
<a id='n6266' href='#n6266'>6266</a>
<a id='n6267' href='#n6267'>6267</a>
<a id='n6268' href='#n6268'>6268</a>
<a id='n6269' href='#n6269'>6269</a>
<a id='n6270' href='#n6270'>6270</a>
<a id='n6271' href='#n6271'>6271</a>
<a id='n6272' href='#n6272'>6272</a>
<a id='n6273' href='#n6273'>6273</a>
<a id='n6274' href='#n6274'>6274</a>
<a id='n6275' href='#n6275'>6275</a>
<a id='n6276' href='#n6276'>6276</a>
<a id='n6277' href='#n6277'>6277</a>
<a id='n6278' href='#n6278'>6278</a>
<a id='n6279' href='#n6279'>6279</a>
<a id='n6280' href='#n6280'>6280</a>
<a id='n6281' href='#n6281'>6281</a>
<a id='n6282' href='#n6282'>6282</a>
<a id='n6283' href='#n6283'>6283</a>
<a id='n6284' href='#n6284'>6284</a>
<a id='n6285' href='#n6285'>6285</a>
<a id='n6286' href='#n6286'>6286</a>
<a id='n6287' href='#n6287'>6287</a>
<a id='n6288' href='#n6288'>6288</a>
<a id='n6289' href='#n6289'>6289</a>
<a id='n6290' href='#n6290'>6290</a>
<a id='n6291' href='#n6291'>6291</a>
<a id='n6292' href='#n6292'>6292</a>
<a id='n6293' href='#n6293'>6293</a>
<a id='n6294' href='#n6294'>6294</a>
<a id='n6295' href='#n6295'>6295</a>
<a id='n6296' href='#n6296'>6296</a>
<a id='n6297' href='#n6297'>6297</a>
<a id='n6298' href='#n6298'>6298</a>
<a id='n6299' href='#n6299'>6299</a>
<a id='n6300' href='#n6300'>6300</a>
<a id='n6301' href='#n6301'>6301</a>
<a id='n6302' href='#n6302'>6302</a>
<a id='n6303' href='#n6303'>6303</a>
<a id='n6304' href='#n6304'>6304</a>
<a id='n6305' href='#n6305'>6305</a>
<a id='n6306' href='#n6306'>6306</a>
<a id='n6307' href='#n6307'>6307</a>
<a id='n6308' href='#n6308'>6308</a>
<a id='n6309' href='#n6309'>6309</a>
<a id='n6310' href='#n6310'>6310</a>
<a id='n6311' href='#n6311'>6311</a>
<a id='n6312' href='#n6312'>6312</a>
<a id='n6313' href='#n6313'>6313</a>
<a id='n6314' href='#n6314'>6314</a>
<a id='n6315' href='#n6315'>6315</a>
<a id='n6316' href='#n6316'>6316</a>
<a id='n6317' href='#n6317'>6317</a>
<a id='n6318' href='#n6318'>6318</a>
<a id='n6319' href='#n6319'>6319</a>
<a id='n6320' href='#n6320'>6320</a>
<a id='n6321' href='#n6321'>6321</a>
<a id='n6322' href='#n6322'>6322</a>
<a id='n6323' href='#n6323'>6323</a>
<a id='n6324' href='#n6324'>6324</a>
<a id='n6325' href='#n6325'>6325</a>
<a id='n6326' href='#n6326'>6326</a>
<a id='n6327' href='#n6327'>6327</a>
<a id='n6328' href='#n6328'>6328</a>
<a id='n6329' href='#n6329'>6329</a>
<a id='n6330' href='#n6330'>6330</a>
<a id='n6331' href='#n6331'>6331</a>
<a id='n6332' href='#n6332'>6332</a>
<a id='n6333' href='#n6333'>6333</a>
<a id='n6334' href='#n6334'>6334</a>
<a id='n6335' href='#n6335'>6335</a>
<a id='n6336' href='#n6336'>6336</a>
<a id='n6337' href='#n6337'>6337</a>
<a id='n6338' href='#n6338'>6338</a>
<a id='n6339' href='#n6339'>6339</a>
<a id='n6340' href='#n6340'>6340</a>
<a id='n6341' href='#n6341'>6341</a>
<a id='n6342' href='#n6342'>6342</a>
<a id='n6343' href='#n6343'>6343</a>
<a id='n6344' href='#n6344'>6344</a>
<a id='n6345' href='#n6345'>6345</a>
<a id='n6346' href='#n6346'>6346</a>
<a id='n6347' href='#n6347'>6347</a>
<a id='n6348' href='#n6348'>6348</a>
<a id='n6349' href='#n6349'>6349</a>
<a id='n6350' href='#n6350'>6350</a>
<a id='n6351' href='#n6351'>6351</a>
<a id='n6352' href='#n6352'>6352</a>
<a id='n6353' href='#n6353'>6353</a>
<a id='n6354' href='#n6354'>6354</a>
<a id='n6355' href='#n6355'>6355</a>
<a id='n6356' href='#n6356'>6356</a>
<a id='n6357' href='#n6357'>6357</a>
<a id='n6358' href='#n6358'>6358</a>
<a id='n6359' href='#n6359'>6359</a>
<a id='n6360' href='#n6360'>6360</a>
<a id='n6361' href='#n6361'>6361</a>
<a id='n6362' href='#n6362'>6362</a>
<a id='n6363' href='#n6363'>6363</a>
<a id='n6364' href='#n6364'>6364</a>
<a id='n6365' href='#n6365'>6365</a>
<a id='n6366' href='#n6366'>6366</a>
<a id='n6367' href='#n6367'>6367</a>
<a id='n6368' href='#n6368'>6368</a>
<a id='n6369' href='#n6369'>6369</a>
<a id='n6370' href='#n6370'>6370</a>
<a id='n6371' href='#n6371'>6371</a>
<a id='n6372' href='#n6372'>6372</a>
<a id='n6373' href='#n6373'>6373</a>
<a id='n6374' href='#n6374'>6374</a>
<a id='n6375' href='#n6375'>6375</a>
<a id='n6376' href='#n6376'>6376</a>
<a id='n6377' href='#n6377'>6377</a>
<a id='n6378' href='#n6378'>6378</a>
<a id='n6379' href='#n6379'>6379</a>
<a id='n6380' href='#n6380'>6380</a>
<a id='n6381' href='#n6381'>6381</a>
<a id='n6382' href='#n6382'>6382</a>
<a id='n6383' href='#n6383'>6383</a>
<a id='n6384' href='#n6384'>6384</a>
<a id='n6385' href='#n6385'>6385</a>
<a id='n6386' href='#n6386'>6386</a>
<a id='n6387' href='#n6387'>6387</a>
<a id='n6388' href='#n6388'>6388</a>
<a id='n6389' href='#n6389'>6389</a>
<a id='n6390' href='#n6390'>6390</a>
<a id='n6391' href='#n6391'>6391</a>
<a id='n6392' href='#n6392'>6392</a>
<a id='n6393' href='#n6393'>6393</a>
<a id='n6394' href='#n6394'>6394</a>
<a id='n6395' href='#n6395'>6395</a>
<a id='n6396' href='#n6396'>6396</a>
<a id='n6397' href='#n6397'>6397</a>
<a id='n6398' href='#n6398'>6398</a>
<a id='n6399' href='#n6399'>6399</a>
<a id='n6400' href='#n6400'>6400</a>
<a id='n6401' href='#n6401'>6401</a>
<a id='n6402' href='#n6402'>6402</a>
<a id='n6403' href='#n6403'>6403</a>
<a id='n6404' href='#n6404'>6404</a>
<a id='n6405' href='#n6405'>6405</a>
<a id='n6406' href='#n6406'>6406</a>
<a id='n6407' href='#n6407'>6407</a>
<a id='n6408' href='#n6408'>6408</a>
<a id='n6409' href='#n6409'>6409</a>
<a id='n6410' href='#n6410'>6410</a>
<a id='n6411' href='#n6411'>6411</a>
<a id='n6412' href='#n6412'>6412</a>
<a id='n6413' href='#n6413'>6413</a>
<a id='n6414' href='#n6414'>6414</a>
<a id='n6415' href='#n6415'>6415</a>
<a id='n6416' href='#n6416'>6416</a>
<a id='n6417' href='#n6417'>6417</a>
<a id='n6418' href='#n6418'>6418</a>
<a id='n6419' href='#n6419'>6419</a>
<a id='n6420' href='#n6420'>6420</a>
<a id='n6421' href='#n6421'>6421</a>
<a id='n6422' href='#n6422'>6422</a>
<a id='n6423' href='#n6423'>6423</a>
<a id='n6424' href='#n6424'>6424</a>
<a id='n6425' href='#n6425'>6425</a>
<a id='n6426' href='#n6426'>6426</a>
<a id='n6427' href='#n6427'>6427</a>
<a id='n6428' href='#n6428'>6428</a>
<a id='n6429' href='#n6429'>6429</a>
<a id='n6430' href='#n6430'>6430</a>
<a id='n6431' href='#n6431'>6431</a>
<a id='n6432' href='#n6432'>6432</a>
<a id='n6433' href='#n6433'>6433</a>
<a id='n6434' href='#n6434'>6434</a>
<a id='n6435' href='#n6435'>6435</a>
<a id='n6436' href='#n6436'>6436</a>
<a id='n6437' href='#n6437'>6437</a>
<a id='n6438' href='#n6438'>6438</a>
<a id='n6439' href='#n6439'>6439</a>
<a id='n6440' href='#n6440'>6440</a>
<a id='n6441' href='#n6441'>6441</a>
<a id='n6442' href='#n6442'>6442</a>
<a id='n6443' href='#n6443'>6443</a>
<a id='n6444' href='#n6444'>6444</a>
<a id='n6445' href='#n6445'>6445</a>
<a id='n6446' href='#n6446'>6446</a>
<a id='n6447' href='#n6447'>6447</a>
<a id='n6448' href='#n6448'>6448</a>
<a id='n6449' href='#n6449'>6449</a>
<a id='n6450' href='#n6450'>6450</a>
<a id='n6451' href='#n6451'>6451</a>
<a id='n6452' href='#n6452'>6452</a>
<a id='n6453' href='#n6453'>6453</a>
<a id='n6454' href='#n6454'>6454</a>
<a id='n6455' href='#n6455'>6455</a>
<a id='n6456' href='#n6456'>6456</a>
<a id='n6457' href='#n6457'>6457</a>
<a id='n6458' href='#n6458'>6458</a>
<a id='n6459' href='#n6459'>6459</a>
<a id='n6460' href='#n6460'>6460</a>
<a id='n6461' href='#n6461'>6461</a>
<a id='n6462' href='#n6462'>6462</a>
<a id='n6463' href='#n6463'>6463</a>
<a id='n6464' href='#n6464'>6464</a>
<a id='n6465' href='#n6465'>6465</a>
<a id='n6466' href='#n6466'>6466</a>
<a id='n6467' href='#n6467'>6467</a>
<a id='n6468' href='#n6468'>6468</a>
<a id='n6469' href='#n6469'>6469</a>
<a id='n6470' href='#n6470'>6470</a>
<a id='n6471' href='#n6471'>6471</a>
<a id='n6472' href='#n6472'>6472</a>
<a id='n6473' href='#n6473'>6473</a>
<a id='n6474' href='#n6474'>6474</a>
<a id='n6475' href='#n6475'>6475</a>
<a id='n6476' href='#n6476'>6476</a>
<a id='n6477' href='#n6477'>6477</a>
<a id='n6478' href='#n6478'>6478</a>
<a id='n6479' href='#n6479'>6479</a>
<a id='n6480' href='#n6480'>6480</a>
<a id='n6481' href='#n6481'>6481</a>
<a id='n6482' href='#n6482'>6482</a>
<a id='n6483' href='#n6483'>6483</a>
<a id='n6484' href='#n6484'>6484</a>
<a id='n6485' href='#n6485'>6485</a>
<a id='n6486' href='#n6486'>6486</a>
<a id='n6487' href='#n6487'>6487</a>
<a id='n6488' href='#n6488'>6488</a>
<a id='n6489' href='#n6489'>6489</a>
<a id='n6490' href='#n6490'>6490</a>
<a id='n6491' href='#n6491'>6491</a>
<a id='n6492' href='#n6492'>6492</a>
<a id='n6493' href='#n6493'>6493</a>
<a id='n6494' href='#n6494'>6494</a>
<a id='n6495' href='#n6495'>6495</a>
<a id='n6496' href='#n6496'>6496</a>
<a id='n6497' href='#n6497'>6497</a>
<a id='n6498' href='#n6498'>6498</a>
<a id='n6499' href='#n6499'>6499</a>
<a id='n6500' href='#n6500'>6500</a>
<a id='n6501' href='#n6501'>6501</a>
<a id='n6502' href='#n6502'>6502</a>
<a id='n6503' href='#n6503'>6503</a>
<a id='n6504' href='#n6504'>6504</a>
<a id='n6505' href='#n6505'>6505</a>
<a id='n6506' href='#n6506'>6506</a>
<a id='n6507' href='#n6507'>6507</a>
<a id='n6508' href='#n6508'>6508</a>
<a id='n6509' href='#n6509'>6509</a>
<a id='n6510' href='#n6510'>6510</a>
<a id='n6511' href='#n6511'>6511</a>
<a id='n6512' href='#n6512'>6512</a>
<a id='n6513' href='#n6513'>6513</a>
<a id='n6514' href='#n6514'>6514</a>
<a id='n6515' href='#n6515'>6515</a>
<a id='n6516' href='#n6516'>6516</a>
<a id='n6517' href='#n6517'>6517</a>
<a id='n6518' href='#n6518'>6518</a>
<a id='n6519' href='#n6519'>6519</a>
<a id='n6520' href='#n6520'>6520</a>
<a id='n6521' href='#n6521'>6521</a>
<a id='n6522' href='#n6522'>6522</a>
<a id='n6523' href='#n6523'>6523</a>
<a id='n6524' href='#n6524'>6524</a>
<a id='n6525' href='#n6525'>6525</a>
<a id='n6526' href='#n6526'>6526</a>
<a id='n6527' href='#n6527'>6527</a>
<a id='n6528' href='#n6528'>6528</a>
<a id='n6529' href='#n6529'>6529</a>
<a id='n6530' href='#n6530'>6530</a>
<a id='n6531' href='#n6531'>6531</a>
<a id='n6532' href='#n6532'>6532</a>
<a id='n6533' href='#n6533'>6533</a>
<a id='n6534' href='#n6534'>6534</a>
<a id='n6535' href='#n6535'>6535</a>
<a id='n6536' href='#n6536'>6536</a>
<a id='n6537' href='#n6537'>6537</a>
<a id='n6538' href='#n6538'>6538</a>
<a id='n6539' href='#n6539'>6539</a>
<a id='n6540' href='#n6540'>6540</a>
<a id='n6541' href='#n6541'>6541</a>
<a id='n6542' href='#n6542'>6542</a>
<a id='n6543' href='#n6543'>6543</a>
<a id='n6544' href='#n6544'>6544</a>
<a id='n6545' href='#n6545'>6545</a>
<a id='n6546' href='#n6546'>6546</a>
<a id='n6547' href='#n6547'>6547</a>
<a id='n6548' href='#n6548'>6548</a>
<a id='n6549' href='#n6549'>6549</a>
<a id='n6550' href='#n6550'>6550</a>
<a id='n6551' href='#n6551'>6551</a>
<a id='n6552' href='#n6552'>6552</a>
<a id='n6553' href='#n6553'>6553</a>
<a id='n6554' href='#n6554'>6554</a>
<a id='n6555' href='#n6555'>6555</a>
<a id='n6556' href='#n6556'>6556</a>
<a id='n6557' href='#n6557'>6557</a>
<a id='n6558' href='#n6558'>6558</a>
<a id='n6559' href='#n6559'>6559</a>
<a id='n6560' href='#n6560'>6560</a>
<a id='n6561' href='#n6561'>6561</a>
<a id='n6562' href='#n6562'>6562</a>
<a id='n6563' href='#n6563'>6563</a>
<a id='n6564' href='#n6564'>6564</a>
<a id='n6565' href='#n6565'>6565</a>
<a id='n6566' href='#n6566'>6566</a>
<a id='n6567' href='#n6567'>6567</a>
<a id='n6568' href='#n6568'>6568</a>
<a id='n6569' href='#n6569'>6569</a>
<a id='n6570' href='#n6570'>6570</a>
<a id='n6571' href='#n6571'>6571</a>
<a id='n6572' href='#n6572'>6572</a>
<a id='n6573' href='#n6573'>6573</a>
<a id='n6574' href='#n6574'>6574</a>
<a id='n6575' href='#n6575'>6575</a>
<a id='n6576' href='#n6576'>6576</a>
<a id='n6577' href='#n6577'>6577</a>
<a id='n6578' href='#n6578'>6578</a>
<a id='n6579' href='#n6579'>6579</a>
<a id='n6580' href='#n6580'>6580</a>
<a id='n6581' href='#n6581'>6581</a>
<a id='n6582' href='#n6582'>6582</a>
<a id='n6583' href='#n6583'>6583</a>
<a id='n6584' href='#n6584'>6584</a>
<a id='n6585' href='#n6585'>6585</a>
<a id='n6586' href='#n6586'>6586</a>
<a id='n6587' href='#n6587'>6587</a>
<a id='n6588' href='#n6588'>6588</a>
<a id='n6589' href='#n6589'>6589</a>
<a id='n6590' href='#n6590'>6590</a>
<a id='n6591' href='#n6591'>6591</a>
<a id='n6592' href='#n6592'>6592</a>
<a id='n6593' href='#n6593'>6593</a>
<a id='n6594' href='#n6594'>6594</a>
<a id='n6595' href='#n6595'>6595</a>
<a id='n6596' href='#n6596'>6596</a>
<a id='n6597' href='#n6597'>6597</a>
<a id='n6598' href='#n6598'>6598</a>
<a id='n6599' href='#n6599'>6599</a>
<a id='n6600' href='#n6600'>6600</a>
<a id='n6601' href='#n6601'>6601</a>
<a id='n6602' href='#n6602'>6602</a>
<a id='n6603' href='#n6603'>6603</a>
<a id='n6604' href='#n6604'>6604</a>
<a id='n6605' href='#n6605'>6605</a>
<a id='n6606' href='#n6606'>6606</a>
<a id='n6607' href='#n6607'>6607</a>
<a id='n6608' href='#n6608'>6608</a>
<a id='n6609' href='#n6609'>6609</a>
<a id='n6610' href='#n6610'>6610</a>
<a id='n6611' href='#n6611'>6611</a>
<a id='n6612' href='#n6612'>6612</a>
<a id='n6613' href='#n6613'>6613</a>
<a id='n6614' href='#n6614'>6614</a>
<a id='n6615' href='#n6615'>6615</a>
<a id='n6616' href='#n6616'>6616</a>
<a id='n6617' href='#n6617'>6617</a>
<a id='n6618' href='#n6618'>6618</a>
<a id='n6619' href='#n6619'>6619</a>
<a id='n6620' href='#n6620'>6620</a>
<a id='n6621' href='#n6621'>6621</a>
<a id='n6622' href='#n6622'>6622</a>
<a id='n6623' href='#n6623'>6623</a>
<a id='n6624' href='#n6624'>6624</a>
<a id='n6625' href='#n6625'>6625</a>
<a id='n6626' href='#n6626'>6626</a>
<a id='n6627' href='#n6627'>6627</a>
<a id='n6628' href='#n6628'>6628</a>
<a id='n6629' href='#n6629'>6629</a>
<a id='n6630' href='#n6630'>6630</a>
<a id='n6631' href='#n6631'>6631</a>
<a id='n6632' href='#n6632'>6632</a>
<a id='n6633' href='#n6633'>6633</a>
<a id='n6634' href='#n6634'>6634</a>
<a id='n6635' href='#n6635'>6635</a>
<a id='n6636' href='#n6636'>6636</a>
<a id='n6637' href='#n6637'>6637</a>
<a id='n6638' href='#n6638'>6638</a>
<a id='n6639' href='#n6639'>6639</a>
<a id='n6640' href='#n6640'>6640</a>
<a id='n6641' href='#n6641'>6641</a>
<a id='n6642' href='#n6642'>6642</a>
<a id='n6643' href='#n6643'>6643</a>
<a id='n6644' href='#n6644'>6644</a>
<a id='n6645' href='#n6645'>6645</a>
<a id='n6646' href='#n6646'>6646</a>
<a id='n6647' href='#n6647'>6647</a>
<a id='n6648' href='#n6648'>6648</a>
<a id='n6649' href='#n6649'>6649</a>
<a id='n6650' href='#n6650'>6650</a>
<a id='n6651' href='#n6651'>6651</a>
<a id='n6652' href='#n6652'>6652</a>
<a id='n6653' href='#n6653'>6653</a>
<a id='n6654' href='#n6654'>6654</a>
<a id='n6655' href='#n6655'>6655</a>
<a id='n6656' href='#n6656'>6656</a>
<a id='n6657' href='#n6657'>6657</a>
<a id='n6658' href='#n6658'>6658</a>
<a id='n6659' href='#n6659'>6659</a>
<a id='n6660' href='#n6660'>6660</a>
<a id='n6661' href='#n6661'>6661</a>
<a id='n6662' href='#n6662'>6662</a>
<a id='n6663' href='#n6663'>6663</a>
<a id='n6664' href='#n6664'>6664</a>
<a id='n6665' href='#n6665'>6665</a>
<a id='n6666' href='#n6666'>6666</a>
<a id='n6667' href='#n6667'>6667</a>
<a id='n6668' href='#n6668'>6668</a>
<a id='n6669' href='#n6669'>6669</a>
<a id='n6670' href='#n6670'>6670</a>
<a id='n6671' href='#n6671'>6671</a>
<a id='n6672' href='#n6672'>6672</a>
<a id='n6673' href='#n6673'>6673</a>
<a id='n6674' href='#n6674'>6674</a>
<a id='n6675' href='#n6675'>6675</a>
<a id='n6676' href='#n6676'>6676</a>
<a id='n6677' href='#n6677'>6677</a>
<a id='n6678' href='#n6678'>6678</a>
<a id='n6679' href='#n6679'>6679</a>
<a id='n6680' href='#n6680'>6680</a>
<a id='n6681' href='#n6681'>6681</a>
<a id='n6682' href='#n6682'>6682</a>
<a id='n6683' href='#n6683'>6683</a>
<a id='n6684' href='#n6684'>6684</a>
<a id='n6685' href='#n6685'>6685</a>
<a id='n6686' href='#n6686'>6686</a>
<a id='n6687' href='#n6687'>6687</a>
<a id='n6688' href='#n6688'>6688</a>
<a id='n6689' href='#n6689'>6689</a>
<a id='n6690' href='#n6690'>6690</a>
<a id='n6691' href='#n6691'>6691</a>
<a id='n6692' href='#n6692'>6692</a>
<a id='n6693' href='#n6693'>6693</a>
<a id='n6694' href='#n6694'>6694</a>
<a id='n6695' href='#n6695'>6695</a>
<a id='n6696' href='#n6696'>6696</a>
<a id='n6697' href='#n6697'>6697</a>
<a id='n6698' href='#n6698'>6698</a>
<a id='n6699' href='#n6699'>6699</a>
<a id='n6700' href='#n6700'>6700</a>
<a id='n6701' href='#n6701'>6701</a>
<a id='n6702' href='#n6702'>6702</a>
<a id='n6703' href='#n6703'>6703</a>
<a id='n6704' href='#n6704'>6704</a>
<a id='n6705' href='#n6705'>6705</a>
<a id='n6706' href='#n6706'>6706</a>
<a id='n6707' href='#n6707'>6707</a>
<a id='n6708' href='#n6708'>6708</a>
<a id='n6709' href='#n6709'>6709</a>
<a id='n6710' href='#n6710'>6710</a>
<a id='n6711' href='#n6711'>6711</a>
<a id='n6712' href='#n6712'>6712</a>
<a id='n6713' href='#n6713'>6713</a>
<a id='n6714' href='#n6714'>6714</a>
<a id='n6715' href='#n6715'>6715</a>
<a id='n6716' href='#n6716'>6716</a>
<a id='n6717' href='#n6717'>6717</a>
<a id='n6718' href='#n6718'>6718</a>
<a id='n6719' href='#n6719'>6719</a>
<a id='n6720' href='#n6720'>6720</a>
<a id='n6721' href='#n6721'>6721</a>
<a id='n6722' href='#n6722'>6722</a>
<a id='n6723' href='#n6723'>6723</a>
<a id='n6724' href='#n6724'>6724</a>
<a id='n6725' href='#n6725'>6725</a>
<a id='n6726' href='#n6726'>6726</a>
<a id='n6727' href='#n6727'>6727</a>
<a id='n6728' href='#n6728'>6728</a>
<a id='n6729' href='#n6729'>6729</a>
<a id='n6730' href='#n6730'>6730</a>
<a id='n6731' href='#n6731'>6731</a>
<a id='n6732' href='#n6732'>6732</a>
<a id='n6733' href='#n6733'>6733</a>
<a id='n6734' href='#n6734'>6734</a>
<a id='n6735' href='#n6735'>6735</a>
<a id='n6736' href='#n6736'>6736</a>
<a id='n6737' href='#n6737'>6737</a>
<a id='n6738' href='#n6738'>6738</a>
<a id='n6739' href='#n6739'>6739</a>
<a id='n6740' href='#n6740'>6740</a>
<a id='n6741' href='#n6741'>6741</a>
<a id='n6742' href='#n6742'>6742</a>
<a id='n6743' href='#n6743'>6743</a>
<a id='n6744' href='#n6744'>6744</a>
<a id='n6745' href='#n6745'>6745</a>
<a id='n6746' href='#n6746'>6746</a>
<a id='n6747' href='#n6747'>6747</a>
<a id='n6748' href='#n6748'>6748</a>
<a id='n6749' href='#n6749'>6749</a>
<a id='n6750' href='#n6750'>6750</a>
<a id='n6751' href='#n6751'>6751</a>
<a id='n6752' href='#n6752'>6752</a>
<a id='n6753' href='#n6753'>6753</a>
<a id='n6754' href='#n6754'>6754</a>
<a id='n6755' href='#n6755'>6755</a>
<a id='n6756' href='#n6756'>6756</a>
<a id='n6757' href='#n6757'>6757</a>
<a id='n6758' href='#n6758'>6758</a>
<a id='n6759' href='#n6759'>6759</a>
<a id='n6760' href='#n6760'>6760</a>
<a id='n6761' href='#n6761'>6761</a>
<a id='n6762' href='#n6762'>6762</a>
<a id='n6763' href='#n6763'>6763</a>
<a id='n6764' href='#n6764'>6764</a>
<a id='n6765' href='#n6765'>6765</a>
<a id='n6766' href='#n6766'>6766</a>
<a id='n6767' href='#n6767'>6767</a>
<a id='n6768' href='#n6768'>6768</a>
<a id='n6769' href='#n6769'>6769</a>
<a id='n6770' href='#n6770'>6770</a>
<a id='n6771' href='#n6771'>6771</a>
<a id='n6772' href='#n6772'>6772</a>
<a id='n6773' href='#n6773'>6773</a>
<a id='n6774' href='#n6774'>6774</a>
<a id='n6775' href='#n6775'>6775</a>
<a id='n6776' href='#n6776'>6776</a>
<a id='n6777' href='#n6777'>6777</a>
<a id='n6778' href='#n6778'>6778</a>
<a id='n6779' href='#n6779'>6779</a>
<a id='n6780' href='#n6780'>6780</a>
<a id='n6781' href='#n6781'>6781</a>
<a id='n6782' href='#n6782'>6782</a>
<a id='n6783' href='#n6783'>6783</a>
<a id='n6784' href='#n6784'>6784</a>
<a id='n6785' href='#n6785'>6785</a>
<a id='n6786' href='#n6786'>6786</a>
<a id='n6787' href='#n6787'>6787</a>
<a id='n6788' href='#n6788'>6788</a>
<a id='n6789' href='#n6789'>6789</a>
<a id='n6790' href='#n6790'>6790</a>
<a id='n6791' href='#n6791'>6791</a>
<a id='n6792' href='#n6792'>6792</a>
<a id='n6793' href='#n6793'>6793</a>
<a id='n6794' href='#n6794'>6794</a>
<a id='n6795' href='#n6795'>6795</a>
<a id='n6796' href='#n6796'>6796</a>
<a id='n6797' href='#n6797'>6797</a>
<a id='n6798' href='#n6798'>6798</a>
<a id='n6799' href='#n6799'>6799</a>
<a id='n6800' href='#n6800'>6800</a>
<a id='n6801' href='#n6801'>6801</a>
<a id='n6802' href='#n6802'>6802</a>
<a id='n6803' href='#n6803'>6803</a>
<a id='n6804' href='#n6804'>6804</a>
<a id='n6805' href='#n6805'>6805</a>
<a id='n6806' href='#n6806'>6806</a>
<a id='n6807' href='#n6807'>6807</a>
<a id='n6808' href='#n6808'>6808</a>
<a id='n6809' href='#n6809'>6809</a>
<a id='n6810' href='#n6810'>6810</a>
<a id='n6811' href='#n6811'>6811</a>
<a id='n6812' href='#n6812'>6812</a>
<a id='n6813' href='#n6813'>6813</a>
<a id='n6814' href='#n6814'>6814</a>
<a id='n6815' href='#n6815'>6815</a>
<a id='n6816' href='#n6816'>6816</a>
<a id='n6817' href='#n6817'>6817</a>
<a id='n6818' href='#n6818'>6818</a>
<a id='n6819' href='#n6819'>6819</a>
<a id='n6820' href='#n6820'>6820</a>
<a id='n6821' href='#n6821'>6821</a>
<a id='n6822' href='#n6822'>6822</a>
<a id='n6823' href='#n6823'>6823</a>
<a id='n6824' href='#n6824'>6824</a>
<a id='n6825' href='#n6825'>6825</a>
<a id='n6826' href='#n6826'>6826</a>
<a id='n6827' href='#n6827'>6827</a>
<a id='n6828' href='#n6828'>6828</a>
<a id='n6829' href='#n6829'>6829</a>
<a id='n6830' href='#n6830'>6830</a>
<a id='n6831' href='#n6831'>6831</a>
<a id='n6832' href='#n6832'>6832</a>
<a id='n6833' href='#n6833'>6833</a>
<a id='n6834' href='#n6834'>6834</a>
<a id='n6835' href='#n6835'>6835</a>
<a id='n6836' href='#n6836'>6836</a>
<a id='n6837' href='#n6837'>6837</a>
<a id='n6838' href='#n6838'>6838</a>
<a id='n6839' href='#n6839'>6839</a>
<a id='n6840' href='#n6840'>6840</a>
<a id='n6841' href='#n6841'>6841</a>
<a id='n6842' href='#n6842'>6842</a>
<a id='n6843' href='#n6843'>6843</a>
<a id='n6844' href='#n6844'>6844</a>
<a id='n6845' href='#n6845'>6845</a>
<a id='n6846' href='#n6846'>6846</a>
<a id='n6847' href='#n6847'>6847</a>
<a id='n6848' href='#n6848'>6848</a>
<a id='n6849' href='#n6849'>6849</a>
<a id='n6850' href='#n6850'>6850</a>
<a id='n6851' href='#n6851'>6851</a>
<a id='n6852' href='#n6852'>6852</a>
<a id='n6853' href='#n6853'>6853</a>
<a id='n6854' href='#n6854'>6854</a>
<a id='n6855' href='#n6855'>6855</a>
<a id='n6856' href='#n6856'>6856</a>
<a id='n6857' href='#n6857'>6857</a>
<a id='n6858' href='#n6858'>6858</a>
<a id='n6859' href='#n6859'>6859</a>
<a id='n6860' href='#n6860'>6860</a>
<a id='n6861' href='#n6861'>6861</a>
<a id='n6862' href='#n6862'>6862</a>
<a id='n6863' href='#n6863'>6863</a>
<a id='n6864' href='#n6864'>6864</a>
<a id='n6865' href='#n6865'>6865</a>
<a id='n6866' href='#n6866'>6866</a>
<a id='n6867' href='#n6867'>6867</a>
<a id='n6868' href='#n6868'>6868</a>
<a id='n6869' href='#n6869'>6869</a>
<a id='n6870' href='#n6870'>6870</a>
<a id='n6871' href='#n6871'>6871</a>
<a id='n6872' href='#n6872'>6872</a>
<a id='n6873' href='#n6873'>6873</a>
<a id='n6874' href='#n6874'>6874</a>
<a id='n6875' href='#n6875'>6875</a>
<a id='n6876' href='#n6876'>6876</a>
<a id='n6877' href='#n6877'>6877</a>
<a id='n6878' href='#n6878'>6878</a>
<a id='n6879' href='#n6879'>6879</a>
<a id='n6880' href='#n6880'>6880</a>
<a id='n6881' href='#n6881'>6881</a>
<a id='n6882' href='#n6882'>6882</a>
<a id='n6883' href='#n6883'>6883</a>
<a id='n6884' href='#n6884'>6884</a>
<a id='n6885' href='#n6885'>6885</a>
<a id='n6886' href='#n6886'>6886</a>
<a id='n6887' href='#n6887'>6887</a>
<a id='n6888' href='#n6888'>6888</a>
<a id='n6889' href='#n6889'>6889</a>
<a id='n6890' href='#n6890'>6890</a>
<a id='n6891' href='#n6891'>6891</a>
<a id='n6892' href='#n6892'>6892</a>
<a id='n6893' href='#n6893'>6893</a>
<a id='n6894' href='#n6894'>6894</a>
<a id='n6895' href='#n6895'>6895</a>
<a id='n6896' href='#n6896'>6896</a>
<a id='n6897' href='#n6897'>6897</a>
<a id='n6898' href='#n6898'>6898</a>
<a id='n6899' href='#n6899'>6899</a>
<a id='n6900' href='#n6900'>6900</a>
<a id='n6901' href='#n6901'>6901</a>
<a id='n6902' href='#n6902'>6902</a>
<a id='n6903' href='#n6903'>6903</a>
<a id='n6904' href='#n6904'>6904</a>
<a id='n6905' href='#n6905'>6905</a>
<a id='n6906' href='#n6906'>6906</a>
<a id='n6907' href='#n6907'>6907</a>
<a id='n6908' href='#n6908'>6908</a>
<a id='n6909' href='#n6909'>6909</a>
<a id='n6910' href='#n6910'>6910</a>
<a id='n6911' href='#n6911'>6911</a>
<a id='n6912' href='#n6912'>6912</a>
<a id='n6913' href='#n6913'>6913</a>
<a id='n6914' href='#n6914'>6914</a>
<a id='n6915' href='#n6915'>6915</a>
<a id='n6916' href='#n6916'>6916</a>
<a id='n6917' href='#n6917'>6917</a>
<a id='n6918' href='#n6918'>6918</a>
<a id='n6919' href='#n6919'>6919</a>
<a id='n6920' href='#n6920'>6920</a>
<a id='n6921' href='#n6921'>6921</a>
<a id='n6922' href='#n6922'>6922</a>
<a id='n6923' href='#n6923'>6923</a>
<a id='n6924' href='#n6924'>6924</a>
<a id='n6925' href='#n6925'>6925</a>
<a id='n6926' href='#n6926'>6926</a>
<a id='n6927' href='#n6927'>6927</a>
<a id='n6928' href='#n6928'>6928</a>
<a id='n6929' href='#n6929'>6929</a>
<a id='n6930' href='#n6930'>6930</a>
<a id='n6931' href='#n6931'>6931</a>
<a id='n6932' href='#n6932'>6932</a>
<a id='n6933' href='#n6933'>6933</a>
<a id='n6934' href='#n6934'>6934</a>
<a id='n6935' href='#n6935'>6935</a>
<a id='n6936' href='#n6936'>6936</a>
<a id='n6937' href='#n6937'>6937</a>
<a id='n6938' href='#n6938'>6938</a>
<a id='n6939' href='#n6939'>6939</a>
<a id='n6940' href='#n6940'>6940</a>
<a id='n6941' href='#n6941'>6941</a>
<a id='n6942' href='#n6942'>6942</a>
<a id='n6943' href='#n6943'>6943</a>
<a id='n6944' href='#n6944'>6944</a>
<a id='n6945' href='#n6945'>6945</a>
</pre></td>
<td class='lines'><pre><code><span class="hl com">/* DO NOT EDIT - This file generated automatically by gl_apitemp.py (from Mesa) script */</span>

<span class="hl com">/*</span>
<span class="hl com"> * Copyright (C) 1999-2001  Brian Paul   All Rights Reserved.</span>
<span class="hl com"> * (C) Copyright IBM Corporation 2004</span>
<span class="hl com"> * All Rights Reserved.</span>
<span class="hl com"> * </span>
<span class="hl com"> * Permission is hereby granted, free of charge, to any person obtaining a</span>
<span class="hl com"> * copy of this software and associated documentation files (the &quot;Software&quot;),</span>
<span class="hl com"> * to deal in the Software without restriction, including without limitation</span>
<span class="hl com"> * the rights to use, copy, modify, merge, publish, distribute, sub license,</span>
<span class="hl com"> * and/or sell copies of the Software, and to permit persons to whom the</span>
<span class="hl com"> * Software is furnished to do so, subject to the following conditions:</span>
<span class="hl com"> * </span>
<span class="hl com"> * The above copyright notice and this permission notice (including the next</span>
<span class="hl com"> * paragraph) shall be included in all copies or substantial portions of the</span>
<span class="hl com"> * Software.</span>
<span class="hl com"> * </span>
<span class="hl com"> * THE SOFTWARE IS PROVIDED &quot;AS IS&quot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR</span>
<span class="hl com"> * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,</span>
<span class="hl com"> * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL</span>
<span class="hl com"> * BRIAN PAUL, IBM,</span>
<span class="hl com"> * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,</span>
<span class="hl com"> * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF</span>
<span class="hl com"> * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE</span>
<span class="hl com"> * SOFTWARE.</span>
<span class="hl com"> */</span>


<span class="hl ppc">#  if (__GNUC__ &gt; 3 || (__GNUC__ == 3 &amp;&amp; __GNUC_MINOR__ &gt;= 3)) &amp;&amp; defined(__ELF__)</span>
<span class="hl ppc">#    define HIDDEN  __attribute__((visibility(</span><span class="hl pps">&quot;hidden&quot;</span><span class="hl ppc">)))</span>
<span class="hl ppc">#  else</span>
<span class="hl ppc">#    define HIDDEN</span>
<span class="hl ppc">#  endif</span>

<span class="hl com">/*</span>
<span class="hl com"> * This file is a template which generates the OpenGL API entry point</span>
<span class="hl com"> * functions.  It should be included by a .c file which first defines</span>
<span class="hl com"> * the following macros:</span>
<span class="hl com"> *   KEYWORD1 - usually nothing, but might be __declspec(dllexport) on Win32</span>
<span class="hl com"> *   KEYWORD2 - usually nothing, but might be __stdcall on Win32</span>
<span class="hl com"> *   NAME(n)  - builds the final function name (usually add &quot;gl&quot; prefix)</span>
<span class="hl com"> *   DISPATCH(func, args, msg) - code to do dispatch of named function.</span>
<span class="hl com"> *                               msg is a printf-style debug message.</span>
<span class="hl com"> *   RETURN_DISPATCH(func, args, msg) - code to do dispatch with a return value</span>
<span class="hl com"> *</span>
<span class="hl com"> * Here is an example which generates the usual OpenGL functions:</span>
<span class="hl com"> *   #define KEYWORD1</span>
<span class="hl com"> *   #define KEYWORD2</span>
<span class="hl com"> *   #define NAME(func)  gl##func</span>
<span class="hl com"> *   #define DISPATCH(func, args, msg)                           \</span>
<span class="hl com"> *          struct _glapi_table *dispatch = CurrentDispatch;     \</span>
<span class="hl com"> *          (*dispatch-&gt;func) args</span>
<span class="hl com"> *   #define RETURN DISPATCH(func, args, msg)                    \</span>
<span class="hl com"> *          struct _glapi_table *dispatch = CurrentDispatch;     \</span>
<span class="hl com"> *          return (*dispatch-&gt;func) args</span>
<span class="hl com"> *</span>
<span class="hl com"> */</span>


<span class="hl ppc">#if defined( NAME )</span>
<span class="hl ppc">#ifndef KEYWORD1</span>
<span class="hl ppc">#define KEYWORD1</span>
<span class="hl ppc">#endif</span>

<span class="hl ppc">#ifndef KEYWORD1_ALT</span>
<span class="hl ppc">#define KEYWORD1_ALT HIDDEN</span>
<span class="hl ppc">#endif</span>

<span class="hl ppc">#ifndef KEYWORD2</span>
<span class="hl ppc">#define KEYWORD2</span>
<span class="hl ppc">#endif</span>

<span class="hl ppc">#ifndef DISPATCH</span>
<span class="hl ppc">#error DISPATCH must be defined</span>
<span class="hl ppc">#endif</span>

<span class="hl ppc">#ifndef RETURN_DISPATCH</span>
<span class="hl ppc">#error RETURN_DISPATCH must be defined</span>
<span class="hl ppc">#endif</span>


KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>NewList<span class="hl opt">)(</span>GLuint list<span class="hl opt">,</span> GLenum mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>NewList<span class="hl opt">, (</span>list<span class="hl opt">,</span> mode<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glNewList(%d, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> list<span class="hl opt">,</span> mode<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EndList<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EndList<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEndList();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CallList<span class="hl opt">)(</span>GLuint list<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CallList<span class="hl opt">, (</span>list<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCallList(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> list<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CallLists<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> lists<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CallLists<span class="hl opt">, (</span>n<span class="hl opt">,</span> type<span class="hl opt">,</span> lists<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCallLists(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> lists<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteLists<span class="hl opt">)(</span>GLuint list<span class="hl opt">,</span> GLsizei range<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteLists<span class="hl opt">, (</span>list<span class="hl opt">,</span> range<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteLists(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> list<span class="hl opt">,</span> range<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLuint KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GenLists<span class="hl opt">)(</span>GLsizei range<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>GenLists<span class="hl opt">, (</span>range<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenLists(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> range<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ListBase<span class="hl opt">)(</span>GLuint base<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ListBase<span class="hl opt">, (</span>base<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glListBase(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> base<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Begin<span class="hl opt">)(</span>GLenum mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Begin<span class="hl opt">, (</span>mode<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBegin(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Bitmap<span class="hl opt">)(</span>GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLfloat xorig<span class="hl opt">,</span> GLfloat yorig<span class="hl opt">,</span> GLfloat xmove<span class="hl opt">,</span> GLfloat ymove<span class="hl opt">,</span> <span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> bitmap<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Bitmap<span class="hl opt">, (</span>width<span class="hl opt">,</span> height<span class="hl opt">,</span> xorig<span class="hl opt">,</span> yorig<span class="hl opt">,</span> xmove<span class="hl opt">,</span> ymove<span class="hl opt">,</span> bitmap<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBitmap(%d, %d, %f, %f, %f, %f, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> xorig<span class="hl opt">,</span> yorig<span class="hl opt">,</span> xmove<span class="hl opt">,</span> ymove<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> bitmap<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color3b<span class="hl opt">)(</span>GLbyte red<span class="hl opt">,</span> GLbyte green<span class="hl opt">,</span> GLbyte blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color3b<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor3b(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color3bv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLbyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color3bv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor3bv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color3d<span class="hl opt">)(</span>GLdouble red<span class="hl opt">,</span> GLdouble green<span class="hl opt">,</span> GLdouble blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color3d<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor3d(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color3dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color3dv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor3dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color3f<span class="hl opt">)(</span>GLfloat red<span class="hl opt">,</span> GLfloat green<span class="hl opt">,</span> GLfloat blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color3f<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor3f(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color3fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color3fv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor3fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color3i<span class="hl opt">)(</span>GLint red<span class="hl opt">,</span> GLint green<span class="hl opt">,</span> GLint blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color3i<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor3i(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color3iv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color3iv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor3iv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color3s<span class="hl opt">)(</span>GLshort red<span class="hl opt">,</span> GLshort green<span class="hl opt">,</span> GLshort blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color3s<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor3s(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color3sv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color3sv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor3sv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color3ub<span class="hl opt">)(</span>GLubyte red<span class="hl opt">,</span> GLubyte green<span class="hl opt">,</span> GLubyte blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color3ub<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor3ub(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color3ubv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color3ubv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor3ubv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color3ui<span class="hl opt">)(</span>GLuint red<span class="hl opt">,</span> GLuint green<span class="hl opt">,</span> GLuint blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color3ui<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor3ui(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color3uiv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color3uiv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor3uiv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color3us<span class="hl opt">)(</span>GLushort red<span class="hl opt">,</span> GLushort green<span class="hl opt">,</span> GLushort blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color3us<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor3us(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color3usv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLushort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color3usv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor3usv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color4b<span class="hl opt">)(</span>GLbyte red<span class="hl opt">,</span> GLbyte green<span class="hl opt">,</span> GLbyte blue<span class="hl opt">,</span> GLbyte alpha<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color4b<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor4b(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color4bv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLbyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color4bv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor4bv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color4d<span class="hl opt">)(</span>GLdouble red<span class="hl opt">,</span> GLdouble green<span class="hl opt">,</span> GLdouble blue<span class="hl opt">,</span> GLdouble alpha<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color4d<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor4d(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color4dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color4dv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor4dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color4f<span class="hl opt">)(</span>GLfloat red<span class="hl opt">,</span> GLfloat green<span class="hl opt">,</span> GLfloat blue<span class="hl opt">,</span> GLfloat alpha<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color4f<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor4f(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color4fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color4fv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor4fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color4i<span class="hl opt">)(</span>GLint red<span class="hl opt">,</span> GLint green<span class="hl opt">,</span> GLint blue<span class="hl opt">,</span> GLint alpha<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color4i<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor4i(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color4iv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color4iv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor4iv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color4s<span class="hl opt">)(</span>GLshort red<span class="hl opt">,</span> GLshort green<span class="hl opt">,</span> GLshort blue<span class="hl opt">,</span> GLshort alpha<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color4s<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor4s(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color4sv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color4sv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor4sv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color4ub<span class="hl opt">)(</span>GLubyte red<span class="hl opt">,</span> GLubyte green<span class="hl opt">,</span> GLubyte blue<span class="hl opt">,</span> GLubyte alpha<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color4ub<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor4ub(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color4ubv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color4ubv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor4ubv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color4ui<span class="hl opt">)(</span>GLuint red<span class="hl opt">,</span> GLuint green<span class="hl opt">,</span> GLuint blue<span class="hl opt">,</span> GLuint alpha<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color4ui<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor4ui(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color4uiv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color4uiv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor4uiv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color4us<span class="hl opt">)(</span>GLushort red<span class="hl opt">,</span> GLushort green<span class="hl opt">,</span> GLushort blue<span class="hl opt">,</span> GLushort alpha<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color4us<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor4us(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Color4usv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLushort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Color4usv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColor4usv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EdgeFlag<span class="hl opt">)(</span>GLboolean flag<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EdgeFlag<span class="hl opt">, (</span>flag<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEdgeFlag(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> flag<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EdgeFlagv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLboolean <span class="hl opt">*</span> flag<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EdgeFlagv<span class="hl opt">, (</span>flag<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEdgeFlagv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> flag<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>End<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>End<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEnd();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Indexd<span class="hl opt">)(</span>GLdouble c<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Indexd<span class="hl opt">, (</span>c<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIndexd(%f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> c<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Indexdv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> c<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Indexdv<span class="hl opt">, (</span>c<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIndexdv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> c<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Indexf<span class="hl opt">)(</span>GLfloat c<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Indexf<span class="hl opt">, (</span>c<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIndexf(%f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> c<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Indexfv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> c<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Indexfv<span class="hl opt">, (</span>c<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIndexfv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> c<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Indexi<span class="hl opt">)(</span>GLint c<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Indexi<span class="hl opt">, (</span>c<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIndexi(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> c<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Indexiv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> c<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Indexiv<span class="hl opt">, (</span>c<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIndexiv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> c<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Indexs<span class="hl opt">)(</span>GLshort c<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Indexs<span class="hl opt">, (</span>c<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIndexs(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> c<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Indexsv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> c<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Indexsv<span class="hl opt">, (</span>c<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIndexsv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> c<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Normal3b<span class="hl opt">)(</span>GLbyte nx<span class="hl opt">,</span> GLbyte ny<span class="hl opt">,</span> GLbyte nz<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Normal3b<span class="hl opt">, (</span>nx<span class="hl opt">,</span> ny<span class="hl opt">,</span> nz<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glNormal3b(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> nx<span class="hl opt">,</span> ny<span class="hl opt">,</span> nz<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Normal3bv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLbyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Normal3bv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glNormal3bv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Normal3d<span class="hl opt">)(</span>GLdouble nx<span class="hl opt">,</span> GLdouble ny<span class="hl opt">,</span> GLdouble nz<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Normal3d<span class="hl opt">, (</span>nx<span class="hl opt">,</span> ny<span class="hl opt">,</span> nz<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glNormal3d(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> nx<span class="hl opt">,</span> ny<span class="hl opt">,</span> nz<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Normal3dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Normal3dv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glNormal3dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Normal3f<span class="hl opt">)(</span>GLfloat nx<span class="hl opt">,</span> GLfloat ny<span class="hl opt">,</span> GLfloat nz<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Normal3f<span class="hl opt">, (</span>nx<span class="hl opt">,</span> ny<span class="hl opt">,</span> nz<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glNormal3f(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> nx<span class="hl opt">,</span> ny<span class="hl opt">,</span> nz<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Normal3fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Normal3fv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glNormal3fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Normal3i<span class="hl opt">)(</span>GLint nx<span class="hl opt">,</span> GLint ny<span class="hl opt">,</span> GLint nz<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Normal3i<span class="hl opt">, (</span>nx<span class="hl opt">,</span> ny<span class="hl opt">,</span> nz<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glNormal3i(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> nx<span class="hl opt">,</span> ny<span class="hl opt">,</span> nz<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Normal3iv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Normal3iv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glNormal3iv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Normal3s<span class="hl opt">)(</span>GLshort nx<span class="hl opt">,</span> GLshort ny<span class="hl opt">,</span> GLshort nz<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Normal3s<span class="hl opt">, (</span>nx<span class="hl opt">,</span> ny<span class="hl opt">,</span> nz<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glNormal3s(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> nx<span class="hl opt">,</span> ny<span class="hl opt">,</span> nz<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Normal3sv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Normal3sv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glNormal3sv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos2d<span class="hl opt">)(</span>GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos2d<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos2d(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos2dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos2dv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos2dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos2f<span class="hl opt">)(</span>GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos2f<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos2f(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos2fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos2fv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos2fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos2i<span class="hl opt">)(</span>GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos2i<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos2i(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos2iv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos2iv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos2iv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos2s<span class="hl opt">)(</span>GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos2s<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos2s(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos2sv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos2sv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos2sv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos3d<span class="hl opt">)(</span>GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos3d<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos3d(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos3dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos3dv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos3dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos3f<span class="hl opt">)(</span>GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos3f<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos3f(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos3fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos3fv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos3fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos3i<span class="hl opt">)(</span>GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLint z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos3i<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos3i(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos3iv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos3iv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos3iv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos3s<span class="hl opt">)(</span>GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">,</span> GLshort z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos3s<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos3s(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos3sv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos3sv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos3sv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos4d<span class="hl opt">)(</span>GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">,</span> GLdouble w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos4d<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos4d(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos4dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos4dv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos4dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos4f<span class="hl opt">)(</span>GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">,</span> GLfloat w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos4f<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos4f(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos4fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos4fv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos4fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos4i<span class="hl opt">)(</span>GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLint z<span class="hl opt">,</span> GLint w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos4i<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos4i(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos4iv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos4iv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos4iv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos4s<span class="hl opt">)(</span>GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">,</span> GLshort z<span class="hl opt">,</span> GLshort w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos4s<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos4s(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RasterPos4sv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RasterPos4sv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRasterPos4sv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Rectd<span class="hl opt">)(</span>GLdouble x1<span class="hl opt">,</span> GLdouble y1<span class="hl opt">,</span> GLdouble x2<span class="hl opt">,</span> GLdouble y2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Rectd<span class="hl opt">, (</span>x1<span class="hl opt">,</span> y1<span class="hl opt">,</span> x2<span class="hl opt">,</span> y2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRectd(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x1<span class="hl opt">,</span> y1<span class="hl opt">,</span> x2<span class="hl opt">,</span> y2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Rectdv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v1<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Rectdv<span class="hl opt">, (</span>v1<span class="hl opt">,</span> v2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRectdv(%p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v1<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Rectf<span class="hl opt">)(</span>GLfloat x1<span class="hl opt">,</span> GLfloat y1<span class="hl opt">,</span> GLfloat x2<span class="hl opt">,</span> GLfloat y2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Rectf<span class="hl opt">, (</span>x1<span class="hl opt">,</span> y1<span class="hl opt">,</span> x2<span class="hl opt">,</span> y2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRectf(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x1<span class="hl opt">,</span> y1<span class="hl opt">,</span> x2<span class="hl opt">,</span> y2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Rectfv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v1<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Rectfv<span class="hl opt">, (</span>v1<span class="hl opt">,</span> v2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRectfv(%p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v1<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Recti<span class="hl opt">)(</span>GLint x1<span class="hl opt">,</span> GLint y1<span class="hl opt">,</span> GLint x2<span class="hl opt">,</span> GLint y2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Recti<span class="hl opt">, (</span>x1<span class="hl opt">,</span> y1<span class="hl opt">,</span> x2<span class="hl opt">,</span> y2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRecti(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x1<span class="hl opt">,</span> y1<span class="hl opt">,</span> x2<span class="hl opt">,</span> y2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Rectiv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v1<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Rectiv<span class="hl opt">, (</span>v1<span class="hl opt">,</span> v2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRectiv(%p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v1<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Rects<span class="hl opt">)(</span>GLshort x1<span class="hl opt">,</span> GLshort y1<span class="hl opt">,</span> GLshort x2<span class="hl opt">,</span> GLshort y2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Rects<span class="hl opt">, (</span>x1<span class="hl opt">,</span> y1<span class="hl opt">,</span> x2<span class="hl opt">,</span> y2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRects(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x1<span class="hl opt">,</span> y1<span class="hl opt">,</span> x2<span class="hl opt">,</span> y2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Rectsv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v1<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Rectsv<span class="hl opt">, (</span>v1<span class="hl opt">,</span> v2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRectsv(%p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v1<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord1d<span class="hl opt">)(</span>GLdouble s<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord1d<span class="hl opt">, (</span>s<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord1d(%f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> s<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord1dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord1dv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord1dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord1f<span class="hl opt">)(</span>GLfloat s<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord1f<span class="hl opt">, (</span>s<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord1f(%f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> s<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord1fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord1fv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord1fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord1i<span class="hl opt">)(</span>GLint s<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord1i<span class="hl opt">, (</span>s<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord1i(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> s<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord1iv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord1iv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord1iv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord1s<span class="hl opt">)(</span>GLshort s<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord1s<span class="hl opt">, (</span>s<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord1s(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> s<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord1sv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord1sv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord1sv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord2d<span class="hl opt">)(</span>GLdouble s<span class="hl opt">,</span> GLdouble t<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord2d<span class="hl opt">, (</span>s<span class="hl opt">,</span> t<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord2d(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord2dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord2dv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord2dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord2f<span class="hl opt">)(</span>GLfloat s<span class="hl opt">,</span> GLfloat t<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord2f<span class="hl opt">, (</span>s<span class="hl opt">,</span> t<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord2f(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord2fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord2fv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord2fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord2i<span class="hl opt">)(</span>GLint s<span class="hl opt">,</span> GLint t<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord2i<span class="hl opt">, (</span>s<span class="hl opt">,</span> t<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord2i(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord2iv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord2iv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord2iv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord2s<span class="hl opt">)(</span>GLshort s<span class="hl opt">,</span> GLshort t<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord2s<span class="hl opt">, (</span>s<span class="hl opt">,</span> t<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord2s(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord2sv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord2sv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord2sv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord3d<span class="hl opt">)(</span>GLdouble s<span class="hl opt">,</span> GLdouble t<span class="hl opt">,</span> GLdouble r<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord3d<span class="hl opt">, (</span>s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord3d(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord3dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord3dv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord3dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord3f<span class="hl opt">)(</span>GLfloat s<span class="hl opt">,</span> GLfloat t<span class="hl opt">,</span> GLfloat r<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord3f<span class="hl opt">, (</span>s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord3f(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord3fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord3fv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord3fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord3i<span class="hl opt">)(</span>GLint s<span class="hl opt">,</span> GLint t<span class="hl opt">,</span> GLint r<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord3i<span class="hl opt">, (</span>s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord3i(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord3iv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord3iv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord3iv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord3s<span class="hl opt">)(</span>GLshort s<span class="hl opt">,</span> GLshort t<span class="hl opt">,</span> GLshort r<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord3s<span class="hl opt">, (</span>s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord3s(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord3sv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord3sv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord3sv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord4d<span class="hl opt">)(</span>GLdouble s<span class="hl opt">,</span> GLdouble t<span class="hl opt">,</span> GLdouble r<span class="hl opt">,</span> GLdouble q<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord4d<span class="hl opt">, (</span>s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord4d(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord4dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord4dv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord4dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord4f<span class="hl opt">)(</span>GLfloat s<span class="hl opt">,</span> GLfloat t<span class="hl opt">,</span> GLfloat r<span class="hl opt">,</span> GLfloat q<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord4f<span class="hl opt">, (</span>s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord4f(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord4fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord4fv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord4fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord4i<span class="hl opt">)(</span>GLint s<span class="hl opt">,</span> GLint t<span class="hl opt">,</span> GLint r<span class="hl opt">,</span> GLint q<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord4i<span class="hl opt">, (</span>s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord4i(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord4iv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord4iv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord4iv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord4s<span class="hl opt">)(</span>GLshort s<span class="hl opt">,</span> GLshort t<span class="hl opt">,</span> GLshort r<span class="hl opt">,</span> GLshort q<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord4s<span class="hl opt">, (</span>s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord4s(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoord4sv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoord4sv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoord4sv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex2d<span class="hl opt">)(</span>GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex2d<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex2d(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex2dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex2dv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex2dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex2f<span class="hl opt">)(</span>GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex2f<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex2f(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex2fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex2fv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex2fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex2i<span class="hl opt">)(</span>GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex2i<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex2i(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex2iv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex2iv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex2iv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex2s<span class="hl opt">)(</span>GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex2s<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex2s(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex2sv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex2sv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex2sv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex3d<span class="hl opt">)(</span>GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex3d<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex3d(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex3dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex3dv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex3dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex3f<span class="hl opt">)(</span>GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex3f<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex3f(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex3fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex3fv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex3fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex3i<span class="hl opt">)(</span>GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLint z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex3i<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex3i(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex3iv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex3iv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex3iv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex3s<span class="hl opt">)(</span>GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">,</span> GLshort z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex3s<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex3s(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex3sv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex3sv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex3sv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex4d<span class="hl opt">)(</span>GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">,</span> GLdouble w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex4d<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex4d(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex4dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex4dv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex4dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex4f<span class="hl opt">)(</span>GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">,</span> GLfloat w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex4f<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex4f(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex4fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex4fv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex4fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex4i<span class="hl opt">)(</span>GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLint z<span class="hl opt">,</span> GLint w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex4i<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex4i(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex4iv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex4iv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex4iv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex4s<span class="hl opt">)(</span>GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">,</span> GLshort z<span class="hl opt">,</span> GLshort w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex4s<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex4s(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Vertex4sv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Vertex4sv<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertex4sv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ClipPlane<span class="hl opt">)(</span>GLenum plane<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> equation<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ClipPlane<span class="hl opt">, (</span>plane<span class="hl opt">,</span> equation<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glClipPlane(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> plane<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> equation<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ColorMaterial<span class="hl opt">)(</span>GLenum face<span class="hl opt">,</span> GLenum mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ColorMaterial<span class="hl opt">, (</span>face<span class="hl opt">,</span> mode<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColorMaterial(0x%x, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> face<span class="hl opt">,</span> mode<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CullFace<span class="hl opt">)(</span>GLenum mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CullFace<span class="hl opt">, (</span>mode<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCullFace(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Fogf<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Fogf<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFogf(0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Fogfv<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Fogfv<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFogfv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Fogi<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLint param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Fogi<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFogi(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Fogiv<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Fogiv<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFogiv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FrontFace<span class="hl opt">)(</span>GLenum mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FrontFace<span class="hl opt">, (</span>mode<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFrontFace(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Hint<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Hint<span class="hl opt">, (</span>target<span class="hl opt">,</span> mode<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glHint(0x%x, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> mode<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Lightf<span class="hl opt">)(</span>GLenum light<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Lightf<span class="hl opt">, (</span>light<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLightf(0x%x, 0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> light<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Lightfv<span class="hl opt">)(</span>GLenum light<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Lightfv<span class="hl opt">, (</span>light<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLightfv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> light<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Lighti<span class="hl opt">)(</span>GLenum light<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Lighti<span class="hl opt">, (</span>light<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLighti(0x%x, 0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> light<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Lightiv<span class="hl opt">)(</span>GLenum light<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Lightiv<span class="hl opt">, (</span>light<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLightiv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> light<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LightModelf<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LightModelf<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLightModelf(0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LightModelfv<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LightModelfv<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLightModelfv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LightModeli<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLint param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LightModeli<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLightModeli(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LightModeliv<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LightModeliv<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLightModeliv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LineStipple<span class="hl opt">)(</span>GLint factor<span class="hl opt">,</span> GLushort pattern<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LineStipple<span class="hl opt">, (</span>factor<span class="hl opt">,</span> pattern<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLineStipple(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> factor<span class="hl opt">,</span> pattern<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LineWidth<span class="hl opt">)(</span>GLfloat width<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LineWidth<span class="hl opt">, (</span>width<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLineWidth(%f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> width<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Materialf<span class="hl opt">)(</span>GLenum face<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Materialf<span class="hl opt">, (</span>face<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMaterialf(0x%x, 0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> face<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Materialfv<span class="hl opt">)(</span>GLenum face<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Materialfv<span class="hl opt">, (</span>face<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMaterialfv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> face<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Materiali<span class="hl opt">)(</span>GLenum face<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Materiali<span class="hl opt">, (</span>face<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMateriali(0x%x, 0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> face<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Materialiv<span class="hl opt">)(</span>GLenum face<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Materialiv<span class="hl opt">, (</span>face<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMaterialiv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> face<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PointSize<span class="hl opt">)(</span>GLfloat size<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PointSize<span class="hl opt">, (</span>size<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPointSize(%f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> size<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PolygonMode<span class="hl opt">)(</span>GLenum face<span class="hl opt">,</span> GLenum mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PolygonMode<span class="hl opt">, (</span>face<span class="hl opt">,</span> mode<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPolygonMode(0x%x, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> face<span class="hl opt">,</span> mode<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PolygonStipple<span class="hl opt">)(</span><span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> mask<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PolygonStipple<span class="hl opt">, (</span>mask<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPolygonStipple(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> mask<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Scissor<span class="hl opt">)(</span>GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Scissor<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glScissor(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ShadeModel<span class="hl opt">)(</span>GLenum mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ShadeModel<span class="hl opt">, (</span>mode<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glShadeModel(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexParameterf<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexParameterf<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexParameterf(0x%x, 0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexParameterfv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexParameterfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexParameterfv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexParameteri<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexParameteri<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexParameteri(0x%x, 0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexParameteriv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexParameteriv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexParameteriv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexImage1D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLint border<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pixels<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexImage1D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> border<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> pixels<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexImage1D(0x%x, %d, %d, %d, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> border<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pixels<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexImage2D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLint border<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pixels<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexImage2D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> border<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> pixels<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexImage2D(0x%x, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> border<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pixels<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexEnvf<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexEnvf<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexEnvf(0x%x, 0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexEnvfv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexEnvfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexEnvfv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexEnvi<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexEnvi<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexEnvi(0x%x, 0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexEnviv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexEnviv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexEnviv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexGend<span class="hl opt">)(</span>GLenum coord<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLdouble param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexGend<span class="hl opt">, (</span>coord<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexGend(0x%x, 0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> coord<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexGendv<span class="hl opt">)(</span>GLenum coord<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexGendv<span class="hl opt">, (</span>coord<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexGendv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> coord<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexGenf<span class="hl opt">)(</span>GLenum coord<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexGenf<span class="hl opt">, (</span>coord<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexGenf(0x%x, 0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> coord<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexGenfv<span class="hl opt">)(</span>GLenum coord<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexGenfv<span class="hl opt">, (</span>coord<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexGenfv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> coord<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexGeni<span class="hl opt">)(</span>GLenum coord<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexGeni<span class="hl opt">, (</span>coord<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexGeni(0x%x, 0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> coord<span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexGeniv<span class="hl opt">)(</span>GLenum coord<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexGeniv<span class="hl opt">, (</span>coord<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexGeniv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> coord<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FeedbackBuffer<span class="hl opt">)(</span>GLsizei size<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> buffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FeedbackBuffer<span class="hl opt">, (</span>size<span class="hl opt">,</span> type<span class="hl opt">,</span> buffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFeedbackBuffer(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> buffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SelectBuffer<span class="hl opt">)(</span>GLsizei size<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> buffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SelectBuffer<span class="hl opt">, (</span>size<span class="hl opt">,</span> buffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSelectBuffer(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> size<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> buffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLint KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RenderMode<span class="hl opt">)(</span>GLenum mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>RenderMode<span class="hl opt">, (</span>mode<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRenderMode(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>InitNames<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>InitNames<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glInitNames();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LoadName<span class="hl opt">)(</span>GLuint name<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LoadName<span class="hl opt">, (</span>name<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLoadName(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> name<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PassThrough<span class="hl opt">)(</span>GLfloat token<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PassThrough<span class="hl opt">, (</span>token<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPassThrough(%f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> token<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PopName<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PopName<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPopName();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PushName<span class="hl opt">)(</span>GLuint name<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PushName<span class="hl opt">, (</span>name<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPushName(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> name<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DrawBuffer<span class="hl opt">)(</span>GLenum mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DrawBuffer<span class="hl opt">, (</span>mode<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDrawBuffer(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Clear<span class="hl opt">)(</span>GLbitfield mask<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Clear<span class="hl opt">, (</span>mask<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glClear(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mask<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ClearAccum<span class="hl opt">)(</span>GLfloat red<span class="hl opt">,</span> GLfloat green<span class="hl opt">,</span> GLfloat blue<span class="hl opt">,</span> GLfloat alpha<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ClearAccum<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glClearAccum(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ClearIndex<span class="hl opt">)(</span>GLfloat c<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ClearIndex<span class="hl opt">, (</span>c<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glClearIndex(%f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> c<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ClearColor<span class="hl opt">)(</span>GLclampf red<span class="hl opt">,</span> GLclampf green<span class="hl opt">,</span> GLclampf blue<span class="hl opt">,</span> GLclampf alpha<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ClearColor<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glClearColor(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ClearStencil<span class="hl opt">)(</span>GLint s<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ClearStencil<span class="hl opt">, (</span>s<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glClearStencil(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> s<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ClearDepth<span class="hl opt">)(</span>GLclampd depth<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ClearDepth<span class="hl opt">, (</span>depth<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glClearDepth(%f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> depth<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>StencilMask<span class="hl opt">)(</span>GLuint mask<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>StencilMask<span class="hl opt">, (</span>mask<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glStencilMask(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mask<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ColorMask<span class="hl opt">)(</span>GLboolean red<span class="hl opt">,</span> GLboolean green<span class="hl opt">,</span> GLboolean blue<span class="hl opt">,</span> GLboolean alpha<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ColorMask<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColorMask(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DepthMask<span class="hl opt">)(</span>GLboolean flag<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DepthMask<span class="hl opt">, (</span>flag<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDepthMask(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> flag<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IndexMask<span class="hl opt">)(</span>GLuint mask<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>IndexMask<span class="hl opt">, (</span>mask<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIndexMask(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mask<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Accum<span class="hl opt">)(</span>GLenum op<span class="hl opt">,</span> GLfloat value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Accum<span class="hl opt">, (</span>op<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glAccum(0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> op<span class="hl opt">,</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Disable<span class="hl opt">)(</span>GLenum cap<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Disable<span class="hl opt">, (</span>cap<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDisable(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> cap<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Enable<span class="hl opt">)(</span>GLenum cap<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Enable<span class="hl opt">, (</span>cap<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEnable(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> cap<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Finish<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Finish<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFinish();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Flush<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Flush<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFlush();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PopAttrib<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PopAttrib<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPopAttrib();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PushAttrib<span class="hl opt">)(</span>GLbitfield mask<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PushAttrib<span class="hl opt">, (</span>mask<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPushAttrib(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mask<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Map1d<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLdouble u1<span class="hl opt">,</span> GLdouble u2<span class="hl opt">,</span> GLint stride<span class="hl opt">,</span> GLint order<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> points<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Map1d<span class="hl opt">, (</span>target<span class="hl opt">,</span> u1<span class="hl opt">,</span> u2<span class="hl opt">,</span> stride<span class="hl opt">,</span> order<span class="hl opt">,</span> points<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMap1d(0x%x, %f, %f, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> u1<span class="hl opt">,</span> u2<span class="hl opt">,</span> stride<span class="hl opt">,</span> order<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> points<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Map1f<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLfloat u1<span class="hl opt">,</span> GLfloat u2<span class="hl opt">,</span> GLint stride<span class="hl opt">,</span> GLint order<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> points<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Map1f<span class="hl opt">, (</span>target<span class="hl opt">,</span> u1<span class="hl opt">,</span> u2<span class="hl opt">,</span> stride<span class="hl opt">,</span> order<span class="hl opt">,</span> points<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMap1f(0x%x, %f, %f, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> u1<span class="hl opt">,</span> u2<span class="hl opt">,</span> stride<span class="hl opt">,</span> order<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> points<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Map2d<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLdouble u1<span class="hl opt">,</span> GLdouble u2<span class="hl opt">,</span> GLint ustride<span class="hl opt">,</span> GLint uorder<span class="hl opt">,</span> GLdouble v1<span class="hl opt">,</span> GLdouble v2<span class="hl opt">,</span> GLint vstride<span class="hl opt">,</span> GLint vorder<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> points<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Map2d<span class="hl opt">, (</span>target<span class="hl opt">,</span> u1<span class="hl opt">,</span> u2<span class="hl opt">,</span> ustride<span class="hl opt">,</span> uorder<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">,</span> vstride<span class="hl opt">,</span> vorder<span class="hl opt">,</span> points<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMap2d(0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> u1<span class="hl opt">,</span> u2<span class="hl opt">,</span> ustride<span class="hl opt">,</span> uorder<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">,</span> vstride<span class="hl opt">,</span> vorder<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> points<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Map2f<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLfloat u1<span class="hl opt">,</span> GLfloat u2<span class="hl opt">,</span> GLint ustride<span class="hl opt">,</span> GLint uorder<span class="hl opt">,</span> GLfloat v1<span class="hl opt">,</span> GLfloat v2<span class="hl opt">,</span> GLint vstride<span class="hl opt">,</span> GLint vorder<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> points<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Map2f<span class="hl opt">, (</span>target<span class="hl opt">,</span> u1<span class="hl opt">,</span> u2<span class="hl opt">,</span> ustride<span class="hl opt">,</span> uorder<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">,</span> vstride<span class="hl opt">,</span> vorder<span class="hl opt">,</span> points<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMap2f(0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> u1<span class="hl opt">,</span> u2<span class="hl opt">,</span> ustride<span class="hl opt">,</span> uorder<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">,</span> vstride<span class="hl opt">,</span> vorder<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> points<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MapGrid1d<span class="hl opt">)(</span>GLint un<span class="hl opt">,</span> GLdouble u1<span class="hl opt">,</span> GLdouble u2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MapGrid1d<span class="hl opt">, (</span>un<span class="hl opt">,</span> u1<span class="hl opt">,</span> u2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMapGrid1d(%d, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> un<span class="hl opt">,</span> u1<span class="hl opt">,</span> u2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MapGrid1f<span class="hl opt">)(</span>GLint un<span class="hl opt">,</span> GLfloat u1<span class="hl opt">,</span> GLfloat u2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MapGrid1f<span class="hl opt">, (</span>un<span class="hl opt">,</span> u1<span class="hl opt">,</span> u2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMapGrid1f(%d, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> un<span class="hl opt">,</span> u1<span class="hl opt">,</span> u2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MapGrid2d<span class="hl opt">)(</span>GLint un<span class="hl opt">,</span> GLdouble u1<span class="hl opt">,</span> GLdouble u2<span class="hl opt">,</span> GLint vn<span class="hl opt">,</span> GLdouble v1<span class="hl opt">,</span> GLdouble v2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MapGrid2d<span class="hl opt">, (</span>un<span class="hl opt">,</span> u1<span class="hl opt">,</span> u2<span class="hl opt">,</span> vn<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMapGrid2d(%d, %f, %f, %d, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> un<span class="hl opt">,</span> u1<span class="hl opt">,</span> u2<span class="hl opt">,</span> vn<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MapGrid2f<span class="hl opt">)(</span>GLint un<span class="hl opt">,</span> GLfloat u1<span class="hl opt">,</span> GLfloat u2<span class="hl opt">,</span> GLint vn<span class="hl opt">,</span> GLfloat v1<span class="hl opt">,</span> GLfloat v2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MapGrid2f<span class="hl opt">, (</span>un<span class="hl opt">,</span> u1<span class="hl opt">,</span> u2<span class="hl opt">,</span> vn<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMapGrid2f(%d, %f, %f, %d, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> un<span class="hl opt">,</span> u1<span class="hl opt">,</span> u2<span class="hl opt">,</span> vn<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EvalCoord1d<span class="hl opt">)(</span>GLdouble u<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EvalCoord1d<span class="hl opt">, (</span>u<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEvalCoord1d(%f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> u<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EvalCoord1dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> u<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EvalCoord1dv<span class="hl opt">, (</span>u<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEvalCoord1dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> u<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EvalCoord1f<span class="hl opt">)(</span>GLfloat u<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EvalCoord1f<span class="hl opt">, (</span>u<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEvalCoord1f(%f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> u<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EvalCoord1fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> u<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EvalCoord1fv<span class="hl opt">, (</span>u<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEvalCoord1fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> u<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EvalCoord2d<span class="hl opt">)(</span>GLdouble u<span class="hl opt">,</span> GLdouble v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EvalCoord2d<span class="hl opt">, (</span>u<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEvalCoord2d(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> u<span class="hl opt">,</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EvalCoord2dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> u<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EvalCoord2dv<span class="hl opt">, (</span>u<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEvalCoord2dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> u<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EvalCoord2f<span class="hl opt">)(</span>GLfloat u<span class="hl opt">,</span> GLfloat v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EvalCoord2f<span class="hl opt">, (</span>u<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEvalCoord2f(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> u<span class="hl opt">,</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EvalCoord2fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> u<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EvalCoord2fv<span class="hl opt">, (</span>u<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEvalCoord2fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> u<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EvalMesh1<span class="hl opt">)(</span>GLenum mode<span class="hl opt">,</span> GLint i1<span class="hl opt">,</span> GLint i2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EvalMesh1<span class="hl opt">, (</span>mode<span class="hl opt">,</span> i1<span class="hl opt">,</span> i2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEvalMesh1(0x%x, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">,</span> i1<span class="hl opt">,</span> i2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EvalPoint1<span class="hl opt">)(</span>GLint i<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EvalPoint1<span class="hl opt">, (</span>i<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEvalPoint1(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> i<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EvalMesh2<span class="hl opt">)(</span>GLenum mode<span class="hl opt">,</span> GLint i1<span class="hl opt">,</span> GLint i2<span class="hl opt">,</span> GLint j1<span class="hl opt">,</span> GLint j2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EvalMesh2<span class="hl opt">, (</span>mode<span class="hl opt">,</span> i1<span class="hl opt">,</span> i2<span class="hl opt">,</span> j1<span class="hl opt">,</span> j2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEvalMesh2(0x%x, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">,</span> i1<span class="hl opt">,</span> i2<span class="hl opt">,</span> j1<span class="hl opt">,</span> j2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EvalPoint2<span class="hl opt">)(</span>GLint i<span class="hl opt">,</span> GLint j<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EvalPoint2<span class="hl opt">, (</span>i<span class="hl opt">,</span> j<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEvalPoint2(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> i<span class="hl opt">,</span> j<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>AlphaFunc<span class="hl opt">)(</span>GLenum func<span class="hl opt">,</span> GLclampf ref<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>AlphaFunc<span class="hl opt">, (</span>func<span class="hl opt">,</span> ref<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glAlphaFunc(0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> func<span class="hl opt">,</span> ref<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BlendFunc<span class="hl opt">)(</span>GLenum sfactor<span class="hl opt">,</span> GLenum dfactor<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BlendFunc<span class="hl opt">, (</span>sfactor<span class="hl opt">,</span> dfactor<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBlendFunc(0x%x, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> sfactor<span class="hl opt">,</span> dfactor<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LogicOp<span class="hl opt">)(</span>GLenum opcode<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LogicOp<span class="hl opt">, (</span>opcode<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLogicOp(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> opcode<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>StencilFunc<span class="hl opt">)(</span>GLenum func<span class="hl opt">,</span> GLint ref<span class="hl opt">,</span> GLuint mask<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>StencilFunc<span class="hl opt">, (</span>func<span class="hl opt">,</span> ref<span class="hl opt">,</span> mask<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glStencilFunc(0x%x, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> func<span class="hl opt">,</span> ref<span class="hl opt">,</span> mask<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>StencilOp<span class="hl opt">)(</span>GLenum fail<span class="hl opt">,</span> GLenum zfail<span class="hl opt">,</span> GLenum zpass<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>StencilOp<span class="hl opt">, (</span>fail<span class="hl opt">,</span> zfail<span class="hl opt">,</span> zpass<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glStencilOp(0x%x, 0x%x, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> fail<span class="hl opt">,</span> zfail<span class="hl opt">,</span> zpass<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DepthFunc<span class="hl opt">)(</span>GLenum func<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DepthFunc<span class="hl opt">, (</span>func<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDepthFunc(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> func<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PixelZoom<span class="hl opt">)(</span>GLfloat xfactor<span class="hl opt">,</span> GLfloat yfactor<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PixelZoom<span class="hl opt">, (</span>xfactor<span class="hl opt">,</span> yfactor<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPixelZoom(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> xfactor<span class="hl opt">,</span> yfactor<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PixelTransferf<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PixelTransferf<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPixelTransferf(0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PixelTransferi<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLint param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PixelTransferi<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPixelTransferi(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PixelStoref<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PixelStoref<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPixelStoref(0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PixelStorei<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLint param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PixelStorei<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPixelStorei(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PixelMapfv<span class="hl opt">)(</span>GLenum map<span class="hl opt">,</span> GLsizei mapsize<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> values<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PixelMapfv<span class="hl opt">, (</span>map<span class="hl opt">,</span> mapsize<span class="hl opt">,</span> values<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPixelMapfv(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> map<span class="hl opt">,</span> mapsize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> values<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PixelMapuiv<span class="hl opt">)(</span>GLenum map<span class="hl opt">,</span> GLsizei mapsize<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> values<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PixelMapuiv<span class="hl opt">, (</span>map<span class="hl opt">,</span> mapsize<span class="hl opt">,</span> values<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPixelMapuiv(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> map<span class="hl opt">,</span> mapsize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> values<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PixelMapusv<span class="hl opt">)(</span>GLenum map<span class="hl opt">,</span> GLsizei mapsize<span class="hl opt">,</span> <span class="hl kwb">const</span> GLushort <span class="hl opt">*</span> values<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PixelMapusv<span class="hl opt">, (</span>map<span class="hl opt">,</span> mapsize<span class="hl opt">,</span> values<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPixelMapusv(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> map<span class="hl opt">,</span> mapsize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> values<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ReadBuffer<span class="hl opt">)(</span>GLenum mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ReadBuffer<span class="hl opt">, (</span>mode<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glReadBuffer(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CopyPixels<span class="hl opt">)(</span>GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLenum type<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyPixels<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> type<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyPixels(%d, %d, %d, %d, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> type<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ReadPixels<span class="hl opt">)(</span>GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> pixels<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ReadPixels<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> pixels<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glReadPixels(%d, %d, %d, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pixels<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DrawPixels<span class="hl opt">)(</span>GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pixels<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DrawPixels<span class="hl opt">, (</span>width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> pixels<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDrawPixels(%d, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pixels<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetBooleanv<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLboolean <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetBooleanv<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetBooleanv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetClipPlane<span class="hl opt">)(</span>GLenum plane<span class="hl opt">,</span> GLdouble <span class="hl opt">*</span> equation<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetClipPlane<span class="hl opt">, (</span>plane<span class="hl opt">,</span> equation<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetClipPlane(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> plane<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> equation<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetDoublev<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLdouble <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetDoublev<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetDoublev(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLenum KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetError<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>GetError<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetError();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetFloatv<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetFloatv<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetFloatv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetIntegerv<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetIntegerv<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetIntegerv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetLightfv<span class="hl opt">)(</span>GLenum light<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetLightfv<span class="hl opt">, (</span>light<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetLightfv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> light<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetLightiv<span class="hl opt">)(</span>GLenum light<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetLightiv<span class="hl opt">, (</span>light<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetLightiv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> light<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetMapdv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum query<span class="hl opt">,</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetMapdv<span class="hl opt">, (</span>target<span class="hl opt">,</span> query<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetMapdv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> query<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetMapfv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum query<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetMapfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> query<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetMapfv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> query<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetMapiv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum query<span class="hl opt">,</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetMapiv<span class="hl opt">, (</span>target<span class="hl opt">,</span> query<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetMapiv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> query<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetMaterialfv<span class="hl opt">)(</span>GLenum face<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetMaterialfv<span class="hl opt">, (</span>face<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetMaterialfv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> face<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetMaterialiv<span class="hl opt">)(</span>GLenum face<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetMaterialiv<span class="hl opt">, (</span>face<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetMaterialiv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> face<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetPixelMapfv<span class="hl opt">)(</span>GLenum map<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> values<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetPixelMapfv<span class="hl opt">, (</span>map<span class="hl opt">,</span> values<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetPixelMapfv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> map<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> values<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetPixelMapuiv<span class="hl opt">)(</span>GLenum map<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> values<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetPixelMapuiv<span class="hl opt">, (</span>map<span class="hl opt">,</span> values<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetPixelMapuiv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> map<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> values<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetPixelMapusv<span class="hl opt">)(</span>GLenum map<span class="hl opt">,</span> GLushort <span class="hl opt">*</span> values<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetPixelMapusv<span class="hl opt">, (</span>map<span class="hl opt">,</span> values<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetPixelMapusv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> map<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> values<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetPolygonStipple<span class="hl opt">)(</span>GLubyte <span class="hl opt">*</span> mask<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetPolygonStipple<span class="hl opt">, (</span>mask<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetPolygonStipple(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> mask<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetString<span class="hl opt">)(</span>GLenum name<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>GetString<span class="hl opt">, (</span>name<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetString(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> name<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetTexEnvfv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetTexEnvfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetTexEnvfv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetTexEnviv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetTexEnviv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetTexEnviv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetTexGendv<span class="hl opt">)(</span>GLenum coord<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLdouble <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetTexGendv<span class="hl opt">, (</span>coord<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetTexGendv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> coord<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetTexGenfv<span class="hl opt">)(</span>GLenum coord<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetTexGenfv<span class="hl opt">, (</span>coord<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetTexGenfv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> coord<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetTexGeniv<span class="hl opt">)(</span>GLenum coord<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetTexGeniv<span class="hl opt">, (</span>coord<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetTexGeniv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> coord<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetTexImage<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> pixels<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetTexImage<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> pixels<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetTexImage(0x%x, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pixels<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetTexParameterfv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetTexParameterfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetTexParameterfv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetTexParameteriv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetTexParameteriv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetTexParameteriv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetTexLevelParameterfv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetTexLevelParameterfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetTexLevelParameterfv(0x%x, %d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetTexLevelParameteriv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetTexLevelParameteriv<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetTexLevelParameteriv(0x%x, %d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsEnabled<span class="hl opt">)(</span>GLenum cap<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsEnabled<span class="hl opt">, (</span>cap<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsEnabled(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> cap<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsList<span class="hl opt">)(</span>GLuint list<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsList<span class="hl opt">, (</span>list<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsList(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> list<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DepthRange<span class="hl opt">)(</span>GLclampd zNear<span class="hl opt">,</span> GLclampd zFar<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DepthRange<span class="hl opt">, (</span>zNear<span class="hl opt">,</span> zFar<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDepthRange(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> zNear<span class="hl opt">,</span> zFar<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Frustum<span class="hl opt">)(</span>GLdouble left<span class="hl opt">,</span> GLdouble right<span class="hl opt">,</span> GLdouble bottom<span class="hl opt">,</span> GLdouble top<span class="hl opt">,</span> GLdouble zNear<span class="hl opt">,</span> GLdouble zFar<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Frustum<span class="hl opt">, (</span>left<span class="hl opt">,</span> right<span class="hl opt">,</span> bottom<span class="hl opt">,</span> top<span class="hl opt">,</span> zNear<span class="hl opt">,</span> zFar<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFrustum(%f, %f, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> left<span class="hl opt">,</span> right<span class="hl opt">,</span> bottom<span class="hl opt">,</span> top<span class="hl opt">,</span> zNear<span class="hl opt">,</span> zFar<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LoadIdentity<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LoadIdentity<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLoadIdentity();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LoadMatrixf<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> m<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LoadMatrixf<span class="hl opt">, (</span>m<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLoadMatrixf(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> m<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LoadMatrixd<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> m<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LoadMatrixd<span class="hl opt">, (</span>m<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLoadMatrixd(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> m<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MatrixMode<span class="hl opt">)(</span>GLenum mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MatrixMode<span class="hl opt">, (</span>mode<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMatrixMode(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultMatrixf<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> m<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultMatrixf<span class="hl opt">, (</span>m<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultMatrixf(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> m<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultMatrixd<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> m<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultMatrixd<span class="hl opt">, (</span>m<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultMatrixd(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> m<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Ortho<span class="hl opt">)(</span>GLdouble left<span class="hl opt">,</span> GLdouble right<span class="hl opt">,</span> GLdouble bottom<span class="hl opt">,</span> GLdouble top<span class="hl opt">,</span> GLdouble zNear<span class="hl opt">,</span> GLdouble zFar<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Ortho<span class="hl opt">, (</span>left<span class="hl opt">,</span> right<span class="hl opt">,</span> bottom<span class="hl opt">,</span> top<span class="hl opt">,</span> zNear<span class="hl opt">,</span> zFar<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glOrtho(%f, %f, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> left<span class="hl opt">,</span> right<span class="hl opt">,</span> bottom<span class="hl opt">,</span> top<span class="hl opt">,</span> zNear<span class="hl opt">,</span> zFar<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PopMatrix<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PopMatrix<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPopMatrix();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PushMatrix<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PushMatrix<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPushMatrix();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Rotated<span class="hl opt">)(</span>GLdouble angle<span class="hl opt">,</span> GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Rotated<span class="hl opt">, (</span>angle<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRotated(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> angle<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Rotatef<span class="hl opt">)(</span>GLfloat angle<span class="hl opt">,</span> GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Rotatef<span class="hl opt">, (</span>angle<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRotatef(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> angle<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Scaled<span class="hl opt">)(</span>GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Scaled<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glScaled(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Scalef<span class="hl opt">)(</span>GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Scalef<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glScalef(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Translated<span class="hl opt">)(</span>GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Translated<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTranslated(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Translatef<span class="hl opt">)(</span>GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Translatef<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTranslatef(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Viewport<span class="hl opt">)(</span>GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Viewport<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glViewport(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ArrayElement<span class="hl opt">)(</span>GLint i<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ArrayElement<span class="hl opt">, (</span>i<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glArrayElement(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> i<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ArrayElementEXT<span class="hl opt">)(</span>GLint i<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ArrayElement<span class="hl opt">, (</span>i<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glArrayElementEXT(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> i<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BindTexture<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint texture<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BindTexture<span class="hl opt">, (</span>target<span class="hl opt">,</span> texture<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBindTexture(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> texture<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BindTextureEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint texture<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BindTexture<span class="hl opt">, (</span>target<span class="hl opt">,</span> texture<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBindTextureEXT(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> texture<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ColorPointer<span class="hl opt">)(</span>GLint size<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ColorPointer<span class="hl opt">, (</span>size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColorPointer(%d, 0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DisableClientState<span class="hl opt">)(</span>GLenum array<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DisableClientState<span class="hl opt">, (</span>array<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDisableClientState(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> array<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DrawArrays<span class="hl opt">)(</span>GLenum mode<span class="hl opt">,</span> GLint first<span class="hl opt">,</span> GLsizei count<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DrawArrays<span class="hl opt">, (</span>mode<span class="hl opt">,</span> first<span class="hl opt">,</span> count<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDrawArrays(0x%x, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">,</span> first<span class="hl opt">,</span> count<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DrawArraysEXT<span class="hl opt">)(</span>GLenum mode<span class="hl opt">,</span> GLint first<span class="hl opt">,</span> GLsizei count<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DrawArrays<span class="hl opt">, (</span>mode<span class="hl opt">,</span> first<span class="hl opt">,</span> count<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDrawArraysEXT(0x%x, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">,</span> first<span class="hl opt">,</span> count<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DrawElements<span class="hl opt">)(</span>GLenum mode<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> indices<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DrawElements<span class="hl opt">, (</span>mode<span class="hl opt">,</span> count<span class="hl opt">,</span> type<span class="hl opt">,</span> indices<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDrawElements(0x%x, %d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">,</span> count<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> indices<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EdgeFlagPointer<span class="hl opt">)(</span>GLsizei stride<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EdgeFlagPointer<span class="hl opt">, (</span>stride<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEdgeFlagPointer(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> stride<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EnableClientState<span class="hl opt">)(</span>GLenum array<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EnableClientState<span class="hl opt">, (</span>array<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEnableClientState(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> array<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IndexPointer<span class="hl opt">)(</span>GLenum type<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>IndexPointer<span class="hl opt">, (</span>type<span class="hl opt">,</span> stride<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIndexPointer(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Indexub<span class="hl opt">)(</span>GLubyte c<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Indexub<span class="hl opt">, (</span>c<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIndexub(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> c<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Indexubv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> c<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Indexubv<span class="hl opt">, (</span>c<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIndexubv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> c<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>InterleavedArrays<span class="hl opt">)(</span>GLenum format<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>InterleavedArrays<span class="hl opt">, (</span>format<span class="hl opt">,</span> stride<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glInterleavedArrays(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> format<span class="hl opt">,</span> stride<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>NormalPointer<span class="hl opt">)(</span>GLenum type<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>NormalPointer<span class="hl opt">, (</span>type<span class="hl opt">,</span> stride<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glNormalPointer(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PolygonOffset<span class="hl opt">)(</span>GLfloat factor<span class="hl opt">,</span> GLfloat units<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PolygonOffset<span class="hl opt">, (</span>factor<span class="hl opt">,</span> units<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPolygonOffset(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> factor<span class="hl opt">,</span> units<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoordPointer<span class="hl opt">)(</span>GLint size<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoordPointer<span class="hl opt">, (</span>size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoordPointer(%d, 0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexPointer<span class="hl opt">)(</span>GLint size<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexPointer<span class="hl opt">, (</span>size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexPointer(%d, 0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>AreTexturesResident<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> textures<span class="hl opt">,</span> GLboolean <span class="hl opt">*</span> residences<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>AreTexturesResident<span class="hl opt">, (</span>n<span class="hl opt">,</span> textures<span class="hl opt">,</span> residences<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glAreTexturesResident(%d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> textures<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> residences<span class="hl opt">));</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>AreTexturesResidentEXT<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> textures<span class="hl opt">,</span> GLboolean <span class="hl opt">*</span> residences<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>AreTexturesResident<span class="hl opt">, (</span>n<span class="hl opt">,</span> textures<span class="hl opt">,</span> residences<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glAreTexturesResidentEXT(%d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> textures<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> residences<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CopyTexImage1D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLint border<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyTexImage1D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> border<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyTexImage1D(0x%x, %d, 0x%x, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> border<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CopyTexImage1DEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLint border<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyTexImage1D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> border<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyTexImage1DEXT(0x%x, %d, 0x%x, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> border<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CopyTexImage2D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLint border<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyTexImage2D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> border<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyTexImage2D(0x%x, %d, 0x%x, %d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> border<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CopyTexImage2DEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLint border<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyTexImage2D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> border<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyTexImage2DEXT(0x%x, %d, 0x%x, %d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> border<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CopyTexSubImage1D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyTexSubImage1D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyTexSubImage1D(0x%x, %d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CopyTexSubImage1DEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyTexSubImage1D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyTexSubImage1DEXT(0x%x, %d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CopyTexSubImage2D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLint yoffset<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyTexSubImage2D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyTexSubImage2D(0x%x, %d, %d, %d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CopyTexSubImage2DEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLint yoffset<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyTexSubImage2D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyTexSubImage2DEXT(0x%x, %d, %d, %d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteTextures<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> textures<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteTextures<span class="hl opt">, (</span>n<span class="hl opt">,</span> textures<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteTextures(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> textures<span class="hl opt">));</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteTexturesEXT<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> textures<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteTextures<span class="hl opt">, (</span>n<span class="hl opt">,</span> textures<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteTexturesEXT(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> textures<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GenTextures<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> textures<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GenTextures<span class="hl opt">, (</span>n<span class="hl opt">,</span> textures<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenTextures(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> textures<span class="hl opt">));</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GenTexturesEXT<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> textures<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GenTextures<span class="hl opt">, (</span>n<span class="hl opt">,</span> textures<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenTexturesEXT(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> textures<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetPointerv<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLvoid <span class="hl opt">**</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetPointerv<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetPointerv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetPointervEXT<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLvoid <span class="hl opt">**</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetPointerv<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetPointervEXT(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsTexture<span class="hl opt">)(</span>GLuint texture<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsTexture<span class="hl opt">, (</span>texture<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsTexture(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> texture<span class="hl opt">));</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsTextureEXT<span class="hl opt">)(</span>GLuint texture<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsTexture<span class="hl opt">, (</span>texture<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsTextureEXT(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> texture<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PrioritizeTextures<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> textures<span class="hl opt">,</span> <span class="hl kwb">const</span> GLclampf <span class="hl opt">*</span> priorities<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PrioritizeTextures<span class="hl opt">, (</span>n<span class="hl opt">,</span> textures<span class="hl opt">,</span> priorities<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPrioritizeTextures(%d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> textures<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> priorities<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PrioritizeTexturesEXT<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> textures<span class="hl opt">,</span> <span class="hl kwb">const</span> GLclampf <span class="hl opt">*</span> priorities<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PrioritizeTextures<span class="hl opt">, (</span>n<span class="hl opt">,</span> textures<span class="hl opt">,</span> priorities<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPrioritizeTexturesEXT(%d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> textures<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> priorities<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexSubImage1D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pixels<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexSubImage1D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> pixels<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexSubImage1D(0x%x, %d, %d, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pixels<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexSubImage1DEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pixels<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexSubImage1D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> pixels<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexSubImage1DEXT(0x%x, %d, %d, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pixels<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexSubImage2D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLint yoffset<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pixels<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexSubImage2D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> pixels<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexSubImage2D(0x%x, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pixels<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexSubImage2DEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLint yoffset<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pixels<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexSubImage2D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> pixels<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexSubImage2DEXT(0x%x, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pixels<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PopClientAttrib<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PopClientAttrib<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPopClientAttrib();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PushClientAttrib<span class="hl opt">)(</span>GLbitfield mask<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PushClientAttrib<span class="hl opt">, (</span>mask<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPushClientAttrib(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mask<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BlendColor<span class="hl opt">)(</span>GLclampf red<span class="hl opt">,</span> GLclampf green<span class="hl opt">,</span> GLclampf blue<span class="hl opt">,</span> GLclampf alpha<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BlendColor<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBlendColor(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BlendColorEXT<span class="hl opt">)(</span>GLclampf red<span class="hl opt">,</span> GLclampf green<span class="hl opt">,</span> GLclampf blue<span class="hl opt">,</span> GLclampf alpha<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BlendColor<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBlendColorEXT(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">,</span> alpha<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BlendEquation<span class="hl opt">)(</span>GLenum mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BlendEquation<span class="hl opt">, (</span>mode<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBlendEquation(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BlendEquationEXT<span class="hl opt">)(</span>GLenum mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BlendEquation<span class="hl opt">, (</span>mode<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBlendEquationEXT(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DrawRangeElements<span class="hl opt">)(</span>GLenum mode<span class="hl opt">,</span> GLuint start<span class="hl opt">,</span> GLuint end<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> indices<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DrawRangeElements<span class="hl opt">, (</span>mode<span class="hl opt">,</span> start<span class="hl opt">,</span> end<span class="hl opt">,</span> count<span class="hl opt">,</span> type<span class="hl opt">,</span> indices<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDrawRangeElements(0x%x, %d, %d, %d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">,</span> start<span class="hl opt">,</span> end<span class="hl opt">,</span> count<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> indices<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DrawRangeElementsEXT<span class="hl opt">)(</span>GLenum mode<span class="hl opt">,</span> GLuint start<span class="hl opt">,</span> GLuint end<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> indices<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DrawRangeElements<span class="hl opt">, (</span>mode<span class="hl opt">,</span> start<span class="hl opt">,</span> end<span class="hl opt">,</span> count<span class="hl opt">,</span> type<span class="hl opt">,</span> indices<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDrawRangeElementsEXT(0x%x, %d, %d, %d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">,</span> start<span class="hl opt">,</span> end<span class="hl opt">,</span> count<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> indices<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ColorTable<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> table<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ColorTable<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> table<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColorTable(0x%x, 0x%x, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> table<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_339<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> table<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_339<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> table<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ColorTable<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> table<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColorTableSGI(0x%x, 0x%x, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> table<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ColorTableEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> table<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ColorTable<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> table<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColorTableEXT(0x%x, 0x%x, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> table<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ColorTableParameterfv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ColorTableParameterfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColorTableParameterfv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_340<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_340<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ColorTableParameterfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColorTableParameterfvSGI(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ColorTableParameteriv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ColorTableParameteriv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColorTableParameteriv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_341<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_341<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ColorTableParameteriv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColorTableParameterivSGI(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CopyColorTable<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyColorTable<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyColorTable(0x%x, 0x%x, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_342<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_342<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyColorTable<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyColorTableSGI(0x%x, 0x%x, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetColorTable<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> table<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetColorTable<span class="hl opt">, (</span>target<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> table<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetColorTable(0x%x, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> table<span class="hl opt">));</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_343<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> table<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_343<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> table<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetColorTable<span class="hl opt">, (</span>target<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> table<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetColorTableSGI(0x%x, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> table<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetColorTableEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> table<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetColorTable<span class="hl opt">, (</span>target<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> table<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetColorTableEXT(0x%x, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> table<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetColorTableParameterfv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetColorTableParameterfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetColorTableParameterfv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_344<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_344<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetColorTableParameterfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetColorTableParameterfvSGI(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetColorTableParameterfvEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetColorTableParameterfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetColorTableParameterfvEXT(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetColorTableParameteriv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetColorTableParameteriv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetColorTableParameteriv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_345<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_345<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetColorTableParameteriv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetColorTableParameterivSGI(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetColorTableParameterivEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetColorTableParameteriv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetColorTableParameterivEXT(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ColorSubTable<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLsizei start<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ColorSubTable<span class="hl opt">, (</span>target<span class="hl opt">,</span> start<span class="hl opt">,</span> count<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColorSubTable(0x%x, %d, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> start<span class="hl opt">,</span> count<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_346<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLsizei start<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_346<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLsizei start<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ColorSubTable<span class="hl opt">, (</span>target<span class="hl opt">,</span> start<span class="hl opt">,</span> count<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColorSubTableEXT(0x%x, %d, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> start<span class="hl opt">,</span> count<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CopyColorSubTable<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLsizei start<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyColorSubTable<span class="hl opt">, (</span>target<span class="hl opt">,</span> start<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyColorSubTable(0x%x, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> start<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_347<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLsizei start<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_347<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLsizei start<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyColorSubTable<span class="hl opt">, (</span>target<span class="hl opt">,</span> start<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyColorSubTableEXT(0x%x, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> start<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ConvolutionFilter1D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> image<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ConvolutionFilter1D<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> image<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glConvolutionFilter1D(0x%x, 0x%x, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> image<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_348<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> image<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_348<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> image<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ConvolutionFilter1D<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> image<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glConvolutionFilter1DEXT(0x%x, 0x%x, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> image<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ConvolutionFilter2D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> image<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ConvolutionFilter2D<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> image<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glConvolutionFilter2D(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> image<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_349<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> image<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_349<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> image<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ConvolutionFilter2D<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> image<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glConvolutionFilter2DEXT(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> image<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ConvolutionParameterf<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ConvolutionParameterf<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glConvolutionParameterf(0x%x, 0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_350<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_350<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ConvolutionParameterf<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glConvolutionParameterfEXT(0x%x, 0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ConvolutionParameterfv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ConvolutionParameterfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glConvolutionParameterfv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_351<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_351<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ConvolutionParameterfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glConvolutionParameterfvEXT(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ConvolutionParameteri<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ConvolutionParameteri<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glConvolutionParameteri(0x%x, 0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_352<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_352<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ConvolutionParameteri<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glConvolutionParameteriEXT(0x%x, 0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ConvolutionParameteriv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ConvolutionParameteriv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glConvolutionParameteriv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_353<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_353<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ConvolutionParameteriv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glConvolutionParameterivEXT(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CopyConvolutionFilter1D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyConvolutionFilter1D<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyConvolutionFilter1D(0x%x, 0x%x, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_354<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_354<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyConvolutionFilter1D<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyConvolutionFilter1DEXT(0x%x, 0x%x, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CopyConvolutionFilter2D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyConvolutionFilter2D<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyConvolutionFilter2D(0x%x, 0x%x, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_355<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_355<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyConvolutionFilter2D<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyConvolutionFilter2DEXT(0x%x, 0x%x, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetConvolutionFilter<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> image<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetConvolutionFilter<span class="hl opt">, (</span>target<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> image<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetConvolutionFilter(0x%x, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> image<span class="hl opt">));</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_356<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> image<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_356<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> image<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetConvolutionFilter<span class="hl opt">, (</span>target<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> image<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetConvolutionFilterEXT(0x%x, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> image<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetConvolutionParameterfv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetConvolutionParameterfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetConvolutionParameterfv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_357<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_357<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetConvolutionParameterfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetConvolutionParameterfvEXT(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetConvolutionParameteriv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetConvolutionParameteriv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetConvolutionParameteriv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_358<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_358<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetConvolutionParameteriv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetConvolutionParameterivEXT(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetSeparableFilter<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> row<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> column<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> span<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetSeparableFilter<span class="hl opt">, (</span>target<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> row<span class="hl opt">,</span> column<span class="hl opt">,</span> span<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetSeparableFilter(0x%x, 0x%x, 0x%x, %p, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> row<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> column<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> span<span class="hl opt">));</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_359<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> row<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> column<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> span<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_359<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> row<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> column<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> span<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetSeparableFilter<span class="hl opt">, (</span>target<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> row<span class="hl opt">,</span> column<span class="hl opt">,</span> span<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetSeparableFilterEXT(0x%x, 0x%x, 0x%x, %p, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> row<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> column<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> span<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SeparableFilter2D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> row<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> column<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SeparableFilter2D<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> row<span class="hl opt">,</span> column<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSeparableFilter2D(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> row<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> column<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_360<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> row<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> column<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_360<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> row<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> column<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SeparableFilter2D<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> row<span class="hl opt">,</span> column<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSeparableFilter2DEXT(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> row<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> column<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetHistogram<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLboolean reset<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> values<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetHistogram<span class="hl opt">, (</span>target<span class="hl opt">,</span> reset<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> values<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetHistogram(0x%x, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> reset<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> values<span class="hl opt">));</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_361<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLboolean reset<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> values<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_361<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLboolean reset<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> values<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetHistogram<span class="hl opt">, (</span>target<span class="hl opt">,</span> reset<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> values<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetHistogramEXT(0x%x, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> reset<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> values<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetHistogramParameterfv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetHistogramParameterfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetHistogramParameterfv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_362<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_362<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetHistogramParameterfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetHistogramParameterfvEXT(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetHistogramParameteriv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetHistogramParameteriv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetHistogramParameteriv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_363<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_363<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetHistogramParameteriv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetHistogramParameterivEXT(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetMinmax<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLboolean reset<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> values<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetMinmax<span class="hl opt">, (</span>target<span class="hl opt">,</span> reset<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> values<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetMinmax(0x%x, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> reset<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> values<span class="hl opt">));</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_364<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLboolean reset<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> values<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_364<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLboolean reset<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> values<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetMinmax<span class="hl opt">, (</span>target<span class="hl opt">,</span> reset<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> values<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetMinmaxEXT(0x%x, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> reset<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> values<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetMinmaxParameterfv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetMinmaxParameterfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetMinmaxParameterfv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_365<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_365<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetMinmaxParameterfv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetMinmaxParameterfvEXT(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetMinmaxParameteriv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetMinmaxParameteriv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetMinmaxParameteriv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

<span class="hl ppc">#ifndef GLX_INDIRECT_RENDERING</span>
KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_366<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_366<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetMinmaxParameteriv<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetMinmaxParameterivEXT(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>
<span class="hl ppc">#endif</span> <span class="hl com">/* GLX_INDIRECT_RENDERING */</span><span class="hl ppc"></span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Histogram<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLboolean sink<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Histogram<span class="hl opt">, (</span>target<span class="hl opt">,</span> width<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> sink<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glHistogram(0x%x, %d, 0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> width<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> sink<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_367<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLboolean sink<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_367<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLboolean sink<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Histogram<span class="hl opt">, (</span>target<span class="hl opt">,</span> width<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> sink<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glHistogramEXT(0x%x, %d, 0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> width<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> sink<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Minmax<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLboolean sink<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Minmax<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> sink<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMinmax(0x%x, 0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> sink<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_368<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLboolean sink<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_368<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLboolean sink<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Minmax<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> sink<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMinmaxEXT(0x%x, 0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> sink<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ResetHistogram<span class="hl opt">)(</span>GLenum target<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ResetHistogram<span class="hl opt">, (</span>target<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glResetHistogram(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_369<span class="hl opt">)(</span>GLenum target<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_369<span class="hl opt">)(</span>GLenum target<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ResetHistogram<span class="hl opt">, (</span>target<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glResetHistogramEXT(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ResetMinmax<span class="hl opt">)(</span>GLenum target<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ResetMinmax<span class="hl opt">, (</span>target<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glResetMinmax(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_370<span class="hl opt">)(</span>GLenum target<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_370<span class="hl opt">)(</span>GLenum target<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ResetMinmax<span class="hl opt">, (</span>target<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glResetMinmaxEXT(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexImage3D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLsizei depth<span class="hl opt">,</span> GLint border<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pixels<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexImage3D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> depth<span class="hl opt">,</span> border<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> pixels<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexImage3D(0x%x, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> depth<span class="hl opt">,</span> border<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pixels<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexImage3DEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLsizei depth<span class="hl opt">,</span> GLint border<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pixels<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexImage3D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> depth<span class="hl opt">,</span> border<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> pixels<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexImage3DEXT(0x%x, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> depth<span class="hl opt">,</span> border<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pixels<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexSubImage3D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLint yoffset<span class="hl opt">,</span> GLint zoffset<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLsizei depth<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pixels<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexSubImage3D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> zoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> depth<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> pixels<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexSubImage3D(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> zoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> depth<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pixels<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexSubImage3DEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLint yoffset<span class="hl opt">,</span> GLint zoffset<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLsizei depth<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pixels<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexSubImage3D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> zoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> depth<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">,</span> pixels<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexSubImage3DEXT(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> zoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> depth<span class="hl opt">,</span> format<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pixels<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CopyTexSubImage3D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLint yoffset<span class="hl opt">,</span> GLint zoffset<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyTexSubImage3D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> zoffset<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyTexSubImage3D(0x%x, %d, %d, %d, %d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> zoffset<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CopyTexSubImage3DEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLint yoffset<span class="hl opt">,</span> GLint zoffset<span class="hl opt">,</span> GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyTexSubImage3D<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> zoffset<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyTexSubImage3DEXT(0x%x, %d, %d, %d, %d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> zoffset<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ActiveTexture<span class="hl opt">)(</span>GLenum texture<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ActiveTextureARB<span class="hl opt">, (</span>texture<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glActiveTexture(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> texture<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ActiveTextureARB<span class="hl opt">)(</span>GLenum texture<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ActiveTextureARB<span class="hl opt">, (</span>texture<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glActiveTextureARB(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> texture<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ClientActiveTexture<span class="hl opt">)(</span>GLenum texture<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ClientActiveTextureARB<span class="hl opt">, (</span>texture<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glClientActiveTexture(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> texture<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ClientActiveTextureARB<span class="hl opt">)(</span>GLenum texture<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ClientActiveTextureARB<span class="hl opt">, (</span>texture<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glClientActiveTextureARB(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> texture<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord1d<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLdouble s<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord1dARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord1d(0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord1dARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLdouble s<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord1dARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord1dARB(0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord1dv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord1dvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord1dv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord1dvARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord1dvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord1dvARB(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord1f<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLfloat s<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord1fARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord1f(0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord1fARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLfloat s<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord1fARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord1fARB(0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord1fv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord1fvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord1fv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord1fvARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord1fvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord1fvARB(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord1i<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint s<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord1iARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord1i(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord1iARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint s<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord1iARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord1iARB(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord1iv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord1ivARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord1iv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord1ivARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord1ivARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord1ivARB(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord1s<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLshort s<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord1sARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord1s(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord1sARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLshort s<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord1sARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord1sARB(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord1sv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord1svARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord1sv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord1svARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord1svARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord1svARB(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord2d<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLdouble s<span class="hl opt">,</span> GLdouble t<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord2dARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord2d(0x%x, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord2dARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLdouble s<span class="hl opt">,</span> GLdouble t<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord2dARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord2dARB(0x%x, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord2dv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord2dvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord2dv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord2dvARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord2dvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord2dvARB(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord2f<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLfloat s<span class="hl opt">,</span> GLfloat t<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord2fARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord2f(0x%x, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord2fARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLfloat s<span class="hl opt">,</span> GLfloat t<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord2fARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord2fARB(0x%x, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord2fv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord2fvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord2fv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord2fvARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord2fvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord2fvARB(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord2i<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint s<span class="hl opt">,</span> GLint t<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord2iARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord2i(0x%x, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord2iARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint s<span class="hl opt">,</span> GLint t<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord2iARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord2iARB(0x%x, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord2iv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord2ivARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord2iv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord2ivARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord2ivARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord2ivARB(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord2s<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLshort s<span class="hl opt">,</span> GLshort t<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord2sARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord2s(0x%x, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord2sARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLshort s<span class="hl opt">,</span> GLshort t<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord2sARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord2sARB(0x%x, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord2sv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord2svARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord2sv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord2svARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord2svARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord2svARB(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord3d<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLdouble s<span class="hl opt">,</span> GLdouble t<span class="hl opt">,</span> GLdouble r<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord3dARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord3d(0x%x, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord3dARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLdouble s<span class="hl opt">,</span> GLdouble t<span class="hl opt">,</span> GLdouble r<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord3dARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord3dARB(0x%x, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord3dv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord3dvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord3dv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord3dvARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord3dvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord3dvARB(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord3f<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLfloat s<span class="hl opt">,</span> GLfloat t<span class="hl opt">,</span> GLfloat r<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord3fARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord3f(0x%x, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord3fARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLfloat s<span class="hl opt">,</span> GLfloat t<span class="hl opt">,</span> GLfloat r<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord3fARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord3fARB(0x%x, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord3fv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord3fvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord3fv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord3fvARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord3fvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord3fvARB(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord3i<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint s<span class="hl opt">,</span> GLint t<span class="hl opt">,</span> GLint r<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord3iARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord3i(0x%x, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord3iARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint s<span class="hl opt">,</span> GLint t<span class="hl opt">,</span> GLint r<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord3iARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord3iARB(0x%x, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord3iv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord3ivARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord3iv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord3ivARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord3ivARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord3ivARB(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord3s<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLshort s<span class="hl opt">,</span> GLshort t<span class="hl opt">,</span> GLshort r<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord3sARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord3s(0x%x, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord3sARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLshort s<span class="hl opt">,</span> GLshort t<span class="hl opt">,</span> GLshort r<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord3sARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord3sARB(0x%x, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord3sv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord3svARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord3sv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord3svARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord3svARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord3svARB(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord4d<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLdouble s<span class="hl opt">,</span> GLdouble t<span class="hl opt">,</span> GLdouble r<span class="hl opt">,</span> GLdouble q<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord4dARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord4d(0x%x, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord4dARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLdouble s<span class="hl opt">,</span> GLdouble t<span class="hl opt">,</span> GLdouble r<span class="hl opt">,</span> GLdouble q<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord4dARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord4dARB(0x%x, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord4dv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord4dvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord4dv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord4dvARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord4dvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord4dvARB(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord4f<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLfloat s<span class="hl opt">,</span> GLfloat t<span class="hl opt">,</span> GLfloat r<span class="hl opt">,</span> GLfloat q<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord4fARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord4f(0x%x, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord4fARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLfloat s<span class="hl opt">,</span> GLfloat t<span class="hl opt">,</span> GLfloat r<span class="hl opt">,</span> GLfloat q<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord4fARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord4fARB(0x%x, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord4fv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord4fvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord4fv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord4fvARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord4fvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord4fvARB(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord4i<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint s<span class="hl opt">,</span> GLint t<span class="hl opt">,</span> GLint r<span class="hl opt">,</span> GLint q<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord4iARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord4i(0x%x, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord4iARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint s<span class="hl opt">,</span> GLint t<span class="hl opt">,</span> GLint r<span class="hl opt">,</span> GLint q<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord4iARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord4iARB(0x%x, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord4iv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord4ivARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord4iv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord4ivARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord4ivARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord4ivARB(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord4s<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLshort s<span class="hl opt">,</span> GLshort t<span class="hl opt">,</span> GLshort r<span class="hl opt">,</span> GLshort q<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord4sARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord4s(0x%x, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord4sARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLshort s<span class="hl opt">,</span> GLshort t<span class="hl opt">,</span> GLshort r<span class="hl opt">,</span> GLshort q<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord4sARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord4sARB(0x%x, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> s<span class="hl opt">,</span> t<span class="hl opt">,</span> r<span class="hl opt">,</span> q<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord4sv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord4svARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord4sv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiTexCoord4svARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiTexCoord4svARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiTexCoord4svARB(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>AttachShader<span class="hl opt">)(</span>GLuint program<span class="hl opt">,</span> GLuint shader<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>AttachShader<span class="hl opt">, (</span>program<span class="hl opt">,</span> shader<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glAttachShader(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">,</span> shader<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLuint KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CreateProgram<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>CreateProgram<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCreateProgram();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLuint KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CreateShader<span class="hl opt">)(</span>GLenum type<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>CreateShader<span class="hl opt">, (</span>type<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCreateShader(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> type<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteProgram<span class="hl opt">)(</span>GLuint program<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteProgram<span class="hl opt">, (</span>program<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteProgram(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteShader<span class="hl opt">)(</span>GLuint program<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteShader<span class="hl opt">, (</span>program<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteShader(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DetachShader<span class="hl opt">)(</span>GLuint program<span class="hl opt">,</span> GLuint shader<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DetachShader<span class="hl opt">, (</span>program<span class="hl opt">,</span> shader<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDetachShader(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">,</span> shader<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetAttachedShaders<span class="hl opt">)(</span>GLuint program<span class="hl opt">,</span> GLsizei maxCount<span class="hl opt">,</span> GLsizei <span class="hl opt">*</span> count<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> obj<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetAttachedShaders<span class="hl opt">, (</span>program<span class="hl opt">,</span> maxCount<span class="hl opt">,</span> count<span class="hl opt">,</span> obj<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetAttachedShaders(%d, %d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">,</span> maxCount<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> obj<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetProgramInfoLog<span class="hl opt">)(</span>GLuint program<span class="hl opt">,</span> GLsizei bufSize<span class="hl opt">,</span> GLsizei <span class="hl opt">*</span> length<span class="hl opt">,</span> GLchar <span class="hl opt">*</span> infoLog<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetProgramInfoLog<span class="hl opt">, (</span>program<span class="hl opt">,</span> bufSize<span class="hl opt">,</span> length<span class="hl opt">,</span> infoLog<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetProgramInfoLog(%d, %d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">,</span> bufSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> length<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> infoLog<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetProgramiv<span class="hl opt">)(</span>GLuint program<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetProgramiv<span class="hl opt">, (</span>program<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetProgramiv(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetShaderInfoLog<span class="hl opt">)(</span>GLuint shader<span class="hl opt">,</span> GLsizei bufSize<span class="hl opt">,</span> GLsizei <span class="hl opt">*</span> length<span class="hl opt">,</span> GLchar <span class="hl opt">*</span> infoLog<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetShaderInfoLog<span class="hl opt">, (</span>shader<span class="hl opt">,</span> bufSize<span class="hl opt">,</span> length<span class="hl opt">,</span> infoLog<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetShaderInfoLog(%d, %d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> shader<span class="hl opt">,</span> bufSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> length<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> infoLog<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetShaderiv<span class="hl opt">)(</span>GLuint shader<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetShaderiv<span class="hl opt">, (</span>shader<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetShaderiv(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> shader<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsProgram<span class="hl opt">)(</span>GLuint program<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsProgram<span class="hl opt">, (</span>program<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsProgram(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsShader<span class="hl opt">)(</span>GLuint shader<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsShader<span class="hl opt">, (</span>shader<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsShader(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> shader<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>StencilFuncSeparate<span class="hl opt">)(</span>GLenum face<span class="hl opt">,</span> GLenum func<span class="hl opt">,</span> GLint ref<span class="hl opt">,</span> GLuint mask<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>StencilFuncSeparate<span class="hl opt">, (</span>face<span class="hl opt">,</span> func<span class="hl opt">,</span> ref<span class="hl opt">,</span> mask<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glStencilFuncSeparate(0x%x, 0x%x, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> face<span class="hl opt">,</span> func<span class="hl opt">,</span> ref<span class="hl opt">,</span> mask<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>StencilMaskSeparate<span class="hl opt">)(</span>GLenum face<span class="hl opt">,</span> GLuint mask<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>StencilMaskSeparate<span class="hl opt">, (</span>face<span class="hl opt">,</span> mask<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glStencilMaskSeparate(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> face<span class="hl opt">,</span> mask<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>StencilOpSeparate<span class="hl opt">)(</span>GLenum face<span class="hl opt">,</span> GLenum sfail<span class="hl opt">,</span> GLenum zfail<span class="hl opt">,</span> GLenum zpass<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>StencilOpSeparate<span class="hl opt">, (</span>face<span class="hl opt">,</span> sfail<span class="hl opt">,</span> zfail<span class="hl opt">,</span> zpass<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glStencilOpSeparate(0x%x, 0x%x, 0x%x, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> face<span class="hl opt">,</span> sfail<span class="hl opt">,</span> zfail<span class="hl opt">,</span> zpass<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_423<span class="hl opt">)(</span>GLenum face<span class="hl opt">,</span> GLenum sfail<span class="hl opt">,</span> GLenum zfail<span class="hl opt">,</span> GLenum zpass<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_423<span class="hl opt">)(</span>GLenum face<span class="hl opt">,</span> GLenum sfail<span class="hl opt">,</span> GLenum zfail<span class="hl opt">,</span> GLenum zpass<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>StencilOpSeparate<span class="hl opt">, (</span>face<span class="hl opt">,</span> sfail<span class="hl opt">,</span> zfail<span class="hl opt">,</span> zpass<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glStencilOpSeparateATI(0x%x, 0x%x, 0x%x, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> face<span class="hl opt">,</span> sfail<span class="hl opt">,</span> zfail<span class="hl opt">,</span> zpass<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>UniformMatrix2x3fv<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLboolean transpose<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>UniformMatrix2x3fv<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniformMatrix2x3fv(%d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>UniformMatrix2x4fv<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLboolean transpose<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>UniformMatrix2x4fv<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniformMatrix2x4fv(%d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>UniformMatrix3x2fv<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLboolean transpose<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>UniformMatrix3x2fv<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniformMatrix3x2fv(%d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>UniformMatrix3x4fv<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLboolean transpose<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>UniformMatrix3x4fv<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniformMatrix3x4fv(%d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>UniformMatrix4x2fv<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLboolean transpose<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>UniformMatrix4x2fv<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniformMatrix4x2fv(%d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>UniformMatrix4x3fv<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLboolean transpose<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>UniformMatrix4x3fv<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniformMatrix4x3fv(%d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LoadTransposeMatrixd<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> m<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LoadTransposeMatrixdARB<span class="hl opt">, (</span>m<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLoadTransposeMatrixd(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> m<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LoadTransposeMatrixdARB<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> m<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LoadTransposeMatrixdARB<span class="hl opt">, (</span>m<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLoadTransposeMatrixdARB(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> m<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LoadTransposeMatrixf<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> m<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LoadTransposeMatrixfARB<span class="hl opt">, (</span>m<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLoadTransposeMatrixf(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> m<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LoadTransposeMatrixfARB<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> m<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LoadTransposeMatrixfARB<span class="hl opt">, (</span>m<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLoadTransposeMatrixfARB(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> m<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultTransposeMatrixd<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> m<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultTransposeMatrixdARB<span class="hl opt">, (</span>m<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultTransposeMatrixd(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> m<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultTransposeMatrixdARB<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> m<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultTransposeMatrixdARB<span class="hl opt">, (</span>m<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultTransposeMatrixdARB(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> m<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultTransposeMatrixf<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> m<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultTransposeMatrixfARB<span class="hl opt">, (</span>m<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultTransposeMatrixf(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> m<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultTransposeMatrixfARB<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> m<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultTransposeMatrixfARB<span class="hl opt">, (</span>m<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultTransposeMatrixfARB(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> m<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SampleCoverage<span class="hl opt">)(</span>GLclampf value<span class="hl opt">,</span> GLboolean invert<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SampleCoverageARB<span class="hl opt">, (</span>value<span class="hl opt">,</span> invert<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSampleCoverage(%f, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> value<span class="hl opt">,</span> invert<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SampleCoverageARB<span class="hl opt">)(</span>GLclampf value<span class="hl opt">,</span> GLboolean invert<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SampleCoverageARB<span class="hl opt">, (</span>value<span class="hl opt">,</span> invert<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSampleCoverageARB(%f, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> value<span class="hl opt">,</span> invert<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CompressedTexImage1D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLint border<span class="hl opt">,</span> GLsizei imageSize<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CompressedTexImage1DARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> border<span class="hl opt">,</span> imageSize<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCompressedTexImage1D(0x%x, %d, 0x%x, %d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> border<span class="hl opt">,</span> imageSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CompressedTexImage1DARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLint border<span class="hl opt">,</span> GLsizei imageSize<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CompressedTexImage1DARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> border<span class="hl opt">,</span> imageSize<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCompressedTexImage1DARB(0x%x, %d, 0x%x, %d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> border<span class="hl opt">,</span> imageSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CompressedTexImage2D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLint border<span class="hl opt">,</span> GLsizei imageSize<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CompressedTexImage2DARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> border<span class="hl opt">,</span> imageSize<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCompressedTexImage2D(0x%x, %d, 0x%x, %d, %d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> border<span class="hl opt">,</span> imageSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CompressedTexImage2DARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLint border<span class="hl opt">,</span> GLsizei imageSize<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CompressedTexImage2DARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> border<span class="hl opt">,</span> imageSize<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCompressedTexImage2DARB(0x%x, %d, 0x%x, %d, %d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> border<span class="hl opt">,</span> imageSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CompressedTexImage3D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLsizei depth<span class="hl opt">,</span> GLint border<span class="hl opt">,</span> GLsizei imageSize<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CompressedTexImage3DARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> depth<span class="hl opt">,</span> border<span class="hl opt">,</span> imageSize<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCompressedTexImage3D(0x%x, %d, 0x%x, %d, %d, %d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> depth<span class="hl opt">,</span> border<span class="hl opt">,</span> imageSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CompressedTexImage3DARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLsizei depth<span class="hl opt">,</span> GLint border<span class="hl opt">,</span> GLsizei imageSize<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CompressedTexImage3DARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> depth<span class="hl opt">,</span> border<span class="hl opt">,</span> imageSize<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCompressedTexImage3DARB(0x%x, %d, 0x%x, %d, %d, %d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> depth<span class="hl opt">,</span> border<span class="hl opt">,</span> imageSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CompressedTexSubImage1D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLsizei imageSize<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CompressedTexSubImage1DARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> imageSize<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCompressedTexSubImage1D(0x%x, %d, %d, %d, 0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> imageSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CompressedTexSubImage1DARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLsizei imageSize<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CompressedTexSubImage1DARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> imageSize<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCompressedTexSubImage1DARB(0x%x, %d, %d, %d, 0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> format<span class="hl opt">,</span> imageSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CompressedTexSubImage2D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLint yoffset<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLsizei imageSize<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CompressedTexSubImage2DARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> imageSize<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCompressedTexSubImage2D(0x%x, %d, %d, %d, %d, %d, 0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> imageSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CompressedTexSubImage2DARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLint yoffset<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLsizei imageSize<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CompressedTexSubImage2DARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> imageSize<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCompressedTexSubImage2DARB(0x%x, %d, %d, %d, %d, %d, 0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> format<span class="hl opt">,</span> imageSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CompressedTexSubImage3D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLint yoffset<span class="hl opt">,</span> GLint zoffset<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLsizei depth<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLsizei imageSize<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CompressedTexSubImage3DARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> zoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> depth<span class="hl opt">,</span> format<span class="hl opt">,</span> imageSize<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCompressedTexSubImage3D(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> zoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> depth<span class="hl opt">,</span> format<span class="hl opt">,</span> imageSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CompressedTexSubImage3DARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint xoffset<span class="hl opt">,</span> GLint yoffset<span class="hl opt">,</span> GLint zoffset<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">,</span> GLsizei depth<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLsizei imageSize<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CompressedTexSubImage3DARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> zoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> depth<span class="hl opt">,</span> format<span class="hl opt">,</span> imageSize<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCompressedTexSubImage3DARB(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">,</span> xoffset<span class="hl opt">,</span> yoffset<span class="hl opt">,</span> zoffset<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">,</span> depth<span class="hl opt">,</span> format<span class="hl opt">,</span> imageSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetCompressedTexImage<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> img<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetCompressedTexImageARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> img<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetCompressedTexImage(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> img<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetCompressedTexImageARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> img<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetCompressedTexImageARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> level<span class="hl opt">,</span> img<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetCompressedTexImageARB(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> level<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> img<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DisableVertexAttribArray<span class="hl opt">)(</span>GLuint index<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DisableVertexAttribArrayARB<span class="hl opt">, (</span>index<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDisableVertexAttribArray(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DisableVertexAttribArrayARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DisableVertexAttribArrayARB<span class="hl opt">, (</span>index<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDisableVertexAttribArrayARB(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EnableVertexAttribArray<span class="hl opt">)(</span>GLuint index<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EnableVertexAttribArrayARB<span class="hl opt">, (</span>index<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEnableVertexAttribArray(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EnableVertexAttribArrayARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EnableVertexAttribArrayARB<span class="hl opt">, (</span>index<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEnableVertexAttribArrayARB(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetProgramEnvParameterdvARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLdouble <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetProgramEnvParameterdvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetProgramEnvParameterdvARB(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetProgramEnvParameterfvARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetProgramEnvParameterfvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetProgramEnvParameterfvARB(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetProgramLocalParameterdvARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLdouble <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetProgramLocalParameterdvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetProgramLocalParameterdvARB(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetProgramLocalParameterfvARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetProgramLocalParameterfvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetProgramLocalParameterfvARB(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetProgramStringARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> string<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetProgramStringARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> string<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetProgramStringARB(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> string<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetProgramivARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetProgramivARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetProgramivARB(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetVertexAttribdv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLdouble <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetVertexAttribdvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetVertexAttribdv(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetVertexAttribdvARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLdouble <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetVertexAttribdvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetVertexAttribdvARB(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetVertexAttribfv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetVertexAttribfvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetVertexAttribfv(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetVertexAttribfvARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetVertexAttribfvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetVertexAttribfvARB(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetVertexAttribiv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetVertexAttribivARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetVertexAttribiv(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetVertexAttribivARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetVertexAttribivARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetVertexAttribivARB(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramEnvParameter4dARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">,</span> GLdouble w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramEnvParameter4dARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramEnvParameter4dARB(0x%x, %d, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramParameter4dNV<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">,</span> GLdouble w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramEnvParameter4dARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramParameter4dNV(0x%x, %d, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramEnvParameter4dvARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramEnvParameter4dvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramEnvParameter4dvARB(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramParameter4dvNV<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramEnvParameter4dvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramParameter4dvNV(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramEnvParameter4fARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">,</span> GLfloat w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramEnvParameter4fARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramEnvParameter4fARB(0x%x, %d, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramParameter4fNV<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">,</span> GLfloat w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramEnvParameter4fARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramParameter4fNV(0x%x, %d, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramEnvParameter4fvARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramEnvParameter4fvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramEnvParameter4fvARB(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramParameter4fvNV<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramEnvParameter4fvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramParameter4fvNV(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramLocalParameter4dARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">,</span> GLdouble w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramLocalParameter4dARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramLocalParameter4dARB(0x%x, %d, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramLocalParameter4dvARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramLocalParameter4dvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramLocalParameter4dvARB(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramLocalParameter4fARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">,</span> GLfloat w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramLocalParameter4fARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramLocalParameter4fARB(0x%x, %d, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramLocalParameter4fvARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramLocalParameter4fvARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramLocalParameter4fvARB(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramStringARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum format<span class="hl opt">,</span> GLsizei len<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> string<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramStringARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> format<span class="hl opt">,</span> len<span class="hl opt">,</span> string<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramStringARB(0x%x, 0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> format<span class="hl opt">,</span> len<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> string<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1d<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLdouble x<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1dARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1d(%d, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1dARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLdouble x<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1dARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1dARB(%d, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1dv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1dvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1dv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1dvARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1dvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1dvARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1f<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLfloat x<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1fARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1f(%d, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1fARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLfloat x<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1fARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1fARB(%d, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1fv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1fvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1fv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1fvARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1fvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1fvARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1s<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLshort x<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1sARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1s(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1sARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLshort x<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1sARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1sARB(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1sv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1svARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1sv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1svARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1svARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1svARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2d<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2dARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2d(%d, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2dARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2dARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2dARB(%d, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2dv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2dvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2dv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2dvARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2dvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2dvARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2f<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2fARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2f(%d, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2fARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2fARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2fARB(%d, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2fv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2fvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2fv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2fvARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2fvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2fvARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2s<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2sARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2s(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2sARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2sARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2sARB(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2sv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2svARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2sv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2svARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2svARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2svARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3d<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3dARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3d(%d, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3dARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3dARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3dARB(%d, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3dv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3dvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3dv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3dvARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3dvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3dvARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3f<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3fARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3f(%d, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3fARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3fARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3fARB(%d, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3fv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3fvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3fv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3fvARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3fvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3fvARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3s<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">,</span> GLshort z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3sARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3s(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3sARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">,</span> GLshort z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3sARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3sARB(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3sv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3svARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3sv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3svARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3svARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3svARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4Nbv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLbyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4NbvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4Nbv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4NbvARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLbyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4NbvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4NbvARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4Niv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4NivARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4Niv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4NivARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4NivARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4NivARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4Nsv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4NsvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4Nsv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4NsvARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4NsvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4NsvARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4Nub<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLubyte x<span class="hl opt">,</span> GLubyte y<span class="hl opt">,</span> GLubyte z<span class="hl opt">,</span> GLubyte w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4NubARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4Nub(%d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4NubARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLubyte x<span class="hl opt">,</span> GLubyte y<span class="hl opt">,</span> GLubyte z<span class="hl opt">,</span> GLubyte w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4NubARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4NubARB(%d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4Nubv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4NubvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4Nubv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4NubvARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4NubvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4NubvARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4Nuiv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4NuivARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4Nuiv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4NuivARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4NuivARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4NuivARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4Nusv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLushort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4NusvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4Nusv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4NusvARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLushort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4NusvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4NusvARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4bv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLbyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4bvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4bv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4bvARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLbyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4bvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4bvARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4d<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">,</span> GLdouble w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4dARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4d(%d, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4dARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">,</span> GLdouble w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4dARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4dARB(%d, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4dv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4dvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4dv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4dvARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4dvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4dvARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4f<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">,</span> GLfloat w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4fARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4f(%d, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4fARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">,</span> GLfloat w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4fARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4fARB(%d, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4fv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4fvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4fv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4fvARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4fvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4fvARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4iv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4ivARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4iv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4ivARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4ivARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4ivARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4s<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">,</span> GLshort z<span class="hl opt">,</span> GLshort w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4sARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4s(%d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4sARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">,</span> GLshort z<span class="hl opt">,</span> GLshort w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4sARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4sARB(%d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4sv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4svARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4sv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4svARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4svARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4svARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4ubv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4ubvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4ubv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4ubvARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4ubvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4ubvARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4uiv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4uivARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4uiv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4uivARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4uivARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4uivARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4usv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLushort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4usvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4usv(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4usvARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLushort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4usvARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4usvARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttribPointer<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLint size<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLboolean normalized<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttribPointerARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> normalized<span class="hl opt">,</span> stride<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttribPointer(%d, %d, 0x%x, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> normalized<span class="hl opt">,</span> stride<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttribPointerARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLint size<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLboolean normalized<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttribPointerARB<span class="hl opt">, (</span>index<span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> normalized<span class="hl opt">,</span> stride<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttribPointerARB(%d, %d, 0x%x, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> normalized<span class="hl opt">,</span> stride<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BindBuffer<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint buffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BindBufferARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> buffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBindBuffer(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> buffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BindBufferARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint buffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BindBufferARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> buffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBindBufferARB(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> buffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BufferData<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLsizeiptr size<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">,</span> GLenum usage<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BufferDataARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> size<span class="hl opt">,</span> data<span class="hl opt">,</span> usage<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBufferData(0x%x, %d, %p, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> size<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">,</span> usage<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BufferDataARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLsizeiptrARB size<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">,</span> GLenum usage<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BufferDataARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> size<span class="hl opt">,</span> data<span class="hl opt">,</span> usage<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBufferDataARB(0x%x, %d, %p, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> size<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">,</span> usage<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BufferSubData<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLintptr offset<span class="hl opt">,</span> GLsizeiptr size<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BufferSubDataARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> offset<span class="hl opt">,</span> size<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBufferSubData(0x%x, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> offset<span class="hl opt">,</span> size<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BufferSubDataARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLintptrARB offset<span class="hl opt">,</span> GLsizeiptrARB size<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BufferSubDataARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> offset<span class="hl opt">,</span> size<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBufferSubDataARB(0x%x, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> offset<span class="hl opt">,</span> size<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteBuffers<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> buffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteBuffersARB<span class="hl opt">, (</span>n<span class="hl opt">,</span> buffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteBuffers(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> buffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteBuffersARB<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> buffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteBuffersARB<span class="hl opt">, (</span>n<span class="hl opt">,</span> buffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteBuffersARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> buffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GenBuffers<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> buffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GenBuffersARB<span class="hl opt">, (</span>n<span class="hl opt">,</span> buffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenBuffers(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> buffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GenBuffersARB<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> buffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GenBuffersARB<span class="hl opt">, (</span>n<span class="hl opt">,</span> buffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenBuffersARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> buffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetBufferParameteriv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetBufferParameterivARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetBufferParameteriv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetBufferParameterivARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetBufferParameterivARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetBufferParameterivARB(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetBufferPointerv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLvoid <span class="hl opt">**</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetBufferPointervARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetBufferPointerv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetBufferPointervARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLvoid <span class="hl opt">**</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetBufferPointervARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetBufferPointervARB(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetBufferSubData<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLintptr offset<span class="hl opt">,</span> GLsizeiptr size<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetBufferSubDataARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> offset<span class="hl opt">,</span> size<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetBufferSubData(0x%x, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> offset<span class="hl opt">,</span> size<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetBufferSubDataARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLintptrARB offset<span class="hl opt">,</span> GLsizeiptrARB size<span class="hl opt">,</span> GLvoid <span class="hl opt">*</span> data<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetBufferSubDataARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> offset<span class="hl opt">,</span> size<span class="hl opt">,</span> data<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetBufferSubDataARB(0x%x, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> offset<span class="hl opt">,</span> size<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> data<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsBuffer<span class="hl opt">)(</span>GLuint buffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsBufferARB<span class="hl opt">, (</span>buffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsBuffer(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> buffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsBufferARB<span class="hl opt">)(</span>GLuint buffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsBufferARB<span class="hl opt">, (</span>buffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsBufferARB(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> buffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLvoid <span class="hl opt">*</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MapBuffer<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum access<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>MapBufferARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> access<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMapBuffer(0x%x, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> access<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLvoid <span class="hl opt">*</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MapBufferARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum access<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>MapBufferARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> access<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMapBufferARB(0x%x, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> access<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>UnmapBuffer<span class="hl opt">)(</span>GLenum target<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>UnmapBufferARB<span class="hl opt">, (</span>target<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUnmapBuffer(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>UnmapBufferARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>UnmapBufferARB<span class="hl opt">, (</span>target<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUnmapBufferARB(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BeginQuery<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint id<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BeginQueryARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> id<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBeginQuery(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> id<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BeginQueryARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint id<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BeginQueryARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> id<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBeginQueryARB(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> id<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteQueries<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> ids<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteQueriesARB<span class="hl opt">, (</span>n<span class="hl opt">,</span> ids<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteQueries(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> ids<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteQueriesARB<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> ids<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteQueriesARB<span class="hl opt">, (</span>n<span class="hl opt">,</span> ids<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteQueriesARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> ids<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EndQuery<span class="hl opt">)(</span>GLenum target<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EndQueryARB<span class="hl opt">, (</span>target<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEndQuery(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EndQueryARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EndQueryARB<span class="hl opt">, (</span>target<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEndQueryARB(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GenQueries<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> ids<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GenQueriesARB<span class="hl opt">, (</span>n<span class="hl opt">,</span> ids<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenQueries(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> ids<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GenQueriesARB<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> ids<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GenQueriesARB<span class="hl opt">, (</span>n<span class="hl opt">,</span> ids<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenQueriesARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> ids<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetQueryObjectiv<span class="hl opt">)(</span>GLuint id<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetQueryObjectivARB<span class="hl opt">, (</span>id<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetQueryObjectiv(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> id<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetQueryObjectivARB<span class="hl opt">)(</span>GLuint id<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetQueryObjectivARB<span class="hl opt">, (</span>id<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetQueryObjectivARB(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> id<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetQueryObjectuiv<span class="hl opt">)(</span>GLuint id<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetQueryObjectuivARB<span class="hl opt">, (</span>id<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetQueryObjectuiv(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> id<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetQueryObjectuivARB<span class="hl opt">)(</span>GLuint id<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetQueryObjectuivARB<span class="hl opt">, (</span>id<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetQueryObjectuivARB(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> id<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetQueryiv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetQueryivARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetQueryiv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetQueryivARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetQueryivARB<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetQueryivARB(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsQuery<span class="hl opt">)(</span>GLuint id<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsQueryARB<span class="hl opt">, (</span>id<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsQuery(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> id<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsQueryARB<span class="hl opt">)(</span>GLuint id<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsQueryARB<span class="hl opt">, (</span>id<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsQueryARB(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> id<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>AttachObjectARB<span class="hl opt">)(</span>GLhandleARB containerObj<span class="hl opt">,</span> GLhandleARB obj<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>AttachObjectARB<span class="hl opt">, (</span>containerObj<span class="hl opt">,</span> obj<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glAttachObjectARB(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> containerObj<span class="hl opt">,</span> obj<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CompileShader<span class="hl opt">)(</span>GLuint shader<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CompileShaderARB<span class="hl opt">, (</span>shader<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCompileShader(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> shader<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CompileShaderARB<span class="hl opt">)(</span>GLhandleARB shader<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CompileShaderARB<span class="hl opt">, (</span>shader<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCompileShaderARB(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> shader<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLhandleARB KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CreateProgramObjectARB<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>CreateProgramObjectARB<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCreateProgramObjectARB();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLhandleARB KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CreateShaderObjectARB<span class="hl opt">)(</span>GLenum shaderType<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>CreateShaderObjectARB<span class="hl opt">, (</span>shaderType<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCreateShaderObjectARB(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> shaderType<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteObjectARB<span class="hl opt">)(</span>GLhandleARB obj<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteObjectARB<span class="hl opt">, (</span>obj<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteObjectARB(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> obj<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DetachObjectARB<span class="hl opt">)(</span>GLhandleARB containerObj<span class="hl opt">,</span> GLhandleARB attachedObj<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DetachObjectARB<span class="hl opt">, (</span>containerObj<span class="hl opt">,</span> attachedObj<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDetachObjectARB(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> containerObj<span class="hl opt">,</span> attachedObj<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetActiveUniform<span class="hl opt">)(</span>GLuint program<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLsizei bufSize<span class="hl opt">,</span> GLsizei <span class="hl opt">*</span> length<span class="hl opt">,</span> GLint <span class="hl opt">*</span> size<span class="hl opt">,</span> GLenum <span class="hl opt">*</span> type<span class="hl opt">,</span> GLchar <span class="hl opt">*</span> name<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetActiveUniformARB<span class="hl opt">, (</span>program<span class="hl opt">,</span> index<span class="hl opt">,</span> bufSize<span class="hl opt">,</span> length<span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> name<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetActiveUniform(%d, %d, %d, %p, %p, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">,</span> index<span class="hl opt">,</span> bufSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> length<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> size<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> name<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetActiveUniformARB<span class="hl opt">)(</span>GLhandleARB program<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLsizei bufSize<span class="hl opt">,</span> GLsizei <span class="hl opt">*</span> length<span class="hl opt">,</span> GLint <span class="hl opt">*</span> size<span class="hl opt">,</span> GLenum <span class="hl opt">*</span> type<span class="hl opt">,</span> GLcharARB <span class="hl opt">*</span> name<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetActiveUniformARB<span class="hl opt">, (</span>program<span class="hl opt">,</span> index<span class="hl opt">,</span> bufSize<span class="hl opt">,</span> length<span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> name<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetActiveUniformARB(%d, %d, %d, %p, %p, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">,</span> index<span class="hl opt">,</span> bufSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> length<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> size<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> name<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetAttachedObjectsARB<span class="hl opt">)(</span>GLhandleARB containerObj<span class="hl opt">,</span> GLsizei maxLength<span class="hl opt">,</span> GLsizei <span class="hl opt">*</span> length<span class="hl opt">,</span> GLhandleARB <span class="hl opt">*</span> infoLog<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetAttachedObjectsARB<span class="hl opt">, (</span>containerObj<span class="hl opt">,</span> maxLength<span class="hl opt">,</span> length<span class="hl opt">,</span> infoLog<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetAttachedObjectsARB(%d, %d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> containerObj<span class="hl opt">,</span> maxLength<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> length<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> infoLog<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLhandleARB KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetHandleARB<span class="hl opt">)(</span>GLenum pname<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>GetHandleARB<span class="hl opt">, (</span>pname<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetHandleARB(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetInfoLogARB<span class="hl opt">)(</span>GLhandleARB obj<span class="hl opt">,</span> GLsizei maxLength<span class="hl opt">,</span> GLsizei <span class="hl opt">*</span> length<span class="hl opt">,</span> GLcharARB <span class="hl opt">*</span> infoLog<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetInfoLogARB<span class="hl opt">, (</span>obj<span class="hl opt">,</span> maxLength<span class="hl opt">,</span> length<span class="hl opt">,</span> infoLog<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetInfoLogARB(%d, %d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> obj<span class="hl opt">,</span> maxLength<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> length<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> infoLog<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetObjectParameterfvARB<span class="hl opt">)(</span>GLhandleARB obj<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetObjectParameterfvARB<span class="hl opt">, (</span>obj<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetObjectParameterfvARB(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> obj<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetObjectParameterivARB<span class="hl opt">)(</span>GLhandleARB obj<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetObjectParameterivARB<span class="hl opt">, (</span>obj<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetObjectParameterivARB(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> obj<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetShaderSource<span class="hl opt">)(</span>GLuint shader<span class="hl opt">,</span> GLsizei bufSize<span class="hl opt">,</span> GLsizei <span class="hl opt">*</span> length<span class="hl opt">,</span> GLchar <span class="hl opt">*</span> source<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetShaderSourceARB<span class="hl opt">, (</span>shader<span class="hl opt">,</span> bufSize<span class="hl opt">,</span> length<span class="hl opt">,</span> source<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetShaderSource(%d, %d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> shader<span class="hl opt">,</span> bufSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> length<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> source<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetShaderSourceARB<span class="hl opt">)(</span>GLhandleARB shader<span class="hl opt">,</span> GLsizei bufSize<span class="hl opt">,</span> GLsizei <span class="hl opt">*</span> length<span class="hl opt">,</span> GLcharARB <span class="hl opt">*</span> source<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetShaderSourceARB<span class="hl opt">, (</span>shader<span class="hl opt">,</span> bufSize<span class="hl opt">,</span> length<span class="hl opt">,</span> source<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetShaderSourceARB(%d, %d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> shader<span class="hl opt">,</span> bufSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> length<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> source<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLint KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetUniformLocation<span class="hl opt">)(</span>GLuint program<span class="hl opt">,</span> <span class="hl kwb">const</span> GLchar <span class="hl opt">*</span> name<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>GetUniformLocationARB<span class="hl opt">, (</span>program<span class="hl opt">,</span> name<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetUniformLocation(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> name<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLint KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetUniformLocationARB<span class="hl opt">)(</span>GLhandleARB program<span class="hl opt">,</span> <span class="hl kwb">const</span> GLcharARB <span class="hl opt">*</span> name<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>GetUniformLocationARB<span class="hl opt">, (</span>program<span class="hl opt">,</span> name<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetUniformLocationARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> name<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetUniformfv<span class="hl opt">)(</span>GLuint program<span class="hl opt">,</span> GLint location<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetUniformfvARB<span class="hl opt">, (</span>program<span class="hl opt">,</span> location<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetUniformfv(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">,</span> location<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetUniformfvARB<span class="hl opt">)(</span>GLhandleARB program<span class="hl opt">,</span> GLint location<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetUniformfvARB<span class="hl opt">, (</span>program<span class="hl opt">,</span> location<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetUniformfvARB(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">,</span> location<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetUniformiv<span class="hl opt">)(</span>GLuint program<span class="hl opt">,</span> GLint location<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetUniformivARB<span class="hl opt">, (</span>program<span class="hl opt">,</span> location<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetUniformiv(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">,</span> location<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetUniformivARB<span class="hl opt">)(</span>GLhandleARB program<span class="hl opt">,</span> GLint location<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetUniformivARB<span class="hl opt">, (</span>program<span class="hl opt">,</span> location<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetUniformivARB(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">,</span> location<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LinkProgram<span class="hl opt">)(</span>GLuint program<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LinkProgramARB<span class="hl opt">, (</span>program<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLinkProgram(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LinkProgramARB<span class="hl opt">)(</span>GLhandleARB program<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LinkProgramARB<span class="hl opt">, (</span>program<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLinkProgramARB(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ShaderSource<span class="hl opt">)(</span>GLuint shader<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLchar <span class="hl opt">**</span> string<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> length<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ShaderSourceARB<span class="hl opt">, (</span>shader<span class="hl opt">,</span> count<span class="hl opt">,</span> string<span class="hl opt">,</span> length<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glShaderSource(%d, %d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> shader<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> string<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> length<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ShaderSourceARB<span class="hl opt">)(</span>GLhandleARB shader<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLcharARB <span class="hl opt">**</span> string<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> length<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ShaderSourceARB<span class="hl opt">, (</span>shader<span class="hl opt">,</span> count<span class="hl opt">,</span> string<span class="hl opt">,</span> length<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glShaderSourceARB(%d, %d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> shader<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> string<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> length<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform1f<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLfloat v0<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform1fARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> v0<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform1f(%d, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> v0<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform1fARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLfloat v0<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform1fARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> v0<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform1fARB(%d, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> v0<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform1fv<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform1fvARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform1fv(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform1fvARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform1fvARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform1fvARB(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform1i<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLint v0<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform1iARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> v0<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform1i(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> v0<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform1iARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLint v0<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform1iARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> v0<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform1iARB(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> v0<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform1iv<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform1ivARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform1iv(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform1ivARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform1ivARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform1ivARB(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform2f<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLfloat v0<span class="hl opt">,</span> GLfloat v1<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform2fARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform2f(%d, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform2fARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLfloat v0<span class="hl opt">,</span> GLfloat v1<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform2fARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform2fARB(%d, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform2fv<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform2fvARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform2fv(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform2fvARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform2fvARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform2fvARB(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform2i<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLint v0<span class="hl opt">,</span> GLint v1<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform2iARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform2i(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform2iARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLint v0<span class="hl opt">,</span> GLint v1<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform2iARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform2iARB(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform2iv<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform2ivARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform2iv(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform2ivARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform2ivARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform2ivARB(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform3f<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLfloat v0<span class="hl opt">,</span> GLfloat v1<span class="hl opt">,</span> GLfloat v2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform3fARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform3f(%d, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform3fARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLfloat v0<span class="hl opt">,</span> GLfloat v1<span class="hl opt">,</span> GLfloat v2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform3fARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform3fARB(%d, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform3fv<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform3fvARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform3fv(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform3fvARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform3fvARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform3fvARB(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform3i<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLint v0<span class="hl opt">,</span> GLint v1<span class="hl opt">,</span> GLint v2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform3iARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform3i(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform3iARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLint v0<span class="hl opt">,</span> GLint v1<span class="hl opt">,</span> GLint v2<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform3iARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform3iARB(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform3iv<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform3ivARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform3iv(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform3ivARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform3ivARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform3ivARB(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform4f<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLfloat v0<span class="hl opt">,</span> GLfloat v1<span class="hl opt">,</span> GLfloat v2<span class="hl opt">,</span> GLfloat v3<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform4fARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">,</span> v3<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform4f(%d, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">,</span> v3<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform4fARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLfloat v0<span class="hl opt">,</span> GLfloat v1<span class="hl opt">,</span> GLfloat v2<span class="hl opt">,</span> GLfloat v3<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform4fARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">,</span> v3<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform4fARB(%d, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">,</span> v3<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform4fv<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform4fvARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform4fv(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform4fvARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform4fvARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform4fvARB(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform4i<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLint v0<span class="hl opt">,</span> GLint v1<span class="hl opt">,</span> GLint v2<span class="hl opt">,</span> GLint v3<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform4iARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">,</span> v3<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform4i(%d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">,</span> v3<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform4iARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLint v0<span class="hl opt">,</span> GLint v1<span class="hl opt">,</span> GLint v2<span class="hl opt">,</span> GLint v3<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform4iARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">,</span> v3<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform4iARB(%d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> v0<span class="hl opt">,</span> v1<span class="hl opt">,</span> v2<span class="hl opt">,</span> v3<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform4iv<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform4ivARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform4iv(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>Uniform4ivARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>Uniform4ivARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniform4ivARB(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>UniformMatrix2fv<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLboolean transpose<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>UniformMatrix2fvARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniformMatrix2fv(%d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>UniformMatrix2fvARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLboolean transpose<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>UniformMatrix2fvARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniformMatrix2fvARB(%d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>UniformMatrix3fv<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLboolean transpose<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>UniformMatrix3fvARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniformMatrix3fv(%d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>UniformMatrix3fvARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLboolean transpose<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>UniformMatrix3fvARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniformMatrix3fvARB(%d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>UniformMatrix4fv<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLboolean transpose<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>UniformMatrix4fvARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniformMatrix4fv(%d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>UniformMatrix4fvARB<span class="hl opt">)(</span>GLint location<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLboolean transpose<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>UniformMatrix4fvARB<span class="hl opt">, (</span>location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUniformMatrix4fvARB(%d, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> location<span class="hl opt">,</span> count<span class="hl opt">,</span> transpose<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>UseProgram<span class="hl opt">)(</span>GLuint program<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>UseProgramObjectARB<span class="hl opt">, (</span>program<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUseProgram(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>UseProgramObjectARB<span class="hl opt">)(</span>GLhandleARB program<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>UseProgramObjectARB<span class="hl opt">, (</span>program<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUseProgramObjectARB(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ValidateProgram<span class="hl opt">)(</span>GLuint program<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ValidateProgramARB<span class="hl opt">, (</span>program<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glValidateProgram(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ValidateProgramARB<span class="hl opt">)(</span>GLhandleARB program<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ValidateProgramARB<span class="hl opt">, (</span>program<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glValidateProgramARB(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BindAttribLocation<span class="hl opt">)(</span>GLuint program<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLchar <span class="hl opt">*</span> name<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BindAttribLocationARB<span class="hl opt">, (</span>program<span class="hl opt">,</span> index<span class="hl opt">,</span> name<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBindAttribLocation(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> name<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BindAttribLocationARB<span class="hl opt">)(</span>GLhandleARB program<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLcharARB <span class="hl opt">*</span> name<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BindAttribLocationARB<span class="hl opt">, (</span>program<span class="hl opt">,</span> index<span class="hl opt">,</span> name<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBindAttribLocationARB(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> name<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetActiveAttrib<span class="hl opt">)(</span>GLuint program<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLsizei  bufSize<span class="hl opt">,</span> GLsizei <span class="hl opt">*</span> length<span class="hl opt">,</span> GLint <span class="hl opt">*</span> size<span class="hl opt">,</span> GLenum <span class="hl opt">*</span> type<span class="hl opt">,</span> GLchar <span class="hl opt">*</span> name<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetActiveAttribARB<span class="hl opt">, (</span>program<span class="hl opt">,</span> index<span class="hl opt">,</span> bufSize<span class="hl opt">,</span> length<span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> name<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetActiveAttrib(%d, %d, %d, %p, %p, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">,</span> index<span class="hl opt">,</span> bufSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> length<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> size<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> name<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetActiveAttribARB<span class="hl opt">)(</span>GLhandleARB program<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLsizei bufSize<span class="hl opt">,</span> GLsizei <span class="hl opt">*</span> length<span class="hl opt">,</span> GLint <span class="hl opt">*</span> size<span class="hl opt">,</span> GLenum <span class="hl opt">*</span> type<span class="hl opt">,</span> GLcharARB <span class="hl opt">*</span> name<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetActiveAttribARB<span class="hl opt">, (</span>program<span class="hl opt">,</span> index<span class="hl opt">,</span> bufSize<span class="hl opt">,</span> length<span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> name<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetActiveAttribARB(%d, %d, %d, %p, %p, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">,</span> index<span class="hl opt">,</span> bufSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> length<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> size<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> name<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLint KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetAttribLocation<span class="hl opt">)(</span>GLuint program<span class="hl opt">,</span> <span class="hl kwb">const</span> GLchar <span class="hl opt">*</span> name<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>GetAttribLocationARB<span class="hl opt">, (</span>program<span class="hl opt">,</span> name<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetAttribLocation(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> name<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLint KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetAttribLocationARB<span class="hl opt">)(</span>GLhandleARB program<span class="hl opt">,</span> <span class="hl kwb">const</span> GLcharARB <span class="hl opt">*</span> name<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>GetAttribLocationARB<span class="hl opt">, (</span>program<span class="hl opt">,</span> name<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetAttribLocationARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> name<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DrawBuffers<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLenum <span class="hl opt">*</span> bufs<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DrawBuffersARB<span class="hl opt">, (</span>n<span class="hl opt">,</span> bufs<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDrawBuffers(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> bufs<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DrawBuffersARB<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLenum <span class="hl opt">*</span> bufs<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DrawBuffersARB<span class="hl opt">, (</span>n<span class="hl opt">,</span> bufs<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDrawBuffersARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> bufs<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DrawBuffersATI<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLenum <span class="hl opt">*</span> bufs<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DrawBuffersARB<span class="hl opt">, (</span>n<span class="hl opt">,</span> bufs<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDrawBuffersATI(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> bufs<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RenderbufferStorageMultisample<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLsizei samples<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RenderbufferStorageMultisample<span class="hl opt">, (</span>target<span class="hl opt">,</span> samples<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRenderbufferStorageMultisample(0x%x, %d, 0x%x, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> samples<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FlushMappedBufferRange<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLintptr offset<span class="hl opt">,</span> GLsizeiptr length<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FlushMappedBufferRange<span class="hl opt">, (</span>target<span class="hl opt">,</span> offset<span class="hl opt">,</span> length<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFlushMappedBufferRange(0x%x, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> offset<span class="hl opt">,</span> length<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLvoid <span class="hl opt">*</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MapBufferRange<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLintptr offset<span class="hl opt">,</span> GLsizeiptr length<span class="hl opt">,</span> GLbitfield access<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>MapBufferRange<span class="hl opt">, (</span>target<span class="hl opt">,</span> offset<span class="hl opt">,</span> length<span class="hl opt">,</span> access<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMapBufferRange(0x%x, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> offset<span class="hl opt">,</span> length<span class="hl opt">,</span> access<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BindVertexArray<span class="hl opt">)(</span>GLuint array<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BindVertexArray<span class="hl opt">, (</span>array<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBindVertexArray(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> array<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GenVertexArrays<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> arrays<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GenVertexArrays<span class="hl opt">, (</span>n<span class="hl opt">,</span> arrays<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenVertexArrays(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> arrays<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CopyBufferSubData<span class="hl opt">)(</span>GLenum readTarget<span class="hl opt">,</span> GLenum writeTarget<span class="hl opt">,</span> GLintptr readOffset<span class="hl opt">,</span> GLintptr writeOffset<span class="hl opt">,</span> GLsizeiptr size<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CopyBufferSubData<span class="hl opt">, (</span>readTarget<span class="hl opt">,</span> writeTarget<span class="hl opt">,</span> readOffset<span class="hl opt">,</span> writeOffset<span class="hl opt">,</span> size<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCopyBufferSubData(0x%x, 0x%x, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> readTarget<span class="hl opt">,</span> writeTarget<span class="hl opt">,</span> readOffset<span class="hl opt">,</span> writeOffset<span class="hl opt">,</span> size<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLenum KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ClientWaitSync<span class="hl opt">)(</span>GLsync sync<span class="hl opt">,</span> GLbitfield flags<span class="hl opt">,</span> GLuint64 timeout<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>ClientWaitSync<span class="hl opt">, (</span>sync<span class="hl opt">,</span> flags<span class="hl opt">,</span> timeout<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glClientWaitSync(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> sync<span class="hl opt">,</span> flags<span class="hl opt">,</span> timeout<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteSync<span class="hl opt">)(</span>GLsync sync<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteSync<span class="hl opt">, (</span>sync<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteSync(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> sync<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLsync KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FenceSync<span class="hl opt">)(</span>GLenum condition<span class="hl opt">,</span> GLbitfield flags<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>FenceSync<span class="hl opt">, (</span>condition<span class="hl opt">,</span> flags<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFenceSync(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> condition<span class="hl opt">,</span> flags<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetInteger64v<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLint64 <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetInteger64v<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetInteger64v(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetSynciv<span class="hl opt">)(</span>GLsync sync<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLsizei bufSize<span class="hl opt">,</span> GLsizei <span class="hl opt">*</span> length<span class="hl opt">,</span> GLint <span class="hl opt">*</span> values<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetSynciv<span class="hl opt">, (</span>sync<span class="hl opt">,</span> pname<span class="hl opt">,</span> bufSize<span class="hl opt">,</span> length<span class="hl opt">,</span> values<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetSynciv(%d, 0x%x, %d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> sync<span class="hl opt">,</span> pname<span class="hl opt">,</span> bufSize<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> length<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> values<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsSync<span class="hl opt">)(</span>GLsync sync<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsSync<span class="hl opt">, (</span>sync<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsSync(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> sync<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WaitSync<span class="hl opt">)(</span>GLsync sync<span class="hl opt">,</span> GLbitfield flags<span class="hl opt">,</span> GLuint64 timeout<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WaitSync<span class="hl opt">, (</span>sync<span class="hl opt">,</span> flags<span class="hl opt">,</span> timeout<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWaitSync(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> sync<span class="hl opt">,</span> flags<span class="hl opt">,</span> timeout<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DrawElementsBaseVertex<span class="hl opt">)(</span>GLenum mode<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> indices<span class="hl opt">,</span> GLint basevertex<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DrawElementsBaseVertex<span class="hl opt">, (</span>mode<span class="hl opt">,</span> count<span class="hl opt">,</span> type<span class="hl opt">,</span> indices<span class="hl opt">,</span> basevertex<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDrawElementsBaseVertex(0x%x, %d, 0x%x, %p, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">,</span> count<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> indices<span class="hl opt">,</span> basevertex<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DrawRangeElementsBaseVertex<span class="hl opt">)(</span>GLenum mode<span class="hl opt">,</span> GLuint start<span class="hl opt">,</span> GLuint end<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> indices<span class="hl opt">,</span> GLint basevertex<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DrawRangeElementsBaseVertex<span class="hl opt">, (</span>mode<span class="hl opt">,</span> start<span class="hl opt">,</span> end<span class="hl opt">,</span> count<span class="hl opt">,</span> type<span class="hl opt">,</span> indices<span class="hl opt">,</span> basevertex<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDrawRangeElementsBaseVertex(0x%x, %d, %d, %d, 0x%x, %p, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">,</span> start<span class="hl opt">,</span> end<span class="hl opt">,</span> count<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> indices<span class="hl opt">,</span> basevertex<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiDrawElementsBaseVertex<span class="hl opt">)(</span>GLenum mode<span class="hl opt">,</span> <span class="hl kwb">const</span> GLsizei <span class="hl opt">*</span> count<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">**</span> indices<span class="hl opt">,</span> GLsizei primcount<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> basevertex<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiDrawElementsBaseVertex<span class="hl opt">, (</span>mode<span class="hl opt">,</span> count<span class="hl opt">,</span> type<span class="hl opt">,</span> indices<span class="hl opt">,</span> primcount<span class="hl opt">,</span> basevertex<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiDrawElementsBaseVertex(0x%x, %p, 0x%x, %p, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> count<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> indices<span class="hl opt">,</span> primcount<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> basevertex<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PolygonOffsetEXT<span class="hl opt">)(</span>GLfloat factor<span class="hl opt">,</span> GLfloat bias<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PolygonOffsetEXT<span class="hl opt">, (</span>factor<span class="hl opt">,</span> bias<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPolygonOffsetEXT(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> factor<span class="hl opt">,</span> bias<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_578<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_578<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetPixelTexGenParameterfvSGIS<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetPixelTexGenParameterfvSGIS(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_579<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_579<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetPixelTexGenParameterivSGIS<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetPixelTexGenParameterivSGIS(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_580<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat param<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_580<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PixelTexGenParameterfSGIS<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPixelTexGenParameterfSGIS(0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_581<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_581<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PixelTexGenParameterfvSGIS<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPixelTexGenParameterfvSGIS(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_582<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLint param<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_582<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLint param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PixelTexGenParameteriSGIS<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPixelTexGenParameteriSGIS(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_583<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_583<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PixelTexGenParameterivSGIS<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPixelTexGenParameterivSGIS(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_584<span class="hl opt">)(</span>GLclampf value<span class="hl opt">,</span> GLboolean invert<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_584<span class="hl opt">)(</span>GLclampf value<span class="hl opt">,</span> GLboolean invert<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SampleMaskSGIS<span class="hl opt">, (</span>value<span class="hl opt">,</span> invert<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSampleMaskSGIS(%f, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> value<span class="hl opt">,</span> invert<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_585<span class="hl opt">)(</span>GLenum pattern<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_585<span class="hl opt">)(</span>GLenum pattern<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SamplePatternSGIS<span class="hl opt">, (</span>pattern<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSamplePatternSGIS(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pattern<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ColorPointerEXT<span class="hl opt">)(</span>GLint size<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ColorPointerEXT<span class="hl opt">, (</span>size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">,</span> count<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColorPointerEXT(%d, 0x%x, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EdgeFlagPointerEXT<span class="hl opt">)(</span>GLsizei stride<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLboolean <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EdgeFlagPointerEXT<span class="hl opt">, (</span>stride<span class="hl opt">,</span> count<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEdgeFlagPointerEXT(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> stride<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IndexPointerEXT<span class="hl opt">)(</span>GLenum type<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>IndexPointerEXT<span class="hl opt">, (</span>type<span class="hl opt">,</span> stride<span class="hl opt">,</span> count<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIndexPointerEXT(0x%x, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>NormalPointerEXT<span class="hl opt">)(</span>GLenum type<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>NormalPointerEXT<span class="hl opt">, (</span>type<span class="hl opt">,</span> stride<span class="hl opt">,</span> count<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glNormalPointerEXT(0x%x, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexCoordPointerEXT<span class="hl opt">)(</span>GLint size<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexCoordPointerEXT<span class="hl opt">, (</span>size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">,</span> count<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexCoordPointerEXT(%d, 0x%x, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexPointerEXT<span class="hl opt">)(</span>GLint size<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> GLsizei count<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexPointerEXT<span class="hl opt">, (</span>size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">,</span> count<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexPointerEXT(%d, 0x%x, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">,</span> count<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PointParameterf<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PointParameterfEXT<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPointParameterf(0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PointParameterfARB<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PointParameterfEXT<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPointParameterfARB(0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PointParameterfEXT<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PointParameterfEXT<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPointParameterfEXT(0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_592<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat param<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_592<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PointParameterfEXT<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPointParameterfSGIS(0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PointParameterfv<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PointParameterfvEXT<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPointParameterfv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PointParameterfvARB<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PointParameterfvEXT<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPointParameterfvARB(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PointParameterfvEXT<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PointParameterfvEXT<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPointParameterfvEXT(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_593<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_593<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PointParameterfvEXT<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPointParameterfvSGIS(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LockArraysEXT<span class="hl opt">)(</span>GLint first<span class="hl opt">,</span> GLsizei count<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LockArraysEXT<span class="hl opt">, (</span>first<span class="hl opt">,</span> count<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLockArraysEXT(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> first<span class="hl opt">,</span> count<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>UnlockArraysEXT<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>UnlockArraysEXT<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glUnlockArraysEXT();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_596<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLdouble <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_596<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLdouble <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CullParameterdvEXT<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCullParameterdvEXT(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_597<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_597<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CullParameterfvEXT<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCullParameterfvEXT(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3b<span class="hl opt">)(</span>GLbyte red<span class="hl opt">,</span> GLbyte green<span class="hl opt">,</span> GLbyte blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3bEXT<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3b(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3bEXT<span class="hl opt">)(</span>GLbyte red<span class="hl opt">,</span> GLbyte green<span class="hl opt">,</span> GLbyte blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3bEXT<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3bEXT(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3bv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLbyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3bvEXT<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3bv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3bvEXT<span class="hl opt">)(</span><span class="hl kwb">const</span> GLbyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3bvEXT<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3bvEXT(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3d<span class="hl opt">)(</span>GLdouble red<span class="hl opt">,</span> GLdouble green<span class="hl opt">,</span> GLdouble blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3dEXT<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3d(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3dEXT<span class="hl opt">)(</span>GLdouble red<span class="hl opt">,</span> GLdouble green<span class="hl opt">,</span> GLdouble blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3dEXT<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3dEXT(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3dvEXT<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3dvEXT<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3dvEXT<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3dvEXT(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3f<span class="hl opt">)(</span>GLfloat red<span class="hl opt">,</span> GLfloat green<span class="hl opt">,</span> GLfloat blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3fEXT<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3f(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3fEXT<span class="hl opt">)(</span>GLfloat red<span class="hl opt">,</span> GLfloat green<span class="hl opt">,</span> GLfloat blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3fEXT<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3fEXT(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3fvEXT<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3fvEXT<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3fvEXT<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3fvEXT(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3i<span class="hl opt">)(</span>GLint red<span class="hl opt">,</span> GLint green<span class="hl opt">,</span> GLint blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3iEXT<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3i(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3iEXT<span class="hl opt">)(</span>GLint red<span class="hl opt">,</span> GLint green<span class="hl opt">,</span> GLint blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3iEXT<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3iEXT(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3iv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3ivEXT<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3iv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3ivEXT<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3ivEXT<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3ivEXT(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3s<span class="hl opt">)(</span>GLshort red<span class="hl opt">,</span> GLshort green<span class="hl opt">,</span> GLshort blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3sEXT<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3s(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3sEXT<span class="hl opt">)(</span>GLshort red<span class="hl opt">,</span> GLshort green<span class="hl opt">,</span> GLshort blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3sEXT<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3sEXT(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3sv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3svEXT<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3sv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3svEXT<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3svEXT<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3svEXT(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3ub<span class="hl opt">)(</span>GLubyte red<span class="hl opt">,</span> GLubyte green<span class="hl opt">,</span> GLubyte blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3ubEXT<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3ub(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3ubEXT<span class="hl opt">)(</span>GLubyte red<span class="hl opt">,</span> GLubyte green<span class="hl opt">,</span> GLubyte blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3ubEXT<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3ubEXT(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3ubv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3ubvEXT<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3ubv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3ubvEXT<span class="hl opt">)(</span><span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3ubvEXT<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3ubvEXT(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3ui<span class="hl opt">)(</span>GLuint red<span class="hl opt">,</span> GLuint green<span class="hl opt">,</span> GLuint blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3uiEXT<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3ui(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3uiEXT<span class="hl opt">)(</span>GLuint red<span class="hl opt">,</span> GLuint green<span class="hl opt">,</span> GLuint blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3uiEXT<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3uiEXT(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3uiv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3uivEXT<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3uiv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3uivEXT<span class="hl opt">)(</span><span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3uivEXT<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3uivEXT(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3us<span class="hl opt">)(</span>GLushort red<span class="hl opt">,</span> GLushort green<span class="hl opt">,</span> GLushort blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3usEXT<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3us(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3usEXT<span class="hl opt">)(</span>GLushort red<span class="hl opt">,</span> GLushort green<span class="hl opt">,</span> GLushort blue<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3usEXT<span class="hl opt">, (</span>red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3usEXT(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> red<span class="hl opt">,</span> green<span class="hl opt">,</span> blue<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3usv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLushort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3usvEXT<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3usv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColor3usvEXT<span class="hl opt">)(</span><span class="hl kwb">const</span> GLushort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColor3usvEXT<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColor3usvEXT(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColorPointer<span class="hl opt">)(</span>GLint size<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColorPointerEXT<span class="hl opt">, (</span>size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColorPointer(%d, 0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SecondaryColorPointerEXT<span class="hl opt">)(</span>GLint size<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SecondaryColorPointerEXT<span class="hl opt">, (</span>size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSecondaryColorPointerEXT(%d, 0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiDrawArrays<span class="hl opt">)(</span>GLenum mode<span class="hl opt">,</span> GLint <span class="hl opt">*</span> first<span class="hl opt">,</span> GLsizei <span class="hl opt">*</span> count<span class="hl opt">,</span> GLsizei primcount<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiDrawArraysEXT<span class="hl opt">, (</span>mode<span class="hl opt">,</span> first<span class="hl opt">,</span> count<span class="hl opt">,</span> primcount<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiDrawArrays(0x%x, %p, %p, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> first<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> count<span class="hl opt">,</span> primcount<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiDrawArraysEXT<span class="hl opt">)(</span>GLenum mode<span class="hl opt">,</span> GLint <span class="hl opt">*</span> first<span class="hl opt">,</span> GLsizei <span class="hl opt">*</span> count<span class="hl opt">,</span> GLsizei primcount<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiDrawArraysEXT<span class="hl opt">, (</span>mode<span class="hl opt">,</span> first<span class="hl opt">,</span> count<span class="hl opt">,</span> primcount<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiDrawArraysEXT(0x%x, %p, %p, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> first<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> count<span class="hl opt">,</span> primcount<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiDrawElements<span class="hl opt">)(</span>GLenum mode<span class="hl opt">,</span> <span class="hl kwb">const</span> GLsizei <span class="hl opt">*</span> count<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">**</span> indices<span class="hl opt">,</span> GLsizei primcount<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiDrawElementsEXT<span class="hl opt">, (</span>mode<span class="hl opt">,</span> count<span class="hl opt">,</span> type<span class="hl opt">,</span> indices<span class="hl opt">,</span> primcount<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiDrawElements(0x%x, %p, 0x%x, %p, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> count<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> indices<span class="hl opt">,</span> primcount<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>MultiDrawElementsEXT<span class="hl opt">)(</span>GLenum mode<span class="hl opt">,</span> <span class="hl kwb">const</span> GLsizei <span class="hl opt">*</span> count<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">**</span> indices<span class="hl opt">,</span> GLsizei primcount<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiDrawElementsEXT<span class="hl opt">, (</span>mode<span class="hl opt">,</span> count<span class="hl opt">,</span> type<span class="hl opt">,</span> indices<span class="hl opt">,</span> primcount<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiDrawElementsEXT(0x%x, %p, 0x%x, %p, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> count<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> indices<span class="hl opt">,</span> primcount<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FogCoordPointer<span class="hl opt">)(</span>GLenum type<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FogCoordPointerEXT<span class="hl opt">, (</span>type<span class="hl opt">,</span> stride<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFogCoordPointer(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FogCoordPointerEXT<span class="hl opt">)(</span>GLenum type<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FogCoordPointerEXT<span class="hl opt">, (</span>type<span class="hl opt">,</span> stride<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFogCoordPointerEXT(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FogCoordd<span class="hl opt">)(</span>GLdouble coord<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FogCoorddEXT<span class="hl opt">, (</span>coord<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFogCoordd(%f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> coord<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FogCoorddEXT<span class="hl opt">)(</span>GLdouble coord<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FogCoorddEXT<span class="hl opt">, (</span>coord<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFogCoorddEXT(%f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> coord<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FogCoorddv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> coord<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FogCoorddvEXT<span class="hl opt">, (</span>coord<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFogCoorddv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> coord<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FogCoorddvEXT<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> coord<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FogCoorddvEXT<span class="hl opt">, (</span>coord<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFogCoorddvEXT(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> coord<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FogCoordf<span class="hl opt">)(</span>GLfloat coord<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FogCoordfEXT<span class="hl opt">, (</span>coord<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFogCoordf(%f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> coord<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FogCoordfEXT<span class="hl opt">)(</span>GLfloat coord<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FogCoordfEXT<span class="hl opt">, (</span>coord<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFogCoordfEXT(%f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> coord<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FogCoordfv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> coord<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FogCoordfvEXT<span class="hl opt">, (</span>coord<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFogCoordfv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> coord<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FogCoordfvEXT<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> coord<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FogCoordfvEXT<span class="hl opt">, (</span>coord<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFogCoordfvEXT(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> coord<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_622<span class="hl opt">)(</span>GLenum mode<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_622<span class="hl opt">)(</span>GLenum mode<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PixelTexGenSGIX<span class="hl opt">, (</span>mode<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPixelTexGenSGIX(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> mode<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BlendFuncSeparate<span class="hl opt">)(</span>GLenum sfactorRGB<span class="hl opt">,</span> GLenum dfactorRGB<span class="hl opt">,</span> GLenum sfactorAlpha<span class="hl opt">,</span> GLenum dfactorAlpha<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BlendFuncSeparateEXT<span class="hl opt">, (</span>sfactorRGB<span class="hl opt">,</span> dfactorRGB<span class="hl opt">,</span> sfactorAlpha<span class="hl opt">,</span> dfactorAlpha<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBlendFuncSeparate(0x%x, 0x%x, 0x%x, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> sfactorRGB<span class="hl opt">,</span> dfactorRGB<span class="hl opt">,</span> sfactorAlpha<span class="hl opt">,</span> dfactorAlpha<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BlendFuncSeparateEXT<span class="hl opt">)(</span>GLenum sfactorRGB<span class="hl opt">,</span> GLenum dfactorRGB<span class="hl opt">,</span> GLenum sfactorAlpha<span class="hl opt">,</span> GLenum dfactorAlpha<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BlendFuncSeparateEXT<span class="hl opt">, (</span>sfactorRGB<span class="hl opt">,</span> dfactorRGB<span class="hl opt">,</span> sfactorAlpha<span class="hl opt">,</span> dfactorAlpha<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBlendFuncSeparateEXT(0x%x, 0x%x, 0x%x, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> sfactorRGB<span class="hl opt">,</span> dfactorRGB<span class="hl opt">,</span> sfactorAlpha<span class="hl opt">,</span> dfactorAlpha<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_623<span class="hl opt">)(</span>GLenum sfactorRGB<span class="hl opt">,</span> GLenum dfactorRGB<span class="hl opt">,</span> GLenum sfactorAlpha<span class="hl opt">,</span> GLenum dfactorAlpha<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_623<span class="hl opt">)(</span>GLenum sfactorRGB<span class="hl opt">,</span> GLenum dfactorRGB<span class="hl opt">,</span> GLenum sfactorAlpha<span class="hl opt">,</span> GLenum dfactorAlpha<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BlendFuncSeparateEXT<span class="hl opt">, (</span>sfactorRGB<span class="hl opt">,</span> dfactorRGB<span class="hl opt">,</span> sfactorAlpha<span class="hl opt">,</span> dfactorAlpha<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBlendFuncSeparateINGR(0x%x, 0x%x, 0x%x, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> sfactorRGB<span class="hl opt">,</span> dfactorRGB<span class="hl opt">,</span> sfactorAlpha<span class="hl opt">,</span> dfactorAlpha<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FlushVertexArrayRangeNV<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FlushVertexArrayRangeNV<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFlushVertexArrayRangeNV();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexArrayRangeNV<span class="hl opt">)(</span>GLsizei length<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexArrayRangeNV<span class="hl opt">, (</span>length<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexArrayRangeNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> length<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CombinerInputNV<span class="hl opt">)(</span>GLenum stage<span class="hl opt">,</span> GLenum portion<span class="hl opt">,</span> GLenum variable<span class="hl opt">,</span> GLenum input<span class="hl opt">,</span> GLenum mapping<span class="hl opt">,</span> GLenum componentUsage<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CombinerInputNV<span class="hl opt">, (</span>stage<span class="hl opt">,</span> portion<span class="hl opt">,</span> variable<span class="hl opt">,</span> input<span class="hl opt">,</span> mapping<span class="hl opt">,</span> componentUsage<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCombinerInputNV(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> stage<span class="hl opt">,</span> portion<span class="hl opt">,</span> variable<span class="hl opt">,</span> input<span class="hl opt">,</span> mapping<span class="hl opt">,</span> componentUsage<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CombinerOutputNV<span class="hl opt">)(</span>GLenum stage<span class="hl opt">,</span> GLenum portion<span class="hl opt">,</span> GLenum abOutput<span class="hl opt">,</span> GLenum cdOutput<span class="hl opt">,</span> GLenum sumOutput<span class="hl opt">,</span> GLenum scale<span class="hl opt">,</span> GLenum bias<span class="hl opt">,</span> GLboolean abDotProduct<span class="hl opt">,</span> GLboolean cdDotProduct<span class="hl opt">,</span> GLboolean muxSum<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CombinerOutputNV<span class="hl opt">, (</span>stage<span class="hl opt">,</span> portion<span class="hl opt">,</span> abOutput<span class="hl opt">,</span> cdOutput<span class="hl opt">,</span> sumOutput<span class="hl opt">,</span> scale<span class="hl opt">,</span> bias<span class="hl opt">,</span> abDotProduct<span class="hl opt">,</span> cdDotProduct<span class="hl opt">,</span> muxSum<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCombinerOutputNV(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> stage<span class="hl opt">,</span> portion<span class="hl opt">,</span> abOutput<span class="hl opt">,</span> cdOutput<span class="hl opt">,</span> sumOutput<span class="hl opt">,</span> scale<span class="hl opt">,</span> bias<span class="hl opt">,</span> abDotProduct<span class="hl opt">,</span> cdDotProduct<span class="hl opt">,</span> muxSum<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CombinerParameterfNV<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CombinerParameterfNV<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCombinerParameterfNV(0x%x, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CombinerParameterfvNV<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CombinerParameterfvNV<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCombinerParameterfvNV(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CombinerParameteriNV<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLint param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CombinerParameteriNV<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCombinerParameteriNV(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CombinerParameterivNV<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>CombinerParameterivNV<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCombinerParameterivNV(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FinalCombinerInputNV<span class="hl opt">)(</span>GLenum variable<span class="hl opt">,</span> GLenum input<span class="hl opt">,</span> GLenum mapping<span class="hl opt">,</span> GLenum componentUsage<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FinalCombinerInputNV<span class="hl opt">, (</span>variable<span class="hl opt">,</span> input<span class="hl opt">,</span> mapping<span class="hl opt">,</span> componentUsage<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFinalCombinerInputNV(0x%x, 0x%x, 0x%x, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> variable<span class="hl opt">,</span> input<span class="hl opt">,</span> mapping<span class="hl opt">,</span> componentUsage<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetCombinerInputParameterfvNV<span class="hl opt">)(</span>GLenum stage<span class="hl opt">,</span> GLenum portion<span class="hl opt">,</span> GLenum variable<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetCombinerInputParameterfvNV<span class="hl opt">, (</span>stage<span class="hl opt">,</span> portion<span class="hl opt">,</span> variable<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetCombinerInputParameterfvNV(0x%x, 0x%x, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> stage<span class="hl opt">,</span> portion<span class="hl opt">,</span> variable<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetCombinerInputParameterivNV<span class="hl opt">)(</span>GLenum stage<span class="hl opt">,</span> GLenum portion<span class="hl opt">,</span> GLenum variable<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetCombinerInputParameterivNV<span class="hl opt">, (</span>stage<span class="hl opt">,</span> portion<span class="hl opt">,</span> variable<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetCombinerInputParameterivNV(0x%x, 0x%x, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> stage<span class="hl opt">,</span> portion<span class="hl opt">,</span> variable<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetCombinerOutputParameterfvNV<span class="hl opt">)(</span>GLenum stage<span class="hl opt">,</span> GLenum portion<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetCombinerOutputParameterfvNV<span class="hl opt">, (</span>stage<span class="hl opt">,</span> portion<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetCombinerOutputParameterfvNV(0x%x, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> stage<span class="hl opt">,</span> portion<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetCombinerOutputParameterivNV<span class="hl opt">)(</span>GLenum stage<span class="hl opt">,</span> GLenum portion<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetCombinerOutputParameterivNV<span class="hl opt">, (</span>stage<span class="hl opt">,</span> portion<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetCombinerOutputParameterivNV(0x%x, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> stage<span class="hl opt">,</span> portion<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetFinalCombinerInputParameterfvNV<span class="hl opt">)(</span>GLenum variable<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetFinalCombinerInputParameterfvNV<span class="hl opt">, (</span>variable<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetFinalCombinerInputParameterfvNV(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> variable<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetFinalCombinerInputParameterivNV<span class="hl opt">)(</span>GLenum variable<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetFinalCombinerInputParameterivNV<span class="hl opt">, (</span>variable<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetFinalCombinerInputParameterivNV(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> variable<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ResizeBuffersMESA<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ResizeBuffersMESA<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glResizeBuffersMESA();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2d<span class="hl opt">)(</span>GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2dMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2d(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2dARB<span class="hl opt">)(</span>GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2dMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2dARB(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2dMESA<span class="hl opt">)(</span>GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2dMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2dMESA(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2dvMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2dvARB<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2dvMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2dvARB(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2dvMESA<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2dvMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2dvMESA(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2f<span class="hl opt">)(</span>GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2fMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2f(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2fARB<span class="hl opt">)(</span>GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2fMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2fARB(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2fMESA<span class="hl opt">)(</span>GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2fMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2fMESA(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2fvMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2fvARB<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2fvMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2fvARB(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2fvMESA<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2fvMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2fvMESA(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2i<span class="hl opt">)(</span>GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2iMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2i(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2iARB<span class="hl opt">)(</span>GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2iMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2iARB(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2iMESA<span class="hl opt">)(</span>GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2iMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2iMESA(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2iv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2ivMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2iv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2ivARB<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2ivMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2ivARB(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2ivMESA<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2ivMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2ivMESA(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2s<span class="hl opt">)(</span>GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2sMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2s(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2sARB<span class="hl opt">)(</span>GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2sMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2sARB(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2sMESA<span class="hl opt">)(</span>GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2sMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2sMESA(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2sv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2svMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2sv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2svARB<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2svMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2svARB(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos2svMESA<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos2svMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos2svMESA(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3d<span class="hl opt">)(</span>GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3dMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3d(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3dARB<span class="hl opt">)(</span>GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3dMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3dARB(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3dMESA<span class="hl opt">)(</span>GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3dMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3dMESA(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3dv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3dvMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3dv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3dvARB<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3dvMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3dvARB(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3dvMESA<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3dvMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3dvMESA(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3f<span class="hl opt">)(</span>GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3fMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3f(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3fARB<span class="hl opt">)(</span>GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3fMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3fARB(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3fMESA<span class="hl opt">)(</span>GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3fMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3fMESA(%f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3fv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3fvMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3fv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3fvARB<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3fvMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3fvARB(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3fvMESA<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3fvMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3fvMESA(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3i<span class="hl opt">)(</span>GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLint z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3iMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3i(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3iARB<span class="hl opt">)(</span>GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLint z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3iMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3iARB(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3iMESA<span class="hl opt">)(</span>GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLint z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3iMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3iMESA(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3iv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3ivMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3iv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3ivARB<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3ivMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3ivARB(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3ivMESA<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3ivMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3ivMESA(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3s<span class="hl opt">)(</span>GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">,</span> GLshort z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3sMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3s(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3sARB<span class="hl opt">)(</span>GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">,</span> GLshort z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3sMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3sARB(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3sMESA<span class="hl opt">)(</span>GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">,</span> GLshort z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3sMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3sMESA(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3sv<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3svMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3sv(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3svARB<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3svMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3svARB(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos3svMESA<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos3svMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos3svMESA(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos4dMESA<span class="hl opt">)(</span>GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">,</span> GLdouble w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos4dMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos4dMESA(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos4dvMESA<span class="hl opt">)(</span><span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos4dvMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos4dvMESA(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos4fMESA<span class="hl opt">)(</span>GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">,</span> GLfloat w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos4fMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos4fMESA(%f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos4fvMESA<span class="hl opt">)(</span><span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos4fvMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos4fvMESA(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos4iMESA<span class="hl opt">)(</span>GLint x<span class="hl opt">,</span> GLint y<span class="hl opt">,</span> GLint z<span class="hl opt">,</span> GLint w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos4iMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos4iMESA(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos4ivMESA<span class="hl opt">)(</span><span class="hl kwb">const</span> GLint <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos4ivMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos4ivMESA(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos4sMESA<span class="hl opt">)(</span>GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">,</span> GLshort z<span class="hl opt">,</span> GLshort w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos4sMESA<span class="hl opt">, (</span>x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos4sMESA(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>WindowPos4svMESA<span class="hl opt">)(</span><span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>WindowPos4svMESA<span class="hl opt">, (</span>v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glWindowPos4svMESA(%p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_664<span class="hl opt">)(</span><span class="hl kwb">const</span> GLenum <span class="hl opt">*</span> mode<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> first<span class="hl opt">,</span> <span class="hl kwb">const</span> GLsizei <span class="hl opt">*</span> count<span class="hl opt">,</span> GLsizei primcount<span class="hl opt">,</span> GLint modestride<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_664<span class="hl opt">)(</span><span class="hl kwb">const</span> GLenum <span class="hl opt">*</span> mode<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> first<span class="hl opt">,</span> <span class="hl kwb">const</span> GLsizei <span class="hl opt">*</span> count<span class="hl opt">,</span> GLsizei primcount<span class="hl opt">,</span> GLint modestride<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiModeDrawArraysIBM<span class="hl opt">, (</span>mode<span class="hl opt">,</span> first<span class="hl opt">,</span> count<span class="hl opt">,</span> primcount<span class="hl opt">,</span> modestride<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiModeDrawArraysIBM(%p, %p, %p, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> mode<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> first<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> count<span class="hl opt">,</span> primcount<span class="hl opt">,</span> modestride<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_665<span class="hl opt">)(</span><span class="hl kwb">const</span> GLenum <span class="hl opt">*</span> mode<span class="hl opt">,</span> <span class="hl kwb">const</span> GLsizei <span class="hl opt">*</span> count<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> <span class="hl kwb">const</span> <span class="hl opt">*</span> indices<span class="hl opt">,</span> GLsizei primcount<span class="hl opt">,</span> GLint modestride<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_665<span class="hl opt">)(</span><span class="hl kwb">const</span> GLenum <span class="hl opt">*</span> mode<span class="hl opt">,</span> <span class="hl kwb">const</span> GLsizei <span class="hl opt">*</span> count<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> <span class="hl kwb">const</span> <span class="hl opt">*</span> indices<span class="hl opt">,</span> GLsizei primcount<span class="hl opt">,</span> GLint modestride<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>MultiModeDrawElementsIBM<span class="hl opt">, (</span>mode<span class="hl opt">,</span> count<span class="hl opt">,</span> type<span class="hl opt">,</span> indices<span class="hl opt">,</span> primcount<span class="hl opt">,</span> modestride<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glMultiModeDrawElementsIBM(%p, %p, 0x%x, %p, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> mode<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> count<span class="hl opt">,</span> type<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> indices<span class="hl opt">,</span> primcount<span class="hl opt">,</span> modestride<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_666<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> fences<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_666<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> fences<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteFencesNV<span class="hl opt">, (</span>n<span class="hl opt">,</span> fences<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteFencesNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> fences<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_667<span class="hl opt">)(</span>GLuint fence<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_667<span class="hl opt">)(</span>GLuint fence<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FinishFenceNV<span class="hl opt">, (</span>fence<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFinishFenceNV(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> fence<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_668<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> fences<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_668<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> fences<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GenFencesNV<span class="hl opt">, (</span>n<span class="hl opt">,</span> fences<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenFencesNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> fences<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_669<span class="hl opt">)(</span>GLuint fence<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_669<span class="hl opt">)(</span>GLuint fence<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetFenceivNV<span class="hl opt">, (</span>fence<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetFenceivNV(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> fence<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_670<span class="hl opt">)(</span>GLuint fence<span class="hl opt">);</span>

KEYWORD1_ALT GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_670<span class="hl opt">)(</span>GLuint fence<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsFenceNV<span class="hl opt">, (</span>fence<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsFenceNV(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> fence<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_671<span class="hl opt">)(</span>GLuint fence<span class="hl opt">,</span> GLenum condition<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_671<span class="hl opt">)(</span>GLuint fence<span class="hl opt">,</span> GLenum condition<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SetFenceNV<span class="hl opt">, (</span>fence<span class="hl opt">,</span> condition<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSetFenceNV(%d, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> fence<span class="hl opt">,</span> condition<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_672<span class="hl opt">)(</span>GLuint fence<span class="hl opt">);</span>

KEYWORD1_ALT GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_672<span class="hl opt">)(</span>GLuint fence<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>TestFenceNV<span class="hl opt">, (</span>fence<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTestFenceNV(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> fence<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>AreProgramsResidentNV<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> ids<span class="hl opt">,</span> GLboolean <span class="hl opt">*</span> residences<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>AreProgramsResidentNV<span class="hl opt">, (</span>n<span class="hl opt">,</span> ids<span class="hl opt">,</span> residences<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glAreProgramsResidentNV(%d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> ids<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> residences<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BindProgramARB<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint program<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BindProgramNV<span class="hl opt">, (</span>target<span class="hl opt">,</span> program<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBindProgramARB(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> program<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BindProgramNV<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint program<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BindProgramNV<span class="hl opt">, (</span>target<span class="hl opt">,</span> program<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBindProgramNV(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> program<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteProgramsARB<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> programs<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteProgramsNV<span class="hl opt">, (</span>n<span class="hl opt">,</span> programs<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteProgramsARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> programs<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteProgramsNV<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> programs<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteProgramsNV<span class="hl opt">, (</span>n<span class="hl opt">,</span> programs<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteProgramsNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> programs<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ExecuteProgramNV<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint id<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ExecuteProgramNV<span class="hl opt">, (</span>target<span class="hl opt">,</span> id<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glExecuteProgramNV(0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> id<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GenProgramsARB<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> programs<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GenProgramsNV<span class="hl opt">, (</span>n<span class="hl opt">,</span> programs<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenProgramsARB(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> programs<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GenProgramsNV<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> programs<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GenProgramsNV<span class="hl opt">, (</span>n<span class="hl opt">,</span> programs<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenProgramsNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> programs<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetProgramParameterdvNV<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLdouble <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetProgramParameterdvNV<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetProgramParameterdvNV(0x%x, %d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetProgramParameterfvNV<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetProgramParameterfvNV<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetProgramParameterfvNV(0x%x, %d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetProgramStringNV<span class="hl opt">)(</span>GLuint id<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLubyte <span class="hl opt">*</span> program<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetProgramStringNV<span class="hl opt">, (</span>id<span class="hl opt">,</span> pname<span class="hl opt">,</span> program<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetProgramStringNV(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> id<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> program<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetProgramivNV<span class="hl opt">)(</span>GLuint id<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetProgramivNV<span class="hl opt">, (</span>id<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetProgramivNV(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> id<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetTrackMatrixivNV<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint address<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetTrackMatrixivNV<span class="hl opt">, (</span>target<span class="hl opt">,</span> address<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetTrackMatrixivNV(0x%x, %d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> address<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetVertexAttribPointerv<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLvoid <span class="hl opt">**</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetVertexAttribPointervNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> pname<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetVertexAttribPointerv(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetVertexAttribPointervARB<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLvoid <span class="hl opt">**</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetVertexAttribPointervNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> pname<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetVertexAttribPointervARB(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetVertexAttribPointervNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLvoid <span class="hl opt">**</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetVertexAttribPointervNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> pname<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetVertexAttribPointervNV(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetVertexAttribdvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLdouble <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetVertexAttribdvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetVertexAttribdvNV(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetVertexAttribfvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetVertexAttribfvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetVertexAttribfvNV(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetVertexAttribivNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetVertexAttribivNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetVertexAttribivNV(%d, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsProgramARB<span class="hl opt">)(</span>GLuint program<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsProgramNV<span class="hl opt">, (</span>program<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsProgramARB(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsProgramNV<span class="hl opt">)(</span>GLuint program<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsProgramNV<span class="hl opt">, (</span>program<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsProgramNV(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> program<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>LoadProgramNV<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint id<span class="hl opt">,</span> GLsizei len<span class="hl opt">,</span> <span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> program<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>LoadProgramNV<span class="hl opt">, (</span>target<span class="hl opt">,</span> id<span class="hl opt">,</span> len<span class="hl opt">,</span> program<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glLoadProgramNV(0x%x, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> id<span class="hl opt">,</span> len<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> program<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramParameters4dvNV<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLuint num<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramParameters4dvNV<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> num<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramParameters4dvNV(0x%x, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">,</span> num<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramParameters4fvNV<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint index<span class="hl opt">,</span> GLuint num<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramParameters4fvNV<span class="hl opt">, (</span>target<span class="hl opt">,</span> index<span class="hl opt">,</span> num<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramParameters4fvNV(0x%x, %d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> index<span class="hl opt">,</span> num<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RequestResidentProgramsNV<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> ids<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RequestResidentProgramsNV<span class="hl opt">, (</span>n<span class="hl opt">,</span> ids<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRequestResidentProgramsNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> ids<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TrackMatrixNV<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint address<span class="hl opt">,</span> GLenum matrix<span class="hl opt">,</span> GLenum transform<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TrackMatrixNV<span class="hl opt">, (</span>target<span class="hl opt">,</span> address<span class="hl opt">,</span> matrix<span class="hl opt">,</span> transform<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTrackMatrixNV(0x%x, %d, 0x%x, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> address<span class="hl opt">,</span> matrix<span class="hl opt">,</span> transform<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1dNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLdouble x<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1dNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1dNV(%d, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1dvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1dvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1dvNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1fNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLfloat x<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1fNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1fNV(%d, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1fvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1fvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1fvNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1sNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLshort x<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1sNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1sNV(%d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib1svNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib1svNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib1svNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2dNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2dNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2dNV(%d, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2dvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2dvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2dvNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2fNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2fNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2fNV(%d, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2fvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2fvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2fvNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2sNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2sNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2sNV(%d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib2svNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib2svNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib2svNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3dNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3dNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3dNV(%d, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3dvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3dvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3dvNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3fNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3fNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3fNV(%d, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3fvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3fvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3fvNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3sNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">,</span> GLshort z<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3sNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3sNV(%d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib3svNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib3svNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib3svNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4dNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">,</span> GLdouble w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4dNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4dNV(%d, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4dvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4dvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4dvNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4fNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">,</span> GLfloat w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4fNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4fNV(%d, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4fvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4fvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4fvNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4sNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLshort x<span class="hl opt">,</span> GLshort y<span class="hl opt">,</span> GLshort z<span class="hl opt">,</span> GLshort w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4sNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4sNV(%d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4svNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4svNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4svNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4ubNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLubyte x<span class="hl opt">,</span> GLubyte y<span class="hl opt">,</span> GLubyte z<span class="hl opt">,</span> GLubyte w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4ubNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4ubNV(%d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttrib4ubvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> <span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttrib4ubvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttrib4ubvNV(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttribPointerNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLint size<span class="hl opt">,</span> GLenum type<span class="hl opt">,</span> GLsizei stride<span class="hl opt">,</span> <span class="hl kwb">const</span> GLvoid <span class="hl opt">*</span> pointer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttribPointerNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">,</span> pointer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttribPointerNV(%d, %d, 0x%x, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> size<span class="hl opt">,</span> type<span class="hl opt">,</span> stride<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> pointer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttribs1dvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttribs1dvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> n<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttribs1dvNV(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttribs1fvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttribs1fvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> n<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttribs1fvNV(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttribs1svNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttribs1svNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> n<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttribs1svNV(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttribs2dvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttribs2dvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> n<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttribs2dvNV(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttribs2fvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttribs2fvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> n<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttribs2fvNV(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttribs2svNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttribs2svNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> n<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttribs2svNV(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttribs3dvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttribs3dvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> n<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttribs3dvNV(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttribs3fvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttribs3fvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> n<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttribs3fvNV(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttribs3svNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttribs3svNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> n<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttribs3svNV(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttribs4dvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttribs4dvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> n<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttribs4dvNV(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttribs4fvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttribs4fvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> n<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttribs4fvNV(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttribs4svNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLshort <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttribs4svNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> n<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttribs4svNV(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>VertexAttribs4ubvNV<span class="hl opt">)(</span>GLuint index<span class="hl opt">,</span> GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>VertexAttribs4ubvNV<span class="hl opt">, (</span>index<span class="hl opt">,</span> n<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glVertexAttribs4ubvNV(%d, %d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> index<span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetTexBumpParameterfvATI<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetTexBumpParameterfvATI<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetTexBumpParameterfvATI(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetTexBumpParameterivATI<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetTexBumpParameterivATI<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetTexBumpParameterivATI(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexBumpParameterfvATI<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexBumpParameterfvATI<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexBumpParameterfvATI(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>TexBumpParameterivATI<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>TexBumpParameterivATI<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glTexBumpParameterivATI(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>AlphaFragmentOp1ATI<span class="hl opt">)(</span>GLenum op<span class="hl opt">,</span> GLuint dst<span class="hl opt">,</span> GLuint dstMod<span class="hl opt">,</span> GLuint arg1<span class="hl opt">,</span> GLuint arg1Rep<span class="hl opt">,</span> GLuint arg1Mod<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>AlphaFragmentOp1ATI<span class="hl opt">, (</span>op<span class="hl opt">,</span> dst<span class="hl opt">,</span> dstMod<span class="hl opt">,</span> arg1<span class="hl opt">,</span> arg1Rep<span class="hl opt">,</span> arg1Mod<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glAlphaFragmentOp1ATI(0x%x, %d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> op<span class="hl opt">,</span> dst<span class="hl opt">,</span> dstMod<span class="hl opt">,</span> arg1<span class="hl opt">,</span> arg1Rep<span class="hl opt">,</span> arg1Mod<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>AlphaFragmentOp2ATI<span class="hl opt">)(</span>GLenum op<span class="hl opt">,</span> GLuint dst<span class="hl opt">,</span> GLuint dstMod<span class="hl opt">,</span> GLuint arg1<span class="hl opt">,</span> GLuint arg1Rep<span class="hl opt">,</span> GLuint arg1Mod<span class="hl opt">,</span> GLuint arg2<span class="hl opt">,</span> GLuint arg2Rep<span class="hl opt">,</span> GLuint arg2Mod<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>AlphaFragmentOp2ATI<span class="hl opt">, (</span>op<span class="hl opt">,</span> dst<span class="hl opt">,</span> dstMod<span class="hl opt">,</span> arg1<span class="hl opt">,</span> arg1Rep<span class="hl opt">,</span> arg1Mod<span class="hl opt">,</span> arg2<span class="hl opt">,</span> arg2Rep<span class="hl opt">,</span> arg2Mod<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glAlphaFragmentOp2ATI(0x%x, %d, %d, %d, %d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> op<span class="hl opt">,</span> dst<span class="hl opt">,</span> dstMod<span class="hl opt">,</span> arg1<span class="hl opt">,</span> arg1Rep<span class="hl opt">,</span> arg1Mod<span class="hl opt">,</span> arg2<span class="hl opt">,</span> arg2Rep<span class="hl opt">,</span> arg2Mod<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>AlphaFragmentOp3ATI<span class="hl opt">)(</span>GLenum op<span class="hl opt">,</span> GLuint dst<span class="hl opt">,</span> GLuint dstMod<span class="hl opt">,</span> GLuint arg1<span class="hl opt">,</span> GLuint arg1Rep<span class="hl opt">,</span> GLuint arg1Mod<span class="hl opt">,</span> GLuint arg2<span class="hl opt">,</span> GLuint arg2Rep<span class="hl opt">,</span> GLuint arg2Mod<span class="hl opt">,</span> GLuint arg3<span class="hl opt">,</span> GLuint arg3Rep<span class="hl opt">,</span> GLuint arg3Mod<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>AlphaFragmentOp3ATI<span class="hl opt">, (</span>op<span class="hl opt">,</span> dst<span class="hl opt">,</span> dstMod<span class="hl opt">,</span> arg1<span class="hl opt">,</span> arg1Rep<span class="hl opt">,</span> arg1Mod<span class="hl opt">,</span> arg2<span class="hl opt">,</span> arg2Rep<span class="hl opt">,</span> arg2Mod<span class="hl opt">,</span> arg3<span class="hl opt">,</span> arg3Rep<span class="hl opt">,</span> arg3Mod<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glAlphaFragmentOp3ATI(0x%x, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> op<span class="hl opt">,</span> dst<span class="hl opt">,</span> dstMod<span class="hl opt">,</span> arg1<span class="hl opt">,</span> arg1Rep<span class="hl opt">,</span> arg1Mod<span class="hl opt">,</span> arg2<span class="hl opt">,</span> arg2Rep<span class="hl opt">,</span> arg2Mod<span class="hl opt">,</span> arg3<span class="hl opt">,</span> arg3Rep<span class="hl opt">,</span> arg3Mod<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BeginFragmentShaderATI<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BeginFragmentShaderATI<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBeginFragmentShaderATI();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BindFragmentShaderATI<span class="hl opt">)(</span>GLuint id<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BindFragmentShaderATI<span class="hl opt">, (</span>id<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBindFragmentShaderATI(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> id<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ColorFragmentOp1ATI<span class="hl opt">)(</span>GLenum op<span class="hl opt">,</span> GLuint dst<span class="hl opt">,</span> GLuint dstMask<span class="hl opt">,</span> GLuint dstMod<span class="hl opt">,</span> GLuint arg1<span class="hl opt">,</span> GLuint arg1Rep<span class="hl opt">,</span> GLuint arg1Mod<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ColorFragmentOp1ATI<span class="hl opt">, (</span>op<span class="hl opt">,</span> dst<span class="hl opt">,</span> dstMask<span class="hl opt">,</span> dstMod<span class="hl opt">,</span> arg1<span class="hl opt">,</span> arg1Rep<span class="hl opt">,</span> arg1Mod<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColorFragmentOp1ATI(0x%x, %d, %d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> op<span class="hl opt">,</span> dst<span class="hl opt">,</span> dstMask<span class="hl opt">,</span> dstMod<span class="hl opt">,</span> arg1<span class="hl opt">,</span> arg1Rep<span class="hl opt">,</span> arg1Mod<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ColorFragmentOp2ATI<span class="hl opt">)(</span>GLenum op<span class="hl opt">,</span> GLuint dst<span class="hl opt">,</span> GLuint dstMask<span class="hl opt">,</span> GLuint dstMod<span class="hl opt">,</span> GLuint arg1<span class="hl opt">,</span> GLuint arg1Rep<span class="hl opt">,</span> GLuint arg1Mod<span class="hl opt">,</span> GLuint arg2<span class="hl opt">,</span> GLuint arg2Rep<span class="hl opt">,</span> GLuint arg2Mod<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ColorFragmentOp2ATI<span class="hl opt">, (</span>op<span class="hl opt">,</span> dst<span class="hl opt">,</span> dstMask<span class="hl opt">,</span> dstMod<span class="hl opt">,</span> arg1<span class="hl opt">,</span> arg1Rep<span class="hl opt">,</span> arg1Mod<span class="hl opt">,</span> arg2<span class="hl opt">,</span> arg2Rep<span class="hl opt">,</span> arg2Mod<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColorFragmentOp2ATI(0x%x, %d, %d, %d, %d, %d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> op<span class="hl opt">,</span> dst<span class="hl opt">,</span> dstMask<span class="hl opt">,</span> dstMod<span class="hl opt">,</span> arg1<span class="hl opt">,</span> arg1Rep<span class="hl opt">,</span> arg1Mod<span class="hl opt">,</span> arg2<span class="hl opt">,</span> arg2Rep<span class="hl opt">,</span> arg2Mod<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ColorFragmentOp3ATI<span class="hl opt">)(</span>GLenum op<span class="hl opt">,</span> GLuint dst<span class="hl opt">,</span> GLuint dstMask<span class="hl opt">,</span> GLuint dstMod<span class="hl opt">,</span> GLuint arg1<span class="hl opt">,</span> GLuint arg1Rep<span class="hl opt">,</span> GLuint arg1Mod<span class="hl opt">,</span> GLuint arg2<span class="hl opt">,</span> GLuint arg2Rep<span class="hl opt">,</span> GLuint arg2Mod<span class="hl opt">,</span> GLuint arg3<span class="hl opt">,</span> GLuint arg3Rep<span class="hl opt">,</span> GLuint arg3Mod<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ColorFragmentOp3ATI<span class="hl opt">, (</span>op<span class="hl opt">,</span> dst<span class="hl opt">,</span> dstMask<span class="hl opt">,</span> dstMod<span class="hl opt">,</span> arg1<span class="hl opt">,</span> arg1Rep<span class="hl opt">,</span> arg1Mod<span class="hl opt">,</span> arg2<span class="hl opt">,</span> arg2Rep<span class="hl opt">,</span> arg2Mod<span class="hl opt">,</span> arg3<span class="hl opt">,</span> arg3Rep<span class="hl opt">,</span> arg3Mod<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glColorFragmentOp3ATI(0x%x, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> op<span class="hl opt">,</span> dst<span class="hl opt">,</span> dstMask<span class="hl opt">,</span> dstMod<span class="hl opt">,</span> arg1<span class="hl opt">,</span> arg1Rep<span class="hl opt">,</span> arg1Mod<span class="hl opt">,</span> arg2<span class="hl opt">,</span> arg2Rep<span class="hl opt">,</span> arg2Mod<span class="hl opt">,</span> arg3<span class="hl opt">,</span> arg3Rep<span class="hl opt">,</span> arg3Mod<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteFragmentShaderATI<span class="hl opt">)(</span>GLuint id<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteFragmentShaderATI<span class="hl opt">, (</span>id<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteFragmentShaderATI(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> id<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>EndFragmentShaderATI<span class="hl opt">)(</span><span class="hl kwb">void</span><span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>EndFragmentShaderATI<span class="hl opt">, (), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glEndFragmentShaderATI();</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLuint KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GenFragmentShadersATI<span class="hl opt">)(</span>GLuint range<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>GenFragmentShadersATI<span class="hl opt">, (</span>range<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenFragmentShadersATI(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> range<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PassTexCoordATI<span class="hl opt">)(</span>GLuint dst<span class="hl opt">,</span> GLuint coord<span class="hl opt">,</span> GLenum swizzle<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PassTexCoordATI<span class="hl opt">, (</span>dst<span class="hl opt">,</span> coord<span class="hl opt">,</span> swizzle<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPassTexCoordATI(%d, %d, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> dst<span class="hl opt">,</span> coord<span class="hl opt">,</span> swizzle<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SampleMapATI<span class="hl opt">)(</span>GLuint dst<span class="hl opt">,</span> GLuint interp<span class="hl opt">,</span> GLenum swizzle<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SampleMapATI<span class="hl opt">, (</span>dst<span class="hl opt">,</span> interp<span class="hl opt">,</span> swizzle<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSampleMapATI(%d, %d, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> dst<span class="hl opt">,</span> interp<span class="hl opt">,</span> swizzle<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>SetFragmentShaderConstantATI<span class="hl opt">)(</span>GLuint dst<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> value<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>SetFragmentShaderConstantATI<span class="hl opt">, (</span>dst<span class="hl opt">,</span> value<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glSetFragmentShaderConstantATI(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> dst<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> value<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PointParameteri<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLint param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PointParameteriNV<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPointParameteri(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PointParameteriNV<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> GLint param<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PointParameteriNV<span class="hl opt">, (</span>pname<span class="hl opt">,</span> param<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPointParameteriNV(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">,</span> param<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PointParameteriv<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PointParameterivNV<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPointParameteriv(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>PointParameterivNV<span class="hl opt">)(</span>GLenum pname<span class="hl opt">,</span> <span class="hl kwb">const</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>PointParameterivNV<span class="hl opt">, (</span>pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glPointParameterivNV(0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_753<span class="hl opt">)(</span>GLenum face<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_753<span class="hl opt">)(</span>GLenum face<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ActiveStencilFaceEXT<span class="hl opt">, (</span>face<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glActiveStencilFaceEXT(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> face<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_754<span class="hl opt">)(</span>GLuint array<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_754<span class="hl opt">)(</span>GLuint array<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BindVertexArrayAPPLE<span class="hl opt">, (</span>array<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBindVertexArrayAPPLE(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> array<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteVertexArrays<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> arrays<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteVertexArraysAPPLE<span class="hl opt">, (</span>n<span class="hl opt">,</span> arrays<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteVertexArrays(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> arrays<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_755<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> arrays<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_755<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> arrays<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteVertexArraysAPPLE<span class="hl opt">, (</span>n<span class="hl opt">,</span> arrays<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteVertexArraysAPPLE(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> arrays<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_756<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> arrays<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_756<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> arrays<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GenVertexArraysAPPLE<span class="hl opt">, (</span>n<span class="hl opt">,</span> arrays<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenVertexArraysAPPLE(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> arrays<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsVertexArray<span class="hl opt">)(</span>GLuint array<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsVertexArrayAPPLE<span class="hl opt">, (</span>array<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsVertexArray(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> array<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_757<span class="hl opt">)(</span>GLuint array<span class="hl opt">);</span>

KEYWORD1_ALT GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_757<span class="hl opt">)(</span>GLuint array<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsVertexArrayAPPLE<span class="hl opt">, (</span>array<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsVertexArrayAPPLE(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> array<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetProgramNamedParameterdvNV<span class="hl opt">)(</span>GLuint id<span class="hl opt">,</span> GLsizei len<span class="hl opt">,</span> <span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> name<span class="hl opt">,</span> GLdouble <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetProgramNamedParameterdvNV<span class="hl opt">, (</span>id<span class="hl opt">,</span> len<span class="hl opt">,</span> name<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetProgramNamedParameterdvNV(%d, %d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> id<span class="hl opt">,</span> len<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> name<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetProgramNamedParameterfvNV<span class="hl opt">)(</span>GLuint id<span class="hl opt">,</span> GLsizei len<span class="hl opt">,</span> <span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> name<span class="hl opt">,</span> GLfloat <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetProgramNamedParameterfvNV<span class="hl opt">, (</span>id<span class="hl opt">,</span> len<span class="hl opt">,</span> name<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetProgramNamedParameterfvNV(%d, %d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> id<span class="hl opt">,</span> len<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> name<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramNamedParameter4dNV<span class="hl opt">)(</span>GLuint id<span class="hl opt">,</span> GLsizei len<span class="hl opt">,</span> <span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> name<span class="hl opt">,</span> GLdouble x<span class="hl opt">,</span> GLdouble y<span class="hl opt">,</span> GLdouble z<span class="hl opt">,</span> GLdouble w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramNamedParameter4dNV<span class="hl opt">, (</span>id<span class="hl opt">,</span> len<span class="hl opt">,</span> name<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramNamedParameter4dNV(%d, %d, %p, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> id<span class="hl opt">,</span> len<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> name<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramNamedParameter4dvNV<span class="hl opt">)(</span>GLuint id<span class="hl opt">,</span> GLsizei len<span class="hl opt">,</span> <span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> name<span class="hl opt">,</span> <span class="hl kwb">const</span> GLdouble <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramNamedParameter4dvNV<span class="hl opt">, (</span>id<span class="hl opt">,</span> len<span class="hl opt">,</span> name<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramNamedParameter4dvNV(%d, %d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> id<span class="hl opt">,</span> len<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> name<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramNamedParameter4fNV<span class="hl opt">)(</span>GLuint id<span class="hl opt">,</span> GLsizei len<span class="hl opt">,</span> <span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> name<span class="hl opt">,</span> GLfloat x<span class="hl opt">,</span> GLfloat y<span class="hl opt">,</span> GLfloat z<span class="hl opt">,</span> GLfloat w<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramNamedParameter4fNV<span class="hl opt">, (</span>id<span class="hl opt">,</span> len<span class="hl opt">,</span> name<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramNamedParameter4fNV(%d, %d, %p, %f, %f, %f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> id<span class="hl opt">,</span> len<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> name<span class="hl opt">,</span> x<span class="hl opt">,</span> y<span class="hl opt">,</span> z<span class="hl opt">,</span> w<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>ProgramNamedParameter4fvNV<span class="hl opt">)(</span>GLuint id<span class="hl opt">,</span> GLsizei len<span class="hl opt">,</span> <span class="hl kwb">const</span> GLubyte <span class="hl opt">*</span> name<span class="hl opt">,</span> <span class="hl kwb">const</span> GLfloat <span class="hl opt">*</span> v<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>ProgramNamedParameter4fvNV<span class="hl opt">, (</span>id<span class="hl opt">,</span> len<span class="hl opt">,</span> name<span class="hl opt">,</span> v<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glProgramNamedParameter4fvNV(%d, %d, %p, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> id<span class="hl opt">,</span> len<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> name<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> v<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_764<span class="hl opt">)(</span>GLclampd zmin<span class="hl opt">,</span> GLclampd zmax<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_764<span class="hl opt">)(</span>GLclampd zmin<span class="hl opt">,</span> GLclampd zmax<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DepthBoundsEXT<span class="hl opt">, (</span>zmin<span class="hl opt">,</span> zmax<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDepthBoundsEXT(%f, %f);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> zmin<span class="hl opt">,</span> zmax<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BlendEquationSeparate<span class="hl opt">)(</span>GLenum modeRGB<span class="hl opt">,</span> GLenum modeA<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BlendEquationSeparateEXT<span class="hl opt">, (</span>modeRGB<span class="hl opt">,</span> modeA<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBlendEquationSeparate(0x%x, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> modeRGB<span class="hl opt">,</span> modeA<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_765<span class="hl opt">)(</span>GLenum modeRGB<span class="hl opt">,</span> GLenum modeA<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_765<span class="hl opt">)(</span>GLenum modeRGB<span class="hl opt">,</span> GLenum modeA<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BlendEquationSeparateEXT<span class="hl opt">, (</span>modeRGB<span class="hl opt">,</span> modeA<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBlendEquationSeparateEXT(0x%x, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> modeRGB<span class="hl opt">,</span> modeA<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BindFramebuffer<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint framebuffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BindFramebufferEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> framebuffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBindFramebuffer(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> framebuffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BindFramebufferEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint framebuffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BindFramebufferEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> framebuffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBindFramebufferEXT(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> framebuffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BindRenderbuffer<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint renderbuffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BindRenderbufferEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> renderbuffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBindRenderbuffer(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> renderbuffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BindRenderbufferEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLuint renderbuffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BindRenderbufferEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> renderbuffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBindRenderbufferEXT(0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> renderbuffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLenum KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CheckFramebufferStatus<span class="hl opt">)(</span>GLenum target<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>CheckFramebufferStatusEXT<span class="hl opt">, (</span>target<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCheckFramebufferStatus(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLenum KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>CheckFramebufferStatusEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>CheckFramebufferStatusEXT<span class="hl opt">, (</span>target<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glCheckFramebufferStatusEXT(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteFramebuffers<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> framebuffers<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteFramebuffersEXT<span class="hl opt">, (</span>n<span class="hl opt">,</span> framebuffers<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteFramebuffers(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> framebuffers<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteFramebuffersEXT<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> framebuffers<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteFramebuffersEXT<span class="hl opt">, (</span>n<span class="hl opt">,</span> framebuffers<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteFramebuffersEXT(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> framebuffers<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteRenderbuffers<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> renderbuffers<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteRenderbuffersEXT<span class="hl opt">, (</span>n<span class="hl opt">,</span> renderbuffers<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteRenderbuffers(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> renderbuffers<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>DeleteRenderbuffersEXT<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> <span class="hl kwb">const</span> GLuint <span class="hl opt">*</span> renderbuffers<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>DeleteRenderbuffersEXT<span class="hl opt">, (</span>n<span class="hl opt">,</span> renderbuffers<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glDeleteRenderbuffersEXT(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> renderbuffers<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FramebufferRenderbuffer<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum attachment<span class="hl opt">,</span> GLenum renderbuffertarget<span class="hl opt">,</span> GLuint renderbuffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FramebufferRenderbufferEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> renderbuffertarget<span class="hl opt">,</span> renderbuffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFramebufferRenderbuffer(0x%x, 0x%x, 0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> renderbuffertarget<span class="hl opt">,</span> renderbuffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FramebufferRenderbufferEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum attachment<span class="hl opt">,</span> GLenum renderbuffertarget<span class="hl opt">,</span> GLuint renderbuffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FramebufferRenderbufferEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> renderbuffertarget<span class="hl opt">,</span> renderbuffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFramebufferRenderbufferEXT(0x%x, 0x%x, 0x%x, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> renderbuffertarget<span class="hl opt">,</span> renderbuffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FramebufferTexture1D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum attachment<span class="hl opt">,</span> GLenum textarget<span class="hl opt">,</span> GLuint texture<span class="hl opt">,</span> GLint level<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FramebufferTexture1DEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> textarget<span class="hl opt">,</span> texture<span class="hl opt">,</span> level<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFramebufferTexture1D(0x%x, 0x%x, 0x%x, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> textarget<span class="hl opt">,</span> texture<span class="hl opt">,</span> level<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FramebufferTexture1DEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum attachment<span class="hl opt">,</span> GLenum textarget<span class="hl opt">,</span> GLuint texture<span class="hl opt">,</span> GLint level<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FramebufferTexture1DEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> textarget<span class="hl opt">,</span> texture<span class="hl opt">,</span> level<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFramebufferTexture1DEXT(0x%x, 0x%x, 0x%x, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> textarget<span class="hl opt">,</span> texture<span class="hl opt">,</span> level<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FramebufferTexture2D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum attachment<span class="hl opt">,</span> GLenum textarget<span class="hl opt">,</span> GLuint texture<span class="hl opt">,</span> GLint level<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FramebufferTexture2DEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> textarget<span class="hl opt">,</span> texture<span class="hl opt">,</span> level<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFramebufferTexture2D(0x%x, 0x%x, 0x%x, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> textarget<span class="hl opt">,</span> texture<span class="hl opt">,</span> level<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FramebufferTexture2DEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum attachment<span class="hl opt">,</span> GLenum textarget<span class="hl opt">,</span> GLuint texture<span class="hl opt">,</span> GLint level<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FramebufferTexture2DEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> textarget<span class="hl opt">,</span> texture<span class="hl opt">,</span> level<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFramebufferTexture2DEXT(0x%x, 0x%x, 0x%x, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> textarget<span class="hl opt">,</span> texture<span class="hl opt">,</span> level<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FramebufferTexture3D<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum attachment<span class="hl opt">,</span> GLenum textarget<span class="hl opt">,</span> GLuint texture<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint zoffset<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FramebufferTexture3DEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> textarget<span class="hl opt">,</span> texture<span class="hl opt">,</span> level<span class="hl opt">,</span> zoffset<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFramebufferTexture3D(0x%x, 0x%x, 0x%x, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> textarget<span class="hl opt">,</span> texture<span class="hl opt">,</span> level<span class="hl opt">,</span> zoffset<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>FramebufferTexture3DEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum attachment<span class="hl opt">,</span> GLenum textarget<span class="hl opt">,</span> GLuint texture<span class="hl opt">,</span> GLint level<span class="hl opt">,</span> GLint zoffset<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>FramebufferTexture3DEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> textarget<span class="hl opt">,</span> texture<span class="hl opt">,</span> level<span class="hl opt">,</span> zoffset<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glFramebufferTexture3DEXT(0x%x, 0x%x, 0x%x, %d, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> textarget<span class="hl opt">,</span> texture<span class="hl opt">,</span> level<span class="hl opt">,</span> zoffset<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GenFramebuffers<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> framebuffers<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GenFramebuffersEXT<span class="hl opt">, (</span>n<span class="hl opt">,</span> framebuffers<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenFramebuffers(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> framebuffers<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GenFramebuffersEXT<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> framebuffers<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GenFramebuffersEXT<span class="hl opt">, (</span>n<span class="hl opt">,</span> framebuffers<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenFramebuffersEXT(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> framebuffers<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GenRenderbuffers<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> renderbuffers<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GenRenderbuffersEXT<span class="hl opt">, (</span>n<span class="hl opt">,</span> renderbuffers<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenRenderbuffers(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> renderbuffers<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GenRenderbuffersEXT<span class="hl opt">)(</span>GLsizei n<span class="hl opt">,</span> GLuint <span class="hl opt">*</span> renderbuffers<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GenRenderbuffersEXT<span class="hl opt">, (</span>n<span class="hl opt">,</span> renderbuffers<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenRenderbuffersEXT(%d, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> n<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> renderbuffers<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GenerateMipmap<span class="hl opt">)(</span>GLenum target<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GenerateMipmapEXT<span class="hl opt">, (</span>target<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenerateMipmap(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GenerateMipmapEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GenerateMipmapEXT<span class="hl opt">, (</span>target<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGenerateMipmapEXT(0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetFramebufferAttachmentParameteriv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum attachment<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetFramebufferAttachmentParameterivEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetFramebufferAttachmentParameteriv(0x%x, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetFramebufferAttachmentParameterivEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum attachment<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetFramebufferAttachmentParameterivEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetFramebufferAttachmentParameterivEXT(0x%x, 0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> attachment<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetRenderbufferParameteriv<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetRenderbufferParameterivEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetRenderbufferParameteriv(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>GetRenderbufferParameterivEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum pname<span class="hl opt">,</span> GLint <span class="hl opt">*</span> params<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>GetRenderbufferParameterivEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> pname<span class="hl opt">,</span> params<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glGetRenderbufferParameterivEXT(0x%x, 0x%x, %p);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> pname<span class="hl opt">, (</span><span class="hl kwb">const void</span> <span class="hl opt">*)</span> params<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsFramebuffer<span class="hl opt">)(</span>GLuint framebuffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsFramebufferEXT<span class="hl opt">, (</span>framebuffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsFramebuffer(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> framebuffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsFramebufferEXT<span class="hl opt">)(</span>GLuint framebuffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsFramebufferEXT<span class="hl opt">, (</span>framebuffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsFramebufferEXT(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> framebuffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsRenderbuffer<span class="hl opt">)(</span>GLuint renderbuffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsRenderbufferEXT<span class="hl opt">, (</span>renderbuffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsRenderbuffer(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> renderbuffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 GLboolean KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>IsRenderbufferEXT<span class="hl opt">)(</span>GLuint renderbuffer<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">RETURN_DISPATCH</span><span class="hl opt">(</span>IsRenderbufferEXT<span class="hl opt">, (</span>renderbuffer<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glIsRenderbufferEXT(%d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> renderbuffer<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RenderbufferStorage<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RenderbufferStorageEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRenderbufferStorage(0x%x, 0x%x, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>RenderbufferStorageEXT<span class="hl opt">)(</span>GLenum target<span class="hl opt">,</span> GLenum internalformat<span class="hl opt">,</span> GLsizei width<span class="hl opt">,</span> GLsizei height<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>RenderbufferStorageEXT<span class="hl opt">, (</span>target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glRenderbufferStorageEXT(0x%x, 0x%x, %d, %d);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> target<span class="hl opt">,</span> internalformat<span class="hl opt">,</span> width<span class="hl opt">,</span> height<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1 <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>BlitFramebuffer<span class="hl opt">)(</span>GLint srcX0<span class="hl opt">,</span> GLint srcY0<span class="hl opt">,</span> GLint srcX1<span class="hl opt">,</span> GLint srcY1<span class="hl opt">,</span> GLint dstX0<span class="hl opt">,</span> GLint dstY0<span class="hl opt">,</span> GLint dstX1<span class="hl opt">,</span> GLint dstY1<span class="hl opt">,</span> GLbitfield mask<span class="hl opt">,</span> GLenum filter<span class="hl opt">)</span>
<span class="hl opt">{</span>
   <span class="hl kwd">DISPATCH</span><span class="hl opt">(</span>BlitFramebufferEXT<span class="hl opt">, (</span>srcX0<span class="hl opt">,</span> srcY0<span class="hl opt">,</span> srcX1<span class="hl opt">,</span> srcY1<span class="hl opt">,</span> dstX0<span class="hl opt">,</span> dstY0<span class="hl opt">,</span> dstX1<span class="hl opt">,</span> dstY1<span class="hl opt">,</span> mask<span class="hl opt">,</span> filter<span class="hl opt">), (</span>F<span class="hl opt">,</span> <span class="hl str">&quot;glBlitFramebuffer(%d, %d, %d, %d, %d, %d, %d, %d, %d, 0x%x);</span><span class="hl esc">\n</span><span class="hl str">&quot;</span><span class="hl opt">,</span> srcX0<span class="hl opt">,</span> srcY0<span class="hl opt">,</span> srcX1<span class="hl opt">,</span> srcY1<span class="hl opt">,</span> dstX0<span class="hl opt">,</span> dstY0<span class="hl opt">,</span> dstX1<span class="hl opt">,</span> dstY1<span class="hl opt">,</span> mask<span class="hl opt">,</span> filter<span class="hl opt">));</span>
<span class="hl opt">}</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_783<span class="hl opt">)(</span>GLint srcX0<span class="hl opt">,</span> GLint srcY0<span class="hl opt">,</span> GLint srcX1<span class="hl opt">,</span> GLint srcY1<span class="hl opt">,</span> GLint dstX0<span class="hl opt">,</span> GLint dstY0<span class="hl opt">,</span> GLint dstX1<span class="hl opt">,</span> GLint dstY1<span class="hl opt">,</span> GLbitfield mask<span class="hl opt">,</span> GLenum filter<span class="hl opt">);</span>

KEYWORD1_ALT <span class="hl kwb">void</span> KEYWORD2 <span class="hl kwd">NAME</span><span class="hl opt">(</span>_dispatch_stub_783<span class="hl opt">)(</span>GLint srcX0<span class="hl opt">,</span> GLint srcY0<span class="hl opt">,</span> GLint srcX1<span class="hl opt">,</span> GLint srcY1<span class="hl opt">,</span> GLint dstX0<span class="hl opt">,</span> GLint dstY0<span class="hl opt">,</span> GLint dstX1<span class="hl opt">,</span> GLint dstY1<span class="hl opt">,</span> GLbitfield mask<span class="hl opt">,</span> GLenum filter<span class="hl opt">)</span>
<span class="hl opt">{