diff --git a/dlls/opengl32/make_opengl b/dlls/opengl32/make_opengl
index 81b7291..480ad68 100755
--- a/dlls/opengl32/make_opengl
+++ b/dlls/opengl32/make_opengl
@@ -1,6 +1,6 @@
 #!/usr/bin/perl -w
 use strict;
-use XML::Simple;
+use XML::LibXML;
 
 # This script is called thus :
 #
@@ -220,30 +220,11 @@
 }
 
 #
-# Used to convert some variable names
-#
-sub ConvertVarName($)
-{
-    my ($type) = @_;
-
-    my %hash = ( "near" => "nearParam",
-                 "far"  => "farParam" );
-
-    foreach my $org (keys %hash) {
-        if ($type =~ /^(.*)$org(.*)$/) {
-            return "$1$hash{$org}$2";
-        }
-    }
-    return $type;
-}
-
-#
 # This functions generates the thunk for a given function.
 #
 sub GenerateThunk($$$)
 {
     my ($name, $func_ref, $prefix) = @_;
-    my $ret = "";
     my $call_arg = "";
     my $trace_call_arg = "";
     my $trace_arg = "";
@@ -253,60 +234,35 @@
     return "" if $name eq "glGetString";
     return "" if $func_ref->[2] && $func_ref->[2]->[0] =~ /WGL_/;
 
-    $ret .= ConvertType($func_ref->[0]) . " WINAPI $name( ";
-    for (my $i = 0; $i < @{$func_ref->[1]}; $i++) {
-        my $type = $func_ref->[1]->[$i]->[0];
-        my $name = ConvertVarName($func_ref->[1]->[$i]->[1]);
-        my ($base_type, $type_specifier, $name_specifier) = ($type, $type, $name);
-        if ($type =~ /(.*) (.*)/) {
-            $base_type = $2;
-        } elsif ($type =~ /(.*)(\[.*)/) {
-            $base_type = $1;
-            $type_specifier = $1;
-            $name_specifier = $name . $2
-        }
-        $ret .= ConvertType($type_specifier) . " $name_specifier";
-        $call_arg .= $name;
-        if ($type =~ /\*/ || $type =~ /\[/) {
+    my $ret = get_func_proto( "%s WINAPI %s(%s)", $name, $func_ref );
+    foreach my $arg (@{$func_ref->[1]}) {
+        my $ptype = get_arg_type( $arg );
+        my $pname = get_arg_name( $arg );
+        my $param = $arg->textContent();
+        $call_arg .= " " . $pname . ",";
+        if ($param =~ /\*/ || $param =~ /\[/) {
             $trace_arg .= "%p";
-            $trace_call_arg .= $name;
-        } elsif (defined $debug_conv{$base_type}) {
-            if ($debug_conv{$base_type} =~ /(.*),(.*)/) {
+            $trace_call_arg .= ", " . $pname;
+        } elsif (defined $debug_conv{$ptype}) {
+            if ($debug_conv{$ptype} =~ /(.*),(.*)/) {
                 $trace_arg .= $1;
-                $trace_call_arg .= sprintf $2, $name;
+                $trace_call_arg .= ", " . sprintf $2, $pname;
             } else {
-                $trace_arg .= $debug_conv{$base_type};
-                $trace_call_arg .= $name;
+                $trace_arg .= $debug_conv{$ptype};
+                $trace_call_arg .= ", " . $pname;
             }
         }
-        else { printf "Unknown type %s\n", $type; }
-        if ($i+1 < @{$func_ref->[1]}) {
-            $ret .= ", ";
-            $call_arg .= ", ";
-            $trace_call_arg .= ", ";
-            $trace_arg .= ", ";
-        } else {
-            $ret .= " ";
-            $call_arg .= " ";
-            $trace_call_arg .= " ";
-        }
+        else { printf "Unknown type %s in %s\n", $param, $name; }
+        $trace_arg .= ", ";
     }
-    $ret .= 'void ' if (!@{$func_ref->[1]});
-    return "$ret) DECLSPEC_HIDDEN;\n" if $name eq "glGetStringi";
-    $ret .= ") {\n";
-    $ret .= "  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;\n";
-    if ($gen_traces) {
-        $ret .= "  TRACE(\"($trace_arg)\\n\"";
-        if ($trace_arg ne "") {
-            $ret .= ", $trace_call_arg";
-        }
-        $ret .= ");\n";
-    }
+    $call_arg =~ s/,$/ /;
+    $trace_arg =~ s/, $//;
+    return "$ret DECLSPEC_HIDDEN;\n" if $name eq "glGetStringi";
+    $ret .= "\n{\n  const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;\n";
+    $ret .= "  TRACE( \"($trace_arg)\\n\"$trace_call_arg );\n" if $gen_traces;
     $ret .= "  ";
-    if ($func_ref->[0] ne "void") {
-        $ret .= "return ";
-    }
-    $ret .= "funcs->$prefix.p_$name( $call_arg);\n";
+    $ret .= "return " unless is_void_func( $func_ref );
+    $ret .= "funcs->$prefix.p_$name($call_arg);\n";
     $ret .= "}\n";
 
     # Return this string....
@@ -320,28 +276,13 @@
 
     return "" if $name eq "glDebugEntry";
 
-    $ret = "static " . ConvertType($func_ref->[0]) . " null_$name( ";
-    for (my $i = 0; $i < @{$func_ref->[1]}; $i++) {
-        my $type = $func_ref->[1]->[$i]->[0];
-        my $name = ConvertVarName($func_ref->[1]->[$i]->[1]);
-        my $base_type;
-        if ($type =~ /(.*)(\[.*)/) {
-            $base_type = $1;
-            $name .= $2;
-        } else {
-            $base_type = $type;
-        }
-        $ret .= ConvertType($base_type) . " $name";
-        $ret .= "," if ($i+1 < @{$func_ref->[1]});
-        $ret .= " ";
-    }
-    $ret .= 'void ' if (!@{$func_ref->[1]});
-    $ret .= ") {";
+    $ret = get_func_proto( "static %s null_%s(%s)", $name, $func_ref );
+    $ret .= " {";
     if ($name eq "glGetError")
     {
         $ret .= " return GL_INVALID_OPERATION;";
     }
-    elsif ($func_ref->[0] ne "void")
+    elsif (!is_void_func( $func_ref ))
     {
         $ret .= " return 0;";
     }
@@ -355,33 +296,55 @@
     my $args=" ";
     foreach my $arg (@{$func->[1]})
     {
-        my $type = $arg->[0];
-        if ($type =~ /\*/) {
+        my $ptype = get_arg_type( $arg );
+        my $param = $arg->textContent();
+        if ($param =~ /[[*]/) {
             $args .= "ptr ";
-        } elsif (defined($arg_conv{$type})) {
-            $args .= "$@$arg_conv{$type}[0] ";
+        } elsif (defined($arg_conv{$ptype})) {
+            $args .= "$@$arg_conv{$ptype}[0] ";
         } else {
-            die "No conversion for func $name type $type\n";
+            die "No conversion for func $name type $param\n";
         }
     }
     $args = substr($args,1,-1);
     return "@ stdcall $_($args)";
 }
 
+sub is_void_func($)
+{
+    my $func = shift;
+    return 0 if @{$func->[0]->findnodes("./ptype")};
+    return $func->[0]->textContent() eq "void ";
+}
+
+sub get_arg_type($)
+{
+    my $p = shift;
+    my @type = $p->findnodes("./ptype");
+    return @type ? $type[0]->textContent() : "GLint";
+}
+
+sub get_arg_name($)
+{
+    my $p = shift;
+    my @name = $p->findnodes("./name");
+    return $name[0]->textContent();
+}
+
 sub get_func_proto($$$)
 {
     my ($format, $name, $func) = @_;
     die "unknown func $name" unless defined $func->[0];
-    my $ret = sprintf "%-10s", ConvertType($func->[0]);
-    $ret .= " " . sprintf($format,$name) . "(";
-    for (my $i = 0; $i < @{$func->[1]}; $i++)
+    my $proto = ConvertType( $func->[0]->textContent() );
+    $proto =~ s/ $//;
+    my $args = "";
+    foreach my $arg (@{$func->[1]})
     {
-        $ret .= ConvertType($func->[1]->[$i]->[0]);
-        $ret .= "," if ($i+1 < @{$func->[1]});
+        $args .= " " . ConvertType( $arg->textContent() ) . ",";
     }
-    $ret .= "void" unless @{$func->[1]};
-    $ret .= ")";
-    return $ret;
+    $args =~ s/,$/ /;
+    $args ||= "void";
+    return sprintf $format, $proto, $name, $args;
 }
 
 #
@@ -425,35 +388,11 @@
 # An element of the hash table is a reference to an array with these
 # elements :
 #
-#  - function name
+#  - XML node of the function prototype
 #
-#  - return type
-#
-#  - reference to an array giving the list of arguments (an empty array
+#  - reference to an array of XML nodes giving the list of arguments (an empty array
 #    for a 'void' function).
 #
-# The list of arguments is itself an array of reference to arrays. Each
-# of these arrays represents the argument type and the argument name.
-#
-# An example :
-#
-# void glBitmap( GLsizei width, GLsizei height,
-#                GLfloat xorig, GLfloat yorig,
-#                GLfloat xmove, GLfloat ymove,
-#                const GLubyte *bitmap );
-#
-# Would give something like that :
-#
-# [ "glBitmap",
-#   "void",
-#   [ [ "GLsizei", "width" ],
-#     [ "GLsizei", "height" ],
-#     [ "GLfloat", "xorig" ],
-#     [ "GLfloat", "yorig" ],
-#     [ "GLfloat", "xmove" ],
-#     [ "GLfloat", "ymove" ],
-#     [ "GLubyte *", "bitmap"] ] ];
-#
 my %norm_functions;
 my %ext_functions;
 my %wgl_functions;
@@ -501,133 +440,110 @@
 
 my %enums;
 
-sub parse_variable($)
-{
-    my $p = shift;
-    my $ptype = '';
-    my $pname = '';
-    my $pnamebefore = '';
-    my $pnameafter = '';
+my %supported_apis =
+    (
+     "gl" => 1,
+    );
 
-    while (my ($k, $v) = each(%$p)){
-        if ($k eq 'ptype') {
-            $ptype = ${$v}[0];
-        } elsif ($k eq 'name') {
-            $pname = ${$v}[0];
-        } elsif ($k eq 'content') {
-            if (ref($v) eq 'ARRAY') {
-                my @n = @{$v};
-                $pnamebefore = $n[0];
-                $pnameafter = $n[1] if (@n > 0);
-            } elsif ($v eq 'const ') {
-                $pnamebefore = $v;
-            } else {
-                $pnameafter = $v;
-            }
-        }
+sub is_supported_api($)
+{
+    my $api = shift;
+    foreach my $i (split /\|/, $api)
+    {
+        return 1 if defined $supported_apis{$i};
     }
-    $ptype = $pnamebefore . $ptype . $pnameafter;
-    $ptype =~ s/ \*/\*/g;
-    $ptype =~ s/ $//g;
-    return [ $ptype, $pname ];
+    return 0;
 }
 
 sub parse_file($$)
 {
     my ($file, $generate_enums) = @_;
-    my $xml = new XML::Simple;
-    my $data = $xml->XMLin($file, ForceArray => 1);
+    my $xml = XML::LibXML->load_xml( location => $file );
     my %functions;
 
     # save all functions
-    for my $cmds (@{$data->{commands}}) {
-      for my $command ( @{$cmds->{'command'}} ) {
-        my $name = '';
-        my $ret = '';
-        my $params = [];
-        my @alias = '';
-        while (my ($k, $v) = each(%$command)){
-            if ($k eq 'param') {
-                push(@$params, parse_variable($_)) for (@{$v});
-            } elsif ($k eq 'proto') {
-                ($ret, $name) = @{parse_variable(${$v}[0])};
-            }
-        }
-        $functions{$name} = [ $ret, $params ];
-      }
+    foreach my $command ($xml->findnodes("/registry/commands/command"))
+    {
+        my $proto = @{$command->findnodes("./proto")}[0];
+        my $name = @{$command->findnodes("./proto/name")}[0];
+        $proto->removeChild( $name );
+        my @params = $command->findnodes("./param");
+        $functions{$name->textContent()} = [ $proto, \@params ];
     }
 
     # save all enums (only GL)
-    if ($generate_enums) {
-        for my $enum ( @{$data->{'enums'}} ) {
-            if (ref($enum->{'enum'}) eq "HASH") {
-                while (my ($k, $v) = each(%{$enum->{'enum'}})){
-                    $enums{$k} = $v->{'value'};
-                }
-            }
+    if ($generate_enums)
+    {
+        foreach my $enum ($xml->findnodes("/registry/enums/enum"))
+        {
+            $enums{$enum->{name}} = $enum->{value};
         }
     }
 
     # generate norm functions
-    while (my ($k, $v) = each(%{$data->{feature}})) {
-        if ($norm_categories{$k}) {
-            for my $req (@{$v->{require}}) {
-                for(keys %{$req->{command}}) {
-                    $norm_functions{$_} = $functions{$_};
+    foreach my $feature ($xml->findnodes("/registry/feature"))
+    {
+        if ($feature->{api} eq "wgl")
+        {
+            foreach my $cmd ($feature->findnodes("./require/command"))
+            {
+                my $name = $cmd->{name};
+                if (defined $remapped_wgl_functions{$name})
+                {
+                    next unless $remapped_wgl_functions{$name};
+                    $name = $remapped_wgl_functions{$name};
                 }
+                $wgl_functions{$name} = $functions{$cmd->{name}};
             }
         }
+        next unless defined $norm_categories{$feature->{name}};
+        foreach my $cmd ($feature->findnodes("./require/command"))
+        {
+            $norm_functions{$cmd->{name}} = $functions{$cmd->{name}};
+        }
     }
 
     # generate extension functions from norm functions, if they are newer than the category
-    my %features = %{$data->{feature}};
-    foreach (sort keys %features) {
-        my ($k, $v) = %features{$_};
-        if (!$norm_categories{$k} && $v->{api} =~ /^gl(\||$)/)
+    foreach my $feature ($xml->findnodes("/registry/feature"))
+    {
+        next if defined $norm_categories{$feature->{name}};
+        next unless is_supported_api( $feature->{api} );
+        foreach my $cmd ($feature->findnodes("./require/command"))
         {
-            for my $req (@{$v->{require}}) {
-                for (keys %{$req->{command}}) {
-                    if (!$ext_functions{$_} && !$norm_functions{$_}) {
-                        $ext_functions{$_} = [ $functions{$_}[0], $functions{$_}[1], [ $k ] ];
-                    }
-                }
-            }
-        }
-        elsif ($v->{api} eq "wgl")
-        {
-            for my $req (@{$v->{require}}) {
-                for (keys %{$req->{command}}) {
-                    if (defined $remapped_wgl_functions{$_}) {
-                        $wgl_functions{$remapped_wgl_functions{$_}} = $functions{$_} if $remapped_wgl_functions{$_};
-                    }
-                    else {
-                        $wgl_functions{$_} = $functions{$_};
-                    }
-                }
-            }
+            my $name = $cmd->{name};
+            next if $norm_functions{$name} || $ext_functions{$name};
+            $ext_functions{$name} = [ $functions{$name}[0], $functions{$name}[1], [ $feature->{name} ] ];
         }
     }
 
     # generate extension functions
-    while (my ($k, $v) = each(%{${$data->{extensions}}[0]->{extension}})) {
-        if ($v->{supported} =~ /^gl(\||$)/) {
-            for my $req (@{$v->{require}}) {
-                if (!defined $req->{api} || $req->{api} =~ /^gl(\||$)/) {
-                    for (keys %{$req->{command}}) {
-                        if (!$ext_functions{$_} && !$norm_functions{$_}) {
-                            $ext_functions{$_} = [$functions{$_}[0], $functions{$_}[1], [ $k ]];
-                        }
-                        elsif ($ext_functions{$_}) {
-                            push @{$ext_functions{$_}->[2]}, $k;
-                        }
-                    }
-                }
+    foreach my $ext ($xml->findnodes("/registry/extensions/extension"))
+    {
+        if ($ext->{supported} eq "wgl")
+        {
+            next unless defined $supported_wgl_extensions{$ext->{name}};
+            foreach my $cmd ($ext->findnodes("./require/command"))
+            {
+                my $name = $cmd->{name};
+                $ext_functions{$name} = [ $functions{$name}[0], $functions{$name}[1], [ $ext->{name} ] ];
             }
+            next;
         }
-        elsif ($v->{supported} =~ /^wgl$/) {
-            for (keys %{${$v->{require}}[0]->{command}}) {
-                if (defined $supported_wgl_extensions{$k}) {
-                    $ext_functions{$_} = [ $functions{$_}[0], $functions{$_}[1], [ $k ] ];
+        next unless is_supported_api( $ext->{supported} );
+        foreach my $req ($ext->findnodes("./require"))
+        {
+            next unless !$req->{api} || $req->{api} eq "gl";
+            foreach my $cmd ($req->findnodes("./command"))
+            {
+                my $name = $cmd->{name};
+                next if $norm_functions{$name};
+                if (!$ext_functions{$name})
+                {
+                    $ext_functions{$name} = [ $functions{$name}[0], $functions{$name}[1], [ $ext->{name} ] ];
+                }
+                else
+                {
+                    push @{$ext_functions{$name}->[2]}, $ext->{name};
                 }
             }
         }
@@ -672,7 +588,7 @@
 foreach (sort keys %wgl_functions)
 {
     next unless defined $supported_wgl_functions{$_};
-    printf HEADER "        %s;\n", get_func_proto("(WINE_GLAPI *p_%s)", $_, $wgl_functions{$_});
+    print HEADER get_func_proto("        %-10s (WINE_GLAPI *p_%s)(%s);\n", $_, $wgl_functions{$_});
 }
 print HEADER "    } wgl;\n\n";
 
@@ -680,14 +596,14 @@
 foreach (sort keys %norm_functions)
 {
     next if $_ eq "glDebugEntry";
-    printf HEADER "        %s;\n", get_func_proto("(WINE_GLAPI *p_%s)", $_, $norm_functions{$_});
+    print HEADER get_func_proto("        %-10s (WINE_GLAPI *p_%s)(%s);\n", $_, $norm_functions{$_});
 }
 print HEADER "    } gl;\n\n";
 
 print HEADER "    struct\n    {\n";
 foreach (sort keys %ext_functions)
 {
-    printf HEADER "        %s;\n", get_func_proto("(WINE_GLAPI *p_%s)", $_, $ext_functions{$_});
+    print HEADER get_func_proto("        %-10s (WINE_GLAPI *p_%s)(%s);\n", $_, $ext_functions{$_});
 }
 print HEADER "    } ext;\n";
 print HEADER "};\n\n";
@@ -717,6 +633,9 @@
 print HEADER "#define GLAPIENTRY __stdcall\n";
 print HEADER "#endif\n\n";
 
+print HEADER "#undef near\n";
+print HEADER "#undef far\n\n";
+
 foreach (sort keys %arg_conv)
 {
     next unless $arg_conv{$_}[1];
@@ -734,7 +653,7 @@
 
 foreach (sort keys %norm_functions)
 {
-    printf HEADER "%s;\n", get_func_proto("GLAPIENTRY %s", $_, $norm_functions{$_});
+    printf HEADER "%s;\n", get_func_proto("%-10s GLAPIENTRY %s(%s)", $_, $norm_functions{$_});
 }
 
 print HEADER "\n#endif /* __WINE_WGL_H */\n";
diff --git a/dlls/opengl32/opengl_ext.c b/dlls/opengl32/opengl_ext.c
index 3efd9ab..7b22e68 100644
--- a/dlls/opengl32/opengl_ext.c
+++ b/dlls/opengl32/opengl_ext.c
@@ -16,15779 +16,18408 @@
 
 const int extension_registry_size = 2655;
 
-static void WINAPI glAccumxOES( GLenum op, GLfixed value ) {
+static void WINAPI glAccumxOES( GLenum op, GLfixed value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", op, value );
+  TRACE( "(%d, %d)\n", op, value );
   funcs->ext.p_glAccumxOES( op, value );
 }
 
-static GLboolean WINAPI glAcquireKeyedMutexWin32EXT( GLuint memory, GLuint64 key, GLuint timeout ) {
+static GLboolean WINAPI glAcquireKeyedMutexWin32EXT( GLuint memory, GLuint64 key, GLuint timeout )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %d)\n", memory, wine_dbgstr_longlong(key), timeout );
+  TRACE( "(%d, %s, %d)\n", memory, wine_dbgstr_longlong(key), timeout );
   return funcs->ext.p_glAcquireKeyedMutexWin32EXT( memory, key, timeout );
 }
 
-static void WINAPI glActiveProgramEXT( GLuint program ) {
+static void WINAPI glActiveProgramEXT( GLuint program )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", program );
+  TRACE( "(%d)\n", program );
   funcs->ext.p_glActiveProgramEXT( program );
 }
 
-static void WINAPI glActiveShaderProgram( GLuint pipeline, GLuint program ) {
+static void WINAPI glActiveShaderProgram( GLuint pipeline, GLuint program )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pipeline, program );
+  TRACE( "(%d, %d)\n", pipeline, program );
   funcs->ext.p_glActiveShaderProgram( pipeline, program );
 }
 
-static void WINAPI glActiveStencilFaceEXT( GLenum face ) {
+static void WINAPI glActiveStencilFaceEXT( GLenum face )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", face );
+  TRACE( "(%d)\n", face );
   funcs->ext.p_glActiveStencilFaceEXT( face );
 }
 
-static void WINAPI glActiveTexture( GLenum texture ) {
+static void WINAPI glActiveTexture( GLenum texture )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", texture );
+  TRACE( "(%d)\n", texture );
   funcs->ext.p_glActiveTexture( texture );
 }
 
-static void WINAPI glActiveTextureARB( GLenum texture ) {
+static void WINAPI glActiveTextureARB( GLenum texture )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", texture );
+  TRACE( "(%d)\n", texture );
   funcs->ext.p_glActiveTextureARB( texture );
 }
 
-static void WINAPI glActiveVaryingNV( GLuint program, const GLchar* name ) {
+static void WINAPI glActiveVaryingNV( GLuint program, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", program, name );
+  TRACE( "(%d, %p)\n", program, name );
   funcs->ext.p_glActiveVaryingNV( program, name );
 }
 
-static void WINAPI glAlphaFragmentOp1ATI( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod ) {
+static void WINAPI glAlphaFragmentOp1ATI( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", op, dst, dstMod, arg1, arg1Rep, arg1Mod );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", op, dst, dstMod, arg1, arg1Rep, arg1Mod );
   funcs->ext.p_glAlphaFragmentOp1ATI( op, dst, dstMod, arg1, arg1Rep, arg1Mod );
 }
 
-static void WINAPI glAlphaFragmentOp2ATI( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod ) {
+static void WINAPI glAlphaFragmentOp2ATI( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod );
   funcs->ext.p_glAlphaFragmentOp2ATI( op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod );
 }
 
-static void WINAPI glAlphaFragmentOp3ATI( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod ) {
+static void WINAPI glAlphaFragmentOp3ATI( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod );
   funcs->ext.p_glAlphaFragmentOp3ATI( op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod );
 }
 
-static void WINAPI glAlphaFuncxOES( GLenum func, GLfixed ref ) {
+static void WINAPI glAlphaFuncxOES( GLenum func, GLfixed ref )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", func, ref );
+  TRACE( "(%d, %d)\n", func, ref );
   funcs->ext.p_glAlphaFuncxOES( func, ref );
 }
 
-static void WINAPI glAlphaToCoverageDitherControlNV( GLenum mode ) {
+static void WINAPI glAlphaToCoverageDitherControlNV( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   funcs->ext.p_glAlphaToCoverageDitherControlNV( mode );
 }
 
-static void WINAPI glApplyFramebufferAttachmentCMAAINTEL( void ) {
+static void WINAPI glApplyFramebufferAttachmentCMAAINTEL(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glApplyFramebufferAttachmentCMAAINTEL( );
+  TRACE( "()\n" );
+  funcs->ext.p_glApplyFramebufferAttachmentCMAAINTEL();
 }
 
-static void WINAPI glApplyTextureEXT( GLenum mode ) {
+static void WINAPI glApplyTextureEXT( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   funcs->ext.p_glApplyTextureEXT( mode );
 }
 
-static GLboolean WINAPI glAreProgramsResidentNV( GLsizei n, const GLuint* programs, GLboolean* residences ) {
+static GLboolean WINAPI glAreProgramsResidentNV( GLsizei n, const GLuint *programs, GLboolean *residences )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %p)\n", n, programs, residences );
+  TRACE( "(%d, %p, %p)\n", n, programs, residences );
   return funcs->ext.p_glAreProgramsResidentNV( n, programs, residences );
 }
 
-static GLboolean WINAPI glAreTexturesResidentEXT( GLsizei n, const GLuint* textures, GLboolean* residences ) {
+static GLboolean WINAPI glAreTexturesResidentEXT( GLsizei n, const GLuint *textures, GLboolean *residences )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %p)\n", n, textures, residences );
+  TRACE( "(%d, %p, %p)\n", n, textures, residences );
   return funcs->ext.p_glAreTexturesResidentEXT( n, textures, residences );
 }
 
-static void WINAPI glArrayElementEXT( GLint i ) {
+static void WINAPI glArrayElementEXT( GLint i )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", i );
+  TRACE( "(%d)\n", i );
   funcs->ext.p_glArrayElementEXT( i );
 }
 
-static void WINAPI glArrayObjectATI( GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset ) {
+static void WINAPI glArrayObjectATI( GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", array, size, type, stride, buffer, offset );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", array, size, type, stride, buffer, offset );
   funcs->ext.p_glArrayObjectATI( array, size, type, stride, buffer, offset );
 }
 
-static void WINAPI glAsyncMarkerSGIX( GLuint marker ) {
+static void WINAPI glAsyncMarkerSGIX( GLuint marker )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", marker );
+  TRACE( "(%d)\n", marker );
   funcs->ext.p_glAsyncMarkerSGIX( marker );
 }
 
-static void WINAPI glAttachObjectARB( GLhandleARB containerObj, GLhandleARB obj ) {
+static void WINAPI glAttachObjectARB( GLhandleARB containerObj, GLhandleARB obj )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", containerObj, obj );
+  TRACE( "(%d, %d)\n", containerObj, obj );
   funcs->ext.p_glAttachObjectARB( containerObj, obj );
 }
 
-static void WINAPI glAttachShader( GLuint program, GLuint shader ) {
+static void WINAPI glAttachShader( GLuint program, GLuint shader )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", program, shader );
+  TRACE( "(%d, %d)\n", program, shader );
   funcs->ext.p_glAttachShader( program, shader );
 }
 
-static void WINAPI glBeginConditionalRender( GLuint id, GLenum mode ) {
+static void WINAPI glBeginConditionalRender( GLuint id, GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", id, mode );
+  TRACE( "(%d, %d)\n", id, mode );
   funcs->ext.p_glBeginConditionalRender( id, mode );
 }
 
-static void WINAPI glBeginConditionalRenderNV( GLuint id, GLenum mode ) {
+static void WINAPI glBeginConditionalRenderNV( GLuint id, GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", id, mode );
+  TRACE( "(%d, %d)\n", id, mode );
   funcs->ext.p_glBeginConditionalRenderNV( id, mode );
 }
 
-static void WINAPI glBeginConditionalRenderNVX( GLuint id ) {
+static void WINAPI glBeginConditionalRenderNVX( GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", id );
+  TRACE( "(%d)\n", id );
   funcs->ext.p_glBeginConditionalRenderNVX( id );
 }
 
-static void WINAPI glBeginFragmentShaderATI( void ) {
+static void WINAPI glBeginFragmentShaderATI(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glBeginFragmentShaderATI( );
+  TRACE( "()\n" );
+  funcs->ext.p_glBeginFragmentShaderATI();
 }
 
-static void WINAPI glBeginOcclusionQueryNV( GLuint id ) {
+static void WINAPI glBeginOcclusionQueryNV( GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", id );
+  TRACE( "(%d)\n", id );
   funcs->ext.p_glBeginOcclusionQueryNV( id );
 }
 
-static void WINAPI glBeginPerfMonitorAMD( GLuint monitor ) {
+static void WINAPI glBeginPerfMonitorAMD( GLuint monitor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", monitor );
+  TRACE( "(%d)\n", monitor );
   funcs->ext.p_glBeginPerfMonitorAMD( monitor );
 }
 
-static void WINAPI glBeginPerfQueryINTEL( GLuint queryHandle ) {
+static void WINAPI glBeginPerfQueryINTEL( GLuint queryHandle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", queryHandle );
+  TRACE( "(%d)\n", queryHandle );
   funcs->ext.p_glBeginPerfQueryINTEL( queryHandle );
 }
 
-static void WINAPI glBeginQuery( GLenum target, GLuint id ) {
+static void WINAPI glBeginQuery( GLenum target, GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, id );
+  TRACE( "(%d, %d)\n", target, id );
   funcs->ext.p_glBeginQuery( target, id );
 }
 
-static void WINAPI glBeginQueryARB( GLenum target, GLuint id ) {
+static void WINAPI glBeginQueryARB( GLenum target, GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, id );
+  TRACE( "(%d, %d)\n", target, id );
   funcs->ext.p_glBeginQueryARB( target, id );
 }
 
-static void WINAPI glBeginQueryIndexed( GLenum target, GLuint index, GLuint id ) {
+static void WINAPI glBeginQueryIndexed( GLenum target, GLuint index, GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, index, id );
+  TRACE( "(%d, %d, %d)\n", target, index, id );
   funcs->ext.p_glBeginQueryIndexed( target, index, id );
 }
 
-static void WINAPI glBeginTransformFeedback( GLenum primitiveMode ) {
+static void WINAPI glBeginTransformFeedback( GLenum primitiveMode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", primitiveMode );
+  TRACE( "(%d)\n", primitiveMode );
   funcs->ext.p_glBeginTransformFeedback( primitiveMode );
 }
 
-static void WINAPI glBeginTransformFeedbackEXT( GLenum primitiveMode ) {
+static void WINAPI glBeginTransformFeedbackEXT( GLenum primitiveMode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", primitiveMode );
+  TRACE( "(%d)\n", primitiveMode );
   funcs->ext.p_glBeginTransformFeedbackEXT( primitiveMode );
 }
 
-static void WINAPI glBeginTransformFeedbackNV( GLenum primitiveMode ) {
+static void WINAPI glBeginTransformFeedbackNV( GLenum primitiveMode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", primitiveMode );
+  TRACE( "(%d)\n", primitiveMode );
   funcs->ext.p_glBeginTransformFeedbackNV( primitiveMode );
 }
 
-static void WINAPI glBeginVertexShaderEXT( void ) {
+static void WINAPI glBeginVertexShaderEXT(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glBeginVertexShaderEXT( );
+  TRACE( "()\n" );
+  funcs->ext.p_glBeginVertexShaderEXT();
 }
 
-static void WINAPI glBeginVideoCaptureNV( GLuint video_capture_slot ) {
+static void WINAPI glBeginVideoCaptureNV( GLuint video_capture_slot )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", video_capture_slot );
+  TRACE( "(%d)\n", video_capture_slot );
   funcs->ext.p_glBeginVideoCaptureNV( video_capture_slot );
 }
 
-static void WINAPI glBindAttribLocation( GLuint program, GLuint index, const GLchar* name ) {
+static void WINAPI glBindAttribLocation( GLuint program, GLuint index, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, index, name );
+  TRACE( "(%d, %d, %p)\n", program, index, name );
   funcs->ext.p_glBindAttribLocation( program, index, name );
 }
 
-static void WINAPI glBindAttribLocationARB( GLhandleARB programObj, GLuint index, const GLcharARB* name ) {
+static void WINAPI glBindAttribLocationARB( GLhandleARB programObj, GLuint index, const GLcharARB *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", programObj, index, name );
+  TRACE( "(%d, %d, %p)\n", programObj, index, name );
   funcs->ext.p_glBindAttribLocationARB( programObj, index, name );
 }
 
-static void WINAPI glBindBuffer( GLenum target, GLuint buffer ) {
+static void WINAPI glBindBuffer( GLenum target, GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, buffer );
+  TRACE( "(%d, %d)\n", target, buffer );
   funcs->ext.p_glBindBuffer( target, buffer );
 }
 
-static void WINAPI glBindBufferARB( GLenum target, GLuint buffer ) {
+static void WINAPI glBindBufferARB( GLenum target, GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, buffer );
+  TRACE( "(%d, %d)\n", target, buffer );
   funcs->ext.p_glBindBufferARB( target, buffer );
 }
 
-static void WINAPI glBindBufferBase( GLenum target, GLuint index, GLuint buffer ) {
+static void WINAPI glBindBufferBase( GLenum target, GLuint index, GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, index, buffer );
+  TRACE( "(%d, %d, %d)\n", target, index, buffer );
   funcs->ext.p_glBindBufferBase( target, index, buffer );
 }
 
-static void WINAPI glBindBufferBaseEXT( GLenum target, GLuint index, GLuint buffer ) {
+static void WINAPI glBindBufferBaseEXT( GLenum target, GLuint index, GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, index, buffer );
+  TRACE( "(%d, %d, %d)\n", target, index, buffer );
   funcs->ext.p_glBindBufferBaseEXT( target, index, buffer );
 }
 
-static void WINAPI glBindBufferBaseNV( GLenum target, GLuint index, GLuint buffer ) {
+static void WINAPI glBindBufferBaseNV( GLenum target, GLuint index, GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, index, buffer );
+  TRACE( "(%d, %d, %d)\n", target, index, buffer );
   funcs->ext.p_glBindBufferBaseNV( target, index, buffer );
 }
 
-static void WINAPI glBindBufferOffsetEXT( GLenum target, GLuint index, GLuint buffer, GLintptr offset ) {
+static void WINAPI glBindBufferOffsetEXT( GLenum target, GLuint index, GLuint buffer, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %ld)\n", target, index, buffer, offset );
+  TRACE( "(%d, %d, %d, %ld)\n", target, index, buffer, offset );
   funcs->ext.p_glBindBufferOffsetEXT( target, index, buffer, offset );
 }
 
-static void WINAPI glBindBufferOffsetNV( GLenum target, GLuint index, GLuint buffer, GLintptr offset ) {
+static void WINAPI glBindBufferOffsetNV( GLenum target, GLuint index, GLuint buffer, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %ld)\n", target, index, buffer, offset );
+  TRACE( "(%d, %d, %d, %ld)\n", target, index, buffer, offset );
   funcs->ext.p_glBindBufferOffsetNV( target, index, buffer, offset );
 }
 
-static void WINAPI glBindBufferRange( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size ) {
+static void WINAPI glBindBufferRange( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %ld, %ld)\n", target, index, buffer, offset, size );
+  TRACE( "(%d, %d, %d, %ld, %ld)\n", target, index, buffer, offset, size );
   funcs->ext.p_glBindBufferRange( target, index, buffer, offset, size );
 }
 
-static void WINAPI glBindBufferRangeEXT( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size ) {
+static void WINAPI glBindBufferRangeEXT( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %ld, %ld)\n", target, index, buffer, offset, size );
+  TRACE( "(%d, %d, %d, %ld, %ld)\n", target, index, buffer, offset, size );
   funcs->ext.p_glBindBufferRangeEXT( target, index, buffer, offset, size );
 }
 
-static void WINAPI glBindBufferRangeNV( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size ) {
+static void WINAPI glBindBufferRangeNV( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %ld, %ld)\n", target, index, buffer, offset, size );
+  TRACE( "(%d, %d, %d, %ld, %ld)\n", target, index, buffer, offset, size );
   funcs->ext.p_glBindBufferRangeNV( target, index, buffer, offset, size );
 }
 
-static void WINAPI glBindBuffersBase( GLenum target, GLuint first, GLsizei count, const GLuint* buffers ) {
+static void WINAPI glBindBuffersBase( GLenum target, GLuint first, GLsizei count, const GLuint *buffers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, first, count, buffers );
+  TRACE( "(%d, %d, %d, %p)\n", target, first, count, buffers );
   funcs->ext.p_glBindBuffersBase( target, first, count, buffers );
 }
 
-static void WINAPI glBindBuffersRange( GLenum target, GLuint first, GLsizei count, const GLuint* buffers, const GLintptr* offsets, const GLsizeiptr* sizes ) {
+static void WINAPI glBindBuffersRange( GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p, %p)\n", target, first, count, buffers, offsets, sizes );
+  TRACE( "(%d, %d, %d, %p, %p, %p)\n", target, first, count, buffers, offsets, sizes );
   funcs->ext.p_glBindBuffersRange( target, first, count, buffers, offsets, sizes );
 }
 
-static void WINAPI glBindFragDataLocation( GLuint program, GLuint color, const GLchar* name ) {
+static void WINAPI glBindFragDataLocation( GLuint program, GLuint color, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, color, name );
+  TRACE( "(%d, %d, %p)\n", program, color, name );
   funcs->ext.p_glBindFragDataLocation( program, color, name );
 }
 
-static void WINAPI glBindFragDataLocationEXT( GLuint program, GLuint color, const GLchar* name ) {
+static void WINAPI glBindFragDataLocationEXT( GLuint program, GLuint color, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, color, name );
+  TRACE( "(%d, %d, %p)\n", program, color, name );
   funcs->ext.p_glBindFragDataLocationEXT( program, color, name );
 }
 
-static void WINAPI glBindFragDataLocationIndexed( GLuint program, GLuint colorNumber, GLuint index, const GLchar* name ) {
+static void WINAPI glBindFragDataLocationIndexed( GLuint program, GLuint colorNumber, GLuint index, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, colorNumber, index, name );
+  TRACE( "(%d, %d, %d, %p)\n", program, colorNumber, index, name );
   funcs->ext.p_glBindFragDataLocationIndexed( program, colorNumber, index, name );
 }
 
-static void WINAPI glBindFragmentShaderATI( GLuint id ) {
+static void WINAPI glBindFragmentShaderATI( GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", id );
+  TRACE( "(%d)\n", id );
   funcs->ext.p_glBindFragmentShaderATI( id );
 }
 
-static void WINAPI glBindFramebuffer( GLenum target, GLuint framebuffer ) {
+static void WINAPI glBindFramebuffer( GLenum target, GLuint framebuffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, framebuffer );
+  TRACE( "(%d, %d)\n", target, framebuffer );
   funcs->ext.p_glBindFramebuffer( target, framebuffer );
 }
 
-static void WINAPI glBindFramebufferEXT( GLenum target, GLuint framebuffer ) {
+static void WINAPI glBindFramebufferEXT( GLenum target, GLuint framebuffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, framebuffer );
+  TRACE( "(%d, %d)\n", target, framebuffer );
   funcs->ext.p_glBindFramebufferEXT( target, framebuffer );
 }
 
-static void WINAPI glBindImageTexture( GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format ) {
+static void WINAPI glBindImageTexture( GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", unit, texture, level, layered, layer, access, format );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", unit, texture, level, layered, layer, access, format );
   funcs->ext.p_glBindImageTexture( unit, texture, level, layered, layer, access, format );
 }
 
-static void WINAPI glBindImageTextureEXT( GLuint index, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLint format ) {
+static void WINAPI glBindImageTextureEXT( GLuint index, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLint format )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", index, texture, level, layered, layer, access, format );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", index, texture, level, layered, layer, access, format );
   funcs->ext.p_glBindImageTextureEXT( index, texture, level, layered, layer, access, format );
 }
 
-static void WINAPI glBindImageTextures( GLuint first, GLsizei count, const GLuint* textures ) {
+static void WINAPI glBindImageTextures( GLuint first, GLsizei count, const GLuint *textures )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", first, count, textures );
+  TRACE( "(%d, %d, %p)\n", first, count, textures );
   funcs->ext.p_glBindImageTextures( first, count, textures );
 }
 
-static GLuint WINAPI glBindLightParameterEXT( GLenum light, GLenum value ) {
+static GLuint WINAPI glBindLightParameterEXT( GLenum light, GLenum value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", light, value );
+  TRACE( "(%d, %d)\n", light, value );
   return funcs->ext.p_glBindLightParameterEXT( light, value );
 }
 
-static GLuint WINAPI glBindMaterialParameterEXT( GLenum face, GLenum value ) {
+static GLuint WINAPI glBindMaterialParameterEXT( GLenum face, GLenum value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", face, value );
+  TRACE( "(%d, %d)\n", face, value );
   return funcs->ext.p_glBindMaterialParameterEXT( face, value );
 }
 
-static void WINAPI glBindMultiTextureEXT( GLenum texunit, GLenum target, GLuint texture ) {
+static void WINAPI glBindMultiTextureEXT( GLenum texunit, GLenum target, GLuint texture )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", texunit, target, texture );
+  TRACE( "(%d, %d, %d)\n", texunit, target, texture );
   funcs->ext.p_glBindMultiTextureEXT( texunit, target, texture );
 }
 
-static GLuint WINAPI glBindParameterEXT( GLenum value ) {
+static GLuint WINAPI glBindParameterEXT( GLenum value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", value );
+  TRACE( "(%d)\n", value );
   return funcs->ext.p_glBindParameterEXT( value );
 }
 
-static void WINAPI glBindProgramARB( GLenum target, GLuint program ) {
+static void WINAPI glBindProgramARB( GLenum target, GLuint program )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, program );
+  TRACE( "(%d, %d)\n", target, program );
   funcs->ext.p_glBindProgramARB( target, program );
 }
 
-static void WINAPI glBindProgramNV( GLenum target, GLuint id ) {
+static void WINAPI glBindProgramNV( GLenum target, GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, id );
+  TRACE( "(%d, %d)\n", target, id );
   funcs->ext.p_glBindProgramNV( target, id );
 }
 
-static void WINAPI glBindProgramPipeline( GLuint pipeline ) {
+static void WINAPI glBindProgramPipeline( GLuint pipeline )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", pipeline );
+  TRACE( "(%d)\n", pipeline );
   funcs->ext.p_glBindProgramPipeline( pipeline );
 }
 
-static void WINAPI glBindRenderbuffer( GLenum target, GLuint renderbuffer ) {
+static void WINAPI glBindRenderbuffer( GLenum target, GLuint renderbuffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, renderbuffer );
+  TRACE( "(%d, %d)\n", target, renderbuffer );
   funcs->ext.p_glBindRenderbuffer( target, renderbuffer );
 }
 
-static void WINAPI glBindRenderbufferEXT( GLenum target, GLuint renderbuffer ) {
+static void WINAPI glBindRenderbufferEXT( GLenum target, GLuint renderbuffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, renderbuffer );
+  TRACE( "(%d, %d)\n", target, renderbuffer );
   funcs->ext.p_glBindRenderbufferEXT( target, renderbuffer );
 }
 
-static void WINAPI glBindSampler( GLuint unit, GLuint sampler ) {
+static void WINAPI glBindSampler( GLuint unit, GLuint sampler )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", unit, sampler );
+  TRACE( "(%d, %d)\n", unit, sampler );
   funcs->ext.p_glBindSampler( unit, sampler );
 }
 
-static void WINAPI glBindSamplers( GLuint first, GLsizei count, const GLuint* samplers ) {
+static void WINAPI glBindSamplers( GLuint first, GLsizei count, const GLuint *samplers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", first, count, samplers );
+  TRACE( "(%d, %d, %p)\n", first, count, samplers );
   funcs->ext.p_glBindSamplers( first, count, samplers );
 }
 
-static GLuint WINAPI glBindTexGenParameterEXT( GLenum unit, GLenum coord, GLenum value ) {
+static GLuint WINAPI glBindTexGenParameterEXT( GLenum unit, GLenum coord, GLenum value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", unit, coord, value );
+  TRACE( "(%d, %d, %d)\n", unit, coord, value );
   return funcs->ext.p_glBindTexGenParameterEXT( unit, coord, value );
 }
 
-static void WINAPI glBindTextureEXT( GLenum target, GLuint texture ) {
+static void WINAPI glBindTextureEXT( GLenum target, GLuint texture )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, texture );
+  TRACE( "(%d, %d)\n", target, texture );
   funcs->ext.p_glBindTextureEXT( target, texture );
 }
 
-static void WINAPI glBindTextureUnit( GLuint unit, GLuint texture ) {
+static void WINAPI glBindTextureUnit( GLuint unit, GLuint texture )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", unit, texture );
+  TRACE( "(%d, %d)\n", unit, texture );
   funcs->ext.p_glBindTextureUnit( unit, texture );
 }
 
-static GLuint WINAPI glBindTextureUnitParameterEXT( GLenum unit, GLenum value ) {
+static GLuint WINAPI glBindTextureUnitParameterEXT( GLenum unit, GLenum value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", unit, value );
+  TRACE( "(%d, %d)\n", unit, value );
   return funcs->ext.p_glBindTextureUnitParameterEXT( unit, value );
 }
 
-static void WINAPI glBindTextures( GLuint first, GLsizei count, const GLuint* textures ) {
+static void WINAPI glBindTextures( GLuint first, GLsizei count, const GLuint *textures )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", first, count, textures );
+  TRACE( "(%d, %d, %p)\n", first, count, textures );
   funcs->ext.p_glBindTextures( first, count, textures );
 }
 
-static void WINAPI glBindTransformFeedback( GLenum target, GLuint id ) {
+static void WINAPI glBindTransformFeedback( GLenum target, GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, id );
+  TRACE( "(%d, %d)\n", target, id );
   funcs->ext.p_glBindTransformFeedback( target, id );
 }
 
-static void WINAPI glBindTransformFeedbackNV( GLenum target, GLuint id ) {
+static void WINAPI glBindTransformFeedbackNV( GLenum target, GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, id );
+  TRACE( "(%d, %d)\n", target, id );
   funcs->ext.p_glBindTransformFeedbackNV( target, id );
 }
 
-static void WINAPI glBindVertexArray( GLuint array ) {
+static void WINAPI glBindVertexArray( GLuint array )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", array );
+  TRACE( "(%d)\n", array );
   funcs->ext.p_glBindVertexArray( array );
 }
 
-static void WINAPI glBindVertexArrayAPPLE( GLuint array ) {
+static void WINAPI glBindVertexArrayAPPLE( GLuint array )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", array );
+  TRACE( "(%d)\n", array );
   funcs->ext.p_glBindVertexArrayAPPLE( array );
 }
 
-static void WINAPI glBindVertexBuffer( GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride ) {
+static void WINAPI glBindVertexBuffer( GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %ld, %d)\n", bindingindex, buffer, offset, stride );
+  TRACE( "(%d, %d, %ld, %d)\n", bindingindex, buffer, offset, stride );
   funcs->ext.p_glBindVertexBuffer( bindingindex, buffer, offset, stride );
 }
 
-static void WINAPI glBindVertexBuffers( GLuint first, GLsizei count, const GLuint* buffers, const GLintptr* offsets, const GLsizei* strides ) {
+static void WINAPI glBindVertexBuffers( GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p, %p)\n", first, count, buffers, offsets, strides );
+  TRACE( "(%d, %d, %p, %p, %p)\n", first, count, buffers, offsets, strides );
   funcs->ext.p_glBindVertexBuffers( first, count, buffers, offsets, strides );
 }
 
-static void WINAPI glBindVertexShaderEXT( GLuint id ) {
+static void WINAPI glBindVertexShaderEXT( GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", id );
+  TRACE( "(%d)\n", id );
   funcs->ext.p_glBindVertexShaderEXT( id );
 }
 
-static void WINAPI glBindVideoCaptureStreamBufferNV( GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLintptrARB offset ) {
+static void WINAPI glBindVideoCaptureStreamBufferNV( GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLintptrARB offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %ld)\n", video_capture_slot, stream, frame_region, offset );
+  TRACE( "(%d, %d, %d, %ld)\n", video_capture_slot, stream, frame_region, offset );
   funcs->ext.p_glBindVideoCaptureStreamBufferNV( video_capture_slot, stream, frame_region, offset );
 }
 
-static void WINAPI glBindVideoCaptureStreamTextureNV( GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLenum target, GLuint texture ) {
+static void WINAPI glBindVideoCaptureStreamTextureNV( GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLenum target, GLuint texture )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", video_capture_slot, stream, frame_region, target, texture );
+  TRACE( "(%d, %d, %d, %d, %d)\n", video_capture_slot, stream, frame_region, target, texture );
   funcs->ext.p_glBindVideoCaptureStreamTextureNV( video_capture_slot, stream, frame_region, target, texture );
 }
 
-static void WINAPI glBinormal3bEXT( GLbyte bx, GLbyte by, GLbyte bz ) {
+static void WINAPI glBinormal3bEXT( GLbyte bx, GLbyte by, GLbyte bz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", bx, by, bz );
+  TRACE( "(%d, %d, %d)\n", bx, by, bz );
   funcs->ext.p_glBinormal3bEXT( bx, by, bz );
 }
 
-static void WINAPI glBinormal3bvEXT( const GLbyte* v ) {
+static void WINAPI glBinormal3bvEXT( const GLbyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glBinormal3bvEXT( v );
 }
 
-static void WINAPI glBinormal3dEXT( GLdouble bx, GLdouble by, GLdouble bz ) {
+static void WINAPI glBinormal3dEXT( GLdouble bx, GLdouble by, GLdouble bz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", bx, by, bz );
+  TRACE( "(%f, %f, %f)\n", bx, by, bz );
   funcs->ext.p_glBinormal3dEXT( bx, by, bz );
 }
 
-static void WINAPI glBinormal3dvEXT( const GLdouble* v ) {
+static void WINAPI glBinormal3dvEXT( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glBinormal3dvEXT( v );
 }
 
-static void WINAPI glBinormal3fEXT( GLfloat bx, GLfloat by, GLfloat bz ) {
+static void WINAPI glBinormal3fEXT( GLfloat bx, GLfloat by, GLfloat bz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", bx, by, bz );
+  TRACE( "(%f, %f, %f)\n", bx, by, bz );
   funcs->ext.p_glBinormal3fEXT( bx, by, bz );
 }
 
-static void WINAPI glBinormal3fvEXT( const GLfloat* v ) {
+static void WINAPI glBinormal3fvEXT( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glBinormal3fvEXT( v );
 }
 
-static void WINAPI glBinormal3iEXT( GLint bx, GLint by, GLint bz ) {
+static void WINAPI glBinormal3iEXT( GLint bx, GLint by, GLint bz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", bx, by, bz );
+  TRACE( "(%d, %d, %d)\n", bx, by, bz );
   funcs->ext.p_glBinormal3iEXT( bx, by, bz );
 }
 
-static void WINAPI glBinormal3ivEXT( const GLint* v ) {
+static void WINAPI glBinormal3ivEXT( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glBinormal3ivEXT( v );
 }
 
-static void WINAPI glBinormal3sEXT( GLshort bx, GLshort by, GLshort bz ) {
+static void WINAPI glBinormal3sEXT( GLshort bx, GLshort by, GLshort bz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", bx, by, bz );
+  TRACE( "(%d, %d, %d)\n", bx, by, bz );
   funcs->ext.p_glBinormal3sEXT( bx, by, bz );
 }
 
-static void WINAPI glBinormal3svEXT( const GLshort* v ) {
+static void WINAPI glBinormal3svEXT( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glBinormal3svEXT( v );
 }
 
-static void WINAPI glBinormalPointerEXT( GLenum type, GLsizei stride, const void* pointer ) {
+static void WINAPI glBinormalPointerEXT( GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", type, stride, pointer );
+  TRACE( "(%d, %d, %p)\n", type, stride, pointer );
   funcs->ext.p_glBinormalPointerEXT( type, stride, pointer );
 }
 
-static void WINAPI glBitmapxOES( GLsizei width, GLsizei height, GLfixed xorig, GLfixed yorig, GLfixed xmove, GLfixed ymove, const GLubyte* bitmap ) {
+static void WINAPI glBitmapxOES( GLsizei width, GLsizei height, GLfixed xorig, GLfixed yorig, GLfixed xmove, GLfixed ymove, const GLubyte *bitmap )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", width, height, xorig, yorig, xmove, ymove, bitmap );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %p)\n", width, height, xorig, yorig, xmove, ymove, bitmap );
   funcs->ext.p_glBitmapxOES( width, height, xorig, yorig, xmove, ymove, bitmap );
 }
 
-static void WINAPI glBlendBarrierKHR( void ) {
+static void WINAPI glBlendBarrierKHR(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glBlendBarrierKHR( );
+  TRACE( "()\n" );
+  funcs->ext.p_glBlendBarrierKHR();
 }
 
-static void WINAPI glBlendBarrierNV( void ) {
+static void WINAPI glBlendBarrierNV(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glBlendBarrierNV( );
+  TRACE( "()\n" );
+  funcs->ext.p_glBlendBarrierNV();
 }
 
-static void WINAPI glBlendColor( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) {
+static void WINAPI glBlendColor( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha );
+  TRACE( "(%f, %f, %f, %f)\n", red, green, blue, alpha );
   funcs->ext.p_glBlendColor( red, green, blue, alpha );
 }
 
-static void WINAPI glBlendColorEXT( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) {
+static void WINAPI glBlendColorEXT( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha );
+  TRACE( "(%f, %f, %f, %f)\n", red, green, blue, alpha );
   funcs->ext.p_glBlendColorEXT( red, green, blue, alpha );
 }
 
-static void WINAPI glBlendColorxOES( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) {
+static void WINAPI glBlendColorxOES( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
+  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
   funcs->ext.p_glBlendColorxOES( red, green, blue, alpha );
 }
 
-static void WINAPI glBlendEquation( GLenum mode ) {
+static void WINAPI glBlendEquation( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   funcs->ext.p_glBlendEquation( mode );
 }
 
-static void WINAPI glBlendEquationEXT( GLenum mode ) {
+static void WINAPI glBlendEquationEXT( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   funcs->ext.p_glBlendEquationEXT( mode );
 }
 
-static void WINAPI glBlendEquationIndexedAMD( GLuint buf, GLenum mode ) {
+static void WINAPI glBlendEquationIndexedAMD( GLuint buf, GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", buf, mode );
+  TRACE( "(%d, %d)\n", buf, mode );
   funcs->ext.p_glBlendEquationIndexedAMD( buf, mode );
 }
 
-static void WINAPI glBlendEquationSeparate( GLenum modeRGB, GLenum modeAlpha ) {
+static void WINAPI glBlendEquationSeparate( GLenum modeRGB, GLenum modeAlpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", modeRGB, modeAlpha );
+  TRACE( "(%d, %d)\n", modeRGB, modeAlpha );
   funcs->ext.p_glBlendEquationSeparate( modeRGB, modeAlpha );
 }
 
-static void WINAPI glBlendEquationSeparateEXT( GLenum modeRGB, GLenum modeAlpha ) {
+static void WINAPI glBlendEquationSeparateEXT( GLenum modeRGB, GLenum modeAlpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", modeRGB, modeAlpha );
+  TRACE( "(%d, %d)\n", modeRGB, modeAlpha );
   funcs->ext.p_glBlendEquationSeparateEXT( modeRGB, modeAlpha );
 }
 
-static void WINAPI glBlendEquationSeparateIndexedAMD( GLuint buf, GLenum modeRGB, GLenum modeAlpha ) {
+static void WINAPI glBlendEquationSeparateIndexedAMD( GLuint buf, GLenum modeRGB, GLenum modeAlpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", buf, modeRGB, modeAlpha );
+  TRACE( "(%d, %d, %d)\n", buf, modeRGB, modeAlpha );
   funcs->ext.p_glBlendEquationSeparateIndexedAMD( buf, modeRGB, modeAlpha );
 }
 
-static void WINAPI glBlendEquationSeparatei( GLuint buf, GLenum modeRGB, GLenum modeAlpha ) {
+static void WINAPI glBlendEquationSeparatei( GLuint buf, GLenum modeRGB, GLenum modeAlpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", buf, modeRGB, modeAlpha );
+  TRACE( "(%d, %d, %d)\n", buf, modeRGB, modeAlpha );
   funcs->ext.p_glBlendEquationSeparatei( buf, modeRGB, modeAlpha );
 }
 
-static void WINAPI glBlendEquationSeparateiARB( GLuint buf, GLenum modeRGB, GLenum modeAlpha ) {
+static void WINAPI glBlendEquationSeparateiARB( GLuint buf, GLenum modeRGB, GLenum modeAlpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", buf, modeRGB, modeAlpha );
+  TRACE( "(%d, %d, %d)\n", buf, modeRGB, modeAlpha );
   funcs->ext.p_glBlendEquationSeparateiARB( buf, modeRGB, modeAlpha );
 }
 
-static void WINAPI glBlendEquationi( GLuint buf, GLenum mode ) {
+static void WINAPI glBlendEquationi( GLuint buf, GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", buf, mode );
+  TRACE( "(%d, %d)\n", buf, mode );
   funcs->ext.p_glBlendEquationi( buf, mode );
 }
 
-static void WINAPI glBlendEquationiARB( GLuint buf, GLenum mode ) {
+static void WINAPI glBlendEquationiARB( GLuint buf, GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", buf, mode );
+  TRACE( "(%d, %d)\n", buf, mode );
   funcs->ext.p_glBlendEquationiARB( buf, mode );
 }
 
-static void WINAPI glBlendFuncIndexedAMD( GLuint buf, GLenum src, GLenum dst ) {
+static void WINAPI glBlendFuncIndexedAMD( GLuint buf, GLenum src, GLenum dst )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", buf, src, dst );
+  TRACE( "(%d, %d, %d)\n", buf, src, dst );
   funcs->ext.p_glBlendFuncIndexedAMD( buf, src, dst );
 }
 
-static void WINAPI glBlendFuncSeparate( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha ) {
+static void WINAPI glBlendFuncSeparate( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha );
+  TRACE( "(%d, %d, %d, %d)\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha );
   funcs->ext.p_glBlendFuncSeparate( sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha );
 }
 
-static void WINAPI glBlendFuncSeparateEXT( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha ) {
+static void WINAPI glBlendFuncSeparateEXT( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha );
+  TRACE( "(%d, %d, %d, %d)\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha );
   funcs->ext.p_glBlendFuncSeparateEXT( sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha );
 }
 
-static void WINAPI glBlendFuncSeparateINGR( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha ) {
+static void WINAPI glBlendFuncSeparateINGR( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha );
+  TRACE( "(%d, %d, %d, %d)\n", sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha );
   funcs->ext.p_glBlendFuncSeparateINGR( sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha );
 }
 
-static void WINAPI glBlendFuncSeparateIndexedAMD( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) {
+static void WINAPI glBlendFuncSeparateIndexedAMD( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", buf, srcRGB, dstRGB, srcAlpha, dstAlpha );
+  TRACE( "(%d, %d, %d, %d, %d)\n", buf, srcRGB, dstRGB, srcAlpha, dstAlpha );
   funcs->ext.p_glBlendFuncSeparateIndexedAMD( buf, srcRGB, dstRGB, srcAlpha, dstAlpha );
 }
 
-static void WINAPI glBlendFuncSeparatei( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) {
+static void WINAPI glBlendFuncSeparatei( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", buf, srcRGB, dstRGB, srcAlpha, dstAlpha );
+  TRACE( "(%d, %d, %d, %d, %d)\n", buf, srcRGB, dstRGB, srcAlpha, dstAlpha );
   funcs->ext.p_glBlendFuncSeparatei( buf, srcRGB, dstRGB, srcAlpha, dstAlpha );
 }
 
-static void WINAPI glBlendFuncSeparateiARB( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha ) {
+static void WINAPI glBlendFuncSeparateiARB( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", buf, srcRGB, dstRGB, srcAlpha, dstAlpha );
+  TRACE( "(%d, %d, %d, %d, %d)\n", buf, srcRGB, dstRGB, srcAlpha, dstAlpha );
   funcs->ext.p_glBlendFuncSeparateiARB( buf, srcRGB, dstRGB, srcAlpha, dstAlpha );
 }
 
-static void WINAPI glBlendFunci( GLuint buf, GLenum src, GLenum dst ) {
+static void WINAPI glBlendFunci( GLuint buf, GLenum src, GLenum dst )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", buf, src, dst );
+  TRACE( "(%d, %d, %d)\n", buf, src, dst );
   funcs->ext.p_glBlendFunci( buf, src, dst );
 }
 
-static void WINAPI glBlendFunciARB( GLuint buf, GLenum src, GLenum dst ) {
+static void WINAPI glBlendFunciARB( GLuint buf, GLenum src, GLenum dst )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", buf, src, dst );
+  TRACE( "(%d, %d, %d)\n", buf, src, dst );
   funcs->ext.p_glBlendFunciARB( buf, src, dst );
 }
 
-static void WINAPI glBlendParameteriNV( GLenum pname, GLint value ) {
+static void WINAPI glBlendParameteriNV( GLenum pname, GLint value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, value );
+  TRACE( "(%d, %d)\n", pname, value );
   funcs->ext.p_glBlendParameteriNV( pname, value );
 }
 
-static void WINAPI glBlitFramebuffer( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter ) {
+static void WINAPI glBlitFramebuffer( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
   funcs->ext.p_glBlitFramebuffer( srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
 }
 
-static void WINAPI glBlitFramebufferEXT( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter ) {
+static void WINAPI glBlitFramebufferEXT( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
   funcs->ext.p_glBlitFramebufferEXT( srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
 }
 
-static void WINAPI glBlitNamedFramebuffer( GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter ) {
+static void WINAPI glBlitNamedFramebuffer( GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
   funcs->ext.p_glBlitNamedFramebuffer( readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
 }
 
-static void WINAPI glBufferAddressRangeNV( GLenum pname, GLuint index, GLuint64EXT address, GLsizeiptr length ) {
+static void WINAPI glBufferAddressRangeNV( GLenum pname, GLuint index, GLuint64EXT address, GLsizeiptr length )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s, %ld)\n", pname, index, wine_dbgstr_longlong(address), length );
+  TRACE( "(%d, %d, %s, %ld)\n", pname, index, wine_dbgstr_longlong(address), length );
   funcs->ext.p_glBufferAddressRangeNV( pname, index, address, length );
 }
 
-static void WINAPI glBufferData( GLenum target, GLsizeiptr size, const void* data, GLenum usage ) {
+static void WINAPI glBufferData( GLenum target, GLsizeiptr size, const void *data, GLenum usage )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %p, %d)\n", target, size, data, usage );
+  TRACE( "(%d, %ld, %p, %d)\n", target, size, data, usage );
   funcs->ext.p_glBufferData( target, size, data, usage );
 }
 
-static void WINAPI glBufferDataARB( GLenum target, GLsizeiptrARB size, const void* data, GLenum usage ) {
+static void WINAPI glBufferDataARB( GLenum target, GLsizeiptrARB size, const void *data, GLenum usage )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %p, %d)\n", target, size, data, usage );
+  TRACE( "(%d, %ld, %p, %d)\n", target, size, data, usage );
   funcs->ext.p_glBufferDataARB( target, size, data, usage );
 }
 
-static void WINAPI glBufferPageCommitmentARB( GLenum target, GLintptr offset, GLsizeiptr size, GLboolean commit ) {
+static void WINAPI glBufferPageCommitmentARB( GLenum target, GLintptr offset, GLsizeiptr size, GLboolean commit )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld, %d)\n", target, offset, size, commit );
+  TRACE( "(%d, %ld, %ld, %d)\n", target, offset, size, commit );
   funcs->ext.p_glBufferPageCommitmentARB( target, offset, size, commit );
 }
 
-static void WINAPI glBufferParameteriAPPLE( GLenum target, GLenum pname, GLint param ) {
+static void WINAPI glBufferParameteriAPPLE( GLenum target, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, pname, param );
+  TRACE( "(%d, %d, %d)\n", target, pname, param );
   funcs->ext.p_glBufferParameteriAPPLE( target, pname, param );
 }
 
-static GLuint WINAPI glBufferRegionEnabled( void ) {
+static GLuint WINAPI glBufferRegionEnabled(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  return funcs->ext.p_glBufferRegionEnabled( );
+  TRACE( "()\n" );
+  return funcs->ext.p_glBufferRegionEnabled();
 }
 
-static void WINAPI glBufferStorage( GLenum target, GLsizeiptr size, const void* data, GLbitfield flags ) {
+static void WINAPI glBufferStorage( GLenum target, GLsizeiptr size, const void *data, GLbitfield flags )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %p, %d)\n", target, size, data, flags );
+  TRACE( "(%d, %ld, %p, %d)\n", target, size, data, flags );
   funcs->ext.p_glBufferStorage( target, size, data, flags );
 }
 
-static void WINAPI glBufferStorageExternalEXT( GLenum target, GLintptr offset, GLsizeiptr size, void * clientBuffer, GLbitfield flags ) {
+static void WINAPI glBufferStorageExternalEXT( GLenum target, GLintptr offset, GLsizeiptr size, void * clientBuffer, GLbitfield flags )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld, %p, %d)\n", target, offset, size, clientBuffer, flags );
+  TRACE( "(%d, %ld, %ld, %p, %d)\n", target, offset, size, clientBuffer, flags );
   funcs->ext.p_glBufferStorageExternalEXT( target, offset, size, clientBuffer, flags );
 }
 
-static void WINAPI glBufferStorageMemEXT( GLenum target, GLsizeiptr size, GLuint memory, GLuint64 offset ) {
+static void WINAPI glBufferStorageMemEXT( GLenum target, GLsizeiptr size, GLuint memory, GLuint64 offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %d, %s)\n", target, size, memory, wine_dbgstr_longlong(offset) );
+  TRACE( "(%d, %ld, %d, %s)\n", target, size, memory, wine_dbgstr_longlong(offset) );
   funcs->ext.p_glBufferStorageMemEXT( target, size, memory, offset );
 }
 
-static void WINAPI glBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, const void* data ) {
+static void WINAPI glBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld, %p)\n", target, offset, size, data );
+  TRACE( "(%d, %ld, %ld, %p)\n", target, offset, size, data );
   funcs->ext.p_glBufferSubData( target, offset, size, data );
 }
 
-static void WINAPI glBufferSubDataARB( GLenum target, GLintptrARB offset, GLsizeiptrARB size, const void* data ) {
+static void WINAPI glBufferSubDataARB( GLenum target, GLintptrARB offset, GLsizeiptrARB size, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld, %p)\n", target, offset, size, data );
+  TRACE( "(%d, %ld, %ld, %p)\n", target, offset, size, data );
   funcs->ext.p_glBufferSubDataARB( target, offset, size, data );
 }
 
-static void WINAPI glCallCommandListNV( GLuint list ) {
+static void WINAPI glCallCommandListNV( GLuint list )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", list );
+  TRACE( "(%d)\n", list );
   funcs->ext.p_glCallCommandListNV( list );
 }
 
-static GLenum WINAPI glCheckFramebufferStatus( GLenum target ) {
+static GLenum WINAPI glCheckFramebufferStatus( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   return funcs->ext.p_glCheckFramebufferStatus( target );
 }
 
-static GLenum WINAPI glCheckFramebufferStatusEXT( GLenum target ) {
+static GLenum WINAPI glCheckFramebufferStatusEXT( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   return funcs->ext.p_glCheckFramebufferStatusEXT( target );
 }
 
-static GLenum WINAPI glCheckNamedFramebufferStatus( GLuint framebuffer, GLenum target ) {
+static GLenum WINAPI glCheckNamedFramebufferStatus( GLuint framebuffer, GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", framebuffer, target );
+  TRACE( "(%d, %d)\n", framebuffer, target );
   return funcs->ext.p_glCheckNamedFramebufferStatus( framebuffer, target );
 }
 
-static GLenum WINAPI glCheckNamedFramebufferStatusEXT( GLuint framebuffer, GLenum target ) {
+static GLenum WINAPI glCheckNamedFramebufferStatusEXT( GLuint framebuffer, GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", framebuffer, target );
+  TRACE( "(%d, %d)\n", framebuffer, target );
   return funcs->ext.p_glCheckNamedFramebufferStatusEXT( framebuffer, target );
 }
 
-static void WINAPI glClampColor( GLenum target, GLenum clamp ) {
+static void WINAPI glClampColor( GLenum target, GLenum clamp )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, clamp );
+  TRACE( "(%d, %d)\n", target, clamp );
   funcs->ext.p_glClampColor( target, clamp );
 }
 
-static void WINAPI glClampColorARB( GLenum target, GLenum clamp ) {
+static void WINAPI glClampColorARB( GLenum target, GLenum clamp )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, clamp );
+  TRACE( "(%d, %d)\n", target, clamp );
   funcs->ext.p_glClampColorARB( target, clamp );
 }
 
-static void WINAPI glClearAccumxOES( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) {
+static void WINAPI glClearAccumxOES( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
+  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
   funcs->ext.p_glClearAccumxOES( red, green, blue, alpha );
 }
 
-static void WINAPI glClearBufferData( GLenum target, GLenum internalformat, GLenum format, GLenum type, const void* data ) {
+static void WINAPI glClearBufferData( GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", target, internalformat, format, type, data );
+  TRACE( "(%d, %d, %d, %d, %p)\n", target, internalformat, format, type, data );
   funcs->ext.p_glClearBufferData( target, internalformat, format, type, data );
 }
 
-static void WINAPI glClearBufferSubData( GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void* data ) {
+static void WINAPI glClearBufferSubData( GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %ld, %ld, %d, %d, %p)\n", target, internalformat, offset, size, format, type, data );
+  TRACE( "(%d, %d, %ld, %ld, %d, %d, %p)\n", target, internalformat, offset, size, format, type, data );
   funcs->ext.p_glClearBufferSubData( target, internalformat, offset, size, format, type, data );
 }
 
-static void WINAPI glClearBufferfi( GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil ) {
+static void WINAPI glClearBufferfi( GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %d)\n", buffer, drawbuffer, depth, stencil );
+  TRACE( "(%d, %d, %f, %d)\n", buffer, drawbuffer, depth, stencil );
   funcs->ext.p_glClearBufferfi( buffer, drawbuffer, depth, stencil );
 }
 
-static void WINAPI glClearBufferfv( GLenum buffer, GLint drawbuffer, const GLfloat* value ) {
+static void WINAPI glClearBufferfv( GLenum buffer, GLint drawbuffer, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", buffer, drawbuffer, value );
+  TRACE( "(%d, %d, %p)\n", buffer, drawbuffer, value );
   funcs->ext.p_glClearBufferfv( buffer, drawbuffer, value );
 }
 
-static void WINAPI glClearBufferiv( GLenum buffer, GLint drawbuffer, const GLint* value ) {
+static void WINAPI glClearBufferiv( GLenum buffer, GLint drawbuffer, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", buffer, drawbuffer, value );
+  TRACE( "(%d, %d, %p)\n", buffer, drawbuffer, value );
   funcs->ext.p_glClearBufferiv( buffer, drawbuffer, value );
 }
 
-static void WINAPI glClearBufferuiv( GLenum buffer, GLint drawbuffer, const GLuint* value ) {
+static void WINAPI glClearBufferuiv( GLenum buffer, GLint drawbuffer, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", buffer, drawbuffer, value );
+  TRACE( "(%d, %d, %p)\n", buffer, drawbuffer, value );
   funcs->ext.p_glClearBufferuiv( buffer, drawbuffer, value );
 }
 
-static void WINAPI glClearColorIiEXT( GLint red, GLint green, GLint blue, GLint alpha ) {
+static void WINAPI glClearColorIiEXT( GLint red, GLint green, GLint blue, GLint alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
+  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
   funcs->ext.p_glClearColorIiEXT( red, green, blue, alpha );
 }
 
-static void WINAPI glClearColorIuiEXT( GLuint red, GLuint green, GLuint blue, GLuint alpha ) {
+static void WINAPI glClearColorIuiEXT( GLuint red, GLuint green, GLuint blue, GLuint alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
+  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
   funcs->ext.p_glClearColorIuiEXT( red, green, blue, alpha );
 }
 
-static void WINAPI glClearColorxOES( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) {
+static void WINAPI glClearColorxOES( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
+  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
   funcs->ext.p_glClearColorxOES( red, green, blue, alpha );
 }
 
-static void WINAPI glClearDepthdNV( GLdouble depth ) {
+static void WINAPI glClearDepthdNV( GLdouble depth )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", depth );
+  TRACE( "(%f)\n", depth );
   funcs->ext.p_glClearDepthdNV( depth );
 }
 
-static void WINAPI glClearDepthf( GLfloat d ) {
+static void WINAPI glClearDepthf( GLfloat d )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", d );
+  TRACE( "(%f)\n", d );
   funcs->ext.p_glClearDepthf( d );
 }
 
-static void WINAPI glClearDepthfOES( GLclampf depth ) {
+static void WINAPI glClearDepthfOES( GLclampf depth )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", depth );
+  TRACE( "(%f)\n", depth );
   funcs->ext.p_glClearDepthfOES( depth );
 }
 
-static void WINAPI glClearDepthxOES( GLfixed depth ) {
+static void WINAPI glClearDepthxOES( GLfixed depth )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", depth );
+  TRACE( "(%d)\n", depth );
   funcs->ext.p_glClearDepthxOES( depth );
 }
 
-static void WINAPI glClearNamedBufferData( GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void* data ) {
+static void WINAPI glClearNamedBufferData( GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", buffer, internalformat, format, type, data );
+  TRACE( "(%d, %d, %d, %d, %p)\n", buffer, internalformat, format, type, data );
   funcs->ext.p_glClearNamedBufferData( buffer, internalformat, format, type, data );
 }
 
-static void WINAPI glClearNamedBufferDataEXT( GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void* data ) {
+static void WINAPI glClearNamedBufferDataEXT( GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", buffer, internalformat, format, type, data );
+  TRACE( "(%d, %d, %d, %d, %p)\n", buffer, internalformat, format, type, data );
   funcs->ext.p_glClearNamedBufferDataEXT( buffer, internalformat, format, type, data );
 }
 
-static void WINAPI glClearNamedBufferSubData( GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void* data ) {
+static void WINAPI glClearNamedBufferSubData( GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %ld, %ld, %d, %d, %p)\n", buffer, internalformat, offset, size, format, type, data );
+  TRACE( "(%d, %d, %ld, %ld, %d, %d, %p)\n", buffer, internalformat, offset, size, format, type, data );
   funcs->ext.p_glClearNamedBufferSubData( buffer, internalformat, offset, size, format, type, data );
 }
 
-static void WINAPI glClearNamedBufferSubDataEXT( GLuint buffer, GLenum internalformat, GLsizeiptr offset, GLsizeiptr size, GLenum format, GLenum type, const void* data ) {
+static void WINAPI glClearNamedBufferSubDataEXT( GLuint buffer, GLenum internalformat, GLsizeiptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %ld, %ld, %d, %d, %p)\n", buffer, internalformat, offset, size, format, type, data );
+  TRACE( "(%d, %d, %ld, %ld, %d, %d, %p)\n", buffer, internalformat, offset, size, format, type, data );
   funcs->ext.p_glClearNamedBufferSubDataEXT( buffer, internalformat, offset, size, format, type, data );
 }
 
-static void WINAPI glClearNamedFramebufferfi( GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil ) {
+static void WINAPI glClearNamedFramebufferfi( GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %f, %d)\n", framebuffer, buffer, drawbuffer, depth, stencil );
+  TRACE( "(%d, %d, %d, %f, %d)\n", framebuffer, buffer, drawbuffer, depth, stencil );
   funcs->ext.p_glClearNamedFramebufferfi( framebuffer, buffer, drawbuffer, depth, stencil );
 }
 
-static void WINAPI glClearNamedFramebufferfv( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat* value ) {
+static void WINAPI glClearNamedFramebufferfv( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", framebuffer, buffer, drawbuffer, value );
+  TRACE( "(%d, %d, %d, %p)\n", framebuffer, buffer, drawbuffer, value );
   funcs->ext.p_glClearNamedFramebufferfv( framebuffer, buffer, drawbuffer, value );
 }
 
-static void WINAPI glClearNamedFramebufferiv( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint* value ) {
+static void WINAPI glClearNamedFramebufferiv( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", framebuffer, buffer, drawbuffer, value );
+  TRACE( "(%d, %d, %d, %p)\n", framebuffer, buffer, drawbuffer, value );
   funcs->ext.p_glClearNamedFramebufferiv( framebuffer, buffer, drawbuffer, value );
 }
 
-static void WINAPI glClearNamedFramebufferuiv( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint* value ) {
+static void WINAPI glClearNamedFramebufferuiv( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", framebuffer, buffer, drawbuffer, value );
+  TRACE( "(%d, %d, %d, %p)\n", framebuffer, buffer, drawbuffer, value );
   funcs->ext.p_glClearNamedFramebufferuiv( framebuffer, buffer, drawbuffer, value );
 }
 
-static void WINAPI glClearTexImage( GLuint texture, GLint level, GLenum format, GLenum type, const void* data ) {
+static void WINAPI glClearTexImage( GLuint texture, GLint level, GLenum format, GLenum type, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", texture, level, format, type, data );
+  TRACE( "(%d, %d, %d, %d, %p)\n", texture, level, format, type, data );
   funcs->ext.p_glClearTexImage( texture, level, format, type, data );
 }
 
-static void WINAPI glClearTexSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* data ) {
+static void WINAPI glClearTexSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data );
   funcs->ext.p_glClearTexSubImage( texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data );
 }
 
-static void WINAPI glClientActiveTexture( GLenum texture ) {
+static void WINAPI glClientActiveTexture( GLenum texture )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", texture );
+  TRACE( "(%d)\n", texture );
   funcs->ext.p_glClientActiveTexture( texture );
 }
 
-static void WINAPI glClientActiveTextureARB( GLenum texture ) {
+static void WINAPI glClientActiveTextureARB( GLenum texture )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", texture );
+  TRACE( "(%d)\n", texture );
   funcs->ext.p_glClientActiveTextureARB( texture );
 }
 
-static void WINAPI glClientActiveVertexStreamATI( GLenum stream ) {
+static void WINAPI glClientActiveVertexStreamATI( GLenum stream )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", stream );
+  TRACE( "(%d)\n", stream );
   funcs->ext.p_glClientActiveVertexStreamATI( stream );
 }
 
-static void WINAPI glClientAttribDefaultEXT( GLbitfield mask ) {
+static void WINAPI glClientAttribDefaultEXT( GLbitfield mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mask );
+  TRACE( "(%d)\n", mask );
   funcs->ext.p_glClientAttribDefaultEXT( mask );
 }
 
-static GLenum WINAPI glClientWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout ) {
+static GLenum WINAPI glClientWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %d, %s)\n", sync, flags, wine_dbgstr_longlong(timeout) );
+  TRACE( "(%p, %d, %s)\n", sync, flags, wine_dbgstr_longlong(timeout) );
   return funcs->ext.p_glClientWaitSync( sync, flags, timeout );
 }
 
-static void WINAPI glClipControl( GLenum origin, GLenum depth ) {
+static void WINAPI glClipControl( GLenum origin, GLenum depth )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", origin, depth );
+  TRACE( "(%d, %d)\n", origin, depth );
   funcs->ext.p_glClipControl( origin, depth );
 }
 
-static void WINAPI glClipPlanefOES( GLenum plane, const GLfloat* equation ) {
+static void WINAPI glClipPlanefOES( GLenum plane, const GLfloat *equation )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", plane, equation );
+  TRACE( "(%d, %p)\n", plane, equation );
   funcs->ext.p_glClipPlanefOES( plane, equation );
 }
 
-static void WINAPI glClipPlanexOES( GLenum plane, const GLfixed* equation ) {
+static void WINAPI glClipPlanexOES( GLenum plane, const GLfixed *equation )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", plane, equation );
+  TRACE( "(%d, %p)\n", plane, equation );
   funcs->ext.p_glClipPlanexOES( plane, equation );
 }
 
-static void WINAPI glColor3fVertex3fSUN( GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glColor3fVertex3fSUN( GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f, %f, %f)\n", r, g, b, x, y, z );
+  TRACE( "(%f, %f, %f, %f, %f, %f)\n", r, g, b, x, y, z );
   funcs->ext.p_glColor3fVertex3fSUN( r, g, b, x, y, z );
 }
 
-static void WINAPI glColor3fVertex3fvSUN( const GLfloat* c, const GLfloat* v ) {
+static void WINAPI glColor3fVertex3fvSUN( const GLfloat *c, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", c, v );
+  TRACE( "(%p, %p)\n", c, v );
   funcs->ext.p_glColor3fVertex3fvSUN( c, v );
 }
 
-static void WINAPI glColor3hNV( GLhalfNV red, GLhalfNV green, GLhalfNV blue ) {
+static void WINAPI glColor3hNV( GLhalfNV red, GLhalfNV green, GLhalfNV blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->ext.p_glColor3hNV( red, green, blue );
 }
 
-static void WINAPI glColor3hvNV( const GLhalfNV* v ) {
+static void WINAPI glColor3hvNV( const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glColor3hvNV( v );
 }
 
-static void WINAPI glColor3xOES( GLfixed red, GLfixed green, GLfixed blue ) {
+static void WINAPI glColor3xOES( GLfixed red, GLfixed green, GLfixed blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->ext.p_glColor3xOES( red, green, blue );
 }
 
-static void WINAPI glColor3xvOES( const GLfixed* components ) {
+static void WINAPI glColor3xvOES( const GLfixed *components )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", components );
+  TRACE( "(%p)\n", components );
   funcs->ext.p_glColor3xvOES( components );
 }
 
-static void WINAPI glColor4fNormal3fVertex3fSUN( GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glColor4fNormal3fVertex3fSUN( GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", r, g, b, a, nx, ny, nz, x, y, z );
+  TRACE( "(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", r, g, b, a, nx, ny, nz, x, y, z );
   funcs->ext.p_glColor4fNormal3fVertex3fSUN( r, g, b, a, nx, ny, nz, x, y, z );
 }
 
-static void WINAPI glColor4fNormal3fVertex3fvSUN( const GLfloat* c, const GLfloat* n, const GLfloat* v ) {
+static void WINAPI glColor4fNormal3fVertex3fvSUN( const GLfloat *c, const GLfloat *n, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p, %p)\n", c, n, v );
+  TRACE( "(%p, %p, %p)\n", c, n, v );
   funcs->ext.p_glColor4fNormal3fVertex3fvSUN( c, n, v );
 }
 
-static void WINAPI glColor4hNV( GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha ) {
+static void WINAPI glColor4hNV( GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
+  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
   funcs->ext.p_glColor4hNV( red, green, blue, alpha );
 }
 
-static void WINAPI glColor4hvNV( const GLhalfNV* v ) {
+static void WINAPI glColor4hvNV( const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glColor4hvNV( v );
 }
 
-static void WINAPI glColor4ubVertex2fSUN( GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y ) {
+static void WINAPI glColor4ubVertex2fSUN( GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %f, %f)\n", r, g, b, a, x, y );
+  TRACE( "(%d, %d, %d, %d, %f, %f)\n", r, g, b, a, x, y );
   funcs->ext.p_glColor4ubVertex2fSUN( r, g, b, a, x, y );
 }
 
-static void WINAPI glColor4ubVertex2fvSUN( const GLubyte* c, const GLfloat* v ) {
+static void WINAPI glColor4ubVertex2fvSUN( const GLubyte *c, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", c, v );
+  TRACE( "(%p, %p)\n", c, v );
   funcs->ext.p_glColor4ubVertex2fvSUN( c, v );
 }
 
-static void WINAPI glColor4ubVertex3fSUN( GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glColor4ubVertex3fSUN( GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %f, %f, %f)\n", r, g, b, a, x, y, z );
+  TRACE( "(%d, %d, %d, %d, %f, %f, %f)\n", r, g, b, a, x, y, z );
   funcs->ext.p_glColor4ubVertex3fSUN( r, g, b, a, x, y, z );
 }
 
-static void WINAPI glColor4ubVertex3fvSUN( const GLubyte* c, const GLfloat* v ) {
+static void WINAPI glColor4ubVertex3fvSUN( const GLubyte *c, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", c, v );
+  TRACE( "(%p, %p)\n", c, v );
   funcs->ext.p_glColor4ubVertex3fvSUN( c, v );
 }
 
-static void WINAPI glColor4xOES( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) {
+static void WINAPI glColor4xOES( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
+  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
   funcs->ext.p_glColor4xOES( red, green, blue, alpha );
 }
 
-static void WINAPI glColor4xvOES( const GLfixed* components ) {
+static void WINAPI glColor4xvOES( const GLfixed *components )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", components );
+  TRACE( "(%p)\n", components );
   funcs->ext.p_glColor4xvOES( components );
 }
 
-static void WINAPI glColorFormatNV( GLint size, GLenum type, GLsizei stride ) {
+static void WINAPI glColorFormatNV( GLint size, GLenum type, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", size, type, stride );
+  TRACE( "(%d, %d, %d)\n", size, type, stride );
   funcs->ext.p_glColorFormatNV( size, type, stride );
 }
 
-static void WINAPI glColorFragmentOp1ATI( GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod ) {
+static void WINAPI glColorFragmentOp1ATI( GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod );
   funcs->ext.p_glColorFragmentOp1ATI( op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod );
 }
 
-static void WINAPI glColorFragmentOp2ATI( GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod ) {
+static void WINAPI glColorFragmentOp2ATI( GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod );
   funcs->ext.p_glColorFragmentOp2ATI( op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod );
 }
 
-static void WINAPI glColorFragmentOp3ATI( GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod ) {
+static void WINAPI glColorFragmentOp3ATI( GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod );
   funcs->ext.p_glColorFragmentOp3ATI( op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod );
 }
 
-static void WINAPI glColorMaskIndexedEXT( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a ) {
+static void WINAPI glColorMaskIndexedEXT( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", index, r, g, b, a );
+  TRACE( "(%d, %d, %d, %d, %d)\n", index, r, g, b, a );
   funcs->ext.p_glColorMaskIndexedEXT( index, r, g, b, a );
 }
 
-static void WINAPI glColorMaski( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a ) {
+static void WINAPI glColorMaski( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", index, r, g, b, a );
+  TRACE( "(%d, %d, %d, %d, %d)\n", index, r, g, b, a );
   funcs->ext.p_glColorMaski( index, r, g, b, a );
 }
 
-static void WINAPI glColorP3ui( GLenum type, GLuint color ) {
+static void WINAPI glColorP3ui( GLenum type, GLuint color )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", type, color );
+  TRACE( "(%d, %d)\n", type, color );
   funcs->ext.p_glColorP3ui( type, color );
 }
 
-static void WINAPI glColorP3uiv( GLenum type, const GLuint* color ) {
+static void WINAPI glColorP3uiv( GLenum type, const GLuint *color )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", type, color );
+  TRACE( "(%d, %p)\n", type, color );
   funcs->ext.p_glColorP3uiv( type, color );
 }
 
-static void WINAPI glColorP4ui( GLenum type, GLuint color ) {
+static void WINAPI glColorP4ui( GLenum type, GLuint color )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", type, color );
+  TRACE( "(%d, %d)\n", type, color );
   funcs->ext.p_glColorP4ui( type, color );
 }
 
-static void WINAPI glColorP4uiv( GLenum type, const GLuint* color ) {
+static void WINAPI glColorP4uiv( GLenum type, const GLuint *color )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", type, color );
+  TRACE( "(%d, %p)\n", type, color );
   funcs->ext.p_glColorP4uiv( type, color );
 }
 
-static void WINAPI glColorPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const void* pointer ) {
+static void WINAPI glColorPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", size, type, stride, count, pointer );
+  TRACE( "(%d, %d, %d, %d, %p)\n", size, type, stride, count, pointer );
   funcs->ext.p_glColorPointerEXT( size, type, stride, count, pointer );
 }
 
-static void WINAPI glColorPointerListIBM( GLint size, GLenum type, GLint stride, const void** pointer, GLint ptrstride ) {
+static void WINAPI glColorPointerListIBM( GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %d)\n", size, type, stride, pointer, ptrstride );
+  TRACE( "(%d, %d, %d, %p, %d)\n", size, type, stride, pointer, ptrstride );
   funcs->ext.p_glColorPointerListIBM( size, type, stride, pointer, ptrstride );
 }
 
-static void WINAPI glColorPointervINTEL( GLint size, GLenum type, const void** pointer ) {
+static void WINAPI glColorPointervINTEL( GLint size, GLenum type, const void **pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", size, type, pointer );
+  TRACE( "(%d, %d, %p)\n", size, type, pointer );
   funcs->ext.p_glColorPointervINTEL( size, type, pointer );
 }
 
-static void WINAPI glColorSubTable( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void* data ) {
+static void WINAPI glColorSubTable( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, start, count, format, type, data );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", target, start, count, format, type, data );
   funcs->ext.p_glColorSubTable( target, start, count, format, type, data );
 }
 
-static void WINAPI glColorSubTableEXT( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void* data ) {
+static void WINAPI glColorSubTableEXT( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, start, count, format, type, data );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", target, start, count, format, type, data );
   funcs->ext.p_glColorSubTableEXT( target, start, count, format, type, data );
 }
 
-static void WINAPI glColorTable( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void* table ) {
+static void WINAPI glColorTable( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, internalformat, width, format, type, table );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", target, internalformat, width, format, type, table );
   funcs->ext.p_glColorTable( target, internalformat, width, format, type, table );
 }
 
-static void WINAPI glColorTableEXT( GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void* table ) {
+static void WINAPI glColorTableEXT( GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void *table )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, internalFormat, width, format, type, table );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", target, internalFormat, width, format, type, table );
   funcs->ext.p_glColorTableEXT( target, internalFormat, width, format, type, table );
 }
 
-static void WINAPI glColorTableParameterfv( GLenum target, GLenum pname, const GLfloat* params ) {
+static void WINAPI glColorTableParameterfv( GLenum target, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glColorTableParameterfv( target, pname, params );
 }
 
-static void WINAPI glColorTableParameterfvSGI( GLenum target, GLenum pname, const GLfloat* params ) {
+static void WINAPI glColorTableParameterfvSGI( GLenum target, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glColorTableParameterfvSGI( target, pname, params );
 }
 
-static void WINAPI glColorTableParameteriv( GLenum target, GLenum pname, const GLint* params ) {
+static void WINAPI glColorTableParameteriv( GLenum target, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glColorTableParameteriv( target, pname, params );
 }
 
-static void WINAPI glColorTableParameterivSGI( GLenum target, GLenum pname, const GLint* params ) {
+static void WINAPI glColorTableParameterivSGI( GLenum target, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glColorTableParameterivSGI( target, pname, params );
 }
 
-static void WINAPI glColorTableSGI( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void* table ) {
+static void WINAPI glColorTableSGI( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, internalformat, width, format, type, table );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", target, internalformat, width, format, type, table );
   funcs->ext.p_glColorTableSGI( target, internalformat, width, format, type, table );
 }
 
-static void WINAPI glCombinerInputNV( GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage ) {
+static void WINAPI glCombinerInputNV( GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", stage, portion, variable, input, mapping, componentUsage );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", stage, portion, variable, input, mapping, componentUsage );
   funcs->ext.p_glCombinerInputNV( stage, portion, variable, input, mapping, componentUsage );
 }
 
-static void WINAPI glCombinerOutputNV( GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum ) {
+static void WINAPI glCombinerOutputNV( GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum );
   funcs->ext.p_glCombinerOutputNV( stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum );
 }
 
-static void WINAPI glCombinerParameterfNV( GLenum pname, GLfloat param ) {
+static void WINAPI glCombinerParameterfNV( GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", pname, param );
+  TRACE( "(%d, %f)\n", pname, param );
   funcs->ext.p_glCombinerParameterfNV( pname, param );
 }
 
-static void WINAPI glCombinerParameterfvNV( GLenum pname, const GLfloat* params ) {
+static void WINAPI glCombinerParameterfvNV( GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glCombinerParameterfvNV( pname, params );
 }
 
-static void WINAPI glCombinerParameteriNV( GLenum pname, GLint param ) {
+static void WINAPI glCombinerParameteriNV( GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->ext.p_glCombinerParameteriNV( pname, param );
 }
 
-static void WINAPI glCombinerParameterivNV( GLenum pname, const GLint* params ) {
+static void WINAPI glCombinerParameterivNV( GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glCombinerParameterivNV( pname, params );
 }
 
-static void WINAPI glCombinerStageParameterfvNV( GLenum stage, GLenum pname, const GLfloat* params ) {
+static void WINAPI glCombinerStageParameterfvNV( GLenum stage, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", stage, pname, params );
+  TRACE( "(%d, %d, %p)\n", stage, pname, params );
   funcs->ext.p_glCombinerStageParameterfvNV( stage, pname, params );
 }
 
-static void WINAPI glCommandListSegmentsNV( GLuint list, GLuint segments ) {
+static void WINAPI glCommandListSegmentsNV( GLuint list, GLuint segments )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", list, segments );
+  TRACE( "(%d, %d)\n", list, segments );
   funcs->ext.p_glCommandListSegmentsNV( list, segments );
 }
 
-static void WINAPI glCompileCommandListNV( GLuint list ) {
+static void WINAPI glCompileCommandListNV( GLuint list )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", list );
+  TRACE( "(%d)\n", list );
   funcs->ext.p_glCompileCommandListNV( list );
 }
 
-static void WINAPI glCompileShader( GLuint shader ) {
+static void WINAPI glCompileShader( GLuint shader )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", shader );
+  TRACE( "(%d)\n", shader );
   funcs->ext.p_glCompileShader( shader );
 }
 
-static void WINAPI glCompileShaderARB( GLhandleARB shaderObj ) {
+static void WINAPI glCompileShaderARB( GLhandleARB shaderObj )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", shaderObj );
+  TRACE( "(%d)\n", shaderObj );
   funcs->ext.p_glCompileShaderARB( shaderObj );
 }
 
-static void WINAPI glCompileShaderIncludeARB( GLuint shader, GLsizei count, const GLchar*const* path, const GLint* length ) {
+static void WINAPI glCompileShaderIncludeARB( GLuint shader, GLsizei count, const GLchar *const*path, const GLint *length )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", shader, count, path, length );
+  TRACE( "(%d, %d, %p, %p)\n", shader, count, path, length );
   funcs->ext.p_glCompileShaderIncludeARB( shader, count, path, length );
 }
 
-static void WINAPI glCompressedMultiTexImage1DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* bits ) {
+static void WINAPI glCompressedMultiTexImage1DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, border, imageSize, bits );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, border, imageSize, bits );
   funcs->ext.p_glCompressedMultiTexImage1DEXT( texunit, target, level, internalformat, width, border, imageSize, bits );
 }
 
-static void WINAPI glCompressedMultiTexImage2DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* bits ) {
+static void WINAPI glCompressedMultiTexImage2DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, height, border, imageSize, bits );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, height, border, imageSize, bits );
   funcs->ext.p_glCompressedMultiTexImage2DEXT( texunit, target, level, internalformat, width, height, border, imageSize, bits );
 }
 
-static void WINAPI glCompressedMultiTexImage3DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* bits ) {
+static void WINAPI glCompressedMultiTexImage3DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, height, depth, border, imageSize, bits );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, height, depth, border, imageSize, bits );
   funcs->ext.p_glCompressedMultiTexImage3DEXT( texunit, target, level, internalformat, width, height, depth, border, imageSize, bits );
 }
 
-static void WINAPI glCompressedMultiTexSubImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* bits ) {
+static void WINAPI glCompressedMultiTexSubImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, width, format, imageSize, bits );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, width, format, imageSize, bits );
   funcs->ext.p_glCompressedMultiTexSubImage1DEXT( texunit, target, level, xoffset, width, format, imageSize, bits );
 }
 
-static void WINAPI glCompressedMultiTexSubImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* bits ) {
+static void WINAPI glCompressedMultiTexSubImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits );
   funcs->ext.p_glCompressedMultiTexSubImage2DEXT( texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits );
 }
 
-static void WINAPI glCompressedMultiTexSubImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* bits ) {
+static void WINAPI glCompressedMultiTexSubImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits );
   funcs->ext.p_glCompressedMultiTexSubImage3DEXT( texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits );
 }
 
-static void WINAPI glCompressedTexImage1D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* data ) {
+static void WINAPI glCompressedTexImage1D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, border, imageSize, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, border, imageSize, data );
   funcs->ext.p_glCompressedTexImage1D( target, level, internalformat, width, border, imageSize, data );
 }
 
-static void WINAPI glCompressedTexImage1DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* data ) {
+static void WINAPI glCompressedTexImage1DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, border, imageSize, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, border, imageSize, data );
   funcs->ext.p_glCompressedTexImage1DARB( target, level, internalformat, width, border, imageSize, data );
 }
 
-static void WINAPI glCompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data ) {
+static void WINAPI glCompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, border, imageSize, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, border, imageSize, data );
   funcs->ext.p_glCompressedTexImage2D( target, level, internalformat, width, height, border, imageSize, data );
 }
 
-static void WINAPI glCompressedTexImage2DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data ) {
+static void WINAPI glCompressedTexImage2DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, border, imageSize, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, border, imageSize, data );
   funcs->ext.p_glCompressedTexImage2DARB( target, level, internalformat, width, height, border, imageSize, data );
 }
 
-static void WINAPI glCompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data ) {
+static void WINAPI glCompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, border, imageSize, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, border, imageSize, data );
   funcs->ext.p_glCompressedTexImage3D( target, level, internalformat, width, height, depth, border, imageSize, data );
 }
 
-static void WINAPI glCompressedTexImage3DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data ) {
+static void WINAPI glCompressedTexImage3DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, border, imageSize, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, border, imageSize, data );
   funcs->ext.p_glCompressedTexImage3DARB( target, level, internalformat, width, height, depth, border, imageSize, data );
 }
 
-static void WINAPI glCompressedTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data ) {
+static void WINAPI glCompressedTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, width, format, imageSize, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, width, format, imageSize, data );
   funcs->ext.p_glCompressedTexSubImage1D( target, level, xoffset, width, format, imageSize, data );
 }
 
-static void WINAPI glCompressedTexSubImage1DARB( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data ) {
+static void WINAPI glCompressedTexSubImage1DARB( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, width, format, imageSize, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, width, format, imageSize, data );
   funcs->ext.p_glCompressedTexSubImage1DARB( target, level, xoffset, width, format, imageSize, data );
 }
 
-static void WINAPI glCompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data ) {
+static void WINAPI glCompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, width, height, format, imageSize, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, width, height, format, imageSize, data );
   funcs->ext.p_glCompressedTexSubImage2D( target, level, xoffset, yoffset, width, height, format, imageSize, data );
 }
 
-static void WINAPI glCompressedTexSubImage2DARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data ) {
+static void WINAPI glCompressedTexSubImage2DARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, width, height, format, imageSize, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, width, height, format, imageSize, data );
   funcs->ext.p_glCompressedTexSubImage2DARB( target, level, xoffset, yoffset, width, height, format, imageSize, data );
 }
 
-static void WINAPI glCompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data ) {
+static void WINAPI glCompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
   funcs->ext.p_glCompressedTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
 }
 
-static void WINAPI glCompressedTexSubImage3DARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data ) {
+static void WINAPI glCompressedTexSubImage3DARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
   funcs->ext.p_glCompressedTexSubImage3DARB( target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
 }
 
-static void WINAPI glCompressedTextureImage1DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* bits ) {
+static void WINAPI glCompressedTextureImage1DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, border, imageSize, bits );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, border, imageSize, bits );
   funcs->ext.p_glCompressedTextureImage1DEXT( texture, target, level, internalformat, width, border, imageSize, bits );
 }
 
-static void WINAPI glCompressedTextureImage2DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* bits ) {
+static void WINAPI glCompressedTextureImage2DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, height, border, imageSize, bits );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, height, border, imageSize, bits );
   funcs->ext.p_glCompressedTextureImage2DEXT( texture, target, level, internalformat, width, height, border, imageSize, bits );
 }
 
-static void WINAPI glCompressedTextureImage3DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* bits ) {
+static void WINAPI glCompressedTextureImage3DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, height, depth, border, imageSize, bits );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, height, depth, border, imageSize, bits );
   funcs->ext.p_glCompressedTextureImage3DEXT( texture, target, level, internalformat, width, height, depth, border, imageSize, bits );
 }
 
-static void WINAPI glCompressedTextureSubImage1D( GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data ) {
+static void WINAPI glCompressedTextureSubImage1D( GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, width, format, imageSize, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, width, format, imageSize, data );
   funcs->ext.p_glCompressedTextureSubImage1D( texture, level, xoffset, width, format, imageSize, data );
 }
 
-static void WINAPI glCompressedTextureSubImage1DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* bits ) {
+static void WINAPI glCompressedTextureSubImage1DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, width, format, imageSize, bits );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, width, format, imageSize, bits );
   funcs->ext.p_glCompressedTextureSubImage1DEXT( texture, target, level, xoffset, width, format, imageSize, bits );
 }
 
-static void WINAPI glCompressedTextureSubImage2D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data ) {
+static void WINAPI glCompressedTextureSubImage2D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, yoffset, width, height, format, imageSize, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, yoffset, width, height, format, imageSize, data );
   funcs->ext.p_glCompressedTextureSubImage2D( texture, level, xoffset, yoffset, width, height, format, imageSize, data );
 }
 
-static void WINAPI glCompressedTextureSubImage2DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* bits ) {
+static void WINAPI glCompressedTextureSubImage2DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits );
   funcs->ext.p_glCompressedTextureSubImage2DEXT( texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits );
 }
 
-static void WINAPI glCompressedTextureSubImage3D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data ) {
+static void WINAPI glCompressedTextureSubImage3D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
   funcs->ext.p_glCompressedTextureSubImage3D( texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data );
 }
 
-static void WINAPI glCompressedTextureSubImage3DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* bits ) {
+static void WINAPI glCompressedTextureSubImage3DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits );
   funcs->ext.p_glCompressedTextureSubImage3DEXT( texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits );
 }
 
-static void WINAPI glConservativeRasterParameterfNV( GLenum pname, GLfloat value ) {
+static void WINAPI glConservativeRasterParameterfNV( GLenum pname, GLfloat value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", pname, value );
+  TRACE( "(%d, %f)\n", pname, value );
   funcs->ext.p_glConservativeRasterParameterfNV( pname, value );
 }
 
-static void WINAPI glConservativeRasterParameteriNV( GLenum pname, GLint param ) {
+static void WINAPI glConservativeRasterParameteriNV( GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->ext.p_glConservativeRasterParameteriNV( pname, param );
 }
 
-static void WINAPI glConvolutionFilter1D( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void* image ) {
+static void WINAPI glConvolutionFilter1D( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, internalformat, width, format, type, image );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", target, internalformat, width, format, type, image );
   funcs->ext.p_glConvolutionFilter1D( target, internalformat, width, format, type, image );
 }
 
-static void WINAPI glConvolutionFilter1DEXT( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void* image ) {
+static void WINAPI glConvolutionFilter1DEXT( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, internalformat, width, format, type, image );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", target, internalformat, width, format, type, image );
   funcs->ext.p_glConvolutionFilter1DEXT( target, internalformat, width, format, type, image );
 }
 
-static void WINAPI glConvolutionFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* image ) {
+static void WINAPI glConvolutionFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, internalformat, width, height, format, type, image );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %p)\n", target, internalformat, width, height, format, type, image );
   funcs->ext.p_glConvolutionFilter2D( target, internalformat, width, height, format, type, image );
 }
 
-static void WINAPI glConvolutionFilter2DEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* image ) {
+static void WINAPI glConvolutionFilter2DEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, internalformat, width, height, format, type, image );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %p)\n", target, internalformat, width, height, format, type, image );
   funcs->ext.p_glConvolutionFilter2DEXT( target, internalformat, width, height, format, type, image );
 }
 
-static void WINAPI glConvolutionParameterf( GLenum target, GLenum pname, GLfloat params ) {
+static void WINAPI glConvolutionParameterf( GLenum target, GLenum pname, GLfloat params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", target, pname, params );
+  TRACE( "(%d, %d, %f)\n", target, pname, params );
   funcs->ext.p_glConvolutionParameterf( target, pname, params );
 }
 
-static void WINAPI glConvolutionParameterfEXT( GLenum target, GLenum pname, GLfloat params ) {
+static void WINAPI glConvolutionParameterfEXT( GLenum target, GLenum pname, GLfloat params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", target, pname, params );
+  TRACE( "(%d, %d, %f)\n", target, pname, params );
   funcs->ext.p_glConvolutionParameterfEXT( target, pname, params );
 }
 
-static void WINAPI glConvolutionParameterfv( GLenum target, GLenum pname, const GLfloat* params ) {
+static void WINAPI glConvolutionParameterfv( GLenum target, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glConvolutionParameterfv( target, pname, params );
 }
 
-static void WINAPI glConvolutionParameterfvEXT( GLenum target, GLenum pname, const GLfloat* params ) {
+static void WINAPI glConvolutionParameterfvEXT( GLenum target, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glConvolutionParameterfvEXT( target, pname, params );
 }
 
-static void WINAPI glConvolutionParameteri( GLenum target, GLenum pname, GLint params ) {
+static void WINAPI glConvolutionParameteri( GLenum target, GLenum pname, GLint params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, pname, params );
+  TRACE( "(%d, %d, %d)\n", target, pname, params );
   funcs->ext.p_glConvolutionParameteri( target, pname, params );
 }
 
-static void WINAPI glConvolutionParameteriEXT( GLenum target, GLenum pname, GLint params ) {
+static void WINAPI glConvolutionParameteriEXT( GLenum target, GLenum pname, GLint params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, pname, params );
+  TRACE( "(%d, %d, %d)\n", target, pname, params );
   funcs->ext.p_glConvolutionParameteriEXT( target, pname, params );
 }
 
-static void WINAPI glConvolutionParameteriv( GLenum target, GLenum pname, const GLint* params ) {
+static void WINAPI glConvolutionParameteriv( GLenum target, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glConvolutionParameteriv( target, pname, params );
 }
 
-static void WINAPI glConvolutionParameterivEXT( GLenum target, GLenum pname, const GLint* params ) {
+static void WINAPI glConvolutionParameterivEXT( GLenum target, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glConvolutionParameterivEXT( target, pname, params );
 }
 
-static void WINAPI glConvolutionParameterxOES( GLenum target, GLenum pname, GLfixed param ) {
+static void WINAPI glConvolutionParameterxOES( GLenum target, GLenum pname, GLfixed param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, pname, param );
+  TRACE( "(%d, %d, %d)\n", target, pname, param );
   funcs->ext.p_glConvolutionParameterxOES( target, pname, param );
 }
 
-static void WINAPI glConvolutionParameterxvOES( GLenum target, GLenum pname, const GLfixed* params ) {
+static void WINAPI glConvolutionParameterxvOES( GLenum target, GLenum pname, const GLfixed *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glConvolutionParameterxvOES( target, pname, params );
 }
 
-static void WINAPI glCopyBufferSubData( GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size ) {
+static void WINAPI glCopyBufferSubData( GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %ld, %ld, %ld)\n", readTarget, writeTarget, readOffset, writeOffset, size );
+  TRACE( "(%d, %d, %ld, %ld, %ld)\n", readTarget, writeTarget, readOffset, writeOffset, size );
   funcs->ext.p_glCopyBufferSubData( readTarget, writeTarget, readOffset, writeOffset, size );
 }
 
-static void WINAPI glCopyColorSubTable( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width ) {
+static void WINAPI glCopyColorSubTable( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, start, x, y, width );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, start, x, y, width );
   funcs->ext.p_glCopyColorSubTable( target, start, x, y, width );
 }
 
-static void WINAPI glCopyColorSubTableEXT( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width ) {
+static void WINAPI glCopyColorSubTableEXT( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, start, x, y, width );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, start, x, y, width );
   funcs->ext.p_glCopyColorSubTableEXT( target, start, x, y, width );
 }
 
-static void WINAPI glCopyColorTable( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) {
+static void WINAPI glCopyColorTable( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, internalformat, x, y, width );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, internalformat, x, y, width );
   funcs->ext.p_glCopyColorTable( target, internalformat, x, y, width );
 }
 
-static void WINAPI glCopyColorTableSGI( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) {
+static void WINAPI glCopyColorTableSGI( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, internalformat, x, y, width );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, internalformat, x, y, width );
   funcs->ext.p_glCopyColorTableSGI( target, internalformat, x, y, width );
 }
 
-static void WINAPI glCopyConvolutionFilter1D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) {
+static void WINAPI glCopyConvolutionFilter1D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, internalformat, x, y, width );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, internalformat, x, y, width );
   funcs->ext.p_glCopyConvolutionFilter1D( target, internalformat, x, y, width );
 }
 
-static void WINAPI glCopyConvolutionFilter1DEXT( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width ) {
+static void WINAPI glCopyConvolutionFilter1DEXT( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, internalformat, x, y, width );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, internalformat, x, y, width );
   funcs->ext.p_glCopyConvolutionFilter1DEXT( target, internalformat, x, y, width );
 }
 
-static void WINAPI glCopyConvolutionFilter2D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height ) {
+static void WINAPI glCopyConvolutionFilter2D( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, internalformat, x, y, width, height );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", target, internalformat, x, y, width, height );
   funcs->ext.p_glCopyConvolutionFilter2D( target, internalformat, x, y, width, height );
 }
 
-static void WINAPI glCopyConvolutionFilter2DEXT( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height ) {
+static void WINAPI glCopyConvolutionFilter2DEXT( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, internalformat, x, y, width, height );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", target, internalformat, x, y, width, height );
   funcs->ext.p_glCopyConvolutionFilter2DEXT( target, internalformat, x, y, width, height );
 }
 
-static void WINAPI glCopyImageSubData( GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth ) {
+static void WINAPI glCopyImageSubData( GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth );
   funcs->ext.p_glCopyImageSubData( srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth );
 }
 
-static void WINAPI glCopyImageSubDataNV( GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth ) {
+static void WINAPI glCopyImageSubDataNV( GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth );
   funcs->ext.p_glCopyImageSubDataNV( srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth );
 }
 
-static void WINAPI glCopyMultiTexImage1DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border ) {
+static void WINAPI glCopyMultiTexImage1DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", texunit, target, level, internalformat, x, y, width, border );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d)\n", texunit, target, level, internalformat, x, y, width, border );
   funcs->ext.p_glCopyMultiTexImage1DEXT( texunit, target, level, internalformat, x, y, width, border );
 }
 
-static void WINAPI glCopyMultiTexImage2DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) {
+static void WINAPI glCopyMultiTexImage2DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texunit, target, level, internalformat, x, y, width, height, border );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texunit, target, level, internalformat, x, y, width, height, border );
   funcs->ext.p_glCopyMultiTexImage2DEXT( texunit, target, level, internalformat, x, y, width, height, border );
 }
 
-static void WINAPI glCopyMultiTexSubImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width ) {
+static void WINAPI glCopyMultiTexSubImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", texunit, target, level, xoffset, x, y, width );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", texunit, target, level, xoffset, x, y, width );
   funcs->ext.p_glCopyMultiTexSubImage1DEXT( texunit, target, level, xoffset, x, y, width );
 }
 
-static void WINAPI glCopyMultiTexSubImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
+static void WINAPI glCopyMultiTexSubImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texunit, target, level, xoffset, yoffset, x, y, width, height );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texunit, target, level, xoffset, yoffset, x, y, width, height );
   funcs->ext.p_glCopyMultiTexSubImage2DEXT( texunit, target, level, xoffset, yoffset, x, y, width, height );
 }
 
-static void WINAPI glCopyMultiTexSubImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
+static void WINAPI glCopyMultiTexSubImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height );
   funcs->ext.p_glCopyMultiTexSubImage3DEXT( texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height );
 }
 
-static void WINAPI glCopyNamedBufferSubData( GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size ) {
+static void WINAPI glCopyNamedBufferSubData( GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %ld, %ld, %ld)\n", readBuffer, writeBuffer, readOffset, writeOffset, size );
+  TRACE( "(%d, %d, %ld, %ld, %ld)\n", readBuffer, writeBuffer, readOffset, writeOffset, size );
   funcs->ext.p_glCopyNamedBufferSubData( readBuffer, writeBuffer, readOffset, writeOffset, size );
 }
 
-static void WINAPI glCopyPathNV( GLuint resultPath, GLuint srcPath ) {
+static void WINAPI glCopyPathNV( GLuint resultPath, GLuint srcPath )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", resultPath, srcPath );
+  TRACE( "(%d, %d)\n", resultPath, srcPath );
   funcs->ext.p_glCopyPathNV( resultPath, srcPath );
 }
 
-static void WINAPI glCopyTexImage1DEXT( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border ) {
+static void WINAPI glCopyTexImage1DEXT( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, border );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, border );
   funcs->ext.p_glCopyTexImage1DEXT( target, level, internalformat, x, y, width, border );
 }
 
-static void WINAPI glCopyTexImage2DEXT( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) {
+static void WINAPI glCopyTexImage2DEXT( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, height, border );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, height, border );
   funcs->ext.p_glCopyTexImage2DEXT( target, level, internalformat, x, y, width, height, border );
 }
 
-static void WINAPI glCopyTexSubImage1DEXT( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width ) {
+static void WINAPI glCopyTexSubImage1DEXT( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, level, xoffset, x, y, width );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", target, level, xoffset, x, y, width );
   funcs->ext.p_glCopyTexSubImage1DEXT( target, level, xoffset, x, y, width );
 }
 
-static void WINAPI glCopyTexSubImage2DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
+static void WINAPI glCopyTexSubImage2DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, x, y, width, height );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, x, y, width, height );
   funcs->ext.p_glCopyTexSubImage2DEXT( target, level, xoffset, yoffset, x, y, width, height );
 }
 
-static void WINAPI glCopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
+static void WINAPI glCopyTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, zoffset, x, y, width, height );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, zoffset, x, y, width, height );
   funcs->ext.p_glCopyTexSubImage3D( target, level, xoffset, yoffset, zoffset, x, y, width, height );
 }
 
-static void WINAPI glCopyTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
+static void WINAPI glCopyTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, zoffset, x, y, width, height );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, zoffset, x, y, width, height );
   funcs->ext.p_glCopyTexSubImage3DEXT( target, level, xoffset, yoffset, zoffset, x, y, width, height );
 }
 
-static void WINAPI glCopyTextureImage1DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border ) {
+static void WINAPI glCopyTextureImage1DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, level, internalformat, x, y, width, border );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, level, internalformat, x, y, width, border );
   funcs->ext.p_glCopyTextureImage1DEXT( texture, target, level, internalformat, x, y, width, border );
 }
 
-static void WINAPI glCopyTextureImage2DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) {
+static void WINAPI glCopyTextureImage2DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, level, internalformat, x, y, width, height, border );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, level, internalformat, x, y, width, height, border );
   funcs->ext.p_glCopyTextureImage2DEXT( texture, target, level, internalformat, x, y, width, height, border );
 }
 
-static void WINAPI glCopyTextureSubImage1D( GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width ) {
+static void WINAPI glCopyTextureSubImage1D( GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", texture, level, xoffset, x, y, width );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", texture, level, xoffset, x, y, width );
   funcs->ext.p_glCopyTextureSubImage1D( texture, level, xoffset, x, y, width );
 }
 
-static void WINAPI glCopyTextureSubImage1DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width ) {
+static void WINAPI glCopyTextureSubImage1DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", texture, target, level, xoffset, x, y, width );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", texture, target, level, xoffset, x, y, width );
   funcs->ext.p_glCopyTextureSubImage1DEXT( texture, target, level, xoffset, x, y, width );
 }
 
-static void WINAPI glCopyTextureSubImage2D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
+static void WINAPI glCopyTextureSubImage2D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, level, xoffset, yoffset, x, y, width, height );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, level, xoffset, yoffset, x, y, width, height );
   funcs->ext.p_glCopyTextureSubImage2D( texture, level, xoffset, yoffset, x, y, width, height );
 }
 
-static void WINAPI glCopyTextureSubImage2DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
+static void WINAPI glCopyTextureSubImage2DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, level, xoffset, yoffset, x, y, width, height );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, level, xoffset, yoffset, x, y, width, height );
   funcs->ext.p_glCopyTextureSubImage2DEXT( texture, target, level, xoffset, yoffset, x, y, width, height );
 }
 
-static void WINAPI glCopyTextureSubImage3D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
+static void WINAPI glCopyTextureSubImage3D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texture, level, xoffset, yoffset, zoffset, x, y, width, height );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texture, level, xoffset, yoffset, zoffset, x, y, width, height );
   funcs->ext.p_glCopyTextureSubImage3D( texture, level, xoffset, yoffset, zoffset, x, y, width, height );
 }
 
-static void WINAPI glCopyTextureSubImage3DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
+static void WINAPI glCopyTextureSubImage3DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, level, xoffset, yoffset, zoffset, x, y, width, height );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, level, xoffset, yoffset, zoffset, x, y, width, height );
   funcs->ext.p_glCopyTextureSubImage3DEXT( texture, target, level, xoffset, yoffset, zoffset, x, y, width, height );
 }
 
-static void WINAPI glCoverFillPathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat* transformValues ) {
+static void WINAPI glCoverFillPathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %d, %d, %p)\n", numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues );
+  TRACE( "(%d, %d, %p, %d, %d, %d, %p)\n", numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues );
   funcs->ext.p_glCoverFillPathInstancedNV( numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues );
 }
 
-static void WINAPI glCoverFillPathNV( GLuint path, GLenum coverMode ) {
+static void WINAPI glCoverFillPathNV( GLuint path, GLenum coverMode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", path, coverMode );
+  TRACE( "(%d, %d)\n", path, coverMode );
   funcs->ext.p_glCoverFillPathNV( path, coverMode );
 }
 
-static void WINAPI glCoverStrokePathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat* transformValues ) {
+static void WINAPI glCoverStrokePathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %d, %d, %p)\n", numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues );
+  TRACE( "(%d, %d, %p, %d, %d, %d, %p)\n", numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues );
   funcs->ext.p_glCoverStrokePathInstancedNV( numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues );
 }
 
-static void WINAPI glCoverStrokePathNV( GLuint path, GLenum coverMode ) {
+static void WINAPI glCoverStrokePathNV( GLuint path, GLenum coverMode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", path, coverMode );
+  TRACE( "(%d, %d)\n", path, coverMode );
   funcs->ext.p_glCoverStrokePathNV( path, coverMode );
 }
 
-static void WINAPI glCoverageModulationNV( GLenum components ) {
+static void WINAPI glCoverageModulationNV( GLenum components )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", components );
+  TRACE( "(%d)\n", components );
   funcs->ext.p_glCoverageModulationNV( components );
 }
 
-static void WINAPI glCoverageModulationTableNV( GLsizei n, const GLfloat* v ) {
+static void WINAPI glCoverageModulationTableNV( GLsizei n, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, v );
+  TRACE( "(%d, %p)\n", n, v );
   funcs->ext.p_glCoverageModulationTableNV( n, v );
 }
 
-static void WINAPI glCreateBuffers( GLsizei n, GLuint* buffers ) {
+static void WINAPI glCreateBuffers( GLsizei n, GLuint *buffers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, buffers );
+  TRACE( "(%d, %p)\n", n, buffers );
   funcs->ext.p_glCreateBuffers( n, buffers );
 }
 
-static void WINAPI glCreateCommandListsNV( GLsizei n, GLuint* lists ) {
+static void WINAPI glCreateCommandListsNV( GLsizei n, GLuint *lists )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, lists );
+  TRACE( "(%d, %p)\n", n, lists );
   funcs->ext.p_glCreateCommandListsNV( n, lists );
 }
 
-static void WINAPI glCreateFramebuffers( GLsizei n, GLuint* framebuffers ) {
+static void WINAPI glCreateFramebuffers( GLsizei n, GLuint *framebuffers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, framebuffers );
+  TRACE( "(%d, %p)\n", n, framebuffers );
   funcs->ext.p_glCreateFramebuffers( n, framebuffers );
 }
 
-static void WINAPI glCreateMemoryObjectsEXT( GLsizei n, GLuint* memoryObjects ) {
+static void WINAPI glCreateMemoryObjectsEXT( GLsizei n, GLuint *memoryObjects )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, memoryObjects );
+  TRACE( "(%d, %p)\n", n, memoryObjects );
   funcs->ext.p_glCreateMemoryObjectsEXT( n, memoryObjects );
 }
 
-static void WINAPI glCreatePerfQueryINTEL( GLuint queryId, GLuint* queryHandle ) {
+static void WINAPI glCreatePerfQueryINTEL( GLuint queryId, GLuint *queryHandle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", queryId, queryHandle );
+  TRACE( "(%d, %p)\n", queryId, queryHandle );
   funcs->ext.p_glCreatePerfQueryINTEL( queryId, queryHandle );
 }
 
-static GLuint WINAPI glCreateProgram( void ) {
+static GLuint WINAPI glCreateProgram(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  return funcs->ext.p_glCreateProgram( );
+  TRACE( "()\n" );
+  return funcs->ext.p_glCreateProgram();
 }
 
-static GLhandleARB WINAPI glCreateProgramObjectARB( void ) {
+static GLhandleARB WINAPI glCreateProgramObjectARB(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  return funcs->ext.p_glCreateProgramObjectARB( );
+  TRACE( "()\n" );
+  return funcs->ext.p_glCreateProgramObjectARB();
 }
 
-static void WINAPI glCreateProgramPipelines( GLsizei n, GLuint* pipelines ) {
+static void WINAPI glCreateProgramPipelines( GLsizei n, GLuint *pipelines )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, pipelines );
+  TRACE( "(%d, %p)\n", n, pipelines );
   funcs->ext.p_glCreateProgramPipelines( n, pipelines );
 }
 
-static void WINAPI glCreateQueries( GLenum target, GLsizei n, GLuint* ids ) {
+static void WINAPI glCreateQueries( GLenum target, GLsizei n, GLuint *ids )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, n, ids );
+  TRACE( "(%d, %d, %p)\n", target, n, ids );
   funcs->ext.p_glCreateQueries( target, n, ids );
 }
 
-static void WINAPI glCreateRenderbuffers( GLsizei n, GLuint* renderbuffers ) {
+static void WINAPI glCreateRenderbuffers( GLsizei n, GLuint *renderbuffers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, renderbuffers );
+  TRACE( "(%d, %p)\n", n, renderbuffers );
   funcs->ext.p_glCreateRenderbuffers( n, renderbuffers );
 }
 
-static void WINAPI glCreateSamplers( GLsizei n, GLuint* samplers ) {
+static void WINAPI glCreateSamplers( GLsizei n, GLuint *samplers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, samplers );
+  TRACE( "(%d, %p)\n", n, samplers );
   funcs->ext.p_glCreateSamplers( n, samplers );
 }
 
-static GLuint WINAPI glCreateShader( GLenum type ) {
+static GLuint WINAPI glCreateShader( GLenum type )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", type );
+  TRACE( "(%d)\n", type );
   return funcs->ext.p_glCreateShader( type );
 }
 
-static GLhandleARB WINAPI glCreateShaderObjectARB( GLenum shaderType ) {
+static GLhandleARB WINAPI glCreateShaderObjectARB( GLenum shaderType )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", shaderType );
+  TRACE( "(%d)\n", shaderType );
   return funcs->ext.p_glCreateShaderObjectARB( shaderType );
 }
 
-static GLuint WINAPI glCreateShaderProgramEXT( GLenum type, const GLchar* string ) {
+static GLuint WINAPI glCreateShaderProgramEXT( GLenum type, const GLchar *string )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", type, string );
+  TRACE( "(%d, %p)\n", type, string );
   return funcs->ext.p_glCreateShaderProgramEXT( type, string );
 }
 
-static GLuint WINAPI glCreateShaderProgramv( GLenum type, GLsizei count, const GLchar*const* strings ) {
+static GLuint WINAPI glCreateShaderProgramv( GLenum type, GLsizei count, const GLchar *const*strings )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", type, count, strings );
+  TRACE( "(%d, %d, %p)\n", type, count, strings );
   return funcs->ext.p_glCreateShaderProgramv( type, count, strings );
 }
 
-static void WINAPI glCreateStatesNV( GLsizei n, GLuint* states ) {
+static void WINAPI glCreateStatesNV( GLsizei n, GLuint *states )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, states );
+  TRACE( "(%d, %p)\n", n, states );
   funcs->ext.p_glCreateStatesNV( n, states );
 }
 
-static GLsync WINAPI glCreateSyncFromCLeventARB( void* context, void* event, GLbitfield flags ) {
+static GLsync WINAPI glCreateSyncFromCLeventARB( void *context, void *event, GLbitfield flags )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p, %d)\n", context, event, flags );
+  TRACE( "(%p, %p, %d)\n", context, event, flags );
   return funcs->ext.p_glCreateSyncFromCLeventARB( context, event, flags );
 }
 
-static void WINAPI glCreateTextures( GLenum target, GLsizei n, GLuint* textures ) {
+static void WINAPI glCreateTextures( GLenum target, GLsizei n, GLuint *textures )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, n, textures );
+  TRACE( "(%d, %d, %p)\n", target, n, textures );
   funcs->ext.p_glCreateTextures( target, n, textures );
 }
 
-static void WINAPI glCreateTransformFeedbacks( GLsizei n, GLuint* ids ) {
+static void WINAPI glCreateTransformFeedbacks( GLsizei n, GLuint *ids )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, ids );
+  TRACE( "(%d, %p)\n", n, ids );
   funcs->ext.p_glCreateTransformFeedbacks( n, ids );
 }
 
-static void WINAPI glCreateVertexArrays( GLsizei n, GLuint* arrays ) {
+static void WINAPI glCreateVertexArrays( GLsizei n, GLuint *arrays )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, arrays );
+  TRACE( "(%d, %p)\n", n, arrays );
   funcs->ext.p_glCreateVertexArrays( n, arrays );
 }
 
-static void WINAPI glCullParameterdvEXT( GLenum pname, GLdouble* params ) {
+static void WINAPI glCullParameterdvEXT( GLenum pname, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glCullParameterdvEXT( pname, params );
 }
 
-static void WINAPI glCullParameterfvEXT( GLenum pname, GLfloat* params ) {
+static void WINAPI glCullParameterfvEXT( GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glCullParameterfvEXT( pname, params );
 }
 
-static void WINAPI glCurrentPaletteMatrixARB( GLint index ) {
+static void WINAPI glCurrentPaletteMatrixARB( GLint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", index );
+  TRACE( "(%d)\n", index );
   funcs->ext.p_glCurrentPaletteMatrixARB( index );
 }
 
-static void WINAPI glDebugMessageCallback( void * callback, const void* userParam ) {
+static void WINAPI glDebugMessageCallback( void * callback, const void *userParam )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", callback, userParam );
+  TRACE( "(%p, %p)\n", callback, userParam );
   funcs->ext.p_glDebugMessageCallback( callback, userParam );
 }
 
-static void WINAPI glDebugMessageCallbackAMD( void * callback, void* userParam ) {
+static void WINAPI glDebugMessageCallbackAMD( void * callback, void *userParam )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", callback, userParam );
+  TRACE( "(%p, %p)\n", callback, userParam );
   funcs->ext.p_glDebugMessageCallbackAMD( callback, userParam );
 }
 
-static void WINAPI glDebugMessageCallbackARB( void * callback, const void* userParam ) {
+static void WINAPI glDebugMessageCallbackARB( void * callback, const void *userParam )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", callback, userParam );
+  TRACE( "(%p, %p)\n", callback, userParam );
   funcs->ext.p_glDebugMessageCallbackARB( callback, userParam );
 }
 
-static void WINAPI glDebugMessageControl( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled ) {
+static void WINAPI glDebugMessageControl( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p, %d)\n", source, type, severity, count, ids, enabled );
+  TRACE( "(%d, %d, %d, %d, %p, %d)\n", source, type, severity, count, ids, enabled );
   funcs->ext.p_glDebugMessageControl( source, type, severity, count, ids, enabled );
 }
 
-static void WINAPI glDebugMessageControlARB( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled ) {
+static void WINAPI glDebugMessageControlARB( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p, %d)\n", source, type, severity, count, ids, enabled );
+  TRACE( "(%d, %d, %d, %d, %p, %d)\n", source, type, severity, count, ids, enabled );
   funcs->ext.p_glDebugMessageControlARB( source, type, severity, count, ids, enabled );
 }
 
-static void WINAPI glDebugMessageEnableAMD( GLenum category, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled ) {
+static void WINAPI glDebugMessageEnableAMD( GLenum category, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %d)\n", category, severity, count, ids, enabled );
+  TRACE( "(%d, %d, %d, %p, %d)\n", category, severity, count, ids, enabled );
   funcs->ext.p_glDebugMessageEnableAMD( category, severity, count, ids, enabled );
 }
 
-static void WINAPI glDebugMessageInsert( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* buf ) {
+static void WINAPI glDebugMessageInsert( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", source, type, id, severity, length, buf );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", source, type, id, severity, length, buf );
   funcs->ext.p_glDebugMessageInsert( source, type, id, severity, length, buf );
 }
 
-static void WINAPI glDebugMessageInsertAMD( GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar* buf ) {
+static void WINAPI glDebugMessageInsertAMD( GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar *buf )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", category, severity, id, length, buf );
+  TRACE( "(%d, %d, %d, %d, %p)\n", category, severity, id, length, buf );
   funcs->ext.p_glDebugMessageInsertAMD( category, severity, id, length, buf );
 }
 
-static void WINAPI glDebugMessageInsertARB( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* buf ) {
+static void WINAPI glDebugMessageInsertARB( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", source, type, id, severity, length, buf );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", source, type, id, severity, length, buf );
   funcs->ext.p_glDebugMessageInsertARB( source, type, id, severity, length, buf );
 }
 
-static void WINAPI glDeformSGIX( GLbitfield mask ) {
+static void WINAPI glDeformSGIX( GLbitfield mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mask );
+  TRACE( "(%d)\n", mask );
   funcs->ext.p_glDeformSGIX( mask );
 }
 
-static void WINAPI glDeformationMap3dSGIX( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, const GLdouble* points ) {
+static void WINAPI glDeformationMap3dSGIX( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, const GLdouble *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %d, %d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points );
+  TRACE( "(%d, %f, %f, %d, %d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points );
   funcs->ext.p_glDeformationMap3dSGIX( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points );
 }
 
-static void WINAPI glDeformationMap3fSGIX( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, const GLfloat* points ) {
+static void WINAPI glDeformationMap3fSGIX( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, const GLfloat *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %d, %d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points );
+  TRACE( "(%d, %f, %f, %d, %d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points );
   funcs->ext.p_glDeformationMap3fSGIX( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points );
 }
 
-static void WINAPI glDeleteAsyncMarkersSGIX( GLuint marker, GLsizei range ) {
+static void WINAPI glDeleteAsyncMarkersSGIX( GLuint marker, GLsizei range )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", marker, range );
+  TRACE( "(%d, %d)\n", marker, range );
   funcs->ext.p_glDeleteAsyncMarkersSGIX( marker, range );
 }
 
-static void WINAPI glDeleteBufferRegion( GLenum region ) {
+static void WINAPI glDeleteBufferRegion( GLenum region )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", region );
+  TRACE( "(%d)\n", region );
   funcs->ext.p_glDeleteBufferRegion( region );
 }
 
-static void WINAPI glDeleteBuffers( GLsizei n, const GLuint* buffers ) {
+static void WINAPI glDeleteBuffers( GLsizei n, const GLuint *buffers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, buffers );
+  TRACE( "(%d, %p)\n", n, buffers );
   funcs->ext.p_glDeleteBuffers( n, buffers );
 }
 
-static void WINAPI glDeleteBuffersARB( GLsizei n, const GLuint* buffers ) {
+static void WINAPI glDeleteBuffersARB( GLsizei n, const GLuint *buffers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, buffers );
+  TRACE( "(%d, %p)\n", n, buffers );
   funcs->ext.p_glDeleteBuffersARB( n, buffers );
 }
 
-static void WINAPI glDeleteCommandListsNV( GLsizei n, const GLuint* lists ) {
+static void WINAPI glDeleteCommandListsNV( GLsizei n, const GLuint *lists )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, lists );
+  TRACE( "(%d, %p)\n", n, lists );
   funcs->ext.p_glDeleteCommandListsNV( n, lists );
 }
 
-static void WINAPI glDeleteFencesAPPLE( GLsizei n, const GLuint* fences ) {
+static void WINAPI glDeleteFencesAPPLE( GLsizei n, const GLuint *fences )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, fences );
+  TRACE( "(%d, %p)\n", n, fences );
   funcs->ext.p_glDeleteFencesAPPLE( n, fences );
 }
 
-static void WINAPI glDeleteFencesNV( GLsizei n, const GLuint* fences ) {
+static void WINAPI glDeleteFencesNV( GLsizei n, const GLuint *fences )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, fences );
+  TRACE( "(%d, %p)\n", n, fences );
   funcs->ext.p_glDeleteFencesNV( n, fences );
 }
 
-static void WINAPI glDeleteFragmentShaderATI( GLuint id ) {
+static void WINAPI glDeleteFragmentShaderATI( GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", id );
+  TRACE( "(%d)\n", id );
   funcs->ext.p_glDeleteFragmentShaderATI( id );
 }
 
-static void WINAPI glDeleteFramebuffers( GLsizei n, const GLuint* framebuffers ) {
+static void WINAPI glDeleteFramebuffers( GLsizei n, const GLuint *framebuffers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, framebuffers );
+  TRACE( "(%d, %p)\n", n, framebuffers );
   funcs->ext.p_glDeleteFramebuffers( n, framebuffers );
 }
 
-static void WINAPI glDeleteFramebuffersEXT( GLsizei n, const GLuint* framebuffers ) {
+static void WINAPI glDeleteFramebuffersEXT( GLsizei n, const GLuint *framebuffers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, framebuffers );
+  TRACE( "(%d, %p)\n", n, framebuffers );
   funcs->ext.p_glDeleteFramebuffersEXT( n, framebuffers );
 }
 
-static void WINAPI glDeleteMemoryObjectsEXT( GLsizei n, const GLuint* memoryObjects ) {
+static void WINAPI glDeleteMemoryObjectsEXT( GLsizei n, const GLuint *memoryObjects )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, memoryObjects );
+  TRACE( "(%d, %p)\n", n, memoryObjects );
   funcs->ext.p_glDeleteMemoryObjectsEXT( n, memoryObjects );
 }
 
-static void WINAPI glDeleteNamedStringARB( GLint namelen, const GLchar* name ) {
+static void WINAPI glDeleteNamedStringARB( GLint namelen, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", namelen, name );
+  TRACE( "(%d, %p)\n", namelen, name );
   funcs->ext.p_glDeleteNamedStringARB( namelen, name );
 }
 
-static void WINAPI glDeleteNamesAMD( GLenum identifier, GLuint num, const GLuint* names ) {
+static void WINAPI glDeleteNamesAMD( GLenum identifier, GLuint num, const GLuint *names )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", identifier, num, names );
+  TRACE( "(%d, %d, %p)\n", identifier, num, names );
   funcs->ext.p_glDeleteNamesAMD( identifier, num, names );
 }
 
-static void WINAPI glDeleteObjectARB( GLhandleARB obj ) {
+static void WINAPI glDeleteObjectARB( GLhandleARB obj )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", obj );
+  TRACE( "(%d)\n", obj );
   funcs->ext.p_glDeleteObjectARB( obj );
 }
 
-static void WINAPI glDeleteObjectBufferATI( GLuint buffer ) {
+static void WINAPI glDeleteObjectBufferATI( GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", buffer );
+  TRACE( "(%d)\n", buffer );
   funcs->ext.p_glDeleteObjectBufferATI( buffer );
 }
 
-static void WINAPI glDeleteOcclusionQueriesNV( GLsizei n, const GLuint* ids ) {
+static void WINAPI glDeleteOcclusionQueriesNV( GLsizei n, const GLuint *ids )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, ids );
+  TRACE( "(%d, %p)\n", n, ids );
   funcs->ext.p_glDeleteOcclusionQueriesNV( n, ids );
 }
 
-static void WINAPI glDeletePathsNV( GLuint path, GLsizei range ) {
+static void WINAPI glDeletePathsNV( GLuint path, GLsizei range )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", path, range );
+  TRACE( "(%d, %d)\n", path, range );
   funcs->ext.p_glDeletePathsNV( path, range );
 }
 
-static void WINAPI glDeletePerfMonitorsAMD( GLsizei n, GLuint* monitors ) {
+static void WINAPI glDeletePerfMonitorsAMD( GLsizei n, GLuint *monitors )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, monitors );
+  TRACE( "(%d, %p)\n", n, monitors );
   funcs->ext.p_glDeletePerfMonitorsAMD( n, monitors );
 }
 
-static void WINAPI glDeletePerfQueryINTEL( GLuint queryHandle ) {
+static void WINAPI glDeletePerfQueryINTEL( GLuint queryHandle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", queryHandle );
+  TRACE( "(%d)\n", queryHandle );
   funcs->ext.p_glDeletePerfQueryINTEL( queryHandle );
 }
 
-static void WINAPI glDeleteProgram( GLuint program ) {
+static void WINAPI glDeleteProgram( GLuint program )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", program );
+  TRACE( "(%d)\n", program );
   funcs->ext.p_glDeleteProgram( program );
 }
 
-static void WINAPI glDeleteProgramPipelines( GLsizei n, const GLuint* pipelines ) {
+static void WINAPI glDeleteProgramPipelines( GLsizei n, const GLuint *pipelines )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, pipelines );
+  TRACE( "(%d, %p)\n", n, pipelines );
   funcs->ext.p_glDeleteProgramPipelines( n, pipelines );
 }
 
-static void WINAPI glDeleteProgramsARB( GLsizei n, const GLuint* programs ) {
+static void WINAPI glDeleteProgramsARB( GLsizei n, const GLuint *programs )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, programs );
+  TRACE( "(%d, %p)\n", n, programs );
   funcs->ext.p_glDeleteProgramsARB( n, programs );
 }
 
-static void WINAPI glDeleteProgramsNV( GLsizei n, const GLuint* programs ) {
+static void WINAPI glDeleteProgramsNV( GLsizei n, const GLuint *programs )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, programs );
+  TRACE( "(%d, %p)\n", n, programs );
   funcs->ext.p_glDeleteProgramsNV( n, programs );
 }
 
-static void WINAPI glDeleteQueries( GLsizei n, const GLuint* ids ) {
+static void WINAPI glDeleteQueries( GLsizei n, const GLuint *ids )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, ids );
+  TRACE( "(%d, %p)\n", n, ids );
   funcs->ext.p_glDeleteQueries( n, ids );
 }
 
-static void WINAPI glDeleteQueriesARB( GLsizei n, const GLuint* ids ) {
+static void WINAPI glDeleteQueriesARB( GLsizei n, const GLuint *ids )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, ids );
+  TRACE( "(%d, %p)\n", n, ids );
   funcs->ext.p_glDeleteQueriesARB( n, ids );
 }
 
-static void WINAPI glDeleteQueryResourceTagNV( GLsizei n, const GLint* tagIds ) {
+static void WINAPI glDeleteQueryResourceTagNV( GLsizei n, const GLint *tagIds )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, tagIds );
+  TRACE( "(%d, %p)\n", n, tagIds );
   funcs->ext.p_glDeleteQueryResourceTagNV( n, tagIds );
 }
 
-static void WINAPI glDeleteRenderbuffers( GLsizei n, const GLuint* renderbuffers ) {
+static void WINAPI glDeleteRenderbuffers( GLsizei n, const GLuint *renderbuffers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, renderbuffers );
+  TRACE( "(%d, %p)\n", n, renderbuffers );
   funcs->ext.p_glDeleteRenderbuffers( n, renderbuffers );
 }
 
-static void WINAPI glDeleteRenderbuffersEXT( GLsizei n, const GLuint* renderbuffers ) {
+static void WINAPI glDeleteRenderbuffersEXT( GLsizei n, const GLuint *renderbuffers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, renderbuffers );
+  TRACE( "(%d, %p)\n", n, renderbuffers );
   funcs->ext.p_glDeleteRenderbuffersEXT( n, renderbuffers );
 }
 
-static void WINAPI glDeleteSamplers( GLsizei count, const GLuint* samplers ) {
+static void WINAPI glDeleteSamplers( GLsizei count, const GLuint *samplers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", count, samplers );
+  TRACE( "(%d, %p)\n", count, samplers );
   funcs->ext.p_glDeleteSamplers( count, samplers );
 }
 
-static void WINAPI glDeleteSemaphoresEXT( GLsizei n, const GLuint* semaphores ) {
+static void WINAPI glDeleteSemaphoresEXT( GLsizei n, const GLuint *semaphores )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, semaphores );
+  TRACE( "(%d, %p)\n", n, semaphores );
   funcs->ext.p_glDeleteSemaphoresEXT( n, semaphores );
 }
 
-static void WINAPI glDeleteShader( GLuint shader ) {
+static void WINAPI glDeleteShader( GLuint shader )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", shader );
+  TRACE( "(%d)\n", shader );
   funcs->ext.p_glDeleteShader( shader );
 }
 
-static void WINAPI glDeleteStatesNV( GLsizei n, const GLuint* states ) {
+static void WINAPI glDeleteStatesNV( GLsizei n, const GLuint *states )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, states );
+  TRACE( "(%d, %p)\n", n, states );
   funcs->ext.p_glDeleteStatesNV( n, states );
 }
 
-static void WINAPI glDeleteSync( GLsync sync ) {
+static void WINAPI glDeleteSync( GLsync sync )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", sync );
+  TRACE( "(%p)\n", sync );
   funcs->ext.p_glDeleteSync( sync );
 }
 
-static void WINAPI glDeleteTexturesEXT( GLsizei n, const GLuint* textures ) {
+static void WINAPI glDeleteTexturesEXT( GLsizei n, const GLuint *textures )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, textures );
+  TRACE( "(%d, %p)\n", n, textures );
   funcs->ext.p_glDeleteTexturesEXT( n, textures );
 }
 
-static void WINAPI glDeleteTransformFeedbacks( GLsizei n, const GLuint* ids ) {
+static void WINAPI glDeleteTransformFeedbacks( GLsizei n, const GLuint *ids )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, ids );
+  TRACE( "(%d, %p)\n", n, ids );
   funcs->ext.p_glDeleteTransformFeedbacks( n, ids );
 }
 
-static void WINAPI glDeleteTransformFeedbacksNV( GLsizei n, const GLuint* ids ) {
+static void WINAPI glDeleteTransformFeedbacksNV( GLsizei n, const GLuint *ids )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, ids );
+  TRACE( "(%d, %p)\n", n, ids );
   funcs->ext.p_glDeleteTransformFeedbacksNV( n, ids );
 }
 
-static void WINAPI glDeleteVertexArrays( GLsizei n, const GLuint* arrays ) {
+static void WINAPI glDeleteVertexArrays( GLsizei n, const GLuint *arrays )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, arrays );
+  TRACE( "(%d, %p)\n", n, arrays );
   funcs->ext.p_glDeleteVertexArrays( n, arrays );
 }
 
-static void WINAPI glDeleteVertexArraysAPPLE( GLsizei n, const GLuint* arrays ) {
+static void WINAPI glDeleteVertexArraysAPPLE( GLsizei n, const GLuint *arrays )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, arrays );
+  TRACE( "(%d, %p)\n", n, arrays );
   funcs->ext.p_glDeleteVertexArraysAPPLE( n, arrays );
 }
 
-static void WINAPI glDeleteVertexShaderEXT( GLuint id ) {
+static void WINAPI glDeleteVertexShaderEXT( GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", id );
+  TRACE( "(%d)\n", id );
   funcs->ext.p_glDeleteVertexShaderEXT( id );
 }
 
-static void WINAPI glDepthBoundsEXT( GLclampd zmin, GLclampd zmax ) {
+static void WINAPI glDepthBoundsEXT( GLclampd zmin, GLclampd zmax )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", zmin, zmax );
+  TRACE( "(%f, %f)\n", zmin, zmax );
   funcs->ext.p_glDepthBoundsEXT( zmin, zmax );
 }
 
-static void WINAPI glDepthBoundsdNV( GLdouble zmin, GLdouble zmax ) {
+static void WINAPI glDepthBoundsdNV( GLdouble zmin, GLdouble zmax )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", zmin, zmax );
+  TRACE( "(%f, %f)\n", zmin, zmax );
   funcs->ext.p_glDepthBoundsdNV( zmin, zmax );
 }
 
-static void WINAPI glDepthRangeArrayv( GLuint first, GLsizei count, const GLdouble* v ) {
+static void WINAPI glDepthRangeArrayv( GLuint first, GLsizei count, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", first, count, v );
+  TRACE( "(%d, %d, %p)\n", first, count, v );
   funcs->ext.p_glDepthRangeArrayv( first, count, v );
 }
 
-static void WINAPI glDepthRangeIndexed( GLuint index, GLdouble n, GLdouble f ) {
+static void WINAPI glDepthRangeIndexed( GLuint index, GLdouble n, GLdouble f )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", index, n, f );
+  TRACE( "(%d, %f, %f)\n", index, n, f );
   funcs->ext.p_glDepthRangeIndexed( index, n, f );
 }
 
-static void WINAPI glDepthRangedNV( GLdouble zNear, GLdouble zFar ) {
+static void WINAPI glDepthRangedNV( GLdouble zNear, GLdouble zFar )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", zNear, zFar );
+  TRACE( "(%f, %f)\n", zNear, zFar );
   funcs->ext.p_glDepthRangedNV( zNear, zFar );
 }
 
-static void WINAPI glDepthRangef( GLfloat n, GLfloat f ) {
+static void WINAPI glDepthRangef( GLfloat n, GLfloat f )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", n, f );
+  TRACE( "(%f, %f)\n", n, f );
   funcs->ext.p_glDepthRangef( n, f );
 }
 
-static void WINAPI glDepthRangefOES( GLclampf n, GLclampf f ) {
+static void WINAPI glDepthRangefOES( GLclampf n, GLclampf f )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", n, f );
+  TRACE( "(%f, %f)\n", n, f );
   funcs->ext.p_glDepthRangefOES( n, f );
 }
 
-static void WINAPI glDepthRangexOES( GLfixed n, GLfixed f ) {
+static void WINAPI glDepthRangexOES( GLfixed n, GLfixed f )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", n, f );
+  TRACE( "(%d, %d)\n", n, f );
   funcs->ext.p_glDepthRangexOES( n, f );
 }
 
-static void WINAPI glDetachObjectARB( GLhandleARB containerObj, GLhandleARB attachedObj ) {
+static void WINAPI glDetachObjectARB( GLhandleARB containerObj, GLhandleARB attachedObj )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", containerObj, attachedObj );
+  TRACE( "(%d, %d)\n", containerObj, attachedObj );
   funcs->ext.p_glDetachObjectARB( containerObj, attachedObj );
 }
 
-static void WINAPI glDetachShader( GLuint program, GLuint shader ) {
+static void WINAPI glDetachShader( GLuint program, GLuint shader )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", program, shader );
+  TRACE( "(%d, %d)\n", program, shader );
   funcs->ext.p_glDetachShader( program, shader );
 }
 
-static void WINAPI glDetailTexFuncSGIS( GLenum target, GLsizei n, const GLfloat* points ) {
+static void WINAPI glDetailTexFuncSGIS( GLenum target, GLsizei n, const GLfloat *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, n, points );
+  TRACE( "(%d, %d, %p)\n", target, n, points );
   funcs->ext.p_glDetailTexFuncSGIS( target, n, points );
 }
 
-static void WINAPI glDisableClientStateIndexedEXT( GLenum array, GLuint index ) {
+static void WINAPI glDisableClientStateIndexedEXT( GLenum array, GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", array, index );
+  TRACE( "(%d, %d)\n", array, index );
   funcs->ext.p_glDisableClientStateIndexedEXT( array, index );
 }
 
-static void WINAPI glDisableClientStateiEXT( GLenum array, GLuint index ) {
+static void WINAPI glDisableClientStateiEXT( GLenum array, GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", array, index );
+  TRACE( "(%d, %d)\n", array, index );
   funcs->ext.p_glDisableClientStateiEXT( array, index );
 }
 
-static void WINAPI glDisableIndexedEXT( GLenum target, GLuint index ) {
+static void WINAPI glDisableIndexedEXT( GLenum target, GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, index );
+  TRACE( "(%d, %d)\n", target, index );
   funcs->ext.p_glDisableIndexedEXT( target, index );
 }
 
-static void WINAPI glDisableVariantClientStateEXT( GLuint id ) {
+static void WINAPI glDisableVariantClientStateEXT( GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", id );
+  TRACE( "(%d)\n", id );
   funcs->ext.p_glDisableVariantClientStateEXT( id );
 }
 
-static void WINAPI glDisableVertexArrayAttrib( GLuint vaobj, GLuint index ) {
+static void WINAPI glDisableVertexArrayAttrib( GLuint vaobj, GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", vaobj, index );
+  TRACE( "(%d, %d)\n", vaobj, index );
   funcs->ext.p_glDisableVertexArrayAttrib( vaobj, index );
 }
 
-static void WINAPI glDisableVertexArrayAttribEXT( GLuint vaobj, GLuint index ) {
+static void WINAPI glDisableVertexArrayAttribEXT( GLuint vaobj, GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", vaobj, index );
+  TRACE( "(%d, %d)\n", vaobj, index );
   funcs->ext.p_glDisableVertexArrayAttribEXT( vaobj, index );
 }
 
-static void WINAPI glDisableVertexArrayEXT( GLuint vaobj, GLenum array ) {
+static void WINAPI glDisableVertexArrayEXT( GLuint vaobj, GLenum array )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", vaobj, array );
+  TRACE( "(%d, %d)\n", vaobj, array );
   funcs->ext.p_glDisableVertexArrayEXT( vaobj, array );
 }
 
-static void WINAPI glDisableVertexAttribAPPLE( GLuint index, GLenum pname ) {
+static void WINAPI glDisableVertexAttribAPPLE( GLuint index, GLenum pname )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", index, pname );
+  TRACE( "(%d, %d)\n", index, pname );
   funcs->ext.p_glDisableVertexAttribAPPLE( index, pname );
 }
 
-static void WINAPI glDisableVertexAttribArray( GLuint index ) {
+static void WINAPI glDisableVertexAttribArray( GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", index );
+  TRACE( "(%d)\n", index );
   funcs->ext.p_glDisableVertexAttribArray( index );
 }
 
-static void WINAPI glDisableVertexAttribArrayARB( GLuint index ) {
+static void WINAPI glDisableVertexAttribArrayARB( GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", index );
+  TRACE( "(%d)\n", index );
   funcs->ext.p_glDisableVertexAttribArrayARB( index );
 }
 
-static void WINAPI glDisablei( GLenum target, GLuint index ) {
+static void WINAPI glDisablei( GLenum target, GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, index );
+  TRACE( "(%d, %d)\n", target, index );
   funcs->ext.p_glDisablei( target, index );
 }
 
-static void WINAPI glDispatchCompute( GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z ) {
+static void WINAPI glDispatchCompute( GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", num_groups_x, num_groups_y, num_groups_z );
+  TRACE( "(%d, %d, %d)\n", num_groups_x, num_groups_y, num_groups_z );
   funcs->ext.p_glDispatchCompute( num_groups_x, num_groups_y, num_groups_z );
 }
 
-static void WINAPI glDispatchComputeGroupSizeARB( GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z, GLuint group_size_x, GLuint group_size_y, GLuint group_size_z ) {
+static void WINAPI glDispatchComputeGroupSizeARB( GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z, GLuint group_size_x, GLuint group_size_y, GLuint group_size_z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", num_groups_x, num_groups_y, num_groups_z, group_size_x, group_size_y, group_size_z );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", num_groups_x, num_groups_y, num_groups_z, group_size_x, group_size_y, group_size_z );
   funcs->ext.p_glDispatchComputeGroupSizeARB( num_groups_x, num_groups_y, num_groups_z, group_size_x, group_size_y, group_size_z );
 }
 
-static void WINAPI glDispatchComputeIndirect( GLintptr indirect ) {
+static void WINAPI glDispatchComputeIndirect( GLintptr indirect )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%ld)\n", indirect );
+  TRACE( "(%ld)\n", indirect );
   funcs->ext.p_glDispatchComputeIndirect( indirect );
 }
 
-static void WINAPI glDrawArraysEXT( GLenum mode, GLint first, GLsizei count ) {
+static void WINAPI glDrawArraysEXT( GLenum mode, GLint first, GLsizei count )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", mode, first, count );
+  TRACE( "(%d, %d, %d)\n", mode, first, count );
   funcs->ext.p_glDrawArraysEXT( mode, first, count );
 }
 
-static void WINAPI glDrawArraysIndirect( GLenum mode, const void* indirect ) {
+static void WINAPI glDrawArraysIndirect( GLenum mode, const void *indirect )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", mode, indirect );
+  TRACE( "(%d, %p)\n", mode, indirect );
   funcs->ext.p_glDrawArraysIndirect( mode, indirect );
 }
 
-static void WINAPI glDrawArraysInstanced( GLenum mode, GLint first, GLsizei count, GLsizei instancecount ) {
+static void WINAPI glDrawArraysInstanced( GLenum mode, GLint first, GLsizei count, GLsizei instancecount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", mode, first, count, instancecount );
+  TRACE( "(%d, %d, %d, %d)\n", mode, first, count, instancecount );
   funcs->ext.p_glDrawArraysInstanced( mode, first, count, instancecount );
 }
 
-static void WINAPI glDrawArraysInstancedARB( GLenum mode, GLint first, GLsizei count, GLsizei primcount ) {
+static void WINAPI glDrawArraysInstancedARB( GLenum mode, GLint first, GLsizei count, GLsizei primcount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", mode, first, count, primcount );
+  TRACE( "(%d, %d, %d, %d)\n", mode, first, count, primcount );
   funcs->ext.p_glDrawArraysInstancedARB( mode, first, count, primcount );
 }
 
-static void WINAPI glDrawArraysInstancedBaseInstance( GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance ) {
+static void WINAPI glDrawArraysInstancedBaseInstance( GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", mode, first, count, instancecount, baseinstance );
+  TRACE( "(%d, %d, %d, %d, %d)\n", mode, first, count, instancecount, baseinstance );
   funcs->ext.p_glDrawArraysInstancedBaseInstance( mode, first, count, instancecount, baseinstance );
 }
 
-static void WINAPI glDrawArraysInstancedEXT( GLenum mode, GLint start, GLsizei count, GLsizei primcount ) {
+static void WINAPI glDrawArraysInstancedEXT( GLenum mode, GLint start, GLsizei count, GLsizei primcount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", mode, start, count, primcount );
+  TRACE( "(%d, %d, %d, %d)\n", mode, start, count, primcount );
   funcs->ext.p_glDrawArraysInstancedEXT( mode, start, count, primcount );
 }
 
-static void WINAPI glDrawBufferRegion( GLenum region, GLint x, GLint y, GLsizei width, GLsizei height, GLint xDest, GLint yDest ) {
+static void WINAPI glDrawBufferRegion( GLenum region, GLint x, GLint y, GLsizei width, GLsizei height, GLint xDest, GLint yDest )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", region, x, y, width, height, xDest, yDest );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", region, x, y, width, height, xDest, yDest );
   funcs->ext.p_glDrawBufferRegion( region, x, y, width, height, xDest, yDest );
 }
 
-static void WINAPI glDrawBuffers( GLsizei n, const GLenum* bufs ) {
+static void WINAPI glDrawBuffers( GLsizei n, const GLenum *bufs )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, bufs );
+  TRACE( "(%d, %p)\n", n, bufs );
   funcs->ext.p_glDrawBuffers( n, bufs );
 }
 
-static void WINAPI glDrawBuffersARB( GLsizei n, const GLenum* bufs ) {
+static void WINAPI glDrawBuffersARB( GLsizei n, const GLenum *bufs )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, bufs );
+  TRACE( "(%d, %p)\n", n, bufs );
   funcs->ext.p_glDrawBuffersARB( n, bufs );
 }
 
-static void WINAPI glDrawBuffersATI( GLsizei n, const GLenum* bufs ) {
+static void WINAPI glDrawBuffersATI( GLsizei n, const GLenum *bufs )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, bufs );
+  TRACE( "(%d, %p)\n", n, bufs );
   funcs->ext.p_glDrawBuffersATI( n, bufs );
 }
 
-static void WINAPI glDrawCommandsAddressNV( GLenum primitiveMode, const GLuint64* indirects, const GLsizei* sizes, GLuint count ) {
+static void WINAPI glDrawCommandsAddressNV( GLenum primitiveMode, const GLuint64 *indirects, const GLsizei *sizes, GLuint count )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %p, %d)\n", primitiveMode, indirects, sizes, count );
+  TRACE( "(%d, %p, %p, %d)\n", primitiveMode, indirects, sizes, count );
   funcs->ext.p_glDrawCommandsAddressNV( primitiveMode, indirects, sizes, count );
 }
 
-static void WINAPI glDrawCommandsNV( GLenum primitiveMode, GLuint buffer, const GLintptr* indirects, const GLsizei* sizes, GLuint count ) {
+static void WINAPI glDrawCommandsNV( GLenum primitiveMode, GLuint buffer, const GLintptr *indirects, const GLsizei *sizes, GLuint count )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p, %d)\n", primitiveMode, buffer, indirects, sizes, count );
+  TRACE( "(%d, %d, %p, %p, %d)\n", primitiveMode, buffer, indirects, sizes, count );
   funcs->ext.p_glDrawCommandsNV( primitiveMode, buffer, indirects, sizes, count );
 }
 
-static void WINAPI glDrawCommandsStatesAddressNV( const GLuint64* indirects, const GLsizei* sizes, const GLuint* states, const GLuint* fbos, GLuint count ) {
+static void WINAPI glDrawCommandsStatesAddressNV( const GLuint64 *indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p, %p, %p, %d)\n", indirects, sizes, states, fbos, count );
+  TRACE( "(%p, %p, %p, %p, %d)\n", indirects, sizes, states, fbos, count );
   funcs->ext.p_glDrawCommandsStatesAddressNV( indirects, sizes, states, fbos, count );
 }
 
-static void WINAPI glDrawCommandsStatesNV( GLuint buffer, const GLintptr* indirects, const GLsizei* sizes, const GLuint* states, const GLuint* fbos, GLuint count ) {
+static void WINAPI glDrawCommandsStatesNV( GLuint buffer, const GLintptr *indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %p, %p, %p, %d)\n", buffer, indirects, sizes, states, fbos, count );
+  TRACE( "(%d, %p, %p, %p, %p, %d)\n", buffer, indirects, sizes, states, fbos, count );
   funcs->ext.p_glDrawCommandsStatesNV( buffer, indirects, sizes, states, fbos, count );
 }
 
-static void WINAPI glDrawElementArrayAPPLE( GLenum mode, GLint first, GLsizei count ) {
+static void WINAPI glDrawElementArrayAPPLE( GLenum mode, GLint first, GLsizei count )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", mode, first, count );
+  TRACE( "(%d, %d, %d)\n", mode, first, count );
   funcs->ext.p_glDrawElementArrayAPPLE( mode, first, count );
 }
 
-static void WINAPI glDrawElementArrayATI( GLenum mode, GLsizei count ) {
+static void WINAPI glDrawElementArrayATI( GLenum mode, GLsizei count )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", mode, count );
+  TRACE( "(%d, %d)\n", mode, count );
   funcs->ext.p_glDrawElementArrayATI( mode, count );
 }
 
-static void WINAPI glDrawElementsBaseVertex( GLenum mode, GLsizei count, GLenum type, const void* indices, GLint basevertex ) {
+static void WINAPI glDrawElementsBaseVertex( GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %d)\n", mode, count, type, indices, basevertex );
+  TRACE( "(%d, %d, %d, %p, %d)\n", mode, count, type, indices, basevertex );
   funcs->ext.p_glDrawElementsBaseVertex( mode, count, type, indices, basevertex );
 }
 
-static void WINAPI glDrawElementsIndirect( GLenum mode, GLenum type, const void* indirect ) {
+static void WINAPI glDrawElementsIndirect( GLenum mode, GLenum type, const void *indirect )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", mode, type, indirect );
+  TRACE( "(%d, %d, %p)\n", mode, type, indirect );
   funcs->ext.p_glDrawElementsIndirect( mode, type, indirect );
 }
 
-static void WINAPI glDrawElementsInstanced( GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount ) {
+static void WINAPI glDrawElementsInstanced( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %d)\n", mode, count, type, indices, instancecount );
+  TRACE( "(%d, %d, %d, %p, %d)\n", mode, count, type, indices, instancecount );
   funcs->ext.p_glDrawElementsInstanced( mode, count, type, indices, instancecount );
 }
 
-static void WINAPI glDrawElementsInstancedARB( GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount ) {
+static void WINAPI glDrawElementsInstancedARB( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %d)\n", mode, count, type, indices, primcount );
+  TRACE( "(%d, %d, %d, %p, %d)\n", mode, count, type, indices, primcount );
   funcs->ext.p_glDrawElementsInstancedARB( mode, count, type, indices, primcount );
 }
 
-static void WINAPI glDrawElementsInstancedBaseInstance( GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLuint baseinstance ) {
+static void WINAPI glDrawElementsInstancedBaseInstance( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %d, %d)\n", mode, count, type, indices, instancecount, baseinstance );
+  TRACE( "(%d, %d, %d, %p, %d, %d)\n", mode, count, type, indices, instancecount, baseinstance );
   funcs->ext.p_glDrawElementsInstancedBaseInstance( mode, count, type, indices, instancecount, baseinstance );
 }
 
-static void WINAPI glDrawElementsInstancedBaseVertex( GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLint basevertex ) {
+static void WINAPI glDrawElementsInstancedBaseVertex( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %d, %d)\n", mode, count, type, indices, instancecount, basevertex );
+  TRACE( "(%d, %d, %d, %p, %d, %d)\n", mode, count, type, indices, instancecount, basevertex );
   funcs->ext.p_glDrawElementsInstancedBaseVertex( mode, count, type, indices, instancecount, basevertex );
 }
 
-static void WINAPI glDrawElementsInstancedBaseVertexBaseInstance( GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance ) {
+static void WINAPI glDrawElementsInstancedBaseVertexBaseInstance( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %d, %d, %d)\n", mode, count, type, indices, instancecount, basevertex, baseinstance );
+  TRACE( "(%d, %d, %d, %p, %d, %d, %d)\n", mode, count, type, indices, instancecount, basevertex, baseinstance );
   funcs->ext.p_glDrawElementsInstancedBaseVertexBaseInstance( mode, count, type, indices, instancecount, basevertex, baseinstance );
 }
 
-static void WINAPI glDrawElementsInstancedEXT( GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount ) {
+static void WINAPI glDrawElementsInstancedEXT( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %d)\n", mode, count, type, indices, primcount );
+  TRACE( "(%d, %d, %d, %p, %d)\n", mode, count, type, indices, primcount );
   funcs->ext.p_glDrawElementsInstancedEXT( mode, count, type, indices, primcount );
 }
 
-static void WINAPI glDrawMeshArraysSUN( GLenum mode, GLint first, GLsizei count, GLsizei width ) {
+static void WINAPI glDrawMeshArraysSUN( GLenum mode, GLint first, GLsizei count, GLsizei width )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", mode, first, count, width );
+  TRACE( "(%d, %d, %d, %d)\n", mode, first, count, width );
   funcs->ext.p_glDrawMeshArraysSUN( mode, first, count, width );
 }
 
-static void WINAPI glDrawRangeElementArrayAPPLE( GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count ) {
+static void WINAPI glDrawRangeElementArrayAPPLE( GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", mode, start, end, first, count );
+  TRACE( "(%d, %d, %d, %d, %d)\n", mode, start, end, first, count );
   funcs->ext.p_glDrawRangeElementArrayAPPLE( mode, start, end, first, count );
 }
 
-static void WINAPI glDrawRangeElementArrayATI( GLenum mode, GLuint start, GLuint end, GLsizei count ) {
+static void WINAPI glDrawRangeElementArrayATI( GLenum mode, GLuint start, GLuint end, GLsizei count )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", mode, start, end, count );
+  TRACE( "(%d, %d, %d, %d)\n", mode, start, end, count );
   funcs->ext.p_glDrawRangeElementArrayATI( mode, start, end, count );
 }
 
-static void WINAPI glDrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices ) {
+static void WINAPI glDrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", mode, start, end, count, type, indices );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", mode, start, end, count, type, indices );
   funcs->ext.p_glDrawRangeElements( mode, start, end, count, type, indices );
 }
 
-static void WINAPI glDrawRangeElementsBaseVertex( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices, GLint basevertex ) {
+static void WINAPI glDrawRangeElementsBaseVertex( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p, %d)\n", mode, start, end, count, type, indices, basevertex );
+  TRACE( "(%d, %d, %d, %d, %d, %p, %d)\n", mode, start, end, count, type, indices, basevertex );
   funcs->ext.p_glDrawRangeElementsBaseVertex( mode, start, end, count, type, indices, basevertex );
 }
 
-static void WINAPI glDrawRangeElementsEXT( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices ) {
+static void WINAPI glDrawRangeElementsEXT( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", mode, start, end, count, type, indices );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", mode, start, end, count, type, indices );
   funcs->ext.p_glDrawRangeElementsEXT( mode, start, end, count, type, indices );
 }
 
-static void WINAPI glDrawTextureNV( GLuint texture, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1 ) {
+static void WINAPI glDrawTextureNV( GLuint texture, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", texture, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1 );
+  TRACE( "(%d, %d, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", texture, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1 );
   funcs->ext.p_glDrawTextureNV( texture, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1 );
 }
 
-static void WINAPI glDrawTransformFeedback( GLenum mode, GLuint id ) {
+static void WINAPI glDrawTransformFeedback( GLenum mode, GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", mode, id );
+  TRACE( "(%d, %d)\n", mode, id );
   funcs->ext.p_glDrawTransformFeedback( mode, id );
 }
 
-static void WINAPI glDrawTransformFeedbackInstanced( GLenum mode, GLuint id, GLsizei instancecount ) {
+static void WINAPI glDrawTransformFeedbackInstanced( GLenum mode, GLuint id, GLsizei instancecount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", mode, id, instancecount );
+  TRACE( "(%d, %d, %d)\n", mode, id, instancecount );
   funcs->ext.p_glDrawTransformFeedbackInstanced( mode, id, instancecount );
 }
 
-static void WINAPI glDrawTransformFeedbackNV( GLenum mode, GLuint id ) {
+static void WINAPI glDrawTransformFeedbackNV( GLenum mode, GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", mode, id );
+  TRACE( "(%d, %d)\n", mode, id );
   funcs->ext.p_glDrawTransformFeedbackNV( mode, id );
 }
 
-static void WINAPI glDrawTransformFeedbackStream( GLenum mode, GLuint id, GLuint stream ) {
+static void WINAPI glDrawTransformFeedbackStream( GLenum mode, GLuint id, GLuint stream )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", mode, id, stream );
+  TRACE( "(%d, %d, %d)\n", mode, id, stream );
   funcs->ext.p_glDrawTransformFeedbackStream( mode, id, stream );
 }
 
-static void WINAPI glDrawTransformFeedbackStreamInstanced( GLenum mode, GLuint id, GLuint stream, GLsizei instancecount ) {
+static void WINAPI glDrawTransformFeedbackStreamInstanced( GLenum mode, GLuint id, GLuint stream, GLsizei instancecount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", mode, id, stream, instancecount );
+  TRACE( "(%d, %d, %d, %d)\n", mode, id, stream, instancecount );
   funcs->ext.p_glDrawTransformFeedbackStreamInstanced( mode, id, stream, instancecount );
 }
 
-static void WINAPI glDrawVkImageNV( GLuint64 vkImage, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1 ) {
+static void WINAPI glDrawVkImageNV( GLuint64 vkImage, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%s, %d, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", wine_dbgstr_longlong(vkImage), sampler, x0, y0, x1, y1, z, s0, t0, s1, t1 );
+  TRACE( "(%s, %d, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", wine_dbgstr_longlong(vkImage), sampler, x0, y0, x1, y1, z, s0, t0, s1, t1 );
   funcs->ext.p_glDrawVkImageNV( vkImage, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1 );
 }
 
-static void WINAPI glEdgeFlagFormatNV( GLsizei stride ) {
+static void WINAPI glEdgeFlagFormatNV( GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", stride );
+  TRACE( "(%d)\n", stride );
   funcs->ext.p_glEdgeFlagFormatNV( stride );
 }
 
-static void WINAPI glEdgeFlagPointerEXT( GLsizei stride, GLsizei count, const GLboolean* pointer ) {
+static void WINAPI glEdgeFlagPointerEXT( GLsizei stride, GLsizei count, const GLboolean *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", stride, count, pointer );
+  TRACE( "(%d, %d, %p)\n", stride, count, pointer );
   funcs->ext.p_glEdgeFlagPointerEXT( stride, count, pointer );
 }
 
-static void WINAPI glEdgeFlagPointerListIBM( GLint stride, const GLboolean** pointer, GLint ptrstride ) {
+static void WINAPI glEdgeFlagPointerListIBM( GLint stride, const GLboolean **pointer, GLint ptrstride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %d)\n", stride, pointer, ptrstride );
+  TRACE( "(%d, %p, %d)\n", stride, pointer, ptrstride );
   funcs->ext.p_glEdgeFlagPointerListIBM( stride, pointer, ptrstride );
 }
 
-static void WINAPI glElementPointerAPPLE( GLenum type, const void* pointer ) {
+static void WINAPI glElementPointerAPPLE( GLenum type, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", type, pointer );
+  TRACE( "(%d, %p)\n", type, pointer );
   funcs->ext.p_glElementPointerAPPLE( type, pointer );
 }
 
-static void WINAPI glElementPointerATI( GLenum type, const void* pointer ) {
+static void WINAPI glElementPointerATI( GLenum type, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", type, pointer );
+  TRACE( "(%d, %p)\n", type, pointer );
   funcs->ext.p_glElementPointerATI( type, pointer );
 }
 
-static void WINAPI glEnableClientStateIndexedEXT( GLenum array, GLuint index ) {
+static void WINAPI glEnableClientStateIndexedEXT( GLenum array, GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", array, index );
+  TRACE( "(%d, %d)\n", array, index );
   funcs->ext.p_glEnableClientStateIndexedEXT( array, index );
 }
 
-static void WINAPI glEnableClientStateiEXT( GLenum array, GLuint index ) {
+static void WINAPI glEnableClientStateiEXT( GLenum array, GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", array, index );
+  TRACE( "(%d, %d)\n", array, index );
   funcs->ext.p_glEnableClientStateiEXT( array, index );
 }
 
-static void WINAPI glEnableIndexedEXT( GLenum target, GLuint index ) {
+static void WINAPI glEnableIndexedEXT( GLenum target, GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, index );
+  TRACE( "(%d, %d)\n", target, index );
   funcs->ext.p_glEnableIndexedEXT( target, index );
 }
 
-static void WINAPI glEnableVariantClientStateEXT( GLuint id ) {
+static void WINAPI glEnableVariantClientStateEXT( GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", id );
+  TRACE( "(%d)\n", id );
   funcs->ext.p_glEnableVariantClientStateEXT( id );
 }
 
-static void WINAPI glEnableVertexArrayAttrib( GLuint vaobj, GLuint index ) {
+static void WINAPI glEnableVertexArrayAttrib( GLuint vaobj, GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", vaobj, index );
+  TRACE( "(%d, %d)\n", vaobj, index );
   funcs->ext.p_glEnableVertexArrayAttrib( vaobj, index );
 }
 
-static void WINAPI glEnableVertexArrayAttribEXT( GLuint vaobj, GLuint index ) {
+static void WINAPI glEnableVertexArrayAttribEXT( GLuint vaobj, GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", vaobj, index );
+  TRACE( "(%d, %d)\n", vaobj, index );
   funcs->ext.p_glEnableVertexArrayAttribEXT( vaobj, index );
 }
 
-static void WINAPI glEnableVertexArrayEXT( GLuint vaobj, GLenum array ) {
+static void WINAPI glEnableVertexArrayEXT( GLuint vaobj, GLenum array )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", vaobj, array );
+  TRACE( "(%d, %d)\n", vaobj, array );
   funcs->ext.p_glEnableVertexArrayEXT( vaobj, array );
 }
 
-static void WINAPI glEnableVertexAttribAPPLE( GLuint index, GLenum pname ) {
+static void WINAPI glEnableVertexAttribAPPLE( GLuint index, GLenum pname )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", index, pname );
+  TRACE( "(%d, %d)\n", index, pname );
   funcs->ext.p_glEnableVertexAttribAPPLE( index, pname );
 }
 
-static void WINAPI glEnableVertexAttribArray( GLuint index ) {
+static void WINAPI glEnableVertexAttribArray( GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", index );
+  TRACE( "(%d)\n", index );
   funcs->ext.p_glEnableVertexAttribArray( index );
 }
 
-static void WINAPI glEnableVertexAttribArrayARB( GLuint index ) {
+static void WINAPI glEnableVertexAttribArrayARB( GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", index );
+  TRACE( "(%d)\n", index );
   funcs->ext.p_glEnableVertexAttribArrayARB( index );
 }
 
-static void WINAPI glEnablei( GLenum target, GLuint index ) {
+static void WINAPI glEnablei( GLenum target, GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, index );
+  TRACE( "(%d, %d)\n", target, index );
   funcs->ext.p_glEnablei( target, index );
 }
 
-static void WINAPI glEndConditionalRender( void ) {
+static void WINAPI glEndConditionalRender(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glEndConditionalRender( );
+  TRACE( "()\n" );
+  funcs->ext.p_glEndConditionalRender();
 }
 
-static void WINAPI glEndConditionalRenderNV( void ) {
+static void WINAPI glEndConditionalRenderNV(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glEndConditionalRenderNV( );
+  TRACE( "()\n" );
+  funcs->ext.p_glEndConditionalRenderNV();
 }
 
-static void WINAPI glEndConditionalRenderNVX( void ) {
+static void WINAPI glEndConditionalRenderNVX(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glEndConditionalRenderNVX( );
+  TRACE( "()\n" );
+  funcs->ext.p_glEndConditionalRenderNVX();
 }
 
-static void WINAPI glEndFragmentShaderATI( void ) {
+static void WINAPI glEndFragmentShaderATI(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glEndFragmentShaderATI( );
+  TRACE( "()\n" );
+  funcs->ext.p_glEndFragmentShaderATI();
 }
 
-static void WINAPI glEndOcclusionQueryNV( void ) {
+static void WINAPI glEndOcclusionQueryNV(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glEndOcclusionQueryNV( );
+  TRACE( "()\n" );
+  funcs->ext.p_glEndOcclusionQueryNV();
 }
 
-static void WINAPI glEndPerfMonitorAMD( GLuint monitor ) {
+static void WINAPI glEndPerfMonitorAMD( GLuint monitor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", monitor );
+  TRACE( "(%d)\n", monitor );
   funcs->ext.p_glEndPerfMonitorAMD( monitor );
 }
 
-static void WINAPI glEndPerfQueryINTEL( GLuint queryHandle ) {
+static void WINAPI glEndPerfQueryINTEL( GLuint queryHandle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", queryHandle );
+  TRACE( "(%d)\n", queryHandle );
   funcs->ext.p_glEndPerfQueryINTEL( queryHandle );
 }
 
-static void WINAPI glEndQuery( GLenum target ) {
+static void WINAPI glEndQuery( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   funcs->ext.p_glEndQuery( target );
 }
 
-static void WINAPI glEndQueryARB( GLenum target ) {
+static void WINAPI glEndQueryARB( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   funcs->ext.p_glEndQueryARB( target );
 }
 
-static void WINAPI glEndQueryIndexed( GLenum target, GLuint index ) {
+static void WINAPI glEndQueryIndexed( GLenum target, GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, index );
+  TRACE( "(%d, %d)\n", target, index );
   funcs->ext.p_glEndQueryIndexed( target, index );
 }
 
-static void WINAPI glEndTransformFeedback( void ) {
+static void WINAPI glEndTransformFeedback(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glEndTransformFeedback( );
+  TRACE( "()\n" );
+  funcs->ext.p_glEndTransformFeedback();
 }
 
-static void WINAPI glEndTransformFeedbackEXT( void ) {
+static void WINAPI glEndTransformFeedbackEXT(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glEndTransformFeedbackEXT( );
+  TRACE( "()\n" );
+  funcs->ext.p_glEndTransformFeedbackEXT();
 }
 
-static void WINAPI glEndTransformFeedbackNV( void ) {
+static void WINAPI glEndTransformFeedbackNV(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glEndTransformFeedbackNV( );
+  TRACE( "()\n" );
+  funcs->ext.p_glEndTransformFeedbackNV();
 }
 
-static void WINAPI glEndVertexShaderEXT( void ) {
+static void WINAPI glEndVertexShaderEXT(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glEndVertexShaderEXT( );
+  TRACE( "()\n" );
+  funcs->ext.p_glEndVertexShaderEXT();
 }
 
-static void WINAPI glEndVideoCaptureNV( GLuint video_capture_slot ) {
+static void WINAPI glEndVideoCaptureNV( GLuint video_capture_slot )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", video_capture_slot );
+  TRACE( "(%d)\n", video_capture_slot );
   funcs->ext.p_glEndVideoCaptureNV( video_capture_slot );
 }
 
-static void WINAPI glEvalCoord1xOES( GLfixed u ) {
+static void WINAPI glEvalCoord1xOES( GLfixed u )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", u );
+  TRACE( "(%d)\n", u );
   funcs->ext.p_glEvalCoord1xOES( u );
 }
 
-static void WINAPI glEvalCoord1xvOES( const GLfixed* coords ) {
+static void WINAPI glEvalCoord1xvOES( const GLfixed *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glEvalCoord1xvOES( coords );
 }
 
-static void WINAPI glEvalCoord2xOES( GLfixed u, GLfixed v ) {
+static void WINAPI glEvalCoord2xOES( GLfixed u, GLfixed v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", u, v );
+  TRACE( "(%d, %d)\n", u, v );
   funcs->ext.p_glEvalCoord2xOES( u, v );
 }
 
-static void WINAPI glEvalCoord2xvOES( const GLfixed* coords ) {
+static void WINAPI glEvalCoord2xvOES( const GLfixed *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glEvalCoord2xvOES( coords );
 }
 
-static void WINAPI glEvalMapsNV( GLenum target, GLenum mode ) {
+static void WINAPI glEvalMapsNV( GLenum target, GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, mode );
+  TRACE( "(%d, %d)\n", target, mode );
   funcs->ext.p_glEvalMapsNV( target, mode );
 }
 
-static void WINAPI glEvaluateDepthValuesARB( void ) {
+static void WINAPI glEvaluateDepthValuesARB(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glEvaluateDepthValuesARB( );
+  TRACE( "()\n" );
+  funcs->ext.p_glEvaluateDepthValuesARB();
 }
 
-static void WINAPI glExecuteProgramNV( GLenum target, GLuint id, const GLfloat* params ) {
+static void WINAPI glExecuteProgramNV( GLenum target, GLuint id, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, id, params );
+  TRACE( "(%d, %d, %p)\n", target, id, params );
   funcs->ext.p_glExecuteProgramNV( target, id, params );
 }
 
-static void WINAPI glExtractComponentEXT( GLuint res, GLuint src, GLuint num ) {
+static void WINAPI glExtractComponentEXT( GLuint res, GLuint src, GLuint num )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", res, src, num );
+  TRACE( "(%d, %d, %d)\n", res, src, num );
   funcs->ext.p_glExtractComponentEXT( res, src, num );
 }
 
-static void WINAPI glFeedbackBufferxOES( GLsizei n, GLenum type, const GLfixed* buffer ) {
+static void WINAPI glFeedbackBufferxOES( GLsizei n, GLenum type, const GLfixed *buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", n, type, buffer );
+  TRACE( "(%d, %d, %p)\n", n, type, buffer );
   funcs->ext.p_glFeedbackBufferxOES( n, type, buffer );
 }
 
-static GLsync WINAPI glFenceSync( GLenum condition, GLbitfield flags ) {
+static GLsync WINAPI glFenceSync( GLenum condition, GLbitfield flags )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", condition, flags );
+  TRACE( "(%d, %d)\n", condition, flags );
   return funcs->ext.p_glFenceSync( condition, flags );
 }
 
-static void WINAPI glFinalCombinerInputNV( GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage ) {
+static void WINAPI glFinalCombinerInputNV( GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", variable, input, mapping, componentUsage );
+  TRACE( "(%d, %d, %d, %d)\n", variable, input, mapping, componentUsage );
   funcs->ext.p_glFinalCombinerInputNV( variable, input, mapping, componentUsage );
 }
 
-static GLint WINAPI glFinishAsyncSGIX( GLuint* markerp ) {
+static GLint WINAPI glFinishAsyncSGIX( GLuint *markerp )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", markerp );
+  TRACE( "(%p)\n", markerp );
   return funcs->ext.p_glFinishAsyncSGIX( markerp );
 }
 
-static void WINAPI glFinishFenceAPPLE( GLuint fence ) {
+static void WINAPI glFinishFenceAPPLE( GLuint fence )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", fence );
+  TRACE( "(%d)\n", fence );
   funcs->ext.p_glFinishFenceAPPLE( fence );
 }
 
-static void WINAPI glFinishFenceNV( GLuint fence ) {
+static void WINAPI glFinishFenceNV( GLuint fence )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", fence );
+  TRACE( "(%d)\n", fence );
   funcs->ext.p_glFinishFenceNV( fence );
 }
 
-static void WINAPI glFinishObjectAPPLE( GLenum object, GLint name ) {
+static void WINAPI glFinishObjectAPPLE( GLenum object, GLint name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", object, name );
+  TRACE( "(%d, %d)\n", object, name );
   funcs->ext.p_glFinishObjectAPPLE( object, name );
 }
 
-static void WINAPI glFinishTextureSUNX( void ) {
+static void WINAPI glFinishTextureSUNX(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glFinishTextureSUNX( );
+  TRACE( "()\n" );
+  funcs->ext.p_glFinishTextureSUNX();
 }
 
-static void WINAPI glFlushMappedBufferRange( GLenum target, GLintptr offset, GLsizeiptr length ) {
+static void WINAPI glFlushMappedBufferRange( GLenum target, GLintptr offset, GLsizeiptr length )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld)\n", target, offset, length );
+  TRACE( "(%d, %ld, %ld)\n", target, offset, length );
   funcs->ext.p_glFlushMappedBufferRange( target, offset, length );
 }
 
-static void WINAPI glFlushMappedBufferRangeAPPLE( GLenum target, GLintptr offset, GLsizeiptr size ) {
+static void WINAPI glFlushMappedBufferRangeAPPLE( GLenum target, GLintptr offset, GLsizeiptr size )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld)\n", target, offset, size );
+  TRACE( "(%d, %ld, %ld)\n", target, offset, size );
   funcs->ext.p_glFlushMappedBufferRangeAPPLE( target, offset, size );
 }
 
-static void WINAPI glFlushMappedNamedBufferRange( GLuint buffer, GLintptr offset, GLsizeiptr length ) {
+static void WINAPI glFlushMappedNamedBufferRange( GLuint buffer, GLintptr offset, GLsizeiptr length )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld)\n", buffer, offset, length );
+  TRACE( "(%d, %ld, %ld)\n", buffer, offset, length );
   funcs->ext.p_glFlushMappedNamedBufferRange( buffer, offset, length );
 }
 
-static void WINAPI glFlushMappedNamedBufferRangeEXT( GLuint buffer, GLintptr offset, GLsizeiptr length ) {
+static void WINAPI glFlushMappedNamedBufferRangeEXT( GLuint buffer, GLintptr offset, GLsizeiptr length )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld)\n", buffer, offset, length );
+  TRACE( "(%d, %ld, %ld)\n", buffer, offset, length );
   funcs->ext.p_glFlushMappedNamedBufferRangeEXT( buffer, offset, length );
 }
 
-static void WINAPI glFlushPixelDataRangeNV( GLenum target ) {
+static void WINAPI glFlushPixelDataRangeNV( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   funcs->ext.p_glFlushPixelDataRangeNV( target );
 }
 
-static void WINAPI glFlushRasterSGIX( void ) {
+static void WINAPI glFlushRasterSGIX(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glFlushRasterSGIX( );
+  TRACE( "()\n" );
+  funcs->ext.p_glFlushRasterSGIX();
 }
 
-static void WINAPI glFlushStaticDataIBM( GLenum target ) {
+static void WINAPI glFlushStaticDataIBM( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   funcs->ext.p_glFlushStaticDataIBM( target );
 }
 
-static void WINAPI glFlushVertexArrayRangeAPPLE( GLsizei length, void* pointer ) {
+static void WINAPI glFlushVertexArrayRangeAPPLE( GLsizei length, void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", length, pointer );
+  TRACE( "(%d, %p)\n", length, pointer );
   funcs->ext.p_glFlushVertexArrayRangeAPPLE( length, pointer );
 }
 
-static void WINAPI glFlushVertexArrayRangeNV( void ) {
+static void WINAPI glFlushVertexArrayRangeNV(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glFlushVertexArrayRangeNV( );
+  TRACE( "()\n" );
+  funcs->ext.p_glFlushVertexArrayRangeNV();
 }
 
-static void WINAPI glFogCoordFormatNV( GLenum type, GLsizei stride ) {
+static void WINAPI glFogCoordFormatNV( GLenum type, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", type, stride );
+  TRACE( "(%d, %d)\n", type, stride );
   funcs->ext.p_glFogCoordFormatNV( type, stride );
 }
 
-static void WINAPI glFogCoordPointer( GLenum type, GLsizei stride, const void* pointer ) {
+static void WINAPI glFogCoordPointer( GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", type, stride, pointer );
+  TRACE( "(%d, %d, %p)\n", type, stride, pointer );
   funcs->ext.p_glFogCoordPointer( type, stride, pointer );
 }
 
-static void WINAPI glFogCoordPointerEXT( GLenum type, GLsizei stride, const void* pointer ) {
+static void WINAPI glFogCoordPointerEXT( GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", type, stride, pointer );
+  TRACE( "(%d, %d, %p)\n", type, stride, pointer );
   funcs->ext.p_glFogCoordPointerEXT( type, stride, pointer );
 }
 
-static void WINAPI glFogCoordPointerListIBM( GLenum type, GLint stride, const void** pointer, GLint ptrstride ) {
+static void WINAPI glFogCoordPointerListIBM( GLenum type, GLint stride, const void **pointer, GLint ptrstride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d)\n", type, stride, pointer, ptrstride );
+  TRACE( "(%d, %d, %p, %d)\n", type, stride, pointer, ptrstride );
   funcs->ext.p_glFogCoordPointerListIBM( type, stride, pointer, ptrstride );
 }
 
-static void WINAPI glFogCoordd( GLdouble coord ) {
+static void WINAPI glFogCoordd( GLdouble coord )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", coord );
+  TRACE( "(%f)\n", coord );
   funcs->ext.p_glFogCoordd( coord );
 }
 
-static void WINAPI glFogCoorddEXT( GLdouble coord ) {
+static void WINAPI glFogCoorddEXT( GLdouble coord )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", coord );
+  TRACE( "(%f)\n", coord );
   funcs->ext.p_glFogCoorddEXT( coord );
 }
 
-static void WINAPI glFogCoorddv( const GLdouble* coord ) {
+static void WINAPI glFogCoorddv( const GLdouble *coord )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coord );
+  TRACE( "(%p)\n", coord );
   funcs->ext.p_glFogCoorddv( coord );
 }
 
-static void WINAPI glFogCoorddvEXT( const GLdouble* coord ) {
+static void WINAPI glFogCoorddvEXT( const GLdouble *coord )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coord );
+  TRACE( "(%p)\n", coord );
   funcs->ext.p_glFogCoorddvEXT( coord );
 }
 
-static void WINAPI glFogCoordf( GLfloat coord ) {
+static void WINAPI glFogCoordf( GLfloat coord )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", coord );
+  TRACE( "(%f)\n", coord );
   funcs->ext.p_glFogCoordf( coord );
 }
 
-static void WINAPI glFogCoordfEXT( GLfloat coord ) {
+static void WINAPI glFogCoordfEXT( GLfloat coord )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", coord );
+  TRACE( "(%f)\n", coord );
   funcs->ext.p_glFogCoordfEXT( coord );
 }
 
-static void WINAPI glFogCoordfv( const GLfloat* coord ) {
+static void WINAPI glFogCoordfv( const GLfloat *coord )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coord );
+  TRACE( "(%p)\n", coord );
   funcs->ext.p_glFogCoordfv( coord );
 }
 
-static void WINAPI glFogCoordfvEXT( const GLfloat* coord ) {
+static void WINAPI glFogCoordfvEXT( const GLfloat *coord )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coord );
+  TRACE( "(%p)\n", coord );
   funcs->ext.p_glFogCoordfvEXT( coord );
 }
 
-static void WINAPI glFogCoordhNV( GLhalfNV fog ) {
+static void WINAPI glFogCoordhNV( GLhalfNV fog )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", fog );
+  TRACE( "(%d)\n", fog );
   funcs->ext.p_glFogCoordhNV( fog );
 }
 
-static void WINAPI glFogCoordhvNV( const GLhalfNV* fog ) {
+static void WINAPI glFogCoordhvNV( const GLhalfNV *fog )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", fog );
+  TRACE( "(%p)\n", fog );
   funcs->ext.p_glFogCoordhvNV( fog );
 }
 
-static void WINAPI glFogFuncSGIS( GLsizei n, const GLfloat* points ) {
+static void WINAPI glFogFuncSGIS( GLsizei n, const GLfloat *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, points );
+  TRACE( "(%d, %p)\n", n, points );
   funcs->ext.p_glFogFuncSGIS( n, points );
 }
 
-static void WINAPI glFogxOES( GLenum pname, GLfixed param ) {
+static void WINAPI glFogxOES( GLenum pname, GLfixed param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->ext.p_glFogxOES( pname, param );
 }
 
-static void WINAPI glFogxvOES( GLenum pname, const GLfixed* param ) {
+static void WINAPI glFogxvOES( GLenum pname, const GLfixed *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, param );
+  TRACE( "(%d, %p)\n", pname, param );
   funcs->ext.p_glFogxvOES( pname, param );
 }
 
-static void WINAPI glFragmentColorMaterialSGIX( GLenum face, GLenum mode ) {
+static void WINAPI glFragmentColorMaterialSGIX( GLenum face, GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", face, mode );
+  TRACE( "(%d, %d)\n", face, mode );
   funcs->ext.p_glFragmentColorMaterialSGIX( face, mode );
 }
 
-static void WINAPI glFragmentCoverageColorNV( GLuint color ) {
+static void WINAPI glFragmentCoverageColorNV( GLuint color )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", color );
+  TRACE( "(%d)\n", color );
   funcs->ext.p_glFragmentCoverageColorNV( color );
 }
 
-static void WINAPI glFragmentLightModelfSGIX( GLenum pname, GLfloat param ) {
+static void WINAPI glFragmentLightModelfSGIX( GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", pname, param );
+  TRACE( "(%d, %f)\n", pname, param );
   funcs->ext.p_glFragmentLightModelfSGIX( pname, param );
 }
 
-static void WINAPI glFragmentLightModelfvSGIX( GLenum pname, const GLfloat* params ) {
+static void WINAPI glFragmentLightModelfvSGIX( GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glFragmentLightModelfvSGIX( pname, params );
 }
 
-static void WINAPI glFragmentLightModeliSGIX( GLenum pname, GLint param ) {
+static void WINAPI glFragmentLightModeliSGIX( GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->ext.p_glFragmentLightModeliSGIX( pname, param );
 }
 
-static void WINAPI glFragmentLightModelivSGIX( GLenum pname, const GLint* params ) {
+static void WINAPI glFragmentLightModelivSGIX( GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glFragmentLightModelivSGIX( pname, params );
 }
 
-static void WINAPI glFragmentLightfSGIX( GLenum light, GLenum pname, GLfloat param ) {
+static void WINAPI glFragmentLightfSGIX( GLenum light, GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", light, pname, param );
+  TRACE( "(%d, %d, %f)\n", light, pname, param );
   funcs->ext.p_glFragmentLightfSGIX( light, pname, param );
 }
 
-static void WINAPI glFragmentLightfvSGIX( GLenum light, GLenum pname, const GLfloat* params ) {
+static void WINAPI glFragmentLightfvSGIX( GLenum light, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", light, pname, params );
+  TRACE( "(%d, %d, %p)\n", light, pname, params );
   funcs->ext.p_glFragmentLightfvSGIX( light, pname, params );
 }
 
-static void WINAPI glFragmentLightiSGIX( GLenum light, GLenum pname, GLint param ) {
+static void WINAPI glFragmentLightiSGIX( GLenum light, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", light, pname, param );
+  TRACE( "(%d, %d, %d)\n", light, pname, param );
   funcs->ext.p_glFragmentLightiSGIX( light, pname, param );
 }
 
-static void WINAPI glFragmentLightivSGIX( GLenum light, GLenum pname, const GLint* params ) {
+static void WINAPI glFragmentLightivSGIX( GLenum light, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", light, pname, params );
+  TRACE( "(%d, %d, %p)\n", light, pname, params );
   funcs->ext.p_glFragmentLightivSGIX( light, pname, params );
 }
 
-static void WINAPI glFragmentMaterialfSGIX( GLenum face, GLenum pname, GLfloat param ) {
+static void WINAPI glFragmentMaterialfSGIX( GLenum face, GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", face, pname, param );
+  TRACE( "(%d, %d, %f)\n", face, pname, param );
   funcs->ext.p_glFragmentMaterialfSGIX( face, pname, param );
 }
 
-static void WINAPI glFragmentMaterialfvSGIX( GLenum face, GLenum pname, const GLfloat* params ) {
+static void WINAPI glFragmentMaterialfvSGIX( GLenum face, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", face, pname, params );
+  TRACE( "(%d, %d, %p)\n", face, pname, params );
   funcs->ext.p_glFragmentMaterialfvSGIX( face, pname, params );
 }
 
-static void WINAPI glFragmentMaterialiSGIX( GLenum face, GLenum pname, GLint param ) {
+static void WINAPI glFragmentMaterialiSGIX( GLenum face, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", face, pname, param );
+  TRACE( "(%d, %d, %d)\n", face, pname, param );
   funcs->ext.p_glFragmentMaterialiSGIX( face, pname, param );
 }
 
-static void WINAPI glFragmentMaterialivSGIX( GLenum face, GLenum pname, const GLint* params ) {
+static void WINAPI glFragmentMaterialivSGIX( GLenum face, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", face, pname, params );
+  TRACE( "(%d, %d, %p)\n", face, pname, params );
   funcs->ext.p_glFragmentMaterialivSGIX( face, pname, params );
 }
 
-static void WINAPI glFrameTerminatorGREMEDY( void ) {
+static void WINAPI glFrameTerminatorGREMEDY(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glFrameTerminatorGREMEDY( );
+  TRACE( "()\n" );
+  funcs->ext.p_glFrameTerminatorGREMEDY();
 }
 
-static void WINAPI glFrameZoomSGIX( GLint factor ) {
+static void WINAPI glFrameZoomSGIX( GLint factor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", factor );
+  TRACE( "(%d)\n", factor );
   funcs->ext.p_glFrameZoomSGIX( factor );
 }
 
-static void WINAPI glFramebufferDrawBufferEXT( GLuint framebuffer, GLenum mode ) {
+static void WINAPI glFramebufferDrawBufferEXT( GLuint framebuffer, GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", framebuffer, mode );
+  TRACE( "(%d, %d)\n", framebuffer, mode );
   funcs->ext.p_glFramebufferDrawBufferEXT( framebuffer, mode );
 }
 
-static void WINAPI glFramebufferDrawBuffersEXT( GLuint framebuffer, GLsizei n, const GLenum* bufs ) {
+static void WINAPI glFramebufferDrawBuffersEXT( GLuint framebuffer, GLsizei n, const GLenum *bufs )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", framebuffer, n, bufs );
+  TRACE( "(%d, %d, %p)\n", framebuffer, n, bufs );
   funcs->ext.p_glFramebufferDrawBuffersEXT( framebuffer, n, bufs );
 }
 
-static void WINAPI glFramebufferParameteri( GLenum target, GLenum pname, GLint param ) {
+static void WINAPI glFramebufferParameteri( GLenum target, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, pname, param );
+  TRACE( "(%d, %d, %d)\n", target, pname, param );
   funcs->ext.p_glFramebufferParameteri( target, pname, param );
 }
 
-static void WINAPI glFramebufferReadBufferEXT( GLuint framebuffer, GLenum mode ) {
+static void WINAPI glFramebufferReadBufferEXT( GLuint framebuffer, GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", framebuffer, mode );
+  TRACE( "(%d, %d)\n", framebuffer, mode );
   funcs->ext.p_glFramebufferReadBufferEXT( framebuffer, mode );
 }
 
-static void WINAPI glFramebufferRenderbuffer( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) {
+static void WINAPI glFramebufferRenderbuffer( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, attachment, renderbuffertarget, renderbuffer );
+  TRACE( "(%d, %d, %d, %d)\n", target, attachment, renderbuffertarget, renderbuffer );
   funcs->ext.p_glFramebufferRenderbuffer( target, attachment, renderbuffertarget, renderbuffer );
 }
 
-static void WINAPI glFramebufferRenderbufferEXT( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) {
+static void WINAPI glFramebufferRenderbufferEXT( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, attachment, renderbuffertarget, renderbuffer );
+  TRACE( "(%d, %d, %d, %d)\n", target, attachment, renderbuffertarget, renderbuffer );
   funcs->ext.p_glFramebufferRenderbufferEXT( target, attachment, renderbuffertarget, renderbuffer );
 }
 
-static void WINAPI glFramebufferSampleLocationsfvARB( GLenum target, GLuint start, GLsizei count, const GLfloat* v ) {
+static void WINAPI glFramebufferSampleLocationsfvARB( GLenum target, GLuint start, GLsizei count, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, start, count, v );
+  TRACE( "(%d, %d, %d, %p)\n", target, start, count, v );
   funcs->ext.p_glFramebufferSampleLocationsfvARB( target, start, count, v );
 }
 
-static void WINAPI glFramebufferSampleLocationsfvNV( GLenum target, GLuint start, GLsizei count, const GLfloat* v ) {
+static void WINAPI glFramebufferSampleLocationsfvNV( GLenum target, GLuint start, GLsizei count, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, start, count, v );
+  TRACE( "(%d, %d, %d, %p)\n", target, start, count, v );
   funcs->ext.p_glFramebufferSampleLocationsfvNV( target, start, count, v );
 }
 
-static void WINAPI glFramebufferSamplePositionsfvAMD( GLenum target, GLuint numsamples, GLuint pixelindex, const GLfloat* values ) {
+static void WINAPI glFramebufferSamplePositionsfvAMD( GLenum target, GLuint numsamples, GLuint pixelindex, const GLfloat *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, numsamples, pixelindex, values );
+  TRACE( "(%d, %d, %d, %p)\n", target, numsamples, pixelindex, values );
   funcs->ext.p_glFramebufferSamplePositionsfvAMD( target, numsamples, pixelindex, values );
 }
 
-static void WINAPI glFramebufferTexture( GLenum target, GLenum attachment, GLuint texture, GLint level ) {
+static void WINAPI glFramebufferTexture( GLenum target, GLenum attachment, GLuint texture, GLint level )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, attachment, texture, level );
+  TRACE( "(%d, %d, %d, %d)\n", target, attachment, texture, level );
   funcs->ext.p_glFramebufferTexture( target, attachment, texture, level );
 }
 
-static void WINAPI glFramebufferTexture1D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) {
+static void WINAPI glFramebufferTexture1D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level );
   funcs->ext.p_glFramebufferTexture1D( target, attachment, textarget, texture, level );
 }
 
-static void WINAPI glFramebufferTexture1DEXT( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) {
+static void WINAPI glFramebufferTexture1DEXT( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level );
   funcs->ext.p_glFramebufferTexture1DEXT( target, attachment, textarget, texture, level );
 }
 
-static void WINAPI glFramebufferTexture2D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) {
+static void WINAPI glFramebufferTexture2D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level );
   funcs->ext.p_glFramebufferTexture2D( target, attachment, textarget, texture, level );
 }
 
-static void WINAPI glFramebufferTexture2DEXT( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) {
+static void WINAPI glFramebufferTexture2DEXT( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level );
   funcs->ext.p_glFramebufferTexture2DEXT( target, attachment, textarget, texture, level );
 }
 
-static void WINAPI glFramebufferTexture3D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset ) {
+static void WINAPI glFramebufferTexture3D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level, zoffset );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level, zoffset );
   funcs->ext.p_glFramebufferTexture3D( target, attachment, textarget, texture, level, zoffset );
 }
 
-static void WINAPI glFramebufferTexture3DEXT( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset ) {
+static void WINAPI glFramebufferTexture3DEXT( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level, zoffset );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", target, attachment, textarget, texture, level, zoffset );
   funcs->ext.p_glFramebufferTexture3DEXT( target, attachment, textarget, texture, level, zoffset );
 }
 
-static void WINAPI glFramebufferTextureARB( GLenum target, GLenum attachment, GLuint texture, GLint level ) {
+static void WINAPI glFramebufferTextureARB( GLenum target, GLenum attachment, GLuint texture, GLint level )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, attachment, texture, level );
+  TRACE( "(%d, %d, %d, %d)\n", target, attachment, texture, level );
   funcs->ext.p_glFramebufferTextureARB( target, attachment, texture, level );
 }
 
-static void WINAPI glFramebufferTextureEXT( GLenum target, GLenum attachment, GLuint texture, GLint level ) {
+static void WINAPI glFramebufferTextureEXT( GLenum target, GLenum attachment, GLuint texture, GLint level )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, attachment, texture, level );
+  TRACE( "(%d, %d, %d, %d)\n", target, attachment, texture, level );
   funcs->ext.p_glFramebufferTextureEXT( target, attachment, texture, level );
 }
 
-static void WINAPI glFramebufferTextureFaceARB( GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face ) {
+static void WINAPI glFramebufferTextureFaceARB( GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, texture, level, face );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, attachment, texture, level, face );
   funcs->ext.p_glFramebufferTextureFaceARB( target, attachment, texture, level, face );
 }
 
-static void WINAPI glFramebufferTextureFaceEXT( GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face ) {
+static void WINAPI glFramebufferTextureFaceEXT( GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, texture, level, face );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, attachment, texture, level, face );
   funcs->ext.p_glFramebufferTextureFaceEXT( target, attachment, texture, level, face );
 }
 
-static void WINAPI glFramebufferTextureLayer( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer ) {
+static void WINAPI glFramebufferTextureLayer( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, texture, level, layer );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, attachment, texture, level, layer );
   funcs->ext.p_glFramebufferTextureLayer( target, attachment, texture, level, layer );
 }
 
-static void WINAPI glFramebufferTextureLayerARB( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer ) {
+static void WINAPI glFramebufferTextureLayerARB( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, texture, level, layer );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, attachment, texture, level, layer );
   funcs->ext.p_glFramebufferTextureLayerARB( target, attachment, texture, level, layer );
 }
 
-static void WINAPI glFramebufferTextureLayerEXT( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer ) {
+static void WINAPI glFramebufferTextureLayerEXT( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, attachment, texture, level, layer );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, attachment, texture, level, layer );
   funcs->ext.p_glFramebufferTextureLayerEXT( target, attachment, texture, level, layer );
 }
 
-static void WINAPI glFramebufferTextureMultiviewOVR( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews ) {
+static void WINAPI glFramebufferTextureMultiviewOVR( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, attachment, texture, level, baseViewIndex, numViews );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", target, attachment, texture, level, baseViewIndex, numViews );
   funcs->ext.p_glFramebufferTextureMultiviewOVR( target, attachment, texture, level, baseViewIndex, numViews );
 }
 
-static void WINAPI glFreeObjectBufferATI( GLuint buffer ) {
+static void WINAPI glFreeObjectBufferATI( GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", buffer );
+  TRACE( "(%d)\n", buffer );
   funcs->ext.p_glFreeObjectBufferATI( buffer );
 }
 
-static void WINAPI glFrustumfOES( GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f ) {
+static void WINAPI glFrustumfOES( GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f, %f, %f)\n", l, r, b, t, n, f );
+  TRACE( "(%f, %f, %f, %f, %f, %f)\n", l, r, b, t, n, f );
   funcs->ext.p_glFrustumfOES( l, r, b, t, n, f );
 }
 
-static void WINAPI glFrustumxOES( GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f ) {
+static void WINAPI glFrustumxOES( GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", l, r, b, t, n, f );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", l, r, b, t, n, f );
   funcs->ext.p_glFrustumxOES( l, r, b, t, n, f );
 }
 
-static GLuint WINAPI glGenAsyncMarkersSGIX( GLsizei range ) {
+static GLuint WINAPI glGenAsyncMarkersSGIX( GLsizei range )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", range );
+  TRACE( "(%d)\n", range );
   return funcs->ext.p_glGenAsyncMarkersSGIX( range );
 }
 
-static void WINAPI glGenBuffers( GLsizei n, GLuint* buffers ) {
+static void WINAPI glGenBuffers( GLsizei n, GLuint *buffers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, buffers );
+  TRACE( "(%d, %p)\n", n, buffers );
   funcs->ext.p_glGenBuffers( n, buffers );
 }
 
-static void WINAPI glGenBuffersARB( GLsizei n, GLuint* buffers ) {
+static void WINAPI glGenBuffersARB( GLsizei n, GLuint *buffers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, buffers );
+  TRACE( "(%d, %p)\n", n, buffers );
   funcs->ext.p_glGenBuffersARB( n, buffers );
 }
 
-static void WINAPI glGenFencesAPPLE( GLsizei n, GLuint* fences ) {
+static void WINAPI glGenFencesAPPLE( GLsizei n, GLuint *fences )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, fences );
+  TRACE( "(%d, %p)\n", n, fences );
   funcs->ext.p_glGenFencesAPPLE( n, fences );
 }
 
-static void WINAPI glGenFencesNV( GLsizei n, GLuint* fences ) {
+static void WINAPI glGenFencesNV( GLsizei n, GLuint *fences )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, fences );
+  TRACE( "(%d, %p)\n", n, fences );
   funcs->ext.p_glGenFencesNV( n, fences );
 }
 
-static GLuint WINAPI glGenFragmentShadersATI( GLuint range ) {
+static GLuint WINAPI glGenFragmentShadersATI( GLuint range )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", range );
+  TRACE( "(%d)\n", range );
   return funcs->ext.p_glGenFragmentShadersATI( range );
 }
 
-static void WINAPI glGenFramebuffers( GLsizei n, GLuint* framebuffers ) {
+static void WINAPI glGenFramebuffers( GLsizei n, GLuint *framebuffers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, framebuffers );
+  TRACE( "(%d, %p)\n", n, framebuffers );
   funcs->ext.p_glGenFramebuffers( n, framebuffers );
 }
 
-static void WINAPI glGenFramebuffersEXT( GLsizei n, GLuint* framebuffers ) {
+static void WINAPI glGenFramebuffersEXT( GLsizei n, GLuint *framebuffers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, framebuffers );
+  TRACE( "(%d, %p)\n", n, framebuffers );
   funcs->ext.p_glGenFramebuffersEXT( n, framebuffers );
 }
 
-static void WINAPI glGenNamesAMD( GLenum identifier, GLuint num, GLuint* names ) {
+static void WINAPI glGenNamesAMD( GLenum identifier, GLuint num, GLuint *names )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", identifier, num, names );
+  TRACE( "(%d, %d, %p)\n", identifier, num, names );
   funcs->ext.p_glGenNamesAMD( identifier, num, names );
 }
 
-static void WINAPI glGenOcclusionQueriesNV( GLsizei n, GLuint* ids ) {
+static void WINAPI glGenOcclusionQueriesNV( GLsizei n, GLuint *ids )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, ids );
+  TRACE( "(%d, %p)\n", n, ids );
   funcs->ext.p_glGenOcclusionQueriesNV( n, ids );
 }
 
-static GLuint WINAPI glGenPathsNV( GLsizei range ) {
+static GLuint WINAPI glGenPathsNV( GLsizei range )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", range );
+  TRACE( "(%d)\n", range );
   return funcs->ext.p_glGenPathsNV( range );
 }
 
-static void WINAPI glGenPerfMonitorsAMD( GLsizei n, GLuint* monitors ) {
+static void WINAPI glGenPerfMonitorsAMD( GLsizei n, GLuint *monitors )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, monitors );
+  TRACE( "(%d, %p)\n", n, monitors );
   funcs->ext.p_glGenPerfMonitorsAMD( n, monitors );
 }
 
-static void WINAPI glGenProgramPipelines( GLsizei n, GLuint* pipelines ) {
+static void WINAPI glGenProgramPipelines( GLsizei n, GLuint *pipelines )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, pipelines );
+  TRACE( "(%d, %p)\n", n, pipelines );
   funcs->ext.p_glGenProgramPipelines( n, pipelines );
 }
 
-static void WINAPI glGenProgramsARB( GLsizei n, GLuint* programs ) {
+static void WINAPI glGenProgramsARB( GLsizei n, GLuint *programs )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, programs );
+  TRACE( "(%d, %p)\n", n, programs );
   funcs->ext.p_glGenProgramsARB( n, programs );
 }
 
-static void WINAPI glGenProgramsNV( GLsizei n, GLuint* programs ) {
+static void WINAPI glGenProgramsNV( GLsizei n, GLuint *programs )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, programs );
+  TRACE( "(%d, %p)\n", n, programs );
   funcs->ext.p_glGenProgramsNV( n, programs );
 }
 
-static void WINAPI glGenQueries( GLsizei n, GLuint* ids ) {
+static void WINAPI glGenQueries( GLsizei n, GLuint *ids )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, ids );
+  TRACE( "(%d, %p)\n", n, ids );
   funcs->ext.p_glGenQueries( n, ids );
 }
 
-static void WINAPI glGenQueriesARB( GLsizei n, GLuint* ids ) {
+static void WINAPI glGenQueriesARB( GLsizei n, GLuint *ids )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, ids );
+  TRACE( "(%d, %p)\n", n, ids );
   funcs->ext.p_glGenQueriesARB( n, ids );
 }
 
-static void WINAPI glGenQueryResourceTagNV( GLsizei n, GLint* tagIds ) {
+static void WINAPI glGenQueryResourceTagNV( GLsizei n, GLint *tagIds )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, tagIds );
+  TRACE( "(%d, %p)\n", n, tagIds );
   funcs->ext.p_glGenQueryResourceTagNV( n, tagIds );
 }
 
-static void WINAPI glGenRenderbuffers( GLsizei n, GLuint* renderbuffers ) {
+static void WINAPI glGenRenderbuffers( GLsizei n, GLuint *renderbuffers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, renderbuffers );
+  TRACE( "(%d, %p)\n", n, renderbuffers );
   funcs->ext.p_glGenRenderbuffers( n, renderbuffers );
 }
 
-static void WINAPI glGenRenderbuffersEXT( GLsizei n, GLuint* renderbuffers ) {
+static void WINAPI glGenRenderbuffersEXT( GLsizei n, GLuint *renderbuffers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, renderbuffers );
+  TRACE( "(%d, %p)\n", n, renderbuffers );
   funcs->ext.p_glGenRenderbuffersEXT( n, renderbuffers );
 }
 
-static void WINAPI glGenSamplers( GLsizei count, GLuint* samplers ) {
+static void WINAPI glGenSamplers( GLsizei count, GLuint *samplers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", count, samplers );
+  TRACE( "(%d, %p)\n", count, samplers );
   funcs->ext.p_glGenSamplers( count, samplers );
 }
 
-static void WINAPI glGenSemaphoresEXT( GLsizei n, GLuint* semaphores ) {
+static void WINAPI glGenSemaphoresEXT( GLsizei n, GLuint *semaphores )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, semaphores );
+  TRACE( "(%d, %p)\n", n, semaphores );
   funcs->ext.p_glGenSemaphoresEXT( n, semaphores );
 }
 
-static GLuint WINAPI glGenSymbolsEXT( GLenum datatype, GLenum storagetype, GLenum range, GLuint components ) {
+static GLuint WINAPI glGenSymbolsEXT( GLenum datatype, GLenum storagetype, GLenum range, GLuint components )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", datatype, storagetype, range, components );
+  TRACE( "(%d, %d, %d, %d)\n", datatype, storagetype, range, components );
   return funcs->ext.p_glGenSymbolsEXT( datatype, storagetype, range, components );
 }
 
-static void WINAPI glGenTexturesEXT( GLsizei n, GLuint* textures ) {
+static void WINAPI glGenTexturesEXT( GLsizei n, GLuint *textures )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, textures );
+  TRACE( "(%d, %p)\n", n, textures );
   funcs->ext.p_glGenTexturesEXT( n, textures );
 }
 
-static void WINAPI glGenTransformFeedbacks( GLsizei n, GLuint* ids ) {
+static void WINAPI glGenTransformFeedbacks( GLsizei n, GLuint *ids )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, ids );
+  TRACE( "(%d, %p)\n", n, ids );
   funcs->ext.p_glGenTransformFeedbacks( n, ids );
 }
 
-static void WINAPI glGenTransformFeedbacksNV( GLsizei n, GLuint* ids ) {
+static void WINAPI glGenTransformFeedbacksNV( GLsizei n, GLuint *ids )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, ids );
+  TRACE( "(%d, %p)\n", n, ids );
   funcs->ext.p_glGenTransformFeedbacksNV( n, ids );
 }
 
-static void WINAPI glGenVertexArrays( GLsizei n, GLuint* arrays ) {
+static void WINAPI glGenVertexArrays( GLsizei n, GLuint *arrays )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, arrays );
+  TRACE( "(%d, %p)\n", n, arrays );
   funcs->ext.p_glGenVertexArrays( n, arrays );
 }
 
-static void WINAPI glGenVertexArraysAPPLE( GLsizei n, GLuint* arrays ) {
+static void WINAPI glGenVertexArraysAPPLE( GLsizei n, GLuint *arrays )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, arrays );
+  TRACE( "(%d, %p)\n", n, arrays );
   funcs->ext.p_glGenVertexArraysAPPLE( n, arrays );
 }
 
-static GLuint WINAPI glGenVertexShadersEXT( GLuint range ) {
+static GLuint WINAPI glGenVertexShadersEXT( GLuint range )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", range );
+  TRACE( "(%d)\n", range );
   return funcs->ext.p_glGenVertexShadersEXT( range );
 }
 
-static void WINAPI glGenerateMipmap( GLenum target ) {
+static void WINAPI glGenerateMipmap( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   funcs->ext.p_glGenerateMipmap( target );
 }
 
-static void WINAPI glGenerateMipmapEXT( GLenum target ) {
+static void WINAPI glGenerateMipmapEXT( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   funcs->ext.p_glGenerateMipmapEXT( target );
 }
 
-static void WINAPI glGenerateMultiTexMipmapEXT( GLenum texunit, GLenum target ) {
+static void WINAPI glGenerateMultiTexMipmapEXT( GLenum texunit, GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", texunit, target );
+  TRACE( "(%d, %d)\n", texunit, target );
   funcs->ext.p_glGenerateMultiTexMipmapEXT( texunit, target );
 }
 
-static void WINAPI glGenerateTextureMipmap( GLuint texture ) {
+static void WINAPI glGenerateTextureMipmap( GLuint texture )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", texture );
+  TRACE( "(%d)\n", texture );
   funcs->ext.p_glGenerateTextureMipmap( texture );
 }
 
-static void WINAPI glGenerateTextureMipmapEXT( GLuint texture, GLenum target ) {
+static void WINAPI glGenerateTextureMipmapEXT( GLuint texture, GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", texture, target );
+  TRACE( "(%d, %d)\n", texture, target );
   funcs->ext.p_glGenerateTextureMipmapEXT( texture, target );
 }
 
-static void WINAPI glGetActiveAtomicCounterBufferiv( GLuint program, GLuint bufferIndex, GLenum pname, GLint* params ) {
+static void WINAPI glGetActiveAtomicCounterBufferiv( GLuint program, GLuint bufferIndex, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, bufferIndex, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, bufferIndex, pname, params );
   funcs->ext.p_glGetActiveAtomicCounterBufferiv( program, bufferIndex, pname, params );
 }
 
-static void WINAPI glGetActiveAttrib( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* type, GLchar* name ) {
+static void WINAPI glGetActiveAttrib( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p, %p, %p)\n", program, index, bufSize, length, size, type, name );
+  TRACE( "(%d, %d, %d, %p, %p, %p, %p)\n", program, index, bufSize, length, size, type, name );
   funcs->ext.p_glGetActiveAttrib( program, index, bufSize, length, size, type, name );
 }
 
-static void WINAPI glGetActiveAttribARB( GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLcharARB* name ) {
+static void WINAPI glGetActiveAttribARB( GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p, %p, %p)\n", programObj, index, maxLength, length, size, type, name );
+  TRACE( "(%d, %d, %d, %p, %p, %p, %p)\n", programObj, index, maxLength, length, size, type, name );
   funcs->ext.p_glGetActiveAttribARB( programObj, index, maxLength, length, size, type, name );
 }
 
-static void WINAPI glGetActiveSubroutineName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, GLchar* name ) {
+static void WINAPI glGetActiveSubroutineName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p, %p)\n", program, shadertype, index, bufsize, length, name );
+  TRACE( "(%d, %d, %d, %d, %p, %p)\n", program, shadertype, index, bufsize, length, name );
   funcs->ext.p_glGetActiveSubroutineName( program, shadertype, index, bufsize, length, name );
 }
 
-static void WINAPI glGetActiveSubroutineUniformName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, GLchar* name ) {
+static void WINAPI glGetActiveSubroutineUniformName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p, %p)\n", program, shadertype, index, bufsize, length, name );
+  TRACE( "(%d, %d, %d, %d, %p, %p)\n", program, shadertype, index, bufsize, length, name );
   funcs->ext.p_glGetActiveSubroutineUniformName( program, shadertype, index, bufsize, length, name );
 }
 
-static void WINAPI glGetActiveSubroutineUniformiv( GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values ) {
+static void WINAPI glGetActiveSubroutineUniformiv( GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, shadertype, index, pname, values );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, shadertype, index, pname, values );
   funcs->ext.p_glGetActiveSubroutineUniformiv( program, shadertype, index, pname, values );
 }
 
-static void WINAPI glGetActiveUniform( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* type, GLchar* name ) {
+static void WINAPI glGetActiveUniform( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p, %p, %p)\n", program, index, bufSize, length, size, type, name );
+  TRACE( "(%d, %d, %d, %p, %p, %p, %p)\n", program, index, bufSize, length, size, type, name );
   funcs->ext.p_glGetActiveUniform( program, index, bufSize, length, size, type, name );
 }
 
-static void WINAPI glGetActiveUniformARB( GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLcharARB* name ) {
+static void WINAPI glGetActiveUniformARB( GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p, %p, %p)\n", programObj, index, maxLength, length, size, type, name );
+  TRACE( "(%d, %d, %d, %p, %p, %p, %p)\n", programObj, index, maxLength, length, size, type, name );
   funcs->ext.p_glGetActiveUniformARB( programObj, index, maxLength, length, size, type, name );
 }
 
-static void WINAPI glGetActiveUniformBlockName( GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName ) {
+static void WINAPI glGetActiveUniformBlockName( GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p)\n", program, uniformBlockIndex, bufSize, length, uniformBlockName );
+  TRACE( "(%d, %d, %d, %p, %p)\n", program, uniformBlockIndex, bufSize, length, uniformBlockName );
   funcs->ext.p_glGetActiveUniformBlockName( program, uniformBlockIndex, bufSize, length, uniformBlockName );
 }
 
-static void WINAPI glGetActiveUniformBlockiv( GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params ) {
+static void WINAPI glGetActiveUniformBlockiv( GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, uniformBlockIndex, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, uniformBlockIndex, pname, params );
   funcs->ext.p_glGetActiveUniformBlockiv( program, uniformBlockIndex, pname, params );
 }
 
-static void WINAPI glGetActiveUniformName( GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName ) {
+static void WINAPI glGetActiveUniformName( GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p)\n", program, uniformIndex, bufSize, length, uniformName );
+  TRACE( "(%d, %d, %d, %p, %p)\n", program, uniformIndex, bufSize, length, uniformName );
   funcs->ext.p_glGetActiveUniformName( program, uniformIndex, bufSize, length, uniformName );
 }
 
-static void WINAPI glGetActiveUniformsiv( GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params ) {
+static void WINAPI glGetActiveUniformsiv( GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %p)\n", program, uniformCount, uniformIndices, pname, params );
+  TRACE( "(%d, %d, %p, %d, %p)\n", program, uniformCount, uniformIndices, pname, params );
   funcs->ext.p_glGetActiveUniformsiv( program, uniformCount, uniformIndices, pname, params );
 }
 
-static void WINAPI glGetActiveVaryingNV( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name ) {
+static void WINAPI glGetActiveVaryingNV( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p, %p, %p)\n", program, index, bufSize, length, size, type, name );
+  TRACE( "(%d, %d, %d, %p, %p, %p, %p)\n", program, index, bufSize, length, size, type, name );
   funcs->ext.p_glGetActiveVaryingNV( program, index, bufSize, length, size, type, name );
 }
 
-static void WINAPI glGetArrayObjectfvATI( GLenum array, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetArrayObjectfvATI( GLenum array, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", array, pname, params );
+  TRACE( "(%d, %d, %p)\n", array, pname, params );
   funcs->ext.p_glGetArrayObjectfvATI( array, pname, params );
 }
 
-static void WINAPI glGetArrayObjectivATI( GLenum array, GLenum pname, GLint* params ) {
+static void WINAPI glGetArrayObjectivATI( GLenum array, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", array, pname, params );
+  TRACE( "(%d, %d, %p)\n", array, pname, params );
   funcs->ext.p_glGetArrayObjectivATI( array, pname, params );
 }
 
-static void WINAPI glGetAttachedObjectsARB( GLhandleARB containerObj, GLsizei maxCount, GLsizei* count, GLhandleARB* obj ) {
+static void WINAPI glGetAttachedObjectsARB( GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", containerObj, maxCount, count, obj );
+  TRACE( "(%d, %d, %p, %p)\n", containerObj, maxCount, count, obj );
   funcs->ext.p_glGetAttachedObjectsARB( containerObj, maxCount, count, obj );
 }
 
-static void WINAPI glGetAttachedShaders( GLuint program, GLsizei maxCount, GLsizei* count, GLuint* shaders ) {
+static void WINAPI glGetAttachedShaders( GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", program, maxCount, count, shaders );
+  TRACE( "(%d, %d, %p, %p)\n", program, maxCount, count, shaders );
   funcs->ext.p_glGetAttachedShaders( program, maxCount, count, shaders );
 }
 
-static GLint WINAPI glGetAttribLocation( GLuint program, const GLchar* name ) {
+static GLint WINAPI glGetAttribLocation( GLuint program, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", program, name );
+  TRACE( "(%d, %p)\n", program, name );
   return funcs->ext.p_glGetAttribLocation( program, name );
 }
 
-static GLint WINAPI glGetAttribLocationARB( GLhandleARB programObj, const GLcharARB* name ) {
+static GLint WINAPI glGetAttribLocationARB( GLhandleARB programObj, const GLcharARB *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", programObj, name );
+  TRACE( "(%d, %p)\n", programObj, name );
   return funcs->ext.p_glGetAttribLocationARB( programObj, name );
 }
 
-static void WINAPI glGetBooleanIndexedvEXT( GLenum target, GLuint index, GLboolean* data ) {
+static void WINAPI glGetBooleanIndexedvEXT( GLenum target, GLuint index, GLboolean *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, data );
+  TRACE( "(%d, %d, %p)\n", target, index, data );
   funcs->ext.p_glGetBooleanIndexedvEXT( target, index, data );
 }
 
-static void WINAPI glGetBooleani_v( GLenum target, GLuint index, GLboolean* data ) {
+static void WINAPI glGetBooleani_v( GLenum target, GLuint index, GLboolean *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, data );
+  TRACE( "(%d, %d, %p)\n", target, index, data );
   funcs->ext.p_glGetBooleani_v( target, index, data );
 }
 
-static void WINAPI glGetBufferParameteri64v( GLenum target, GLenum pname, GLint64* params ) {
+static void WINAPI glGetBufferParameteri64v( GLenum target, GLenum pname, GLint64 *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetBufferParameteri64v( target, pname, params );
 }
 
-static void WINAPI glGetBufferParameteriv( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetBufferParameteriv( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetBufferParameteriv( target, pname, params );
 }
 
-static void WINAPI glGetBufferParameterivARB( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetBufferParameterivARB( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetBufferParameterivARB( target, pname, params );
 }
 
-static void WINAPI glGetBufferParameterui64vNV( GLenum target, GLenum pname, GLuint64EXT* params ) {
+static void WINAPI glGetBufferParameterui64vNV( GLenum target, GLenum pname, GLuint64EXT *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetBufferParameterui64vNV( target, pname, params );
 }
 
-static void WINAPI glGetBufferPointerv( GLenum target, GLenum pname, void** params ) {
+static void WINAPI glGetBufferPointerv( GLenum target, GLenum pname, void **params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetBufferPointerv( target, pname, params );
 }
 
-static void WINAPI glGetBufferPointervARB( GLenum target, GLenum pname, void** params ) {
+static void WINAPI glGetBufferPointervARB( GLenum target, GLenum pname, void **params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetBufferPointervARB( target, pname, params );
 }
 
-static void WINAPI glGetBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, void* data ) {
+static void WINAPI glGetBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld, %p)\n", target, offset, size, data );
+  TRACE( "(%d, %ld, %ld, %p)\n", target, offset, size, data );
   funcs->ext.p_glGetBufferSubData( target, offset, size, data );
 }
 
-static void WINAPI glGetBufferSubDataARB( GLenum target, GLintptrARB offset, GLsizeiptrARB size, void* data ) {
+static void WINAPI glGetBufferSubDataARB( GLenum target, GLintptrARB offset, GLsizeiptrARB size, void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld, %p)\n", target, offset, size, data );
+  TRACE( "(%d, %ld, %ld, %p)\n", target, offset, size, data );
   funcs->ext.p_glGetBufferSubDataARB( target, offset, size, data );
 }
 
-static void WINAPI glGetClipPlanefOES( GLenum plane, GLfloat* equation ) {
+static void WINAPI glGetClipPlanefOES( GLenum plane, GLfloat *equation )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", plane, equation );
+  TRACE( "(%d, %p)\n", plane, equation );
   funcs->ext.p_glGetClipPlanefOES( plane, equation );
 }
 
-static void WINAPI glGetClipPlanexOES( GLenum plane, GLfixed* equation ) {
+static void WINAPI glGetClipPlanexOES( GLenum plane, GLfixed *equation )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", plane, equation );
+  TRACE( "(%d, %p)\n", plane, equation );
   funcs->ext.p_glGetClipPlanexOES( plane, equation );
 }
 
-static void WINAPI glGetColorTable( GLenum target, GLenum format, GLenum type, void* table ) {
+static void WINAPI glGetColorTable( GLenum target, GLenum format, GLenum type, void *table )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, format, type, table );
+  TRACE( "(%d, %d, %d, %p)\n", target, format, type, table );
   funcs->ext.p_glGetColorTable( target, format, type, table );
 }
 
-static void WINAPI glGetColorTableEXT( GLenum target, GLenum format, GLenum type, void* data ) {
+static void WINAPI glGetColorTableEXT( GLenum target, GLenum format, GLenum type, void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, format, type, data );
+  TRACE( "(%d, %d, %d, %p)\n", target, format, type, data );
   funcs->ext.p_glGetColorTableEXT( target, format, type, data );
 }
 
-static void WINAPI glGetColorTableParameterfv( GLenum target, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetColorTableParameterfv( target, pname, params );
 }
 
-static void WINAPI glGetColorTableParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetColorTableParameterfvEXT( GLenum target, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetColorTableParameterfvEXT( target, pname, params );
 }
 
-static void WINAPI glGetColorTableParameterfvSGI( GLenum target, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetColorTableParameterfvSGI( GLenum target, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetColorTableParameterfvSGI( target, pname, params );
 }
 
-static void WINAPI glGetColorTableParameteriv( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetColorTableParameteriv( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetColorTableParameteriv( target, pname, params );
 }
 
-static void WINAPI glGetColorTableParameterivEXT( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetColorTableParameterivEXT( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetColorTableParameterivEXT( target, pname, params );
 }
 
-static void WINAPI glGetColorTableParameterivSGI( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetColorTableParameterivSGI( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetColorTableParameterivSGI( target, pname, params );
 }
 
-static void WINAPI glGetColorTableSGI( GLenum target, GLenum format, GLenum type, void* table ) {
+static void WINAPI glGetColorTableSGI( GLenum target, GLenum format, GLenum type, void *table )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, format, type, table );
+  TRACE( "(%d, %d, %d, %p)\n", target, format, type, table );
   funcs->ext.p_glGetColorTableSGI( target, format, type, table );
 }
 
-static void WINAPI glGetCombinerInputParameterfvNV( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetCombinerInputParameterfvNV( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", stage, portion, variable, pname, params );
+  TRACE( "(%d, %d, %d, %d, %p)\n", stage, portion, variable, pname, params );
   funcs->ext.p_glGetCombinerInputParameterfvNV( stage, portion, variable, pname, params );
 }
 
-static void WINAPI glGetCombinerInputParameterivNV( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint* params ) {
+static void WINAPI glGetCombinerInputParameterivNV( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", stage, portion, variable, pname, params );
+  TRACE( "(%d, %d, %d, %d, %p)\n", stage, portion, variable, pname, params );
   funcs->ext.p_glGetCombinerInputParameterivNV( stage, portion, variable, pname, params );
 }
 
-static void WINAPI glGetCombinerOutputParameterfvNV( GLenum stage, GLenum portion, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetCombinerOutputParameterfvNV( GLenum stage, GLenum portion, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", stage, portion, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", stage, portion, pname, params );
   funcs->ext.p_glGetCombinerOutputParameterfvNV( stage, portion, pname, params );
 }
 
-static void WINAPI glGetCombinerOutputParameterivNV( GLenum stage, GLenum portion, GLenum pname, GLint* params ) {
+static void WINAPI glGetCombinerOutputParameterivNV( GLenum stage, GLenum portion, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", stage, portion, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", stage, portion, pname, params );
   funcs->ext.p_glGetCombinerOutputParameterivNV( stage, portion, pname, params );
 }
 
-static void WINAPI glGetCombinerStageParameterfvNV( GLenum stage, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetCombinerStageParameterfvNV( GLenum stage, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", stage, pname, params );
+  TRACE( "(%d, %d, %p)\n", stage, pname, params );
   funcs->ext.p_glGetCombinerStageParameterfvNV( stage, pname, params );
 }
 
-static GLuint WINAPI glGetCommandHeaderNV( GLenum tokenID, GLuint size ) {
+static GLuint WINAPI glGetCommandHeaderNV( GLenum tokenID, GLuint size )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", tokenID, size );
+  TRACE( "(%d, %d)\n", tokenID, size );
   return funcs->ext.p_glGetCommandHeaderNV( tokenID, size );
 }
 
-static void WINAPI glGetCompressedMultiTexImageEXT( GLenum texunit, GLenum target, GLint lod, void* img ) {
+static void WINAPI glGetCompressedMultiTexImageEXT( GLenum texunit, GLenum target, GLint lod, void *img )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, target, lod, img );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, target, lod, img );
   funcs->ext.p_glGetCompressedMultiTexImageEXT( texunit, target, lod, img );
 }
 
-static void WINAPI glGetCompressedTexImage( GLenum target, GLint level, void* img ) {
+static void WINAPI glGetCompressedTexImage( GLenum target, GLint level, void *img )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, level, img );
+  TRACE( "(%d, %d, %p)\n", target, level, img );
   funcs->ext.p_glGetCompressedTexImage( target, level, img );
 }
 
-static void WINAPI glGetCompressedTexImageARB( GLenum target, GLint level, void* img ) {
+static void WINAPI glGetCompressedTexImageARB( GLenum target, GLint level, void *img )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, level, img );
+  TRACE( "(%d, %d, %p)\n", target, level, img );
   funcs->ext.p_glGetCompressedTexImageARB( target, level, img );
 }
 
-static void WINAPI glGetCompressedTextureImage( GLuint texture, GLint level, GLsizei bufSize, void* pixels ) {
+static void WINAPI glGetCompressedTextureImage( GLuint texture, GLint level, GLsizei bufSize, void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texture, level, bufSize, pixels );
+  TRACE( "(%d, %d, %d, %p)\n", texture, level, bufSize, pixels );
   funcs->ext.p_glGetCompressedTextureImage( texture, level, bufSize, pixels );
 }
 
-static void WINAPI glGetCompressedTextureImageEXT( GLuint texture, GLenum target, GLint lod, void* img ) {
+static void WINAPI glGetCompressedTextureImageEXT( GLuint texture, GLenum target, GLint lod, void *img )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texture, target, lod, img );
+  TRACE( "(%d, %d, %d, %p)\n", texture, target, lod, img );
   funcs->ext.p_glGetCompressedTextureImageEXT( texture, target, lod, img );
 }
 
-static void WINAPI glGetCompressedTextureSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void* pixels ) {
+static void WINAPI glGetCompressedTextureSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels );
   funcs->ext.p_glGetCompressedTextureSubImage( texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels );
 }
 
-static void WINAPI glGetConvolutionFilter( GLenum target, GLenum format, GLenum type, void* image ) {
+static void WINAPI glGetConvolutionFilter( GLenum target, GLenum format, GLenum type, void *image )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, format, type, image );
+  TRACE( "(%d, %d, %d, %p)\n", target, format, type, image );
   funcs->ext.p_glGetConvolutionFilter( target, format, type, image );
 }
 
-static void WINAPI glGetConvolutionFilterEXT( GLenum target, GLenum format, GLenum type, void* image ) {
+static void WINAPI glGetConvolutionFilterEXT( GLenum target, GLenum format, GLenum type, void *image )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, format, type, image );
+  TRACE( "(%d, %d, %d, %p)\n", target, format, type, image );
   funcs->ext.p_glGetConvolutionFilterEXT( target, format, type, image );
 }
 
-static void WINAPI glGetConvolutionParameterfv( GLenum target, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetConvolutionParameterfv( GLenum target, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetConvolutionParameterfv( target, pname, params );
 }
 
-static void WINAPI glGetConvolutionParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetConvolutionParameterfvEXT( GLenum target, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetConvolutionParameterfvEXT( target, pname, params );
 }
 
-static void WINAPI glGetConvolutionParameteriv( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetConvolutionParameteriv( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetConvolutionParameteriv( target, pname, params );
 }
 
-static void WINAPI glGetConvolutionParameterivEXT( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetConvolutionParameterivEXT( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetConvolutionParameterivEXT( target, pname, params );
 }
 
-static void WINAPI glGetConvolutionParameterxvOES( GLenum target, GLenum pname, GLfixed* params ) {
+static void WINAPI glGetConvolutionParameterxvOES( GLenum target, GLenum pname, GLfixed *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetConvolutionParameterxvOES( target, pname, params );
 }
 
-static void WINAPI glGetCoverageModulationTableNV( GLsizei bufsize, GLfloat* v ) {
+static void WINAPI glGetCoverageModulationTableNV( GLsizei bufsize, GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", bufsize, v );
+  TRACE( "(%d, %p)\n", bufsize, v );
   funcs->ext.p_glGetCoverageModulationTableNV( bufsize, v );
 }
 
-static GLuint WINAPI glGetDebugMessageLog( GLuint count, GLsizei bufSize, GLenum* sources, GLenum* types, GLuint* ids, GLenum* severities, GLsizei* lengths, GLchar* messageLog ) {
+static GLuint WINAPI glGetDebugMessageLog( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p, %p, %p, %p, %p)\n", count, bufSize, sources, types, ids, severities, lengths, messageLog );
+  TRACE( "(%d, %d, %p, %p, %p, %p, %p, %p)\n", count, bufSize, sources, types, ids, severities, lengths, messageLog );
   return funcs->ext.p_glGetDebugMessageLog( count, bufSize, sources, types, ids, severities, lengths, messageLog );
 }
 
-static GLuint WINAPI glGetDebugMessageLogAMD( GLuint count, GLsizei bufsize, GLenum* categories, GLuint* severities, GLuint* ids, GLsizei* lengths, GLchar* message ) {
+static GLuint WINAPI glGetDebugMessageLogAMD( GLuint count, GLsizei bufsize, GLenum *categories, GLuint *severities, GLuint *ids, GLsizei *lengths, GLchar *message )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p, %p, %p, %p)\n", count, bufsize, categories, severities, ids, lengths, message );
+  TRACE( "(%d, %d, %p, %p, %p, %p, %p)\n", count, bufsize, categories, severities, ids, lengths, message );
   return funcs->ext.p_glGetDebugMessageLogAMD( count, bufsize, categories, severities, ids, lengths, message );
 }
 
-static GLuint WINAPI glGetDebugMessageLogARB( GLuint count, GLsizei bufSize, GLenum* sources, GLenum* types, GLuint* ids, GLenum* severities, GLsizei* lengths, GLchar* messageLog ) {
+static GLuint WINAPI glGetDebugMessageLogARB( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p, %p, %p, %p, %p)\n", count, bufSize, sources, types, ids, severities, lengths, messageLog );
+  TRACE( "(%d, %d, %p, %p, %p, %p, %p, %p)\n", count, bufSize, sources, types, ids, severities, lengths, messageLog );
   return funcs->ext.p_glGetDebugMessageLogARB( count, bufSize, sources, types, ids, severities, lengths, messageLog );
 }
 
-static void WINAPI glGetDetailTexFuncSGIS( GLenum target, GLfloat* points ) {
+static void WINAPI glGetDetailTexFuncSGIS( GLenum target, GLfloat *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, points );
+  TRACE( "(%d, %p)\n", target, points );
   funcs->ext.p_glGetDetailTexFuncSGIS( target, points );
 }
 
-static void WINAPI glGetDoubleIndexedvEXT( GLenum target, GLuint index, GLdouble* data ) {
+static void WINAPI glGetDoubleIndexedvEXT( GLenum target, GLuint index, GLdouble *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, data );
+  TRACE( "(%d, %d, %p)\n", target, index, data );
   funcs->ext.p_glGetDoubleIndexedvEXT( target, index, data );
 }
 
-static void WINAPI glGetDoublei_v( GLenum target, GLuint index, GLdouble* data ) {
+static void WINAPI glGetDoublei_v( GLenum target, GLuint index, GLdouble *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, data );
+  TRACE( "(%d, %d, %p)\n", target, index, data );
   funcs->ext.p_glGetDoublei_v( target, index, data );
 }
 
-static void WINAPI glGetDoublei_vEXT( GLenum pname, GLuint index, GLdouble* params ) {
+static void WINAPI glGetDoublei_vEXT( GLenum pname, GLuint index, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", pname, index, params );
+  TRACE( "(%d, %d, %p)\n", pname, index, params );
   funcs->ext.p_glGetDoublei_vEXT( pname, index, params );
 }
 
-static void WINAPI glGetFenceivNV( GLuint fence, GLenum pname, GLint* params ) {
+static void WINAPI glGetFenceivNV( GLuint fence, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", fence, pname, params );
+  TRACE( "(%d, %d, %p)\n", fence, pname, params );
   funcs->ext.p_glGetFenceivNV( fence, pname, params );
 }
 
-static void WINAPI glGetFinalCombinerInputParameterfvNV( GLenum variable, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetFinalCombinerInputParameterfvNV( GLenum variable, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", variable, pname, params );
+  TRACE( "(%d, %d, %p)\n", variable, pname, params );
   funcs->ext.p_glGetFinalCombinerInputParameterfvNV( variable, pname, params );
 }
 
-static void WINAPI glGetFinalCombinerInputParameterivNV( GLenum variable, GLenum pname, GLint* params ) {
+static void WINAPI glGetFinalCombinerInputParameterivNV( GLenum variable, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", variable, pname, params );
+  TRACE( "(%d, %d, %p)\n", variable, pname, params );
   funcs->ext.p_glGetFinalCombinerInputParameterivNV( variable, pname, params );
 }
 
-static void WINAPI glGetFirstPerfQueryIdINTEL( GLuint* queryId ) {
+static void WINAPI glGetFirstPerfQueryIdINTEL( GLuint *queryId )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", queryId );
+  TRACE( "(%p)\n", queryId );
   funcs->ext.p_glGetFirstPerfQueryIdINTEL( queryId );
 }
 
-static void WINAPI glGetFixedvOES( GLenum pname, GLfixed* params ) {
+static void WINAPI glGetFixedvOES( GLenum pname, GLfixed *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glGetFixedvOES( pname, params );
 }
 
-static void WINAPI glGetFloatIndexedvEXT( GLenum target, GLuint index, GLfloat* data ) {
+static void WINAPI glGetFloatIndexedvEXT( GLenum target, GLuint index, GLfloat *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, data );
+  TRACE( "(%d, %d, %p)\n", target, index, data );
   funcs->ext.p_glGetFloatIndexedvEXT( target, index, data );
 }
 
-static void WINAPI glGetFloati_v( GLenum target, GLuint index, GLfloat* data ) {
+static void WINAPI glGetFloati_v( GLenum target, GLuint index, GLfloat *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, data );
+  TRACE( "(%d, %d, %p)\n", target, index, data );
   funcs->ext.p_glGetFloati_v( target, index, data );
 }
 
-static void WINAPI glGetFloati_vEXT( GLenum pname, GLuint index, GLfloat* params ) {
+static void WINAPI glGetFloati_vEXT( GLenum pname, GLuint index, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", pname, index, params );
+  TRACE( "(%d, %d, %p)\n", pname, index, params );
   funcs->ext.p_glGetFloati_vEXT( pname, index, params );
 }
 
-static void WINAPI glGetFogFuncSGIS( GLfloat* points ) {
+static void WINAPI glGetFogFuncSGIS( GLfloat *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", points );
+  TRACE( "(%p)\n", points );
   funcs->ext.p_glGetFogFuncSGIS( points );
 }
 
-static GLint WINAPI glGetFragDataIndex( GLuint program, const GLchar* name ) {
+static GLint WINAPI glGetFragDataIndex( GLuint program, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", program, name );
+  TRACE( "(%d, %p)\n", program, name );
   return funcs->ext.p_glGetFragDataIndex( program, name );
 }
 
-static GLint WINAPI glGetFragDataLocation( GLuint program, const GLchar* name ) {
+static GLint WINAPI glGetFragDataLocation( GLuint program, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", program, name );
+  TRACE( "(%d, %p)\n", program, name );
   return funcs->ext.p_glGetFragDataLocation( program, name );
 }
 
-static GLint WINAPI glGetFragDataLocationEXT( GLuint program, const GLchar* name ) {
+static GLint WINAPI glGetFragDataLocationEXT( GLuint program, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", program, name );
+  TRACE( "(%d, %p)\n", program, name );
   return funcs->ext.p_glGetFragDataLocationEXT( program, name );
 }
 
-static void WINAPI glGetFragmentLightfvSGIX( GLenum light, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetFragmentLightfvSGIX( GLenum light, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", light, pname, params );
+  TRACE( "(%d, %d, %p)\n", light, pname, params );
   funcs->ext.p_glGetFragmentLightfvSGIX( light, pname, params );
 }
 
-static void WINAPI glGetFragmentLightivSGIX( GLenum light, GLenum pname, GLint* params ) {
+static void WINAPI glGetFragmentLightivSGIX( GLenum light, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", light, pname, params );
+  TRACE( "(%d, %d, %p)\n", light, pname, params );
   funcs->ext.p_glGetFragmentLightivSGIX( light, pname, params );
 }
 
-static void WINAPI glGetFragmentMaterialfvSGIX( GLenum face, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetFragmentMaterialfvSGIX( GLenum face, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", face, pname, params );
+  TRACE( "(%d, %d, %p)\n", face, pname, params );
   funcs->ext.p_glGetFragmentMaterialfvSGIX( face, pname, params );
 }
 
-static void WINAPI glGetFragmentMaterialivSGIX( GLenum face, GLenum pname, GLint* params ) {
+static void WINAPI glGetFragmentMaterialivSGIX( GLenum face, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", face, pname, params );
+  TRACE( "(%d, %d, %p)\n", face, pname, params );
   funcs->ext.p_glGetFragmentMaterialivSGIX( face, pname, params );
 }
 
-static void WINAPI glGetFramebufferAttachmentParameteriv( GLenum target, GLenum attachment, GLenum pname, GLint* params ) {
+static void WINAPI glGetFramebufferAttachmentParameteriv( GLenum target, GLenum attachment, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, attachment, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", target, attachment, pname, params );
   funcs->ext.p_glGetFramebufferAttachmentParameteriv( target, attachment, pname, params );
 }
 
-static void WINAPI glGetFramebufferAttachmentParameterivEXT( GLenum target, GLenum attachment, GLenum pname, GLint* params ) {
+static void WINAPI glGetFramebufferAttachmentParameterivEXT( GLenum target, GLenum attachment, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, attachment, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", target, attachment, pname, params );
   funcs->ext.p_glGetFramebufferAttachmentParameterivEXT( target, attachment, pname, params );
 }
 
-static void WINAPI glGetFramebufferParameterfvAMD( GLenum target, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, GLfloat* values ) {
+static void WINAPI glGetFramebufferParameterfvAMD( GLenum target, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, GLfloat *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, pname, numsamples, pixelindex, size, values );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", target, pname, numsamples, pixelindex, size, values );
   funcs->ext.p_glGetFramebufferParameterfvAMD( target, pname, numsamples, pixelindex, size, values );
 }
 
-static void WINAPI glGetFramebufferParameteriv( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetFramebufferParameteriv( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetFramebufferParameteriv( target, pname, params );
 }
 
-static void WINAPI glGetFramebufferParameterivEXT( GLuint framebuffer, GLenum pname, GLint* params ) {
+static void WINAPI glGetFramebufferParameterivEXT( GLuint framebuffer, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", framebuffer, pname, params );
+  TRACE( "(%d, %d, %p)\n", framebuffer, pname, params );
   funcs->ext.p_glGetFramebufferParameterivEXT( framebuffer, pname, params );
 }
 
-static GLenum WINAPI glGetGraphicsResetStatus( void ) {
+static GLenum WINAPI glGetGraphicsResetStatus(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  return funcs->ext.p_glGetGraphicsResetStatus( );
+  TRACE( "()\n" );
+  return funcs->ext.p_glGetGraphicsResetStatus();
 }
 
-static GLenum WINAPI glGetGraphicsResetStatusARB( void ) {
+static GLenum WINAPI glGetGraphicsResetStatusARB(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  return funcs->ext.p_glGetGraphicsResetStatusARB( );
+  TRACE( "()\n" );
+  return funcs->ext.p_glGetGraphicsResetStatusARB();
 }
 
-static GLhandleARB WINAPI glGetHandleARB( GLenum pname ) {
+static GLhandleARB WINAPI glGetHandleARB( GLenum pname )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", pname );
+  TRACE( "(%d)\n", pname );
   return funcs->ext.p_glGetHandleARB( pname );
 }
 
-static void WINAPI glGetHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, void* values ) {
+static void WINAPI glGetHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, void *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", target, reset, format, type, values );
+  TRACE( "(%d, %d, %d, %d, %p)\n", target, reset, format, type, values );
   funcs->ext.p_glGetHistogram( target, reset, format, type, values );
 }
 
-static void WINAPI glGetHistogramEXT( GLenum target, GLboolean reset, GLenum format, GLenum type, void* values ) {
+static void WINAPI glGetHistogramEXT( GLenum target, GLboolean reset, GLenum format, GLenum type, void *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", target, reset, format, type, values );
+  TRACE( "(%d, %d, %d, %d, %p)\n", target, reset, format, type, values );
   funcs->ext.p_glGetHistogramEXT( target, reset, format, type, values );
 }
 
-static void WINAPI glGetHistogramParameterfv( GLenum target, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetHistogramParameterfv( GLenum target, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetHistogramParameterfv( target, pname, params );
 }
 
-static void WINAPI glGetHistogramParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetHistogramParameterfvEXT( GLenum target, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetHistogramParameterfvEXT( target, pname, params );
 }
 
-static void WINAPI glGetHistogramParameteriv( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetHistogramParameteriv( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetHistogramParameteriv( target, pname, params );
 }
 
-static void WINAPI glGetHistogramParameterivEXT( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetHistogramParameterivEXT( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetHistogramParameterivEXT( target, pname, params );
 }
 
-static void WINAPI glGetHistogramParameterxvOES( GLenum target, GLenum pname, GLfixed* params ) {
+static void WINAPI glGetHistogramParameterxvOES( GLenum target, GLenum pname, GLfixed *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetHistogramParameterxvOES( target, pname, params );
 }
 
-static GLuint64 WINAPI glGetImageHandleARB( GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format ) {
+static GLuint64 WINAPI glGetImageHandleARB( GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", texture, level, layered, layer, format );
+  TRACE( "(%d, %d, %d, %d, %d)\n", texture, level, layered, layer, format );
   return funcs->ext.p_glGetImageHandleARB( texture, level, layered, layer, format );
 }
 
-static GLuint64 WINAPI glGetImageHandleNV( GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format ) {
+static GLuint64 WINAPI glGetImageHandleNV( GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", texture, level, layered, layer, format );
+  TRACE( "(%d, %d, %d, %d, %d)\n", texture, level, layered, layer, format );
   return funcs->ext.p_glGetImageHandleNV( texture, level, layered, layer, format );
 }
 
-static void WINAPI glGetImageTransformParameterfvHP( GLenum target, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetImageTransformParameterfvHP( GLenum target, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetImageTransformParameterfvHP( target, pname, params );
 }
 
-static void WINAPI glGetImageTransformParameterivHP( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetImageTransformParameterivHP( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetImageTransformParameterivHP( target, pname, params );
 }
 
-static void WINAPI glGetInfoLogARB( GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB* infoLog ) {
+static void WINAPI glGetInfoLogARB( GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", obj, maxLength, length, infoLog );
+  TRACE( "(%d, %d, %p, %p)\n", obj, maxLength, length, infoLog );
   funcs->ext.p_glGetInfoLogARB( obj, maxLength, length, infoLog );
 }
 
-static GLint WINAPI glGetInstrumentsSGIX( void ) {
+static GLint WINAPI glGetInstrumentsSGIX(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  return funcs->ext.p_glGetInstrumentsSGIX( );
+  TRACE( "()\n" );
+  return funcs->ext.p_glGetInstrumentsSGIX();
 }
 
-static void WINAPI glGetInteger64i_v( GLenum target, GLuint index, GLint64* data ) {
+static void WINAPI glGetInteger64i_v( GLenum target, GLuint index, GLint64 *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, data );
+  TRACE( "(%d, %d, %p)\n", target, index, data );
   funcs->ext.p_glGetInteger64i_v( target, index, data );
 }
 
-static void WINAPI glGetInteger64v( GLenum pname, GLint64* data ) {
+static void WINAPI glGetInteger64v( GLenum pname, GLint64 *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, data );
+  TRACE( "(%d, %p)\n", pname, data );
   funcs->ext.p_glGetInteger64v( pname, data );
 }
 
-static void WINAPI glGetIntegerIndexedvEXT( GLenum target, GLuint index, GLint* data ) {
+static void WINAPI glGetIntegerIndexedvEXT( GLenum target, GLuint index, GLint *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, data );
+  TRACE( "(%d, %d, %p)\n", target, index, data );
   funcs->ext.p_glGetIntegerIndexedvEXT( target, index, data );
 }
 
-static void WINAPI glGetIntegeri_v( GLenum target, GLuint index, GLint* data ) {
+static void WINAPI glGetIntegeri_v( GLenum target, GLuint index, GLint *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, data );
+  TRACE( "(%d, %d, %p)\n", target, index, data );
   funcs->ext.p_glGetIntegeri_v( target, index, data );
 }
 
-static void WINAPI glGetIntegerui64i_vNV( GLenum value, GLuint index, GLuint64EXT* result ) {
+static void WINAPI glGetIntegerui64i_vNV( GLenum value, GLuint index, GLuint64EXT *result )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", value, index, result );
+  TRACE( "(%d, %d, %p)\n", value, index, result );
   funcs->ext.p_glGetIntegerui64i_vNV( value, index, result );
 }
 
-static void WINAPI glGetIntegerui64vNV( GLenum value, GLuint64EXT* result ) {
+static void WINAPI glGetIntegerui64vNV( GLenum value, GLuint64EXT *result )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", value, result );
+  TRACE( "(%d, %p)\n", value, result );
   funcs->ext.p_glGetIntegerui64vNV( value, result );
 }
 
-static void WINAPI glGetInternalformatSampleivNV( GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, GLsizei bufSize, GLint* params ) {
+static void WINAPI glGetInternalformatSampleivNV( GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, GLsizei bufSize, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, internalformat, samples, pname, bufSize, params );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", target, internalformat, samples, pname, bufSize, params );
   funcs->ext.p_glGetInternalformatSampleivNV( target, internalformat, samples, pname, bufSize, params );
 }
 
-static void WINAPI glGetInternalformati64v( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64* params ) {
+static void WINAPI glGetInternalformati64v( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", target, internalformat, pname, bufSize, params );
+  TRACE( "(%d, %d, %d, %d, %p)\n", target, internalformat, pname, bufSize, params );
   funcs->ext.p_glGetInternalformati64v( target, internalformat, pname, bufSize, params );
 }
 
-static void WINAPI glGetInternalformativ( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params ) {
+static void WINAPI glGetInternalformativ( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", target, internalformat, pname, bufSize, params );
+  TRACE( "(%d, %d, %d, %d, %p)\n", target, internalformat, pname, bufSize, params );
   funcs->ext.p_glGetInternalformativ( target, internalformat, pname, bufSize, params );
 }
 
-static void WINAPI glGetInvariantBooleanvEXT( GLuint id, GLenum value, GLboolean* data ) {
+static void WINAPI glGetInvariantBooleanvEXT( GLuint id, GLenum value, GLboolean *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, value, data );
+  TRACE( "(%d, %d, %p)\n", id, value, data );
   funcs->ext.p_glGetInvariantBooleanvEXT( id, value, data );
 }
 
-static void WINAPI glGetInvariantFloatvEXT( GLuint id, GLenum value, GLfloat* data ) {
+static void WINAPI glGetInvariantFloatvEXT( GLuint id, GLenum value, GLfloat *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, value, data );
+  TRACE( "(%d, %d, %p)\n", id, value, data );
   funcs->ext.p_glGetInvariantFloatvEXT( id, value, data );
 }
 
-static void WINAPI glGetInvariantIntegervEXT( GLuint id, GLenum value, GLint* data ) {
+static void WINAPI glGetInvariantIntegervEXT( GLuint id, GLenum value, GLint *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, value, data );
+  TRACE( "(%d, %d, %p)\n", id, value, data );
   funcs->ext.p_glGetInvariantIntegervEXT( id, value, data );
 }
 
-static void WINAPI glGetLightxOES( GLenum light, GLenum pname, GLfixed* params ) {
+static void WINAPI glGetLightxOES( GLenum light, GLenum pname, GLfixed *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", light, pname, params );
+  TRACE( "(%d, %d, %p)\n", light, pname, params );
   funcs->ext.p_glGetLightxOES( light, pname, params );
 }
 
-static void WINAPI glGetListParameterfvSGIX( GLuint list, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetListParameterfvSGIX( GLuint list, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", list, pname, params );
+  TRACE( "(%d, %d, %p)\n", list, pname, params );
   funcs->ext.p_glGetListParameterfvSGIX( list, pname, params );
 }
 
-static void WINAPI glGetListParameterivSGIX( GLuint list, GLenum pname, GLint* params ) {
+static void WINAPI glGetListParameterivSGIX( GLuint list, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", list, pname, params );
+  TRACE( "(%d, %d, %p)\n", list, pname, params );
   funcs->ext.p_glGetListParameterivSGIX( list, pname, params );
 }
 
-static void WINAPI glGetLocalConstantBooleanvEXT( GLuint id, GLenum value, GLboolean* data ) {
+static void WINAPI glGetLocalConstantBooleanvEXT( GLuint id, GLenum value, GLboolean *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, value, data );
+  TRACE( "(%d, %d, %p)\n", id, value, data );
   funcs->ext.p_glGetLocalConstantBooleanvEXT( id, value, data );
 }
 
-static void WINAPI glGetLocalConstantFloatvEXT( GLuint id, GLenum value, GLfloat* data ) {
+static void WINAPI glGetLocalConstantFloatvEXT( GLuint id, GLenum value, GLfloat *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, value, data );
+  TRACE( "(%d, %d, %p)\n", id, value, data );
   funcs->ext.p_glGetLocalConstantFloatvEXT( id, value, data );
 }
 
-static void WINAPI glGetLocalConstantIntegervEXT( GLuint id, GLenum value, GLint* data ) {
+static void WINAPI glGetLocalConstantIntegervEXT( GLuint id, GLenum value, GLint *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, value, data );
+  TRACE( "(%d, %d, %p)\n", id, value, data );
   funcs->ext.p_glGetLocalConstantIntegervEXT( id, value, data );
 }
 
-static void WINAPI glGetMapAttribParameterfvNV( GLenum target, GLuint index, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetMapAttribParameterfvNV( GLenum target, GLuint index, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, index, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", target, index, pname, params );
   funcs->ext.p_glGetMapAttribParameterfvNV( target, index, pname, params );
 }
 
-static void WINAPI glGetMapAttribParameterivNV( GLenum target, GLuint index, GLenum pname, GLint* params ) {
+static void WINAPI glGetMapAttribParameterivNV( GLenum target, GLuint index, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, index, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", target, index, pname, params );
   funcs->ext.p_glGetMapAttribParameterivNV( target, index, pname, params );
 }
 
-static void WINAPI glGetMapControlPointsNV( GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, void* points ) {
+static void WINAPI glGetMapControlPointsNV( GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, void *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, index, type, ustride, vstride, packed, points );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %p)\n", target, index, type, ustride, vstride, packed, points );
   funcs->ext.p_glGetMapControlPointsNV( target, index, type, ustride, vstride, packed, points );
 }
 
-static void WINAPI glGetMapParameterfvNV( GLenum target, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetMapParameterfvNV( GLenum target, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetMapParameterfvNV( target, pname, params );
 }
 
-static void WINAPI glGetMapParameterivNV( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetMapParameterivNV( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetMapParameterivNV( target, pname, params );
 }
 
-static void WINAPI glGetMapxvOES( GLenum target, GLenum query, GLfixed* v ) {
+static void WINAPI glGetMapxvOES( GLenum target, GLenum query, GLfixed *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, query, v );
+  TRACE( "(%d, %d, %p)\n", target, query, v );
   funcs->ext.p_glGetMapxvOES( target, query, v );
 }
 
-static void WINAPI glGetMaterialxOES( GLenum face, GLenum pname, GLfixed param ) {
+static void WINAPI glGetMaterialxOES( GLenum face, GLenum pname, GLfixed param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", face, pname, param );
+  TRACE( "(%d, %d, %d)\n", face, pname, param );
   funcs->ext.p_glGetMaterialxOES( face, pname, param );
 }
 
-static void WINAPI glGetMemoryObjectParameterivEXT( GLuint memoryObject, GLenum pname, GLint* params ) {
+static void WINAPI glGetMemoryObjectParameterivEXT( GLuint memoryObject, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", memoryObject, pname, params );
+  TRACE( "(%d, %d, %p)\n", memoryObject, pname, params );
   funcs->ext.p_glGetMemoryObjectParameterivEXT( memoryObject, pname, params );
 }
 
-static void WINAPI glGetMinmax( GLenum target, GLboolean reset, GLenum format, GLenum type, void* values ) {
+static void WINAPI glGetMinmax( GLenum target, GLboolean reset, GLenum format, GLenum type, void *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", target, reset, format, type, values );
+  TRACE( "(%d, %d, %d, %d, %p)\n", target, reset, format, type, values );
   funcs->ext.p_glGetMinmax( target, reset, format, type, values );
 }
 
-static void WINAPI glGetMinmaxEXT( GLenum target, GLboolean reset, GLenum format, GLenum type, void* values ) {
+static void WINAPI glGetMinmaxEXT( GLenum target, GLboolean reset, GLenum format, GLenum type, void *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", target, reset, format, type, values );
+  TRACE( "(%d, %d, %d, %d, %p)\n", target, reset, format, type, values );
   funcs->ext.p_glGetMinmaxEXT( target, reset, format, type, values );
 }
 
-static void WINAPI glGetMinmaxParameterfv( GLenum target, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetMinmaxParameterfv( GLenum target, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetMinmaxParameterfv( target, pname, params );
 }
 
-static void WINAPI glGetMinmaxParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetMinmaxParameterfvEXT( GLenum target, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetMinmaxParameterfvEXT( target, pname, params );
 }
 
-static void WINAPI glGetMinmaxParameteriv( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetMinmaxParameteriv( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetMinmaxParameteriv( target, pname, params );
 }
 
-static void WINAPI glGetMinmaxParameterivEXT( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetMinmaxParameterivEXT( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetMinmaxParameterivEXT( target, pname, params );
 }
 
-static void WINAPI glGetMultiTexEnvfvEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetMultiTexEnvfvEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, target, pname, params );
   funcs->ext.p_glGetMultiTexEnvfvEXT( texunit, target, pname, params );
 }
 
-static void WINAPI glGetMultiTexEnvivEXT( GLenum texunit, GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetMultiTexEnvivEXT( GLenum texunit, GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, target, pname, params );
   funcs->ext.p_glGetMultiTexEnvivEXT( texunit, target, pname, params );
 }
 
-static void WINAPI glGetMultiTexGendvEXT( GLenum texunit, GLenum coord, GLenum pname, GLdouble* params ) {
+static void WINAPI glGetMultiTexGendvEXT( GLenum texunit, GLenum coord, GLenum pname, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, coord, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, coord, pname, params );
   funcs->ext.p_glGetMultiTexGendvEXT( texunit, coord, pname, params );
 }
 
-static void WINAPI glGetMultiTexGenfvEXT( GLenum texunit, GLenum coord, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetMultiTexGenfvEXT( GLenum texunit, GLenum coord, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, coord, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, coord, pname, params );
   funcs->ext.p_glGetMultiTexGenfvEXT( texunit, coord, pname, params );
 }
 
-static void WINAPI glGetMultiTexGenivEXT( GLenum texunit, GLenum coord, GLenum pname, GLint* params ) {
+static void WINAPI glGetMultiTexGenivEXT( GLenum texunit, GLenum coord, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, coord, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, coord, pname, params );
   funcs->ext.p_glGetMultiTexGenivEXT( texunit, coord, pname, params );
 }
 
-static void WINAPI glGetMultiTexImageEXT( GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void* pixels ) {
+static void WINAPI glGetMultiTexImageEXT( GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", texunit, target, level, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", texunit, target, level, format, type, pixels );
   funcs->ext.p_glGetMultiTexImageEXT( texunit, target, level, format, type, pixels );
 }
 
-static void WINAPI glGetMultiTexLevelParameterfvEXT( GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetMultiTexLevelParameterfvEXT( GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", texunit, target, level, pname, params );
+  TRACE( "(%d, %d, %d, %d, %p)\n", texunit, target, level, pname, params );
   funcs->ext.p_glGetMultiTexLevelParameterfvEXT( texunit, target, level, pname, params );
 }
 
-static void WINAPI glGetMultiTexLevelParameterivEXT( GLenum texunit, GLenum target, GLint level, GLenum pname, GLint* params ) {
+static void WINAPI glGetMultiTexLevelParameterivEXT( GLenum texunit, GLenum target, GLint level, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", texunit, target, level, pname, params );
+  TRACE( "(%d, %d, %d, %d, %p)\n", texunit, target, level, pname, params );
   funcs->ext.p_glGetMultiTexLevelParameterivEXT( texunit, target, level, pname, params );
 }
 
-static void WINAPI glGetMultiTexParameterIivEXT( GLenum texunit, GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetMultiTexParameterIivEXT( GLenum texunit, GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, target, pname, params );
   funcs->ext.p_glGetMultiTexParameterIivEXT( texunit, target, pname, params );
 }
 
-static void WINAPI glGetMultiTexParameterIuivEXT( GLenum texunit, GLenum target, GLenum pname, GLuint* params ) {
+static void WINAPI glGetMultiTexParameterIuivEXT( GLenum texunit, GLenum target, GLenum pname, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, target, pname, params );
   funcs->ext.p_glGetMultiTexParameterIuivEXT( texunit, target, pname, params );
 }
 
-static void WINAPI glGetMultiTexParameterfvEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetMultiTexParameterfvEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, target, pname, params );
   funcs->ext.p_glGetMultiTexParameterfvEXT( texunit, target, pname, params );
 }
 
-static void WINAPI glGetMultiTexParameterivEXT( GLenum texunit, GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetMultiTexParameterivEXT( GLenum texunit, GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, target, pname, params );
   funcs->ext.p_glGetMultiTexParameterivEXT( texunit, target, pname, params );
 }
 
-static void WINAPI glGetMultisamplefv( GLenum pname, GLuint index, GLfloat* val ) {
+static void WINAPI glGetMultisamplefv( GLenum pname, GLuint index, GLfloat *val )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", pname, index, val );
+  TRACE( "(%d, %d, %p)\n", pname, index, val );
   funcs->ext.p_glGetMultisamplefv( pname, index, val );
 }
 
-static void WINAPI glGetMultisamplefvNV( GLenum pname, GLuint index, GLfloat* val ) {
+static void WINAPI glGetMultisamplefvNV( GLenum pname, GLuint index, GLfloat *val )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", pname, index, val );
+  TRACE( "(%d, %d, %p)\n", pname, index, val );
   funcs->ext.p_glGetMultisamplefvNV( pname, index, val );
 }
 
-static void WINAPI glGetNamedBufferParameteri64v( GLuint buffer, GLenum pname, GLint64* params ) {
+static void WINAPI glGetNamedBufferParameteri64v( GLuint buffer, GLenum pname, GLint64 *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", buffer, pname, params );
+  TRACE( "(%d, %d, %p)\n", buffer, pname, params );
   funcs->ext.p_glGetNamedBufferParameteri64v( buffer, pname, params );
 }
 
-static void WINAPI glGetNamedBufferParameteriv( GLuint buffer, GLenum pname, GLint* params ) {
+static void WINAPI glGetNamedBufferParameteriv( GLuint buffer, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", buffer, pname, params );
+  TRACE( "(%d, %d, %p)\n", buffer, pname, params );
   funcs->ext.p_glGetNamedBufferParameteriv( buffer, pname, params );
 }
 
-static void WINAPI glGetNamedBufferParameterivEXT( GLuint buffer, GLenum pname, GLint* params ) {
+static void WINAPI glGetNamedBufferParameterivEXT( GLuint buffer, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", buffer, pname, params );
+  TRACE( "(%d, %d, %p)\n", buffer, pname, params );
   funcs->ext.p_glGetNamedBufferParameterivEXT( buffer, pname, params );
 }
 
-static void WINAPI glGetNamedBufferParameterui64vNV( GLuint buffer, GLenum pname, GLuint64EXT* params ) {
+static void WINAPI glGetNamedBufferParameterui64vNV( GLuint buffer, GLenum pname, GLuint64EXT *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", buffer, pname, params );
+  TRACE( "(%d, %d, %p)\n", buffer, pname, params );
   funcs->ext.p_glGetNamedBufferParameterui64vNV( buffer, pname, params );
 }
 
-static void WINAPI glGetNamedBufferPointerv( GLuint buffer, GLenum pname, void** params ) {
+static void WINAPI glGetNamedBufferPointerv( GLuint buffer, GLenum pname, void **params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", buffer, pname, params );
+  TRACE( "(%d, %d, %p)\n", buffer, pname, params );
   funcs->ext.p_glGetNamedBufferPointerv( buffer, pname, params );
 }
 
-static void WINAPI glGetNamedBufferPointervEXT( GLuint buffer, GLenum pname, void** params ) {
+static void WINAPI glGetNamedBufferPointervEXT( GLuint buffer, GLenum pname, void **params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", buffer, pname, params );
+  TRACE( "(%d, %d, %p)\n", buffer, pname, params );
   funcs->ext.p_glGetNamedBufferPointervEXT( buffer, pname, params );
 }
 
-static void WINAPI glGetNamedBufferSubData( GLuint buffer, GLintptr offset, GLsizeiptr size, void* data ) {
+static void WINAPI glGetNamedBufferSubData( GLuint buffer, GLintptr offset, GLsizeiptr size, void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld, %p)\n", buffer, offset, size, data );
+  TRACE( "(%d, %ld, %ld, %p)\n", buffer, offset, size, data );
   funcs->ext.p_glGetNamedBufferSubData( buffer, offset, size, data );
 }
 
-static void WINAPI glGetNamedBufferSubDataEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, void* data ) {
+static void WINAPI glGetNamedBufferSubDataEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld, %p)\n", buffer, offset, size, data );
+  TRACE( "(%d, %ld, %ld, %p)\n", buffer, offset, size, data );
   funcs->ext.p_glGetNamedBufferSubDataEXT( buffer, offset, size, data );
 }
 
-static void WINAPI glGetNamedFramebufferAttachmentParameteriv( GLuint framebuffer, GLenum attachment, GLenum pname, GLint* params ) {
+static void WINAPI glGetNamedFramebufferAttachmentParameteriv( GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", framebuffer, attachment, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", framebuffer, attachment, pname, params );
   funcs->ext.p_glGetNamedFramebufferAttachmentParameteriv( framebuffer, attachment, pname, params );
 }
 
-static void WINAPI glGetNamedFramebufferAttachmentParameterivEXT( GLuint framebuffer, GLenum attachment, GLenum pname, GLint* params ) {
+static void WINAPI glGetNamedFramebufferAttachmentParameterivEXT( GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", framebuffer, attachment, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", framebuffer, attachment, pname, params );
   funcs->ext.p_glGetNamedFramebufferAttachmentParameterivEXT( framebuffer, attachment, pname, params );
 }
 
-static void WINAPI glGetNamedFramebufferParameterfvAMD( GLuint framebuffer, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, GLfloat* values ) {
+static void WINAPI glGetNamedFramebufferParameterfvAMD( GLuint framebuffer, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, GLfloat *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", framebuffer, pname, numsamples, pixelindex, size, values );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", framebuffer, pname, numsamples, pixelindex, size, values );
   funcs->ext.p_glGetNamedFramebufferParameterfvAMD( framebuffer, pname, numsamples, pixelindex, size, values );
 }
 
-static void WINAPI glGetNamedFramebufferParameteriv( GLuint framebuffer, GLenum pname, GLint* param ) {
+static void WINAPI glGetNamedFramebufferParameteriv( GLuint framebuffer, GLenum pname, GLint *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", framebuffer, pname, param );
+  TRACE( "(%d, %d, %p)\n", framebuffer, pname, param );
   funcs->ext.p_glGetNamedFramebufferParameteriv( framebuffer, pname, param );
 }
 
-static void WINAPI glGetNamedFramebufferParameterivEXT( GLuint framebuffer, GLenum pname, GLint* params ) {
+static void WINAPI glGetNamedFramebufferParameterivEXT( GLuint framebuffer, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", framebuffer, pname, params );
+  TRACE( "(%d, %d, %p)\n", framebuffer, pname, params );
   funcs->ext.p_glGetNamedFramebufferParameterivEXT( framebuffer, pname, params );
 }
 
-static void WINAPI glGetNamedProgramLocalParameterIivEXT( GLuint program, GLenum target, GLuint index, GLint* params ) {
+static void WINAPI glGetNamedProgramLocalParameterIivEXT( GLuint program, GLenum target, GLuint index, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, target, index, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, target, index, params );
   funcs->ext.p_glGetNamedProgramLocalParameterIivEXT( program, target, index, params );
 }
 
-static void WINAPI glGetNamedProgramLocalParameterIuivEXT( GLuint program, GLenum target, GLuint index, GLuint* params ) {
+static void WINAPI glGetNamedProgramLocalParameterIuivEXT( GLuint program, GLenum target, GLuint index, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, target, index, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, target, index, params );
   funcs->ext.p_glGetNamedProgramLocalParameterIuivEXT( program, target, index, params );
 }
 
-static void WINAPI glGetNamedProgramLocalParameterdvEXT( GLuint program, GLenum target, GLuint index, GLdouble* params ) {
+static void WINAPI glGetNamedProgramLocalParameterdvEXT( GLuint program, GLenum target, GLuint index, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, target, index, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, target, index, params );
   funcs->ext.p_glGetNamedProgramLocalParameterdvEXT( program, target, index, params );
 }
 
-static void WINAPI glGetNamedProgramLocalParameterfvEXT( GLuint program, GLenum target, GLuint index, GLfloat* params ) {
+static void WINAPI glGetNamedProgramLocalParameterfvEXT( GLuint program, GLenum target, GLuint index, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, target, index, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, target, index, params );
   funcs->ext.p_glGetNamedProgramLocalParameterfvEXT( program, target, index, params );
 }
 
-static void WINAPI glGetNamedProgramStringEXT( GLuint program, GLenum target, GLenum pname, void* string ) {
+static void WINAPI glGetNamedProgramStringEXT( GLuint program, GLenum target, GLenum pname, void *string )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, target, pname, string );
+  TRACE( "(%d, %d, %d, %p)\n", program, target, pname, string );
   funcs->ext.p_glGetNamedProgramStringEXT( program, target, pname, string );
 }
 
-static void WINAPI glGetNamedProgramivEXT( GLuint program, GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetNamedProgramivEXT( GLuint program, GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, target, pname, params );
   funcs->ext.p_glGetNamedProgramivEXT( program, target, pname, params );
 }
 
-static void WINAPI glGetNamedRenderbufferParameteriv( GLuint renderbuffer, GLenum pname, GLint* params ) {
+static void WINAPI glGetNamedRenderbufferParameteriv( GLuint renderbuffer, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", renderbuffer, pname, params );
+  TRACE( "(%d, %d, %p)\n", renderbuffer, pname, params );
   funcs->ext.p_glGetNamedRenderbufferParameteriv( renderbuffer, pname, params );
 }
 
-static void WINAPI glGetNamedRenderbufferParameterivEXT( GLuint renderbuffer, GLenum pname, GLint* params ) {
+static void WINAPI glGetNamedRenderbufferParameterivEXT( GLuint renderbuffer, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", renderbuffer, pname, params );
+  TRACE( "(%d, %d, %p)\n", renderbuffer, pname, params );
   funcs->ext.p_glGetNamedRenderbufferParameterivEXT( renderbuffer, pname, params );
 }
 
-static void WINAPI glGetNamedStringARB( GLint namelen, const GLchar* name, GLsizei bufSize, GLint* stringlen, GLchar* string ) {
+static void WINAPI glGetNamedStringARB( GLint namelen, const GLchar *name, GLsizei bufSize, GLint *stringlen, GLchar *string )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %d, %p, %p)\n", namelen, name, bufSize, stringlen, string );
+  TRACE( "(%d, %p, %d, %p, %p)\n", namelen, name, bufSize, stringlen, string );
   funcs->ext.p_glGetNamedStringARB( namelen, name, bufSize, stringlen, string );
 }
 
-static void WINAPI glGetNamedStringivARB( GLint namelen, const GLchar* name, GLenum pname, GLint* params ) {
+static void WINAPI glGetNamedStringivARB( GLint namelen, const GLchar *name, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %d, %p)\n", namelen, name, pname, params );
+  TRACE( "(%d, %p, %d, %p)\n", namelen, name, pname, params );
   funcs->ext.p_glGetNamedStringivARB( namelen, name, pname, params );
 }
 
-static void WINAPI glGetNextPerfQueryIdINTEL( GLuint queryId, GLuint* nextQueryId ) {
+static void WINAPI glGetNextPerfQueryIdINTEL( GLuint queryId, GLuint *nextQueryId )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", queryId, nextQueryId );
+  TRACE( "(%d, %p)\n", queryId, nextQueryId );
   funcs->ext.p_glGetNextPerfQueryIdINTEL( queryId, nextQueryId );
 }
 
-static void WINAPI glGetObjectBufferfvATI( GLuint buffer, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetObjectBufferfvATI( GLuint buffer, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", buffer, pname, params );
+  TRACE( "(%d, %d, %p)\n", buffer, pname, params );
   funcs->ext.p_glGetObjectBufferfvATI( buffer, pname, params );
 }
 
-static void WINAPI glGetObjectBufferivATI( GLuint buffer, GLenum pname, GLint* params ) {
+static void WINAPI glGetObjectBufferivATI( GLuint buffer, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", buffer, pname, params );
+  TRACE( "(%d, %d, %p)\n", buffer, pname, params );
   funcs->ext.p_glGetObjectBufferivATI( buffer, pname, params );
 }
 
-static void WINAPI glGetObjectLabel( GLenum identifier, GLuint name, GLsizei bufSize, GLsizei* length, GLchar* label ) {
+static void WINAPI glGetObjectLabel( GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p)\n", identifier, name, bufSize, length, label );
+  TRACE( "(%d, %d, %d, %p, %p)\n", identifier, name, bufSize, length, label );
   funcs->ext.p_glGetObjectLabel( identifier, name, bufSize, length, label );
 }
 
-static void WINAPI glGetObjectLabelEXT( GLenum type, GLuint object, GLsizei bufSize, GLsizei* length, GLchar* label ) {
+static void WINAPI glGetObjectLabelEXT( GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p)\n", type, object, bufSize, length, label );
+  TRACE( "(%d, %d, %d, %p, %p)\n", type, object, bufSize, length, label );
   funcs->ext.p_glGetObjectLabelEXT( type, object, bufSize, length, label );
 }
 
-static void WINAPI glGetObjectParameterfvARB( GLhandleARB obj, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetObjectParameterfvARB( GLhandleARB obj, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", obj, pname, params );
+  TRACE( "(%d, %d, %p)\n", obj, pname, params );
   funcs->ext.p_glGetObjectParameterfvARB( obj, pname, params );
 }
 
-static void WINAPI glGetObjectParameterivAPPLE( GLenum objectType, GLuint name, GLenum pname, GLint* params ) {
+static void WINAPI glGetObjectParameterivAPPLE( GLenum objectType, GLuint name, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", objectType, name, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", objectType, name, pname, params );
   funcs->ext.p_glGetObjectParameterivAPPLE( objectType, name, pname, params );
 }
 
-static void WINAPI glGetObjectParameterivARB( GLhandleARB obj, GLenum pname, GLint* params ) {
+static void WINAPI glGetObjectParameterivARB( GLhandleARB obj, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", obj, pname, params );
+  TRACE( "(%d, %d, %p)\n", obj, pname, params );
   funcs->ext.p_glGetObjectParameterivARB( obj, pname, params );
 }
 
-static void WINAPI glGetObjectPtrLabel( const void* ptr, GLsizei bufSize, GLsizei* length, GLchar* label ) {
+static void WINAPI glGetObjectPtrLabel( const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %d, %p, %p)\n", ptr, bufSize, length, label );
+  TRACE( "(%p, %d, %p, %p)\n", ptr, bufSize, length, label );
   funcs->ext.p_glGetObjectPtrLabel( ptr, bufSize, length, label );
 }
 
-static void WINAPI glGetOcclusionQueryivNV( GLuint id, GLenum pname, GLint* params ) {
+static void WINAPI glGetOcclusionQueryivNV( GLuint id, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, pname, params );
+  TRACE( "(%d, %d, %p)\n", id, pname, params );
   funcs->ext.p_glGetOcclusionQueryivNV( id, pname, params );
 }
 
-static void WINAPI glGetOcclusionQueryuivNV( GLuint id, GLenum pname, GLuint* params ) {
+static void WINAPI glGetOcclusionQueryuivNV( GLuint id, GLenum pname, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, pname, params );
+  TRACE( "(%d, %d, %p)\n", id, pname, params );
   funcs->ext.p_glGetOcclusionQueryuivNV( id, pname, params );
 }
 
-static void WINAPI glGetPathColorGenfvNV( GLenum color, GLenum pname, GLfloat* value ) {
+static void WINAPI glGetPathColorGenfvNV( GLenum color, GLenum pname, GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", color, pname, value );
+  TRACE( "(%d, %d, %p)\n", color, pname, value );
   funcs->ext.p_glGetPathColorGenfvNV( color, pname, value );
 }
 
-static void WINAPI glGetPathColorGenivNV( GLenum color, GLenum pname, GLint* value ) {
+static void WINAPI glGetPathColorGenivNV( GLenum color, GLenum pname, GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", color, pname, value );
+  TRACE( "(%d, %d, %p)\n", color, pname, value );
   funcs->ext.p_glGetPathColorGenivNV( color, pname, value );
 }
 
-static void WINAPI glGetPathCommandsNV( GLuint path, GLubyte* commands ) {
+static void WINAPI glGetPathCommandsNV( GLuint path, GLubyte *commands )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", path, commands );
+  TRACE( "(%d, %p)\n", path, commands );
   funcs->ext.p_glGetPathCommandsNV( path, commands );
 }
 
-static void WINAPI glGetPathCoordsNV( GLuint path, GLfloat* coords ) {
+static void WINAPI glGetPathCoordsNV( GLuint path, GLfloat *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", path, coords );
+  TRACE( "(%d, %p)\n", path, coords );
   funcs->ext.p_glGetPathCoordsNV( path, coords );
 }
 
-static void WINAPI glGetPathDashArrayNV( GLuint path, GLfloat* dashArray ) {
+static void WINAPI glGetPathDashArrayNV( GLuint path, GLfloat *dashArray )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", path, dashArray );
+  TRACE( "(%d, %p)\n", path, dashArray );
   funcs->ext.p_glGetPathDashArrayNV( path, dashArray );
 }
 
-static GLfloat WINAPI glGetPathLengthNV( GLuint path, GLsizei startSegment, GLsizei numSegments ) {
+static GLfloat WINAPI glGetPathLengthNV( GLuint path, GLsizei startSegment, GLsizei numSegments )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", path, startSegment, numSegments );
+  TRACE( "(%d, %d, %d)\n", path, startSegment, numSegments );
   return funcs->ext.p_glGetPathLengthNV( path, startSegment, numSegments );
 }
 
-static void WINAPI glGetPathMetricRangeNV( GLbitfield metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat* metrics ) {
+static void WINAPI glGetPathMetricRangeNV( GLbitfield metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat *metrics )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", metricQueryMask, firstPathName, numPaths, stride, metrics );
+  TRACE( "(%d, %d, %d, %d, %p)\n", metricQueryMask, firstPathName, numPaths, stride, metrics );
   funcs->ext.p_glGetPathMetricRangeNV( metricQueryMask, firstPathName, numPaths, stride, metrics );
 }
 
-static void WINAPI glGetPathMetricsNV( GLbitfield metricQueryMask, GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLsizei stride, GLfloat* metrics ) {
+static void WINAPI glGetPathMetricsNV( GLbitfield metricQueryMask, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLsizei stride, GLfloat *metrics )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %d, %d, %p)\n", metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics );
+  TRACE( "(%d, %d, %d, %p, %d, %d, %p)\n", metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics );
   funcs->ext.p_glGetPathMetricsNV( metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics );
 }
 
-static void WINAPI glGetPathParameterfvNV( GLuint path, GLenum pname, GLfloat* value ) {
+static void WINAPI glGetPathParameterfvNV( GLuint path, GLenum pname, GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", path, pname, value );
+  TRACE( "(%d, %d, %p)\n", path, pname, value );
   funcs->ext.p_glGetPathParameterfvNV( path, pname, value );
 }
 
-static void WINAPI glGetPathParameterivNV( GLuint path, GLenum pname, GLint* value ) {
+static void WINAPI glGetPathParameterivNV( GLuint path, GLenum pname, GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", path, pname, value );
+  TRACE( "(%d, %d, %p)\n", path, pname, value );
   funcs->ext.p_glGetPathParameterivNV( path, pname, value );
 }
 
-static void WINAPI glGetPathSpacingNV( GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, GLfloat* returnedSpacing ) {
+static void WINAPI glGetPathSpacingNV( GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, GLfloat *returnedSpacing )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %d, %f, %f, %d, %p)\n", pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing );
+  TRACE( "(%d, %d, %d, %p, %d, %f, %f, %d, %p)\n", pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing );
   funcs->ext.p_glGetPathSpacingNV( pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing );
 }
 
-static void WINAPI glGetPathTexGenfvNV( GLenum texCoordSet, GLenum pname, GLfloat* value ) {
+static void WINAPI glGetPathTexGenfvNV( GLenum texCoordSet, GLenum pname, GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", texCoordSet, pname, value );
+  TRACE( "(%d, %d, %p)\n", texCoordSet, pname, value );
   funcs->ext.p_glGetPathTexGenfvNV( texCoordSet, pname, value );
 }
 
-static void WINAPI glGetPathTexGenivNV( GLenum texCoordSet, GLenum pname, GLint* value ) {
+static void WINAPI glGetPathTexGenivNV( GLenum texCoordSet, GLenum pname, GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", texCoordSet, pname, value );
+  TRACE( "(%d, %d, %p)\n", texCoordSet, pname, value );
   funcs->ext.p_glGetPathTexGenivNV( texCoordSet, pname, value );
 }
 
-static void WINAPI glGetPerfCounterInfoINTEL( GLuint queryId, GLuint counterId, GLuint counterNameLength, GLchar* counterName, GLuint counterDescLength, GLchar* counterDesc, GLuint* counterOffset, GLuint* counterDataSize, GLuint* counterTypeEnum, GLuint* counterDataTypeEnum, GLuint64* rawCounterMaxValue ) {
+static void WINAPI glGetPerfCounterInfoINTEL( GLuint queryId, GLuint counterId, GLuint counterNameLength, GLchar *counterName, GLuint counterDescLength, GLchar *counterDesc, GLuint *counterOffset, GLuint *counterDataSize, GLuint *counterTypeEnum, GLuint *counterDataTypeEnum, GLuint64 *rawCounterMaxValue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %d, %p, %p, %p, %p, %p, %p)\n", queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue );
+  TRACE( "(%d, %d, %d, %p, %d, %p, %p, %p, %p, %p, %p)\n", queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue );
   funcs->ext.p_glGetPerfCounterInfoINTEL( queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue );
 }
 
-static void WINAPI glGetPerfMonitorCounterDataAMD( GLuint monitor, GLenum pname, GLsizei dataSize, GLuint* data, GLint* bytesWritten ) {
+static void WINAPI glGetPerfMonitorCounterDataAMD( GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p)\n", monitor, pname, dataSize, data, bytesWritten );
+  TRACE( "(%d, %d, %d, %p, %p)\n", monitor, pname, dataSize, data, bytesWritten );
   funcs->ext.p_glGetPerfMonitorCounterDataAMD( monitor, pname, dataSize, data, bytesWritten );
 }
 
-static void WINAPI glGetPerfMonitorCounterInfoAMD( GLuint group, GLuint counter, GLenum pname, void* data ) {
+static void WINAPI glGetPerfMonitorCounterInfoAMD( GLuint group, GLuint counter, GLenum pname, void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", group, counter, pname, data );
+  TRACE( "(%d, %d, %d, %p)\n", group, counter, pname, data );
   funcs->ext.p_glGetPerfMonitorCounterInfoAMD( group, counter, pname, data );
 }
 
-static void WINAPI glGetPerfMonitorCounterStringAMD( GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, GLchar* counterString ) {
+static void WINAPI glGetPerfMonitorCounterStringAMD( GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p)\n", group, counter, bufSize, length, counterString );
+  TRACE( "(%d, %d, %d, %p, %p)\n", group, counter, bufSize, length, counterString );
   funcs->ext.p_glGetPerfMonitorCounterStringAMD( group, counter, bufSize, length, counterString );
 }
 
-static void WINAPI glGetPerfMonitorCountersAMD( GLuint group, GLint* numCounters, GLint* maxActiveCounters, GLsizei counterSize, GLuint* counters ) {
+static void WINAPI glGetPerfMonitorCountersAMD( GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %p, %d, %p)\n", group, numCounters, maxActiveCounters, counterSize, counters );
+  TRACE( "(%d, %p, %p, %d, %p)\n", group, numCounters, maxActiveCounters, counterSize, counters );
   funcs->ext.p_glGetPerfMonitorCountersAMD( group, numCounters, maxActiveCounters, counterSize, counters );
 }
 
-static void WINAPI glGetPerfMonitorGroupStringAMD( GLuint group, GLsizei bufSize, GLsizei* length, GLchar* groupString ) {
+static void WINAPI glGetPerfMonitorGroupStringAMD( GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", group, bufSize, length, groupString );
+  TRACE( "(%d, %d, %p, %p)\n", group, bufSize, length, groupString );
   funcs->ext.p_glGetPerfMonitorGroupStringAMD( group, bufSize, length, groupString );
 }
 
-static void WINAPI glGetPerfMonitorGroupsAMD( GLint* numGroups, GLsizei groupsSize, GLuint* groups ) {
+static void WINAPI glGetPerfMonitorGroupsAMD( GLint *numGroups, GLsizei groupsSize, GLuint *groups )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %d, %p)\n", numGroups, groupsSize, groups );
+  TRACE( "(%p, %d, %p)\n", numGroups, groupsSize, groups );
   funcs->ext.p_glGetPerfMonitorGroupsAMD( numGroups, groupsSize, groups );
 }
 
-static void WINAPI glGetPerfQueryDataINTEL( GLuint queryHandle, GLuint flags, GLsizei dataSize, GLvoid* data, GLuint* bytesWritten ) {
+static void WINAPI glGetPerfQueryDataINTEL( GLuint queryHandle, GLuint flags, GLsizei dataSize, GLvoid *data, GLuint *bytesWritten )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p)\n", queryHandle, flags, dataSize, data, bytesWritten );
+  TRACE( "(%d, %d, %d, %p, %p)\n", queryHandle, flags, dataSize, data, bytesWritten );
   funcs->ext.p_glGetPerfQueryDataINTEL( queryHandle, flags, dataSize, data, bytesWritten );
 }
 
-static void WINAPI glGetPerfQueryIdByNameINTEL( GLchar* queryName, GLuint* queryId ) {
+static void WINAPI glGetPerfQueryIdByNameINTEL( GLchar *queryName, GLuint *queryId )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", queryName, queryId );
+  TRACE( "(%p, %p)\n", queryName, queryId );
   funcs->ext.p_glGetPerfQueryIdByNameINTEL( queryName, queryId );
 }
 
-static void WINAPI glGetPerfQueryInfoINTEL( GLuint queryId, GLuint queryNameLength, GLchar* queryName, GLuint* dataSize, GLuint* noCounters, GLuint* noInstances, GLuint* capsMask ) {
+static void WINAPI glGetPerfQueryInfoINTEL( GLuint queryId, GLuint queryNameLength, GLchar *queryName, GLuint *dataSize, GLuint *noCounters, GLuint *noInstances, GLuint *capsMask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p, %p, %p, %p)\n", queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask );
+  TRACE( "(%d, %d, %p, %p, %p, %p, %p)\n", queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask );
   funcs->ext.p_glGetPerfQueryInfoINTEL( queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask );
 }
 
-static void WINAPI glGetPixelMapxv( GLenum map, GLint size, GLfixed* values ) {
+static void WINAPI glGetPixelMapxv( GLenum map, GLint size, GLfixed *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", map, size, values );
+  TRACE( "(%d, %d, %p)\n", map, size, values );
   funcs->ext.p_glGetPixelMapxv( map, size, values );
 }
 
-static void WINAPI glGetPixelTexGenParameterfvSGIS( GLenum pname, GLfloat* params ) {
+static void WINAPI glGetPixelTexGenParameterfvSGIS( GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glGetPixelTexGenParameterfvSGIS( pname, params );
 }
 
-static void WINAPI glGetPixelTexGenParameterivSGIS( GLenum pname, GLint* params ) {
+static void WINAPI glGetPixelTexGenParameterivSGIS( GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glGetPixelTexGenParameterivSGIS( pname, params );
 }
 
-static void WINAPI glGetPixelTransformParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetPixelTransformParameterfvEXT( GLenum target, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetPixelTransformParameterfvEXT( target, pname, params );
 }
 
-static void WINAPI glGetPixelTransformParameterivEXT( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetPixelTransformParameterivEXT( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetPixelTransformParameterivEXT( target, pname, params );
 }
 
-static void WINAPI glGetPointerIndexedvEXT( GLenum target, GLuint index, void** data ) {
+static void WINAPI glGetPointerIndexedvEXT( GLenum target, GLuint index, void **data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, data );
+  TRACE( "(%d, %d, %p)\n", target, index, data );
   funcs->ext.p_glGetPointerIndexedvEXT( target, index, data );
 }
 
-static void WINAPI glGetPointeri_vEXT( GLenum pname, GLuint index, void** params ) {
+static void WINAPI glGetPointeri_vEXT( GLenum pname, GLuint index, void **params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", pname, index, params );
+  TRACE( "(%d, %d, %p)\n", pname, index, params );
   funcs->ext.p_glGetPointeri_vEXT( pname, index, params );
 }
 
-static void WINAPI glGetPointervEXT( GLenum pname, void** params ) {
+static void WINAPI glGetPointervEXT( GLenum pname, void **params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glGetPointervEXT( pname, params );
 }
 
-static void WINAPI glGetProgramBinary( GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, void* binary ) {
+static void WINAPI glGetProgramBinary( GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p, %p)\n", program, bufSize, length, binaryFormat, binary );
+  TRACE( "(%d, %d, %p, %p, %p)\n", program, bufSize, length, binaryFormat, binary );
   funcs->ext.p_glGetProgramBinary( program, bufSize, length, binaryFormat, binary );
 }
 
-static void WINAPI glGetProgramEnvParameterIivNV( GLenum target, GLuint index, GLint* params ) {
+static void WINAPI glGetProgramEnvParameterIivNV( GLenum target, GLuint index, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, params );
+  TRACE( "(%d, %d, %p)\n", target, index, params );
   funcs->ext.p_glGetProgramEnvParameterIivNV( target, index, params );
 }
 
-static void WINAPI glGetProgramEnvParameterIuivNV( GLenum target, GLuint index, GLuint* params ) {
+static void WINAPI glGetProgramEnvParameterIuivNV( GLenum target, GLuint index, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, params );
+  TRACE( "(%d, %d, %p)\n", target, index, params );
   funcs->ext.p_glGetProgramEnvParameterIuivNV( target, index, params );
 }
 
-static void WINAPI glGetProgramEnvParameterdvARB( GLenum target, GLuint index, GLdouble* params ) {
+static void WINAPI glGetProgramEnvParameterdvARB( GLenum target, GLuint index, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, params );
+  TRACE( "(%d, %d, %p)\n", target, index, params );
   funcs->ext.p_glGetProgramEnvParameterdvARB( target, index, params );
 }
 
-static void WINAPI glGetProgramEnvParameterfvARB( GLenum target, GLuint index, GLfloat* params ) {
+static void WINAPI glGetProgramEnvParameterfvARB( GLenum target, GLuint index, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, params );
+  TRACE( "(%d, %d, %p)\n", target, index, params );
   funcs->ext.p_glGetProgramEnvParameterfvARB( target, index, params );
 }
 
-static void WINAPI glGetProgramInfoLog( GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog ) {
+static void WINAPI glGetProgramInfoLog( GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", program, bufSize, length, infoLog );
+  TRACE( "(%d, %d, %p, %p)\n", program, bufSize, length, infoLog );
   funcs->ext.p_glGetProgramInfoLog( program, bufSize, length, infoLog );
 }
 
-static void WINAPI glGetProgramInterfaceiv( GLuint program, GLenum programInterface, GLenum pname, GLint* params ) {
+static void WINAPI glGetProgramInterfaceiv( GLuint program, GLenum programInterface, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, programInterface, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, programInterface, pname, params );
   funcs->ext.p_glGetProgramInterfaceiv( program, programInterface, pname, params );
 }
 
-static void WINAPI glGetProgramLocalParameterIivNV( GLenum target, GLuint index, GLint* params ) {
+static void WINAPI glGetProgramLocalParameterIivNV( GLenum target, GLuint index, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, params );
+  TRACE( "(%d, %d, %p)\n", target, index, params );
   funcs->ext.p_glGetProgramLocalParameterIivNV( target, index, params );
 }
 
-static void WINAPI glGetProgramLocalParameterIuivNV( GLenum target, GLuint index, GLuint* params ) {
+static void WINAPI glGetProgramLocalParameterIuivNV( GLenum target, GLuint index, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, params );
+  TRACE( "(%d, %d, %p)\n", target, index, params );
   funcs->ext.p_glGetProgramLocalParameterIuivNV( target, index, params );
 }
 
-static void WINAPI glGetProgramLocalParameterdvARB( GLenum target, GLuint index, GLdouble* params ) {
+static void WINAPI glGetProgramLocalParameterdvARB( GLenum target, GLuint index, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, params );
+  TRACE( "(%d, %d, %p)\n", target, index, params );
   funcs->ext.p_glGetProgramLocalParameterdvARB( target, index, params );
 }
 
-static void WINAPI glGetProgramLocalParameterfvARB( GLenum target, GLuint index, GLfloat* params ) {
+static void WINAPI glGetProgramLocalParameterfvARB( GLenum target, GLuint index, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, params );
+  TRACE( "(%d, %d, %p)\n", target, index, params );
   funcs->ext.p_glGetProgramLocalParameterfvARB( target, index, params );
 }
 
-static void WINAPI glGetProgramNamedParameterdvNV( GLuint id, GLsizei len, const GLubyte* name, GLdouble* params ) {
+static void WINAPI glGetProgramNamedParameterdvNV( GLuint id, GLsizei len, const GLubyte *name, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", id, len, name, params );
+  TRACE( "(%d, %d, %p, %p)\n", id, len, name, params );
   funcs->ext.p_glGetProgramNamedParameterdvNV( id, len, name, params );
 }
 
-static void WINAPI glGetProgramNamedParameterfvNV( GLuint id, GLsizei len, const GLubyte* name, GLfloat* params ) {
+static void WINAPI glGetProgramNamedParameterfvNV( GLuint id, GLsizei len, const GLubyte *name, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", id, len, name, params );
+  TRACE( "(%d, %d, %p, %p)\n", id, len, name, params );
   funcs->ext.p_glGetProgramNamedParameterfvNV( id, len, name, params );
 }
 
-static void WINAPI glGetProgramParameterdvNV( GLenum target, GLuint index, GLenum pname, GLdouble* params ) {
+static void WINAPI glGetProgramParameterdvNV( GLenum target, GLuint index, GLenum pname, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, index, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", target, index, pname, params );
   funcs->ext.p_glGetProgramParameterdvNV( target, index, pname, params );
 }
 
-static void WINAPI glGetProgramParameterfvNV( GLenum target, GLuint index, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetProgramParameterfvNV( GLenum target, GLuint index, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, index, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", target, index, pname, params );
   funcs->ext.p_glGetProgramParameterfvNV( target, index, pname, params );
 }
 
-static void WINAPI glGetProgramPipelineInfoLog( GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog ) {
+static void WINAPI glGetProgramPipelineInfoLog( GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", pipeline, bufSize, length, infoLog );
+  TRACE( "(%d, %d, %p, %p)\n", pipeline, bufSize, length, infoLog );
   funcs->ext.p_glGetProgramPipelineInfoLog( pipeline, bufSize, length, infoLog );
 }
 
-static void WINAPI glGetProgramPipelineiv( GLuint pipeline, GLenum pname, GLint* params ) {
+static void WINAPI glGetProgramPipelineiv( GLuint pipeline, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", pipeline, pname, params );
+  TRACE( "(%d, %d, %p)\n", pipeline, pname, params );
   funcs->ext.p_glGetProgramPipelineiv( pipeline, pname, params );
 }
 
-static GLuint WINAPI glGetProgramResourceIndex( GLuint program, GLenum programInterface, const GLchar* name ) {
+static GLuint WINAPI glGetProgramResourceIndex( GLuint program, GLenum programInterface, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, programInterface, name );
+  TRACE( "(%d, %d, %p)\n", program, programInterface, name );
   return funcs->ext.p_glGetProgramResourceIndex( program, programInterface, name );
 }
 
-static GLint WINAPI glGetProgramResourceLocation( GLuint program, GLenum programInterface, const GLchar* name ) {
+static GLint WINAPI glGetProgramResourceLocation( GLuint program, GLenum programInterface, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, programInterface, name );
+  TRACE( "(%d, %d, %p)\n", program, programInterface, name );
   return funcs->ext.p_glGetProgramResourceLocation( program, programInterface, name );
 }
 
-static GLint WINAPI glGetProgramResourceLocationIndex( GLuint program, GLenum programInterface, const GLchar* name ) {
+static GLint WINAPI glGetProgramResourceLocationIndex( GLuint program, GLenum programInterface, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, programInterface, name );
+  TRACE( "(%d, %d, %p)\n", program, programInterface, name );
   return funcs->ext.p_glGetProgramResourceLocationIndex( program, programInterface, name );
 }
 
-static void WINAPI glGetProgramResourceName( GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name ) {
+static void WINAPI glGetProgramResourceName( GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p, %p)\n", program, programInterface, index, bufSize, length, name );
+  TRACE( "(%d, %d, %d, %d, %p, %p)\n", program, programInterface, index, bufSize, length, name );
   funcs->ext.p_glGetProgramResourceName( program, programInterface, index, bufSize, length, name );
 }
 
-static void WINAPI glGetProgramResourcefvNV( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum* props, GLsizei bufSize, GLsizei* length, GLfloat* params ) {
+static void WINAPI glGetProgramResourcefvNV( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p, %d, %p, %p)\n", program, programInterface, index, propCount, props, bufSize, length, params );
+  TRACE( "(%d, %d, %d, %d, %p, %d, %p, %p)\n", program, programInterface, index, propCount, props, bufSize, length, params );
   funcs->ext.p_glGetProgramResourcefvNV( program, programInterface, index, propCount, props, bufSize, length, params );
 }
 
-static void WINAPI glGetProgramResourceiv( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params ) {
+static void WINAPI glGetProgramResourceiv( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p, %d, %p, %p)\n", program, programInterface, index, propCount, props, bufSize, length, params );
+  TRACE( "(%d, %d, %d, %d, %p, %d, %p, %p)\n", program, programInterface, index, propCount, props, bufSize, length, params );
   funcs->ext.p_glGetProgramResourceiv( program, programInterface, index, propCount, props, bufSize, length, params );
 }
 
-static void WINAPI glGetProgramStageiv( GLuint program, GLenum shadertype, GLenum pname, GLint* values ) {
+static void WINAPI glGetProgramStageiv( GLuint program, GLenum shadertype, GLenum pname, GLint *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, shadertype, pname, values );
+  TRACE( "(%d, %d, %d, %p)\n", program, shadertype, pname, values );
   funcs->ext.p_glGetProgramStageiv( program, shadertype, pname, values );
 }
 
-static void WINAPI glGetProgramStringARB( GLenum target, GLenum pname, void* string ) {
+static void WINAPI glGetProgramStringARB( GLenum target, GLenum pname, void *string )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, string );
+  TRACE( "(%d, %d, %p)\n", target, pname, string );
   funcs->ext.p_glGetProgramStringARB( target, pname, string );
 }
 
-static void WINAPI glGetProgramStringNV( GLuint id, GLenum pname, GLubyte* program ) {
+static void WINAPI glGetProgramStringNV( GLuint id, GLenum pname, GLubyte *program )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, pname, program );
+  TRACE( "(%d, %d, %p)\n", id, pname, program );
   funcs->ext.p_glGetProgramStringNV( id, pname, program );
 }
 
-static void WINAPI glGetProgramSubroutineParameteruivNV( GLenum target, GLuint index, GLuint* param ) {
+static void WINAPI glGetProgramSubroutineParameteruivNV( GLenum target, GLuint index, GLuint *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, param );
+  TRACE( "(%d, %d, %p)\n", target, index, param );
   funcs->ext.p_glGetProgramSubroutineParameteruivNV( target, index, param );
 }
 
-static void WINAPI glGetProgramiv( GLuint program, GLenum pname, GLint* params ) {
+static void WINAPI glGetProgramiv( GLuint program, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, pname, params );
+  TRACE( "(%d, %d, %p)\n", program, pname, params );
   funcs->ext.p_glGetProgramiv( program, pname, params );
 }
 
-static void WINAPI glGetProgramivARB( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetProgramivARB( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetProgramivARB( target, pname, params );
 }
 
-static void WINAPI glGetProgramivNV( GLuint id, GLenum pname, GLint* params ) {
+static void WINAPI glGetProgramivNV( GLuint id, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, pname, params );
+  TRACE( "(%d, %d, %p)\n", id, pname, params );
   funcs->ext.p_glGetProgramivNV( id, pname, params );
 }
 
-static void WINAPI glGetQueryBufferObjecti64v( GLuint id, GLuint buffer, GLenum pname, GLintptr offset ) {
+static void WINAPI glGetQueryBufferObjecti64v( GLuint id, GLuint buffer, GLenum pname, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %ld)\n", id, buffer, pname, offset );
+  TRACE( "(%d, %d, %d, %ld)\n", id, buffer, pname, offset );
   funcs->ext.p_glGetQueryBufferObjecti64v( id, buffer, pname, offset );
 }
 
-static void WINAPI glGetQueryBufferObjectiv( GLuint id, GLuint buffer, GLenum pname, GLintptr offset ) {
+static void WINAPI glGetQueryBufferObjectiv( GLuint id, GLuint buffer, GLenum pname, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %ld)\n", id, buffer, pname, offset );
+  TRACE( "(%d, %d, %d, %ld)\n", id, buffer, pname, offset );
   funcs->ext.p_glGetQueryBufferObjectiv( id, buffer, pname, offset );
 }
 
-static void WINAPI glGetQueryBufferObjectui64v( GLuint id, GLuint buffer, GLenum pname, GLintptr offset ) {
+static void WINAPI glGetQueryBufferObjectui64v( GLuint id, GLuint buffer, GLenum pname, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %ld)\n", id, buffer, pname, offset );
+  TRACE( "(%d, %d, %d, %ld)\n", id, buffer, pname, offset );
   funcs->ext.p_glGetQueryBufferObjectui64v( id, buffer, pname, offset );
 }
 
-static void WINAPI glGetQueryBufferObjectuiv( GLuint id, GLuint buffer, GLenum pname, GLintptr offset ) {
+static void WINAPI glGetQueryBufferObjectuiv( GLuint id, GLuint buffer, GLenum pname, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %ld)\n", id, buffer, pname, offset );
+  TRACE( "(%d, %d, %d, %ld)\n", id, buffer, pname, offset );
   funcs->ext.p_glGetQueryBufferObjectuiv( id, buffer, pname, offset );
 }
 
-static void WINAPI glGetQueryIndexediv( GLenum target, GLuint index, GLenum pname, GLint* params ) {
+static void WINAPI glGetQueryIndexediv( GLenum target, GLuint index, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, index, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", target, index, pname, params );
   funcs->ext.p_glGetQueryIndexediv( target, index, pname, params );
 }
 
-static void WINAPI glGetQueryObjecti64v( GLuint id, GLenum pname, GLint64* params ) {
+static void WINAPI glGetQueryObjecti64v( GLuint id, GLenum pname, GLint64 *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, pname, params );
+  TRACE( "(%d, %d, %p)\n", id, pname, params );
   funcs->ext.p_glGetQueryObjecti64v( id, pname, params );
 }
 
-static void WINAPI glGetQueryObjecti64vEXT( GLuint id, GLenum pname, GLint64* params ) {
+static void WINAPI glGetQueryObjecti64vEXT( GLuint id, GLenum pname, GLint64 *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, pname, params );
+  TRACE( "(%d, %d, %p)\n", id, pname, params );
   funcs->ext.p_glGetQueryObjecti64vEXT( id, pname, params );
 }
 
-static void WINAPI glGetQueryObjectiv( GLuint id, GLenum pname, GLint* params ) {
+static void WINAPI glGetQueryObjectiv( GLuint id, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, pname, params );
+  TRACE( "(%d, %d, %p)\n", id, pname, params );
   funcs->ext.p_glGetQueryObjectiv( id, pname, params );
 }
 
-static void WINAPI glGetQueryObjectivARB( GLuint id, GLenum pname, GLint* params ) {
+static void WINAPI glGetQueryObjectivARB( GLuint id, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, pname, params );
+  TRACE( "(%d, %d, %p)\n", id, pname, params );
   funcs->ext.p_glGetQueryObjectivARB( id, pname, params );
 }
 
-static void WINAPI glGetQueryObjectui64v( GLuint id, GLenum pname, GLuint64* params ) {
+static void WINAPI glGetQueryObjectui64v( GLuint id, GLenum pname, GLuint64 *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, pname, params );
+  TRACE( "(%d, %d, %p)\n", id, pname, params );
   funcs->ext.p_glGetQueryObjectui64v( id, pname, params );
 }
 
-static void WINAPI glGetQueryObjectui64vEXT( GLuint id, GLenum pname, GLuint64* params ) {
+static void WINAPI glGetQueryObjectui64vEXT( GLuint id, GLenum pname, GLuint64 *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, pname, params );
+  TRACE( "(%d, %d, %p)\n", id, pname, params );
   funcs->ext.p_glGetQueryObjectui64vEXT( id, pname, params );
 }
 
-static void WINAPI glGetQueryObjectuiv( GLuint id, GLenum pname, GLuint* params ) {
+static void WINAPI glGetQueryObjectuiv( GLuint id, GLenum pname, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, pname, params );
+  TRACE( "(%d, %d, %p)\n", id, pname, params );
   funcs->ext.p_glGetQueryObjectuiv( id, pname, params );
 }
 
-static void WINAPI glGetQueryObjectuivARB( GLuint id, GLenum pname, GLuint* params ) {
+static void WINAPI glGetQueryObjectuivARB( GLuint id, GLenum pname, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, pname, params );
+  TRACE( "(%d, %d, %p)\n", id, pname, params );
   funcs->ext.p_glGetQueryObjectuivARB( id, pname, params );
 }
 
-static void WINAPI glGetQueryiv( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetQueryiv( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetQueryiv( target, pname, params );
 }
 
-static void WINAPI glGetQueryivARB( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetQueryivARB( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetQueryivARB( target, pname, params );
 }
 
-static void WINAPI glGetRenderbufferParameteriv( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetRenderbufferParameteriv( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetRenderbufferParameteriv( target, pname, params );
 }
 
-static void WINAPI glGetRenderbufferParameterivEXT( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetRenderbufferParameterivEXT( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetRenderbufferParameterivEXT( target, pname, params );
 }
 
-static void WINAPI glGetSamplerParameterIiv( GLuint sampler, GLenum pname, GLint* params ) {
+static void WINAPI glGetSamplerParameterIiv( GLuint sampler, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", sampler, pname, params );
+  TRACE( "(%d, %d, %p)\n", sampler, pname, params );
   funcs->ext.p_glGetSamplerParameterIiv( sampler, pname, params );
 }
 
-static void WINAPI glGetSamplerParameterIuiv( GLuint sampler, GLenum pname, GLuint* params ) {
+static void WINAPI glGetSamplerParameterIuiv( GLuint sampler, GLenum pname, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", sampler, pname, params );
+  TRACE( "(%d, %d, %p)\n", sampler, pname, params );
   funcs->ext.p_glGetSamplerParameterIuiv( sampler, pname, params );
 }
 
-static void WINAPI glGetSamplerParameterfv( GLuint sampler, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetSamplerParameterfv( GLuint sampler, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", sampler, pname, params );
+  TRACE( "(%d, %d, %p)\n", sampler, pname, params );
   funcs->ext.p_glGetSamplerParameterfv( sampler, pname, params );
 }
 
-static void WINAPI glGetSamplerParameteriv( GLuint sampler, GLenum pname, GLint* params ) {
+static void WINAPI glGetSamplerParameteriv( GLuint sampler, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", sampler, pname, params );
+  TRACE( "(%d, %d, %p)\n", sampler, pname, params );
   funcs->ext.p_glGetSamplerParameteriv( sampler, pname, params );
 }
 
-static void WINAPI glGetSemaphoreParameterui64vEXT( GLuint semaphore, GLenum pname, GLuint64* params ) {
+static void WINAPI glGetSemaphoreParameterui64vEXT( GLuint semaphore, GLenum pname, GLuint64 *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", semaphore, pname, params );
+  TRACE( "(%d, %d, %p)\n", semaphore, pname, params );
   funcs->ext.p_glGetSemaphoreParameterui64vEXT( semaphore, pname, params );
 }
 
-static void WINAPI glGetSeparableFilter( GLenum target, GLenum format, GLenum type, void* row, void* column, void* span ) {
+static void WINAPI glGetSeparableFilter( GLenum target, GLenum format, GLenum type, void *row, void *column, void *span )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p, %p)\n", target, format, type, row, column, span );
+  TRACE( "(%d, %d, %d, %p, %p, %p)\n", target, format, type, row, column, span );
   funcs->ext.p_glGetSeparableFilter( target, format, type, row, column, span );
 }
 
-static void WINAPI glGetSeparableFilterEXT( GLenum target, GLenum format, GLenum type, void* row, void* column, void* span ) {
+static void WINAPI glGetSeparableFilterEXT( GLenum target, GLenum format, GLenum type, void *row, void *column, void *span )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p, %p)\n", target, format, type, row, column, span );
+  TRACE( "(%d, %d, %d, %p, %p, %p)\n", target, format, type, row, column, span );
   funcs->ext.p_glGetSeparableFilterEXT( target, format, type, row, column, span );
 }
 
-static void WINAPI glGetShaderInfoLog( GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog ) {
+static void WINAPI glGetShaderInfoLog( GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", shader, bufSize, length, infoLog );
+  TRACE( "(%d, %d, %p, %p)\n", shader, bufSize, length, infoLog );
   funcs->ext.p_glGetShaderInfoLog( shader, bufSize, length, infoLog );
 }
 
-static void WINAPI glGetShaderPrecisionFormat( GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision ) {
+static void WINAPI glGetShaderPrecisionFormat( GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", shadertype, precisiontype, range, precision );
+  TRACE( "(%d, %d, %p, %p)\n", shadertype, precisiontype, range, precision );
   funcs->ext.p_glGetShaderPrecisionFormat( shadertype, precisiontype, range, precision );
 }
 
-static void WINAPI glGetShaderSource( GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source ) {
+static void WINAPI glGetShaderSource( GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", shader, bufSize, length, source );
+  TRACE( "(%d, %d, %p, %p)\n", shader, bufSize, length, source );
   funcs->ext.p_glGetShaderSource( shader, bufSize, length, source );
 }
 
-static void WINAPI glGetShaderSourceARB( GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB* source ) {
+static void WINAPI glGetShaderSourceARB( GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *source )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", obj, maxLength, length, source );
+  TRACE( "(%d, %d, %p, %p)\n", obj, maxLength, length, source );
   funcs->ext.p_glGetShaderSourceARB( obj, maxLength, length, source );
 }
 
-static void WINAPI glGetShaderiv( GLuint shader, GLenum pname, GLint* params ) {
+static void WINAPI glGetShaderiv( GLuint shader, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", shader, pname, params );
+  TRACE( "(%d, %d, %p)\n", shader, pname, params );
   funcs->ext.p_glGetShaderiv( shader, pname, params );
 }
 
-static void WINAPI glGetSharpenTexFuncSGIS( GLenum target, GLfloat* points ) {
+static void WINAPI glGetSharpenTexFuncSGIS( GLenum target, GLfloat *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, points );
+  TRACE( "(%d, %p)\n", target, points );
   funcs->ext.p_glGetSharpenTexFuncSGIS( target, points );
 }
 
-static GLushort WINAPI glGetStageIndexNV( GLenum shadertype ) {
+static GLushort WINAPI glGetStageIndexNV( GLenum shadertype )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", shadertype );
+  TRACE( "(%d)\n", shadertype );
   return funcs->ext.p_glGetStageIndexNV( shadertype );
 }
 
-const GLubyte* WINAPI glGetStringi( GLenum name, GLuint index ) DECLSPEC_HIDDEN;
+const GLubyte * WINAPI glGetStringi( GLenum name, GLuint index ) DECLSPEC_HIDDEN;
 
-static GLuint WINAPI glGetSubroutineIndex( GLuint program, GLenum shadertype, const GLchar* name ) {
+static GLuint WINAPI glGetSubroutineIndex( GLuint program, GLenum shadertype, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, shadertype, name );
+  TRACE( "(%d, %d, %p)\n", program, shadertype, name );
   return funcs->ext.p_glGetSubroutineIndex( program, shadertype, name );
 }
 
-static GLint WINAPI glGetSubroutineUniformLocation( GLuint program, GLenum shadertype, const GLchar* name ) {
+static GLint WINAPI glGetSubroutineUniformLocation( GLuint program, GLenum shadertype, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, shadertype, name );
+  TRACE( "(%d, %d, %p)\n", program, shadertype, name );
   return funcs->ext.p_glGetSubroutineUniformLocation( program, shadertype, name );
 }
 
-static void WINAPI glGetSynciv( GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values ) {
+static void WINAPI glGetSynciv( GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %d, %d, %p, %p)\n", sync, pname, bufSize, length, values );
+  TRACE( "(%p, %d, %d, %p, %p)\n", sync, pname, bufSize, length, values );
   funcs->ext.p_glGetSynciv( sync, pname, bufSize, length, values );
 }
 
-static void WINAPI glGetTexBumpParameterfvATI( GLenum pname, GLfloat* param ) {
+static void WINAPI glGetTexBumpParameterfvATI( GLenum pname, GLfloat *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, param );
+  TRACE( "(%d, %p)\n", pname, param );
   funcs->ext.p_glGetTexBumpParameterfvATI( pname, param );
 }
 
-static void WINAPI glGetTexBumpParameterivATI( GLenum pname, GLint* param ) {
+static void WINAPI glGetTexBumpParameterivATI( GLenum pname, GLint *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, param );
+  TRACE( "(%d, %p)\n", pname, param );
   funcs->ext.p_glGetTexBumpParameterivATI( pname, param );
 }
 
-static void WINAPI glGetTexEnvxvOES( GLenum target, GLenum pname, GLfixed* params ) {
+static void WINAPI glGetTexEnvxvOES( GLenum target, GLenum pname, GLfixed *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetTexEnvxvOES( target, pname, params );
 }
 
-static void WINAPI glGetTexFilterFuncSGIS( GLenum target, GLenum filter, GLfloat* weights ) {
+static void WINAPI glGetTexFilterFuncSGIS( GLenum target, GLenum filter, GLfloat *weights )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, filter, weights );
+  TRACE( "(%d, %d, %p)\n", target, filter, weights );
   funcs->ext.p_glGetTexFilterFuncSGIS( target, filter, weights );
 }
 
-static void WINAPI glGetTexGenxvOES( GLenum coord, GLenum pname, GLfixed* params ) {
+static void WINAPI glGetTexGenxvOES( GLenum coord, GLenum pname, GLfixed *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", coord, pname, params );
+  TRACE( "(%d, %d, %p)\n", coord, pname, params );
   funcs->ext.p_glGetTexGenxvOES( coord, pname, params );
 }
 
-static void WINAPI glGetTexLevelParameterxvOES( GLenum target, GLint level, GLenum pname, GLfixed* params ) {
+static void WINAPI glGetTexLevelParameterxvOES( GLenum target, GLint level, GLenum pname, GLfixed *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, level, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", target, level, pname, params );
   funcs->ext.p_glGetTexLevelParameterxvOES( target, level, pname, params );
 }
 
-static void WINAPI glGetTexParameterIiv( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetTexParameterIiv( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetTexParameterIiv( target, pname, params );
 }
 
-static void WINAPI glGetTexParameterIivEXT( GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetTexParameterIivEXT( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetTexParameterIivEXT( target, pname, params );
 }
 
-static void WINAPI glGetTexParameterIuiv( GLenum target, GLenum pname, GLuint* params ) {
+static void WINAPI glGetTexParameterIuiv( GLenum target, GLenum pname, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetTexParameterIuiv( target, pname, params );
 }
 
-static void WINAPI glGetTexParameterIuivEXT( GLenum target, GLenum pname, GLuint* params ) {
+static void WINAPI glGetTexParameterIuivEXT( GLenum target, GLenum pname, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetTexParameterIuivEXT( target, pname, params );
 }
 
-static void WINAPI glGetTexParameterPointervAPPLE( GLenum target, GLenum pname, void** params ) {
+static void WINAPI glGetTexParameterPointervAPPLE( GLenum target, GLenum pname, void **params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetTexParameterPointervAPPLE( target, pname, params );
 }
 
-static void WINAPI glGetTexParameterxvOES( GLenum target, GLenum pname, GLfixed* params ) {
+static void WINAPI glGetTexParameterxvOES( GLenum target, GLenum pname, GLfixed *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glGetTexParameterxvOES( target, pname, params );
 }
 
-static GLuint64 WINAPI glGetTextureHandleARB( GLuint texture ) {
+static GLuint64 WINAPI glGetTextureHandleARB( GLuint texture )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", texture );
+  TRACE( "(%d)\n", texture );
   return funcs->ext.p_glGetTextureHandleARB( texture );
 }
 
-static GLuint64 WINAPI glGetTextureHandleNV( GLuint texture ) {
+static GLuint64 WINAPI glGetTextureHandleNV( GLuint texture )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", texture );
+  TRACE( "(%d)\n", texture );
   return funcs->ext.p_glGetTextureHandleNV( texture );
 }
 
-static void WINAPI glGetTextureImage( GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* pixels ) {
+static void WINAPI glGetTextureImage( GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", texture, level, format, type, bufSize, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", texture, level, format, type, bufSize, pixels );
   funcs->ext.p_glGetTextureImage( texture, level, format, type, bufSize, pixels );
 }
 
-static void WINAPI glGetTextureImageEXT( GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void* pixels ) {
+static void WINAPI glGetTextureImageEXT( GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", texture, target, level, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", texture, target, level, format, type, pixels );
   funcs->ext.p_glGetTextureImageEXT( texture, target, level, format, type, pixels );
 }
 
-static void WINAPI glGetTextureLevelParameterfv( GLuint texture, GLint level, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetTextureLevelParameterfv( GLuint texture, GLint level, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texture, level, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texture, level, pname, params );
   funcs->ext.p_glGetTextureLevelParameterfv( texture, level, pname, params );
 }
 
-static void WINAPI glGetTextureLevelParameterfvEXT( GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetTextureLevelParameterfvEXT( GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", texture, target, level, pname, params );
+  TRACE( "(%d, %d, %d, %d, %p)\n", texture, target, level, pname, params );
   funcs->ext.p_glGetTextureLevelParameterfvEXT( texture, target, level, pname, params );
 }
 
-static void WINAPI glGetTextureLevelParameteriv( GLuint texture, GLint level, GLenum pname, GLint* params ) {
+static void WINAPI glGetTextureLevelParameteriv( GLuint texture, GLint level, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texture, level, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texture, level, pname, params );
   funcs->ext.p_glGetTextureLevelParameteriv( texture, level, pname, params );
 }
 
-static void WINAPI glGetTextureLevelParameterivEXT( GLuint texture, GLenum target, GLint level, GLenum pname, GLint* params ) {
+static void WINAPI glGetTextureLevelParameterivEXT( GLuint texture, GLenum target, GLint level, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", texture, target, level, pname, params );
+  TRACE( "(%d, %d, %d, %d, %p)\n", texture, target, level, pname, params );
   funcs->ext.p_glGetTextureLevelParameterivEXT( texture, target, level, pname, params );
 }
 
-static void WINAPI glGetTextureParameterIiv( GLuint texture, GLenum pname, GLint* params ) {
+static void WINAPI glGetTextureParameterIiv( GLuint texture, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", texture, pname, params );
+  TRACE( "(%d, %d, %p)\n", texture, pname, params );
   funcs->ext.p_glGetTextureParameterIiv( texture, pname, params );
 }
 
-static void WINAPI glGetTextureParameterIivEXT( GLuint texture, GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetTextureParameterIivEXT( GLuint texture, GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texture, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texture, target, pname, params );
   funcs->ext.p_glGetTextureParameterIivEXT( texture, target, pname, params );
 }
 
-static void WINAPI glGetTextureParameterIuiv( GLuint texture, GLenum pname, GLuint* params ) {
+static void WINAPI glGetTextureParameterIuiv( GLuint texture, GLenum pname, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", texture, pname, params );
+  TRACE( "(%d, %d, %p)\n", texture, pname, params );
   funcs->ext.p_glGetTextureParameterIuiv( texture, pname, params );
 }
 
-static void WINAPI glGetTextureParameterIuivEXT( GLuint texture, GLenum target, GLenum pname, GLuint* params ) {
+static void WINAPI glGetTextureParameterIuivEXT( GLuint texture, GLenum target, GLenum pname, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texture, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texture, target, pname, params );
   funcs->ext.p_glGetTextureParameterIuivEXT( texture, target, pname, params );
 }
 
-static void WINAPI glGetTextureParameterfv( GLuint texture, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetTextureParameterfv( GLuint texture, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", texture, pname, params );
+  TRACE( "(%d, %d, %p)\n", texture, pname, params );
   funcs->ext.p_glGetTextureParameterfv( texture, pname, params );
 }
 
-static void WINAPI glGetTextureParameterfvEXT( GLuint texture, GLenum target, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetTextureParameterfvEXT( GLuint texture, GLenum target, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texture, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texture, target, pname, params );
   funcs->ext.p_glGetTextureParameterfvEXT( texture, target, pname, params );
 }
 
-static void WINAPI glGetTextureParameteriv( GLuint texture, GLenum pname, GLint* params ) {
+static void WINAPI glGetTextureParameteriv( GLuint texture, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", texture, pname, params );
+  TRACE( "(%d, %d, %p)\n", texture, pname, params );
   funcs->ext.p_glGetTextureParameteriv( texture, pname, params );
 }
 
-static void WINAPI glGetTextureParameterivEXT( GLuint texture, GLenum target, GLenum pname, GLint* params ) {
+static void WINAPI glGetTextureParameterivEXT( GLuint texture, GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texture, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texture, target, pname, params );
   funcs->ext.p_glGetTextureParameterivEXT( texture, target, pname, params );
 }
 
-static GLuint64 WINAPI glGetTextureSamplerHandleARB( GLuint texture, GLuint sampler ) {
+static GLuint64 WINAPI glGetTextureSamplerHandleARB( GLuint texture, GLuint sampler )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", texture, sampler );
+  TRACE( "(%d, %d)\n", texture, sampler );
   return funcs->ext.p_glGetTextureSamplerHandleARB( texture, sampler );
 }
 
-static GLuint64 WINAPI glGetTextureSamplerHandleNV( GLuint texture, GLuint sampler ) {
+static GLuint64 WINAPI glGetTextureSamplerHandleNV( GLuint texture, GLuint sampler )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", texture, sampler );
+  TRACE( "(%d, %d)\n", texture, sampler );
   return funcs->ext.p_glGetTextureSamplerHandleNV( texture, sampler );
 }
 
-static void WINAPI glGetTextureSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void* pixels ) {
+static void WINAPI glGetTextureSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels );
   funcs->ext.p_glGetTextureSubImage( texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels );
 }
 
-static void WINAPI glGetTrackMatrixivNV( GLenum target, GLuint address, GLenum pname, GLint* params ) {
+static void WINAPI glGetTrackMatrixivNV( GLenum target, GLuint address, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, address, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", target, address, pname, params );
   funcs->ext.p_glGetTrackMatrixivNV( target, address, pname, params );
 }
 
-static void WINAPI glGetTransformFeedbackVarying( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name ) {
+static void WINAPI glGetTransformFeedbackVarying( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p, %p, %p)\n", program, index, bufSize, length, size, type, name );
+  TRACE( "(%d, %d, %d, %p, %p, %p, %p)\n", program, index, bufSize, length, size, type, name );
   funcs->ext.p_glGetTransformFeedbackVarying( program, index, bufSize, length, size, type, name );
 }
 
-static void WINAPI glGetTransformFeedbackVaryingEXT( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name ) {
+static void WINAPI glGetTransformFeedbackVaryingEXT( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p, %p, %p)\n", program, index, bufSize, length, size, type, name );
+  TRACE( "(%d, %d, %d, %p, %p, %p, %p)\n", program, index, bufSize, length, size, type, name );
   funcs->ext.p_glGetTransformFeedbackVaryingEXT( program, index, bufSize, length, size, type, name );
 }
 
-static void WINAPI glGetTransformFeedbackVaryingNV( GLuint program, GLuint index, GLint* location ) {
+static void WINAPI glGetTransformFeedbackVaryingNV( GLuint program, GLuint index, GLint *location )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, index, location );
+  TRACE( "(%d, %d, %p)\n", program, index, location );
   funcs->ext.p_glGetTransformFeedbackVaryingNV( program, index, location );
 }
 
-static void WINAPI glGetTransformFeedbacki64_v( GLuint xfb, GLenum pname, GLuint index, GLint64* param ) {
+static void WINAPI glGetTransformFeedbacki64_v( GLuint xfb, GLenum pname, GLuint index, GLint64 *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", xfb, pname, index, param );
+  TRACE( "(%d, %d, %d, %p)\n", xfb, pname, index, param );
   funcs->ext.p_glGetTransformFeedbacki64_v( xfb, pname, index, param );
 }
 
-static void WINAPI glGetTransformFeedbacki_v( GLuint xfb, GLenum pname, GLuint index, GLint* param ) {
+static void WINAPI glGetTransformFeedbacki_v( GLuint xfb, GLenum pname, GLuint index, GLint *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", xfb, pname, index, param );
+  TRACE( "(%d, %d, %d, %p)\n", xfb, pname, index, param );
   funcs->ext.p_glGetTransformFeedbacki_v( xfb, pname, index, param );
 }
 
-static void WINAPI glGetTransformFeedbackiv( GLuint xfb, GLenum pname, GLint* param ) {
+static void WINAPI glGetTransformFeedbackiv( GLuint xfb, GLenum pname, GLint *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", xfb, pname, param );
+  TRACE( "(%d, %d, %p)\n", xfb, pname, param );
   funcs->ext.p_glGetTransformFeedbackiv( xfb, pname, param );
 }
 
-static GLuint WINAPI glGetUniformBlockIndex( GLuint program, const GLchar* uniformBlockName ) {
+static GLuint WINAPI glGetUniformBlockIndex( GLuint program, const GLchar *uniformBlockName )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", program, uniformBlockName );
+  TRACE( "(%d, %p)\n", program, uniformBlockName );
   return funcs->ext.p_glGetUniformBlockIndex( program, uniformBlockName );
 }
 
-static GLint WINAPI glGetUniformBufferSizeEXT( GLuint program, GLint location ) {
+static GLint WINAPI glGetUniformBufferSizeEXT( GLuint program, GLint location )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", program, location );
+  TRACE( "(%d, %d)\n", program, location );
   return funcs->ext.p_glGetUniformBufferSizeEXT( program, location );
 }
 
-static void WINAPI glGetUniformIndices( GLuint program, GLsizei uniformCount, const GLchar*const* uniformNames, GLuint* uniformIndices ) {
+static void WINAPI glGetUniformIndices( GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", program, uniformCount, uniformNames, uniformIndices );
+  TRACE( "(%d, %d, %p, %p)\n", program, uniformCount, uniformNames, uniformIndices );
   funcs->ext.p_glGetUniformIndices( program, uniformCount, uniformNames, uniformIndices );
 }
 
-static GLint WINAPI glGetUniformLocation( GLuint program, const GLchar* name ) {
+static GLint WINAPI glGetUniformLocation( GLuint program, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", program, name );
+  TRACE( "(%d, %p)\n", program, name );
   return funcs->ext.p_glGetUniformLocation( program, name );
 }
 
-static GLint WINAPI glGetUniformLocationARB( GLhandleARB programObj, const GLcharARB* name ) {
+static GLint WINAPI glGetUniformLocationARB( GLhandleARB programObj, const GLcharARB *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", programObj, name );
+  TRACE( "(%d, %p)\n", programObj, name );
   return funcs->ext.p_glGetUniformLocationARB( programObj, name );
 }
 
-static GLintptr WINAPI glGetUniformOffsetEXT( GLuint program, GLint location ) {
+static GLintptr WINAPI glGetUniformOffsetEXT( GLuint program, GLint location )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", program, location );
+  TRACE( "(%d, %d)\n", program, location );
   return funcs->ext.p_glGetUniformOffsetEXT( program, location );
 }
 
-static void WINAPI glGetUniformSubroutineuiv( GLenum shadertype, GLint location, GLuint* params ) {
+static void WINAPI glGetUniformSubroutineuiv( GLenum shadertype, GLint location, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", shadertype, location, params );
+  TRACE( "(%d, %d, %p)\n", shadertype, location, params );
   funcs->ext.p_glGetUniformSubroutineuiv( shadertype, location, params );
 }
 
-static void WINAPI glGetUniformdv( GLuint program, GLint location, GLdouble* params ) {
+static void WINAPI glGetUniformdv( GLuint program, GLint location, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, location, params );
+  TRACE( "(%d, %d, %p)\n", program, location, params );
   funcs->ext.p_glGetUniformdv( program, location, params );
 }
 
-static void WINAPI glGetUniformfv( GLuint program, GLint location, GLfloat* params ) {
+static void WINAPI glGetUniformfv( GLuint program, GLint location, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, location, params );
+  TRACE( "(%d, %d, %p)\n", program, location, params );
   funcs->ext.p_glGetUniformfv( program, location, params );
 }
 
-static void WINAPI glGetUniformfvARB( GLhandleARB programObj, GLint location, GLfloat* params ) {
+static void WINAPI glGetUniformfvARB( GLhandleARB programObj, GLint location, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", programObj, location, params );
+  TRACE( "(%d, %d, %p)\n", programObj, location, params );
   funcs->ext.p_glGetUniformfvARB( programObj, location, params );
 }
 
-static void WINAPI glGetUniformi64vARB( GLuint program, GLint location, GLint64* params ) {
+static void WINAPI glGetUniformi64vARB( GLuint program, GLint location, GLint64 *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, location, params );
+  TRACE( "(%d, %d, %p)\n", program, location, params );
   funcs->ext.p_glGetUniformi64vARB( program, location, params );
 }
 
-static void WINAPI glGetUniformi64vNV( GLuint program, GLint location, GLint64EXT* params ) {
+static void WINAPI glGetUniformi64vNV( GLuint program, GLint location, GLint64EXT *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, location, params );
+  TRACE( "(%d, %d, %p)\n", program, location, params );
   funcs->ext.p_glGetUniformi64vNV( program, location, params );
 }
 
-static void WINAPI glGetUniformiv( GLuint program, GLint location, GLint* params ) {
+static void WINAPI glGetUniformiv( GLuint program, GLint location, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, location, params );
+  TRACE( "(%d, %d, %p)\n", program, location, params );
   funcs->ext.p_glGetUniformiv( program, location, params );
 }
 
-static void WINAPI glGetUniformivARB( GLhandleARB programObj, GLint location, GLint* params ) {
+static void WINAPI glGetUniformivARB( GLhandleARB programObj, GLint location, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", programObj, location, params );
+  TRACE( "(%d, %d, %p)\n", programObj, location, params );
   funcs->ext.p_glGetUniformivARB( programObj, location, params );
 }
 
-static void WINAPI glGetUniformui64vARB( GLuint program, GLint location, GLuint64* params ) {
+static void WINAPI glGetUniformui64vARB( GLuint program, GLint location, GLuint64 *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, location, params );
+  TRACE( "(%d, %d, %p)\n", program, location, params );
   funcs->ext.p_glGetUniformui64vARB( program, location, params );
 }
 
-static void WINAPI glGetUniformui64vNV( GLuint program, GLint location, GLuint64EXT* params ) {
+static void WINAPI glGetUniformui64vNV( GLuint program, GLint location, GLuint64EXT *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, location, params );
+  TRACE( "(%d, %d, %p)\n", program, location, params );
   funcs->ext.p_glGetUniformui64vNV( program, location, params );
 }
 
-static void WINAPI glGetUniformuiv( GLuint program, GLint location, GLuint* params ) {
+static void WINAPI glGetUniformuiv( GLuint program, GLint location, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, location, params );
+  TRACE( "(%d, %d, %p)\n", program, location, params );
   funcs->ext.p_glGetUniformuiv( program, location, params );
 }
 
-static void WINAPI glGetUniformuivEXT( GLuint program, GLint location, GLuint* params ) {
+static void WINAPI glGetUniformuivEXT( GLuint program, GLint location, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", program, location, params );
+  TRACE( "(%d, %d, %p)\n", program, location, params );
   funcs->ext.p_glGetUniformuivEXT( program, location, params );
 }
 
-static void WINAPI glGetUnsignedBytei_vEXT( GLenum target, GLuint index, GLubyte* data ) {
+static void WINAPI glGetUnsignedBytei_vEXT( GLenum target, GLuint index, GLubyte *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, data );
+  TRACE( "(%d, %d, %p)\n", target, index, data );
   funcs->ext.p_glGetUnsignedBytei_vEXT( target, index, data );
 }
 
-static void WINAPI glGetUnsignedBytevEXT( GLenum pname, GLubyte* data ) {
+static void WINAPI glGetUnsignedBytevEXT( GLenum pname, GLubyte *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, data );
+  TRACE( "(%d, %p)\n", pname, data );
   funcs->ext.p_glGetUnsignedBytevEXT( pname, data );
 }
 
-static void WINAPI glGetVariantArrayObjectfvATI( GLuint id, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetVariantArrayObjectfvATI( GLuint id, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, pname, params );
+  TRACE( "(%d, %d, %p)\n", id, pname, params );
   funcs->ext.p_glGetVariantArrayObjectfvATI( id, pname, params );
 }
 
-static void WINAPI glGetVariantArrayObjectivATI( GLuint id, GLenum pname, GLint* params ) {
+static void WINAPI glGetVariantArrayObjectivATI( GLuint id, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, pname, params );
+  TRACE( "(%d, %d, %p)\n", id, pname, params );
   funcs->ext.p_glGetVariantArrayObjectivATI( id, pname, params );
 }
 
-static void WINAPI glGetVariantBooleanvEXT( GLuint id, GLenum value, GLboolean* data ) {
+static void WINAPI glGetVariantBooleanvEXT( GLuint id, GLenum value, GLboolean *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, value, data );
+  TRACE( "(%d, %d, %p)\n", id, value, data );
   funcs->ext.p_glGetVariantBooleanvEXT( id, value, data );
 }
 
-static void WINAPI glGetVariantFloatvEXT( GLuint id, GLenum value, GLfloat* data ) {
+static void WINAPI glGetVariantFloatvEXT( GLuint id, GLenum value, GLfloat *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, value, data );
+  TRACE( "(%d, %d, %p)\n", id, value, data );
   funcs->ext.p_glGetVariantFloatvEXT( id, value, data );
 }
 
-static void WINAPI glGetVariantIntegervEXT( GLuint id, GLenum value, GLint* data ) {
+static void WINAPI glGetVariantIntegervEXT( GLuint id, GLenum value, GLint *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, value, data );
+  TRACE( "(%d, %d, %p)\n", id, value, data );
   funcs->ext.p_glGetVariantIntegervEXT( id, value, data );
 }
 
-static void WINAPI glGetVariantPointervEXT( GLuint id, GLenum value, void** data ) {
+static void WINAPI glGetVariantPointervEXT( GLuint id, GLenum value, void **data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, value, data );
+  TRACE( "(%d, %d, %p)\n", id, value, data );
   funcs->ext.p_glGetVariantPointervEXT( id, value, data );
 }
 
-static GLint WINAPI glGetVaryingLocationNV( GLuint program, const GLchar* name ) {
+static GLint WINAPI glGetVaryingLocationNV( GLuint program, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", program, name );
+  TRACE( "(%d, %p)\n", program, name );
   return funcs->ext.p_glGetVaryingLocationNV( program, name );
 }
 
-static void WINAPI glGetVertexArrayIndexed64iv( GLuint vaobj, GLuint index, GLenum pname, GLint64* param ) {
+static void WINAPI glGetVertexArrayIndexed64iv( GLuint vaobj, GLuint index, GLenum pname, GLint64 *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", vaobj, index, pname, param );
+  TRACE( "(%d, %d, %d, %p)\n", vaobj, index, pname, param );
   funcs->ext.p_glGetVertexArrayIndexed64iv( vaobj, index, pname, param );
 }
 
-static void WINAPI glGetVertexArrayIndexediv( GLuint vaobj, GLuint index, GLenum pname, GLint* param ) {
+static void WINAPI glGetVertexArrayIndexediv( GLuint vaobj, GLuint index, GLenum pname, GLint *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", vaobj, index, pname, param );
+  TRACE( "(%d, %d, %d, %p)\n", vaobj, index, pname, param );
   funcs->ext.p_glGetVertexArrayIndexediv( vaobj, index, pname, param );
 }
 
-static void WINAPI glGetVertexArrayIntegeri_vEXT( GLuint vaobj, GLuint index, GLenum pname, GLint* param ) {
+static void WINAPI glGetVertexArrayIntegeri_vEXT( GLuint vaobj, GLuint index, GLenum pname, GLint *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", vaobj, index, pname, param );
+  TRACE( "(%d, %d, %d, %p)\n", vaobj, index, pname, param );
   funcs->ext.p_glGetVertexArrayIntegeri_vEXT( vaobj, index, pname, param );
 }
 
-static void WINAPI glGetVertexArrayIntegervEXT( GLuint vaobj, GLenum pname, GLint* param ) {
+static void WINAPI glGetVertexArrayIntegervEXT( GLuint vaobj, GLenum pname, GLint *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", vaobj, pname, param );
+  TRACE( "(%d, %d, %p)\n", vaobj, pname, param );
   funcs->ext.p_glGetVertexArrayIntegervEXT( vaobj, pname, param );
 }
 
-static void WINAPI glGetVertexArrayPointeri_vEXT( GLuint vaobj, GLuint index, GLenum pname, void** param ) {
+static void WINAPI glGetVertexArrayPointeri_vEXT( GLuint vaobj, GLuint index, GLenum pname, void **param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", vaobj, index, pname, param );
+  TRACE( "(%d, %d, %d, %p)\n", vaobj, index, pname, param );
   funcs->ext.p_glGetVertexArrayPointeri_vEXT( vaobj, index, pname, param );
 }
 
-static void WINAPI glGetVertexArrayPointervEXT( GLuint vaobj, GLenum pname, void** param ) {
+static void WINAPI glGetVertexArrayPointervEXT( GLuint vaobj, GLenum pname, void **param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", vaobj, pname, param );
+  TRACE( "(%d, %d, %p)\n", vaobj, pname, param );
   funcs->ext.p_glGetVertexArrayPointervEXT( vaobj, pname, param );
 }
 
-static void WINAPI glGetVertexArrayiv( GLuint vaobj, GLenum pname, GLint* param ) {
+static void WINAPI glGetVertexArrayiv( GLuint vaobj, GLenum pname, GLint *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", vaobj, pname, param );
+  TRACE( "(%d, %d, %p)\n", vaobj, pname, param );
   funcs->ext.p_glGetVertexArrayiv( vaobj, pname, param );
 }
 
-static void WINAPI glGetVertexAttribArrayObjectfvATI( GLuint index, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetVertexAttribArrayObjectfvATI( GLuint index, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribArrayObjectfvATI( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribArrayObjectivATI( GLuint index, GLenum pname, GLint* params ) {
+static void WINAPI glGetVertexAttribArrayObjectivATI( GLuint index, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribArrayObjectivATI( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribIiv( GLuint index, GLenum pname, GLint* params ) {
+static void WINAPI glGetVertexAttribIiv( GLuint index, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribIiv( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribIivEXT( GLuint index, GLenum pname, GLint* params ) {
+static void WINAPI glGetVertexAttribIivEXT( GLuint index, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribIivEXT( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribIuiv( GLuint index, GLenum pname, GLuint* params ) {
+static void WINAPI glGetVertexAttribIuiv( GLuint index, GLenum pname, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribIuiv( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribIuivEXT( GLuint index, GLenum pname, GLuint* params ) {
+static void WINAPI glGetVertexAttribIuivEXT( GLuint index, GLenum pname, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribIuivEXT( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribLdv( GLuint index, GLenum pname, GLdouble* params ) {
+static void WINAPI glGetVertexAttribLdv( GLuint index, GLenum pname, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribLdv( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribLdvEXT( GLuint index, GLenum pname, GLdouble* params ) {
+static void WINAPI glGetVertexAttribLdvEXT( GLuint index, GLenum pname, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribLdvEXT( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribLi64vNV( GLuint index, GLenum pname, GLint64EXT* params ) {
+static void WINAPI glGetVertexAttribLi64vNV( GLuint index, GLenum pname, GLint64EXT *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribLi64vNV( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribLui64vARB( GLuint index, GLenum pname, GLuint64EXT* params ) {
+static void WINAPI glGetVertexAttribLui64vARB( GLuint index, GLenum pname, GLuint64EXT *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribLui64vARB( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribLui64vNV( GLuint index, GLenum pname, GLuint64EXT* params ) {
+static void WINAPI glGetVertexAttribLui64vNV( GLuint index, GLenum pname, GLuint64EXT *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribLui64vNV( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribPointerv( GLuint index, GLenum pname, void** pointer ) {
+static void WINAPI glGetVertexAttribPointerv( GLuint index, GLenum pname, void **pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, pointer );
+  TRACE( "(%d, %d, %p)\n", index, pname, pointer );
   funcs->ext.p_glGetVertexAttribPointerv( index, pname, pointer );
 }
 
-static void WINAPI glGetVertexAttribPointervARB( GLuint index, GLenum pname, void** pointer ) {
+static void WINAPI glGetVertexAttribPointervARB( GLuint index, GLenum pname, void **pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, pointer );
+  TRACE( "(%d, %d, %p)\n", index, pname, pointer );
   funcs->ext.p_glGetVertexAttribPointervARB( index, pname, pointer );
 }
 
-static void WINAPI glGetVertexAttribPointervNV( GLuint index, GLenum pname, void** pointer ) {
+static void WINAPI glGetVertexAttribPointervNV( GLuint index, GLenum pname, void **pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, pointer );
+  TRACE( "(%d, %d, %p)\n", index, pname, pointer );
   funcs->ext.p_glGetVertexAttribPointervNV( index, pname, pointer );
 }
 
-static void WINAPI glGetVertexAttribdv( GLuint index, GLenum pname, GLdouble* params ) {
+static void WINAPI glGetVertexAttribdv( GLuint index, GLenum pname, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribdv( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribdvARB( GLuint index, GLenum pname, GLdouble* params ) {
+static void WINAPI glGetVertexAttribdvARB( GLuint index, GLenum pname, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribdvARB( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribdvNV( GLuint index, GLenum pname, GLdouble* params ) {
+static void WINAPI glGetVertexAttribdvNV( GLuint index, GLenum pname, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribdvNV( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribfv( GLuint index, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetVertexAttribfv( GLuint index, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribfv( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribfvARB( GLuint index, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetVertexAttribfvARB( GLuint index, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribfvARB( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribfvNV( GLuint index, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetVertexAttribfvNV( GLuint index, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribfvNV( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribiv( GLuint index, GLenum pname, GLint* params ) {
+static void WINAPI glGetVertexAttribiv( GLuint index, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribiv( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribivARB( GLuint index, GLenum pname, GLint* params ) {
+static void WINAPI glGetVertexAttribivARB( GLuint index, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribivARB( index, pname, params );
 }
 
-static void WINAPI glGetVertexAttribivNV( GLuint index, GLenum pname, GLint* params ) {
+static void WINAPI glGetVertexAttribivNV( GLuint index, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, pname, params );
+  TRACE( "(%d, %d, %p)\n", index, pname, params );
   funcs->ext.p_glGetVertexAttribivNV( index, pname, params );
 }
 
-static void WINAPI glGetVideoCaptureStreamdvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble* params ) {
+static void WINAPI glGetVideoCaptureStreamdvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params );
   funcs->ext.p_glGetVideoCaptureStreamdvNV( video_capture_slot, stream, pname, params );
 }
 
-static void WINAPI glGetVideoCaptureStreamfvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat* params ) {
+static void WINAPI glGetVideoCaptureStreamfvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params );
   funcs->ext.p_glGetVideoCaptureStreamfvNV( video_capture_slot, stream, pname, params );
 }
 
-static void WINAPI glGetVideoCaptureStreamivNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLint* params ) {
+static void WINAPI glGetVideoCaptureStreamivNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params );
   funcs->ext.p_glGetVideoCaptureStreamivNV( video_capture_slot, stream, pname, params );
 }
 
-static void WINAPI glGetVideoCaptureivNV( GLuint video_capture_slot, GLenum pname, GLint* params ) {
+static void WINAPI glGetVideoCaptureivNV( GLuint video_capture_slot, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", video_capture_slot, pname, params );
+  TRACE( "(%d, %d, %p)\n", video_capture_slot, pname, params );
   funcs->ext.p_glGetVideoCaptureivNV( video_capture_slot, pname, params );
 }
 
-static void WINAPI glGetVideoi64vNV( GLuint video_slot, GLenum pname, GLint64EXT* params ) {
+static void WINAPI glGetVideoi64vNV( GLuint video_slot, GLenum pname, GLint64EXT *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", video_slot, pname, params );
+  TRACE( "(%d, %d, %p)\n", video_slot, pname, params );
   funcs->ext.p_glGetVideoi64vNV( video_slot, pname, params );
 }
 
-static void WINAPI glGetVideoivNV( GLuint video_slot, GLenum pname, GLint* params ) {
+static void WINAPI glGetVideoivNV( GLuint video_slot, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", video_slot, pname, params );
+  TRACE( "(%d, %d, %p)\n", video_slot, pname, params );
   funcs->ext.p_glGetVideoivNV( video_slot, pname, params );
 }
 
-static void WINAPI glGetVideoui64vNV( GLuint video_slot, GLenum pname, GLuint64EXT* params ) {
+static void WINAPI glGetVideoui64vNV( GLuint video_slot, GLenum pname, GLuint64EXT *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", video_slot, pname, params );
+  TRACE( "(%d, %d, %p)\n", video_slot, pname, params );
   funcs->ext.p_glGetVideoui64vNV( video_slot, pname, params );
 }
 
-static void WINAPI glGetVideouivNV( GLuint video_slot, GLenum pname, GLuint* params ) {
+static void WINAPI glGetVideouivNV( GLuint video_slot, GLenum pname, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", video_slot, pname, params );
+  TRACE( "(%d, %d, %p)\n", video_slot, pname, params );
   funcs->ext.p_glGetVideouivNV( video_slot, pname, params );
 }
 
-static void * WINAPI glGetVkProcAddrNV( const GLchar* name ) {
+static void * WINAPI glGetVkProcAddrNV( const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", name );
+  TRACE( "(%p)\n", name );
   return funcs->ext.p_glGetVkProcAddrNV( name );
 }
 
-static void WINAPI glGetnColorTable( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void* table ) {
+static void WINAPI glGetnColorTable( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", target, format, type, bufSize, table );
+  TRACE( "(%d, %d, %d, %d, %p)\n", target, format, type, bufSize, table );
   funcs->ext.p_glGetnColorTable( target, format, type, bufSize, table );
 }
 
-static void WINAPI glGetnColorTableARB( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void* table ) {
+static void WINAPI glGetnColorTableARB( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", target, format, type, bufSize, table );
+  TRACE( "(%d, %d, %d, %d, %p)\n", target, format, type, bufSize, table );
   funcs->ext.p_glGetnColorTableARB( target, format, type, bufSize, table );
 }
 
-static void WINAPI glGetnCompressedTexImage( GLenum target, GLint lod, GLsizei bufSize, void* pixels ) {
+static void WINAPI glGetnCompressedTexImage( GLenum target, GLint lod, GLsizei bufSize, void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, lod, bufSize, pixels );
+  TRACE( "(%d, %d, %d, %p)\n", target, lod, bufSize, pixels );
   funcs->ext.p_glGetnCompressedTexImage( target, lod, bufSize, pixels );
 }
 
-static void WINAPI glGetnCompressedTexImageARB( GLenum target, GLint lod, GLsizei bufSize, void* img ) {
+static void WINAPI glGetnCompressedTexImageARB( GLenum target, GLint lod, GLsizei bufSize, void *img )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, lod, bufSize, img );
+  TRACE( "(%d, %d, %d, %p)\n", target, lod, bufSize, img );
   funcs->ext.p_glGetnCompressedTexImageARB( target, lod, bufSize, img );
 }
 
-static void WINAPI glGetnConvolutionFilter( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void* image ) {
+static void WINAPI glGetnConvolutionFilter( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", target, format, type, bufSize, image );
+  TRACE( "(%d, %d, %d, %d, %p)\n", target, format, type, bufSize, image );
   funcs->ext.p_glGetnConvolutionFilter( target, format, type, bufSize, image );
 }
 
-static void WINAPI glGetnConvolutionFilterARB( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void* image ) {
+static void WINAPI glGetnConvolutionFilterARB( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", target, format, type, bufSize, image );
+  TRACE( "(%d, %d, %d, %d, %p)\n", target, format, type, bufSize, image );
   funcs->ext.p_glGetnConvolutionFilterARB( target, format, type, bufSize, image );
 }
 
-static void WINAPI glGetnHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void* values ) {
+static void WINAPI glGetnHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, reset, format, type, bufSize, values );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", target, reset, format, type, bufSize, values );
   funcs->ext.p_glGetnHistogram( target, reset, format, type, bufSize, values );
 }
 
-static void WINAPI glGetnHistogramARB( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void* values ) {
+static void WINAPI glGetnHistogramARB( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, reset, format, type, bufSize, values );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", target, reset, format, type, bufSize, values );
   funcs->ext.p_glGetnHistogramARB( target, reset, format, type, bufSize, values );
 }
 
-static void WINAPI glGetnMapdv( GLenum target, GLenum query, GLsizei bufSize, GLdouble* v ) {
+static void WINAPI glGetnMapdv( GLenum target, GLenum query, GLsizei bufSize, GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, query, bufSize, v );
+  TRACE( "(%d, %d, %d, %p)\n", target, query, bufSize, v );
   funcs->ext.p_glGetnMapdv( target, query, bufSize, v );
 }
 
-static void WINAPI glGetnMapdvARB( GLenum target, GLenum query, GLsizei bufSize, GLdouble* v ) {
+static void WINAPI glGetnMapdvARB( GLenum target, GLenum query, GLsizei bufSize, GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, query, bufSize, v );
+  TRACE( "(%d, %d, %d, %p)\n", target, query, bufSize, v );
   funcs->ext.p_glGetnMapdvARB( target, query, bufSize, v );
 }
 
-static void WINAPI glGetnMapfv( GLenum target, GLenum query, GLsizei bufSize, GLfloat* v ) {
+static void WINAPI glGetnMapfv( GLenum target, GLenum query, GLsizei bufSize, GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, query, bufSize, v );
+  TRACE( "(%d, %d, %d, %p)\n", target, query, bufSize, v );
   funcs->ext.p_glGetnMapfv( target, query, bufSize, v );
 }
 
-static void WINAPI glGetnMapfvARB( GLenum target, GLenum query, GLsizei bufSize, GLfloat* v ) {
+static void WINAPI glGetnMapfvARB( GLenum target, GLenum query, GLsizei bufSize, GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, query, bufSize, v );
+  TRACE( "(%d, %d, %d, %p)\n", target, query, bufSize, v );
   funcs->ext.p_glGetnMapfvARB( target, query, bufSize, v );
 }
 
-static void WINAPI glGetnMapiv( GLenum target, GLenum query, GLsizei bufSize, GLint* v ) {
+static void WINAPI glGetnMapiv( GLenum target, GLenum query, GLsizei bufSize, GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, query, bufSize, v );
+  TRACE( "(%d, %d, %d, %p)\n", target, query, bufSize, v );
   funcs->ext.p_glGetnMapiv( target, query, bufSize, v );
 }
 
-static void WINAPI glGetnMapivARB( GLenum target, GLenum query, GLsizei bufSize, GLint* v ) {
+static void WINAPI glGetnMapivARB( GLenum target, GLenum query, GLsizei bufSize, GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, query, bufSize, v );
+  TRACE( "(%d, %d, %d, %p)\n", target, query, bufSize, v );
   funcs->ext.p_glGetnMapivARB( target, query, bufSize, v );
 }
 
-static void WINAPI glGetnMinmax( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void* values ) {
+static void WINAPI glGetnMinmax( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, reset, format, type, bufSize, values );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", target, reset, format, type, bufSize, values );
   funcs->ext.p_glGetnMinmax( target, reset, format, type, bufSize, values );
 }
 
-static void WINAPI glGetnMinmaxARB( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void* values ) {
+static void WINAPI glGetnMinmaxARB( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, reset, format, type, bufSize, values );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", target, reset, format, type, bufSize, values );
   funcs->ext.p_glGetnMinmaxARB( target, reset, format, type, bufSize, values );
 }
 
-static void WINAPI glGetnPixelMapfv( GLenum map, GLsizei bufSize, GLfloat* values ) {
+static void WINAPI glGetnPixelMapfv( GLenum map, GLsizei bufSize, GLfloat *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", map, bufSize, values );
+  TRACE( "(%d, %d, %p)\n", map, bufSize, values );
   funcs->ext.p_glGetnPixelMapfv( map, bufSize, values );
 }
 
-static void WINAPI glGetnPixelMapfvARB( GLenum map, GLsizei bufSize, GLfloat* values ) {
+static void WINAPI glGetnPixelMapfvARB( GLenum map, GLsizei bufSize, GLfloat *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", map, bufSize, values );
+  TRACE( "(%d, %d, %p)\n", map, bufSize, values );
   funcs->ext.p_glGetnPixelMapfvARB( map, bufSize, values );
 }
 
-static void WINAPI glGetnPixelMapuiv( GLenum map, GLsizei bufSize, GLuint* values ) {
+static void WINAPI glGetnPixelMapuiv( GLenum map, GLsizei bufSize, GLuint *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", map, bufSize, values );
+  TRACE( "(%d, %d, %p)\n", map, bufSize, values );
   funcs->ext.p_glGetnPixelMapuiv( map, bufSize, values );
 }
 
-static void WINAPI glGetnPixelMapuivARB( GLenum map, GLsizei bufSize, GLuint* values ) {
+static void WINAPI glGetnPixelMapuivARB( GLenum map, GLsizei bufSize, GLuint *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", map, bufSize, values );
+  TRACE( "(%d, %d, %p)\n", map, bufSize, values );
   funcs->ext.p_glGetnPixelMapuivARB( map, bufSize, values );
 }
 
-static void WINAPI glGetnPixelMapusv( GLenum map, GLsizei bufSize, GLushort* values ) {
+static void WINAPI glGetnPixelMapusv( GLenum map, GLsizei bufSize, GLushort *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", map, bufSize, values );
+  TRACE( "(%d, %d, %p)\n", map, bufSize, values );
   funcs->ext.p_glGetnPixelMapusv( map, bufSize, values );
 }
 
-static void WINAPI glGetnPixelMapusvARB( GLenum map, GLsizei bufSize, GLushort* values ) {
+static void WINAPI glGetnPixelMapusvARB( GLenum map, GLsizei bufSize, GLushort *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", map, bufSize, values );
+  TRACE( "(%d, %d, %p)\n", map, bufSize, values );
   funcs->ext.p_glGetnPixelMapusvARB( map, bufSize, values );
 }
 
-static void WINAPI glGetnPolygonStipple( GLsizei bufSize, GLubyte* pattern ) {
+static void WINAPI glGetnPolygonStipple( GLsizei bufSize, GLubyte *pattern )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", bufSize, pattern );
+  TRACE( "(%d, %p)\n", bufSize, pattern );
   funcs->ext.p_glGetnPolygonStipple( bufSize, pattern );
 }
 
-static void WINAPI glGetnPolygonStippleARB( GLsizei bufSize, GLubyte* pattern ) {
+static void WINAPI glGetnPolygonStippleARB( GLsizei bufSize, GLubyte *pattern )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", bufSize, pattern );
+  TRACE( "(%d, %p)\n", bufSize, pattern );
   funcs->ext.p_glGetnPolygonStippleARB( bufSize, pattern );
 }
 
-static void WINAPI glGetnSeparableFilter( GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void* row, GLsizei columnBufSize, void* column, void* span ) {
+static void WINAPI glGetnSeparableFilter( GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void *row, GLsizei columnBufSize, void *column, void *span )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p, %d, %p, %p)\n", target, format, type, rowBufSize, row, columnBufSize, column, span );
+  TRACE( "(%d, %d, %d, %d, %p, %d, %p, %p)\n", target, format, type, rowBufSize, row, columnBufSize, column, span );
   funcs->ext.p_glGetnSeparableFilter( target, format, type, rowBufSize, row, columnBufSize, column, span );
 }
 
-static void WINAPI glGetnSeparableFilterARB( GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void* row, GLsizei columnBufSize, void* column, void* span ) {
+static void WINAPI glGetnSeparableFilterARB( GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void *row, GLsizei columnBufSize, void *column, void *span )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p, %d, %p, %p)\n", target, format, type, rowBufSize, row, columnBufSize, column, span );
+  TRACE( "(%d, %d, %d, %d, %p, %d, %p, %p)\n", target, format, type, rowBufSize, row, columnBufSize, column, span );
   funcs->ext.p_glGetnSeparableFilterARB( target, format, type, rowBufSize, row, columnBufSize, column, span );
 }
 
-static void WINAPI glGetnTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* pixels ) {
+static void WINAPI glGetnTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, level, format, type, bufSize, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", target, level, format, type, bufSize, pixels );
   funcs->ext.p_glGetnTexImage( target, level, format, type, bufSize, pixels );
 }
 
-static void WINAPI glGetnTexImageARB( GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* img ) {
+static void WINAPI glGetnTexImageARB( GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *img )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", target, level, format, type, bufSize, img );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", target, level, format, type, bufSize, img );
   funcs->ext.p_glGetnTexImageARB( target, level, format, type, bufSize, img );
 }
 
-static void WINAPI glGetnUniformdv( GLuint program, GLint location, GLsizei bufSize, GLdouble* params ) {
+static void WINAPI glGetnUniformdv( GLuint program, GLint location, GLsizei bufSize, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, bufSize, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, bufSize, params );
   funcs->ext.p_glGetnUniformdv( program, location, bufSize, params );
 }
 
-static void WINAPI glGetnUniformdvARB( GLuint program, GLint location, GLsizei bufSize, GLdouble* params ) {
+static void WINAPI glGetnUniformdvARB( GLuint program, GLint location, GLsizei bufSize, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, bufSize, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, bufSize, params );
   funcs->ext.p_glGetnUniformdvARB( program, location, bufSize, params );
 }
 
-static void WINAPI glGetnUniformfv( GLuint program, GLint location, GLsizei bufSize, GLfloat* params ) {
+static void WINAPI glGetnUniformfv( GLuint program, GLint location, GLsizei bufSize, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, bufSize, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, bufSize, params );
   funcs->ext.p_glGetnUniformfv( program, location, bufSize, params );
 }
 
-static void WINAPI glGetnUniformfvARB( GLuint program, GLint location, GLsizei bufSize, GLfloat* params ) {
+static void WINAPI glGetnUniformfvARB( GLuint program, GLint location, GLsizei bufSize, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, bufSize, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, bufSize, params );
   funcs->ext.p_glGetnUniformfvARB( program, location, bufSize, params );
 }
 
-static void WINAPI glGetnUniformi64vARB( GLuint program, GLint location, GLsizei bufSize, GLint64* params ) {
+static void WINAPI glGetnUniformi64vARB( GLuint program, GLint location, GLsizei bufSize, GLint64 *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, bufSize, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, bufSize, params );
   funcs->ext.p_glGetnUniformi64vARB( program, location, bufSize, params );
 }
 
-static void WINAPI glGetnUniformiv( GLuint program, GLint location, GLsizei bufSize, GLint* params ) {
+static void WINAPI glGetnUniformiv( GLuint program, GLint location, GLsizei bufSize, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, bufSize, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, bufSize, params );
   funcs->ext.p_glGetnUniformiv( program, location, bufSize, params );
 }
 
-static void WINAPI glGetnUniformivARB( GLuint program, GLint location, GLsizei bufSize, GLint* params ) {
+static void WINAPI glGetnUniformivARB( GLuint program, GLint location, GLsizei bufSize, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, bufSize, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, bufSize, params );
   funcs->ext.p_glGetnUniformivARB( program, location, bufSize, params );
 }
 
-static void WINAPI glGetnUniformui64vARB( GLuint program, GLint location, GLsizei bufSize, GLuint64* params ) {
+static void WINAPI glGetnUniformui64vARB( GLuint program, GLint location, GLsizei bufSize, GLuint64 *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, bufSize, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, bufSize, params );
   funcs->ext.p_glGetnUniformui64vARB( program, location, bufSize, params );
 }
 
-static void WINAPI glGetnUniformuiv( GLuint program, GLint location, GLsizei bufSize, GLuint* params ) {
+static void WINAPI glGetnUniformuiv( GLuint program, GLint location, GLsizei bufSize, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, bufSize, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, bufSize, params );
   funcs->ext.p_glGetnUniformuiv( program, location, bufSize, params );
 }
 
-static void WINAPI glGetnUniformuivARB( GLuint program, GLint location, GLsizei bufSize, GLuint* params ) {
+static void WINAPI glGetnUniformuivARB( GLuint program, GLint location, GLsizei bufSize, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, bufSize, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, bufSize, params );
   funcs->ext.p_glGetnUniformuivARB( program, location, bufSize, params );
 }
 
-static void WINAPI glGlobalAlphaFactorbSUN( GLbyte factor ) {
+static void WINAPI glGlobalAlphaFactorbSUN( GLbyte factor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", factor );
+  TRACE( "(%d)\n", factor );
   funcs->ext.p_glGlobalAlphaFactorbSUN( factor );
 }
 
-static void WINAPI glGlobalAlphaFactordSUN( GLdouble factor ) {
+static void WINAPI glGlobalAlphaFactordSUN( GLdouble factor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", factor );
+  TRACE( "(%f)\n", factor );
   funcs->ext.p_glGlobalAlphaFactordSUN( factor );
 }
 
-static void WINAPI glGlobalAlphaFactorfSUN( GLfloat factor ) {
+static void WINAPI glGlobalAlphaFactorfSUN( GLfloat factor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", factor );
+  TRACE( "(%f)\n", factor );
   funcs->ext.p_glGlobalAlphaFactorfSUN( factor );
 }
 
-static void WINAPI glGlobalAlphaFactoriSUN( GLint factor ) {
+static void WINAPI glGlobalAlphaFactoriSUN( GLint factor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", factor );
+  TRACE( "(%d)\n", factor );
   funcs->ext.p_glGlobalAlphaFactoriSUN( factor );
 }
 
-static void WINAPI glGlobalAlphaFactorsSUN( GLshort factor ) {
+static void WINAPI glGlobalAlphaFactorsSUN( GLshort factor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", factor );
+  TRACE( "(%d)\n", factor );
   funcs->ext.p_glGlobalAlphaFactorsSUN( factor );
 }
 
-static void WINAPI glGlobalAlphaFactorubSUN( GLubyte factor ) {
+static void WINAPI glGlobalAlphaFactorubSUN( GLubyte factor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", factor );
+  TRACE( "(%d)\n", factor );
   funcs->ext.p_glGlobalAlphaFactorubSUN( factor );
 }
 
-static void WINAPI glGlobalAlphaFactoruiSUN( GLuint factor ) {
+static void WINAPI glGlobalAlphaFactoruiSUN( GLuint factor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", factor );
+  TRACE( "(%d)\n", factor );
   funcs->ext.p_glGlobalAlphaFactoruiSUN( factor );
 }
 
-static void WINAPI glGlobalAlphaFactorusSUN( GLushort factor ) {
+static void WINAPI glGlobalAlphaFactorusSUN( GLushort factor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", factor );
+  TRACE( "(%d)\n", factor );
   funcs->ext.p_glGlobalAlphaFactorusSUN( factor );
 }
 
-static void WINAPI glHintPGI( GLenum target, GLint mode ) {
+static void WINAPI glHintPGI( GLenum target, GLint mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, mode );
+  TRACE( "(%d, %d)\n", target, mode );
   funcs->ext.p_glHintPGI( target, mode );
 }
 
-static void WINAPI glHistogram( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink ) {
+static void WINAPI glHistogram( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, width, internalformat, sink );
+  TRACE( "(%d, %d, %d, %d)\n", target, width, internalformat, sink );
   funcs->ext.p_glHistogram( target, width, internalformat, sink );
 }
 
-static void WINAPI glHistogramEXT( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink ) {
+static void WINAPI glHistogramEXT( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, width, internalformat, sink );
+  TRACE( "(%d, %d, %d, %d)\n", target, width, internalformat, sink );
   funcs->ext.p_glHistogramEXT( target, width, internalformat, sink );
 }
 
-static void WINAPI glIglooInterfaceSGIX( GLenum pname, const void* params ) {
+static void WINAPI glIglooInterfaceSGIX( GLenum pname, const void *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glIglooInterfaceSGIX( pname, params );
 }
 
-static void WINAPI glImageTransformParameterfHP( GLenum target, GLenum pname, GLfloat param ) {
+static void WINAPI glImageTransformParameterfHP( GLenum target, GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", target, pname, param );
+  TRACE( "(%d, %d, %f)\n", target, pname, param );
   funcs->ext.p_glImageTransformParameterfHP( target, pname, param );
 }
 
-static void WINAPI glImageTransformParameterfvHP( GLenum target, GLenum pname, const GLfloat* params ) {
+static void WINAPI glImageTransformParameterfvHP( GLenum target, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glImageTransformParameterfvHP( target, pname, params );
 }
 
-static void WINAPI glImageTransformParameteriHP( GLenum target, GLenum pname, GLint param ) {
+static void WINAPI glImageTransformParameteriHP( GLenum target, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, pname, param );
+  TRACE( "(%d, %d, %d)\n", target, pname, param );
   funcs->ext.p_glImageTransformParameteriHP( target, pname, param );
 }
 
-static void WINAPI glImageTransformParameterivHP( GLenum target, GLenum pname, const GLint* params ) {
+static void WINAPI glImageTransformParameterivHP( GLenum target, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glImageTransformParameterivHP( target, pname, params );
 }
 
-static void WINAPI glImportMemoryFdEXT( GLuint memory, GLuint64 size, GLenum handleType, GLint fd ) {
+static void WINAPI glImportMemoryFdEXT( GLuint memory, GLuint64 size, GLenum handleType, GLint fd )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %d, %d)\n", memory, wine_dbgstr_longlong(size), handleType, fd );
+  TRACE( "(%d, %s, %d, %d)\n", memory, wine_dbgstr_longlong(size), handleType, fd );
   funcs->ext.p_glImportMemoryFdEXT( memory, size, handleType, fd );
 }
 
-static void WINAPI glImportMemoryWin32HandleEXT( GLuint memory, GLuint64 size, GLenum handleType, void* handle ) {
+static void WINAPI glImportMemoryWin32HandleEXT( GLuint memory, GLuint64 size, GLenum handleType, void *handle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %d, %p)\n", memory, wine_dbgstr_longlong(size), handleType, handle );
+  TRACE( "(%d, %s, %d, %p)\n", memory, wine_dbgstr_longlong(size), handleType, handle );
   funcs->ext.p_glImportMemoryWin32HandleEXT( memory, size, handleType, handle );
 }
 
-static void WINAPI glImportMemoryWin32NameEXT( GLuint memory, GLuint64 size, GLenum handleType, const void* name ) {
+static void WINAPI glImportMemoryWin32NameEXT( GLuint memory, GLuint64 size, GLenum handleType, const void *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %d, %p)\n", memory, wine_dbgstr_longlong(size), handleType, name );
+  TRACE( "(%d, %s, %d, %p)\n", memory, wine_dbgstr_longlong(size), handleType, name );
   funcs->ext.p_glImportMemoryWin32NameEXT( memory, size, handleType, name );
 }
 
-static void WINAPI glImportSemaphoreFdEXT( GLuint semaphore, GLenum handleType, GLint fd ) {
+static void WINAPI glImportSemaphoreFdEXT( GLuint semaphore, GLenum handleType, GLint fd )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", semaphore, handleType, fd );
+  TRACE( "(%d, %d, %d)\n", semaphore, handleType, fd );
   funcs->ext.p_glImportSemaphoreFdEXT( semaphore, handleType, fd );
 }
 
-static void WINAPI glImportSemaphoreWin32HandleEXT( GLuint semaphore, GLenum handleType, void* handle ) {
+static void WINAPI glImportSemaphoreWin32HandleEXT( GLuint semaphore, GLenum handleType, void *handle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", semaphore, handleType, handle );
+  TRACE( "(%d, %d, %p)\n", semaphore, handleType, handle );
   funcs->ext.p_glImportSemaphoreWin32HandleEXT( semaphore, handleType, handle );
 }
 
-static void WINAPI glImportSemaphoreWin32NameEXT( GLuint semaphore, GLenum handleType, const void* name ) {
+static void WINAPI glImportSemaphoreWin32NameEXT( GLuint semaphore, GLenum handleType, const void *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", semaphore, handleType, name );
+  TRACE( "(%d, %d, %p)\n", semaphore, handleType, name );
   funcs->ext.p_glImportSemaphoreWin32NameEXT( semaphore, handleType, name );
 }
 
-static GLsync WINAPI glImportSyncEXT( GLenum external_sync_type, GLintptr external_sync, GLbitfield flags ) {
+static GLsync WINAPI glImportSyncEXT( GLenum external_sync_type, GLintptr external_sync, GLbitfield flags )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %d)\n", external_sync_type, external_sync, flags );
+  TRACE( "(%d, %ld, %d)\n", external_sync_type, external_sync, flags );
   return funcs->ext.p_glImportSyncEXT( external_sync_type, external_sync, flags );
 }
 
-static void WINAPI glIndexFormatNV( GLenum type, GLsizei stride ) {
+static void WINAPI glIndexFormatNV( GLenum type, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", type, stride );
+  TRACE( "(%d, %d)\n", type, stride );
   funcs->ext.p_glIndexFormatNV( type, stride );
 }
 
-static void WINAPI glIndexFuncEXT( GLenum func, GLclampf ref ) {
+static void WINAPI glIndexFuncEXT( GLenum func, GLclampf ref )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", func, ref );
+  TRACE( "(%d, %f)\n", func, ref );
   funcs->ext.p_glIndexFuncEXT( func, ref );
 }
 
-static void WINAPI glIndexMaterialEXT( GLenum face, GLenum mode ) {
+static void WINAPI glIndexMaterialEXT( GLenum face, GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", face, mode );
+  TRACE( "(%d, %d)\n", face, mode );
   funcs->ext.p_glIndexMaterialEXT( face, mode );
 }
 
-static void WINAPI glIndexPointerEXT( GLenum type, GLsizei stride, GLsizei count, const void* pointer ) {
+static void WINAPI glIndexPointerEXT( GLenum type, GLsizei stride, GLsizei count, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", type, stride, count, pointer );
+  TRACE( "(%d, %d, %d, %p)\n", type, stride, count, pointer );
   funcs->ext.p_glIndexPointerEXT( type, stride, count, pointer );
 }
 
-static void WINAPI glIndexPointerListIBM( GLenum type, GLint stride, const void** pointer, GLint ptrstride ) {
+static void WINAPI glIndexPointerListIBM( GLenum type, GLint stride, const void **pointer, GLint ptrstride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d)\n", type, stride, pointer, ptrstride );
+  TRACE( "(%d, %d, %p, %d)\n", type, stride, pointer, ptrstride );
   funcs->ext.p_glIndexPointerListIBM( type, stride, pointer, ptrstride );
 }
 
-static void WINAPI glIndexxOES( GLfixed component ) {
+static void WINAPI glIndexxOES( GLfixed component )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", component );
+  TRACE( "(%d)\n", component );
   funcs->ext.p_glIndexxOES( component );
 }
 
-static void WINAPI glIndexxvOES( const GLfixed* component ) {
+static void WINAPI glIndexxvOES( const GLfixed *component )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", component );
+  TRACE( "(%p)\n", component );
   funcs->ext.p_glIndexxvOES( component );
 }
 
-static void WINAPI glInsertComponentEXT( GLuint res, GLuint src, GLuint num ) {
+static void WINAPI glInsertComponentEXT( GLuint res, GLuint src, GLuint num )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", res, src, num );
+  TRACE( "(%d, %d, %d)\n", res, src, num );
   funcs->ext.p_glInsertComponentEXT( res, src, num );
 }
 
-static void WINAPI glInsertEventMarkerEXT( GLsizei length, const GLchar* marker ) {
+static void WINAPI glInsertEventMarkerEXT( GLsizei length, const GLchar *marker )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", length, marker );
+  TRACE( "(%d, %p)\n", length, marker );
   funcs->ext.p_glInsertEventMarkerEXT( length, marker );
 }
 
-static void WINAPI glInstrumentsBufferSGIX( GLsizei size, GLint* buffer ) {
+static void WINAPI glInstrumentsBufferSGIX( GLsizei size, GLint *buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", size, buffer );
+  TRACE( "(%d, %p)\n", size, buffer );
   funcs->ext.p_glInstrumentsBufferSGIX( size, buffer );
 }
 
-static void WINAPI glInterpolatePathsNV( GLuint resultPath, GLuint pathA, GLuint pathB, GLfloat weight ) {
+static void WINAPI glInterpolatePathsNV( GLuint resultPath, GLuint pathA, GLuint pathB, GLfloat weight )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %f)\n", resultPath, pathA, pathB, weight );
+  TRACE( "(%d, %d, %d, %f)\n", resultPath, pathA, pathB, weight );
   funcs->ext.p_glInterpolatePathsNV( resultPath, pathA, pathB, weight );
 }
 
-static void WINAPI glInvalidateBufferData( GLuint buffer ) {
+static void WINAPI glInvalidateBufferData( GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", buffer );
+  TRACE( "(%d)\n", buffer );
   funcs->ext.p_glInvalidateBufferData( buffer );
 }
 
-static void WINAPI glInvalidateBufferSubData( GLuint buffer, GLintptr offset, GLsizeiptr length ) {
+static void WINAPI glInvalidateBufferSubData( GLuint buffer, GLintptr offset, GLsizeiptr length )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld)\n", buffer, offset, length );
+  TRACE( "(%d, %ld, %ld)\n", buffer, offset, length );
   funcs->ext.p_glInvalidateBufferSubData( buffer, offset, length );
 }
 
-static void WINAPI glInvalidateFramebuffer( GLenum target, GLsizei numAttachments, const GLenum* attachments ) {
+static void WINAPI glInvalidateFramebuffer( GLenum target, GLsizei numAttachments, const GLenum *attachments )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, numAttachments, attachments );
+  TRACE( "(%d, %d, %p)\n", target, numAttachments, attachments );
   funcs->ext.p_glInvalidateFramebuffer( target, numAttachments, attachments );
 }
 
-static void WINAPI glInvalidateNamedFramebufferData( GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments ) {
+static void WINAPI glInvalidateNamedFramebufferData( GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", framebuffer, numAttachments, attachments );
+  TRACE( "(%d, %d, %p)\n", framebuffer, numAttachments, attachments );
   funcs->ext.p_glInvalidateNamedFramebufferData( framebuffer, numAttachments, attachments );
 }
 
-static void WINAPI glInvalidateNamedFramebufferSubData( GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height ) {
+static void WINAPI glInvalidateNamedFramebufferSubData( GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %d, %d, %d)\n", framebuffer, numAttachments, attachments, x, y, width, height );
+  TRACE( "(%d, %d, %p, %d, %d, %d, %d)\n", framebuffer, numAttachments, attachments, x, y, width, height );
   funcs->ext.p_glInvalidateNamedFramebufferSubData( framebuffer, numAttachments, attachments, x, y, width, height );
 }
 
-static void WINAPI glInvalidateSubFramebuffer( GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height ) {
+static void WINAPI glInvalidateSubFramebuffer( GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %d, %d, %d)\n", target, numAttachments, attachments, x, y, width, height );
+  TRACE( "(%d, %d, %p, %d, %d, %d, %d)\n", target, numAttachments, attachments, x, y, width, height );
   funcs->ext.p_glInvalidateSubFramebuffer( target, numAttachments, attachments, x, y, width, height );
 }
 
-static void WINAPI glInvalidateTexImage( GLuint texture, GLint level ) {
+static void WINAPI glInvalidateTexImage( GLuint texture, GLint level )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", texture, level );
+  TRACE( "(%d, %d)\n", texture, level );
   funcs->ext.p_glInvalidateTexImage( texture, level );
 }
 
-static void WINAPI glInvalidateTexSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth ) {
+static void WINAPI glInvalidateTexSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, level, xoffset, yoffset, zoffset, width, height, depth );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, level, xoffset, yoffset, zoffset, width, height, depth );
   funcs->ext.p_glInvalidateTexSubImage( texture, level, xoffset, yoffset, zoffset, width, height, depth );
 }
 
-static GLboolean WINAPI glIsAsyncMarkerSGIX( GLuint marker ) {
+static GLboolean WINAPI glIsAsyncMarkerSGIX( GLuint marker )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", marker );
+  TRACE( "(%d)\n", marker );
   return funcs->ext.p_glIsAsyncMarkerSGIX( marker );
 }
 
-static GLboolean WINAPI glIsBuffer( GLuint buffer ) {
+static GLboolean WINAPI glIsBuffer( GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", buffer );
+  TRACE( "(%d)\n", buffer );
   return funcs->ext.p_glIsBuffer( buffer );
 }
 
-static GLboolean WINAPI glIsBufferARB( GLuint buffer ) {
+static GLboolean WINAPI glIsBufferARB( GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", buffer );
+  TRACE( "(%d)\n", buffer );
   return funcs->ext.p_glIsBufferARB( buffer );
 }
 
-static GLboolean WINAPI glIsBufferResidentNV( GLenum target ) {
+static GLboolean WINAPI glIsBufferResidentNV( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   return funcs->ext.p_glIsBufferResidentNV( target );
 }
 
-static GLboolean WINAPI glIsCommandListNV( GLuint list ) {
+static GLboolean WINAPI glIsCommandListNV( GLuint list )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", list );
+  TRACE( "(%d)\n", list );
   return funcs->ext.p_glIsCommandListNV( list );
 }
 
-static GLboolean WINAPI glIsEnabledIndexedEXT( GLenum target, GLuint index ) {
+static GLboolean WINAPI glIsEnabledIndexedEXT( GLenum target, GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, index );
+  TRACE( "(%d, %d)\n", target, index );
   return funcs->ext.p_glIsEnabledIndexedEXT( target, index );
 }
 
-static GLboolean WINAPI glIsEnabledi( GLenum target, GLuint index ) {
+static GLboolean WINAPI glIsEnabledi( GLenum target, GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, index );
+  TRACE( "(%d, %d)\n", target, index );
   return funcs->ext.p_glIsEnabledi( target, index );
 }
 
-static GLboolean WINAPI glIsFenceAPPLE( GLuint fence ) {
+static GLboolean WINAPI glIsFenceAPPLE( GLuint fence )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", fence );
+  TRACE( "(%d)\n", fence );
   return funcs->ext.p_glIsFenceAPPLE( fence );
 }
 
-static GLboolean WINAPI glIsFenceNV( GLuint fence ) {
+static GLboolean WINAPI glIsFenceNV( GLuint fence )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", fence );
+  TRACE( "(%d)\n", fence );
   return funcs->ext.p_glIsFenceNV( fence );
 }
 
-static GLboolean WINAPI glIsFramebuffer( GLuint framebuffer ) {
+static GLboolean WINAPI glIsFramebuffer( GLuint framebuffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", framebuffer );
+  TRACE( "(%d)\n", framebuffer );
   return funcs->ext.p_glIsFramebuffer( framebuffer );
 }
 
-static GLboolean WINAPI glIsFramebufferEXT( GLuint framebuffer ) {
+static GLboolean WINAPI glIsFramebufferEXT( GLuint framebuffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", framebuffer );
+  TRACE( "(%d)\n", framebuffer );
   return funcs->ext.p_glIsFramebufferEXT( framebuffer );
 }
 
-static GLboolean WINAPI glIsImageHandleResidentARB( GLuint64 handle ) {
+static GLboolean WINAPI glIsImageHandleResidentARB( GLuint64 handle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%s)\n", wine_dbgstr_longlong(handle) );
+  TRACE( "(%s)\n", wine_dbgstr_longlong(handle) );
   return funcs->ext.p_glIsImageHandleResidentARB( handle );
 }
 
-static GLboolean WINAPI glIsImageHandleResidentNV( GLuint64 handle ) {
+static GLboolean WINAPI glIsImageHandleResidentNV( GLuint64 handle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%s)\n", wine_dbgstr_longlong(handle) );
+  TRACE( "(%s)\n", wine_dbgstr_longlong(handle) );
   return funcs->ext.p_glIsImageHandleResidentNV( handle );
 }
 
-static GLboolean WINAPI glIsMemoryObjectEXT( GLuint memoryObject ) {
+static GLboolean WINAPI glIsMemoryObjectEXT( GLuint memoryObject )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", memoryObject );
+  TRACE( "(%d)\n", memoryObject );
   return funcs->ext.p_glIsMemoryObjectEXT( memoryObject );
 }
 
-static GLboolean WINAPI glIsNameAMD( GLenum identifier, GLuint name ) {
+static GLboolean WINAPI glIsNameAMD( GLenum identifier, GLuint name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", identifier, name );
+  TRACE( "(%d, %d)\n", identifier, name );
   return funcs->ext.p_glIsNameAMD( identifier, name );
 }
 
-static GLboolean WINAPI glIsNamedBufferResidentNV( GLuint buffer ) {
+static GLboolean WINAPI glIsNamedBufferResidentNV( GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", buffer );
+  TRACE( "(%d)\n", buffer );
   return funcs->ext.p_glIsNamedBufferResidentNV( buffer );
 }
 
-static GLboolean WINAPI glIsNamedStringARB( GLint namelen, const GLchar* name ) {
+static GLboolean WINAPI glIsNamedStringARB( GLint namelen, const GLchar *name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", namelen, name );
+  TRACE( "(%d, %p)\n", namelen, name );
   return funcs->ext.p_glIsNamedStringARB( namelen, name );
 }
 
-static GLboolean WINAPI glIsObjectBufferATI( GLuint buffer ) {
+static GLboolean WINAPI glIsObjectBufferATI( GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", buffer );
+  TRACE( "(%d)\n", buffer );
   return funcs->ext.p_glIsObjectBufferATI( buffer );
 }
 
-static GLboolean WINAPI glIsOcclusionQueryNV( GLuint id ) {
+static GLboolean WINAPI glIsOcclusionQueryNV( GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", id );
+  TRACE( "(%d)\n", id );
   return funcs->ext.p_glIsOcclusionQueryNV( id );
 }
 
-static GLboolean WINAPI glIsPathNV( GLuint path ) {
+static GLboolean WINAPI glIsPathNV( GLuint path )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", path );
+  TRACE( "(%d)\n", path );
   return funcs->ext.p_glIsPathNV( path );
 }
 
-static GLboolean WINAPI glIsPointInFillPathNV( GLuint path, GLuint mask, GLfloat x, GLfloat y ) {
+static GLboolean WINAPI glIsPointInFillPathNV( GLuint path, GLuint mask, GLfloat x, GLfloat y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f)\n", path, mask, x, y );
+  TRACE( "(%d, %d, %f, %f)\n", path, mask, x, y );
   return funcs->ext.p_glIsPointInFillPathNV( path, mask, x, y );
 }
 
-static GLboolean WINAPI glIsPointInStrokePathNV( GLuint path, GLfloat x, GLfloat y ) {
+static GLboolean WINAPI glIsPointInStrokePathNV( GLuint path, GLfloat x, GLfloat y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", path, x, y );
+  TRACE( "(%d, %f, %f)\n", path, x, y );
   return funcs->ext.p_glIsPointInStrokePathNV( path, x, y );
 }
 
-static GLboolean WINAPI glIsProgram( GLuint program ) {
+static GLboolean WINAPI glIsProgram( GLuint program )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", program );
+  TRACE( "(%d)\n", program );
   return funcs->ext.p_glIsProgram( program );
 }
 
-static GLboolean WINAPI glIsProgramARB( GLuint program ) {
+static GLboolean WINAPI glIsProgramARB( GLuint program )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", program );
+  TRACE( "(%d)\n", program );
   return funcs->ext.p_glIsProgramARB( program );
 }
 
-static GLboolean WINAPI glIsProgramNV( GLuint id ) {
+static GLboolean WINAPI glIsProgramNV( GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", id );
+  TRACE( "(%d)\n", id );
   return funcs->ext.p_glIsProgramNV( id );
 }
 
-static GLboolean WINAPI glIsProgramPipeline( GLuint pipeline ) {
+static GLboolean WINAPI glIsProgramPipeline( GLuint pipeline )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", pipeline );
+  TRACE( "(%d)\n", pipeline );
   return funcs->ext.p_glIsProgramPipeline( pipeline );
 }
 
-static GLboolean WINAPI glIsQuery( GLuint id ) {
+static GLboolean WINAPI glIsQuery( GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", id );
+  TRACE( "(%d)\n", id );
   return funcs->ext.p_glIsQuery( id );
 }
 
-static GLboolean WINAPI glIsQueryARB( GLuint id ) {
+static GLboolean WINAPI glIsQueryARB( GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", id );
+  TRACE( "(%d)\n", id );
   return funcs->ext.p_glIsQueryARB( id );
 }
 
-static GLboolean WINAPI glIsRenderbuffer( GLuint renderbuffer ) {
+static GLboolean WINAPI glIsRenderbuffer( GLuint renderbuffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", renderbuffer );
+  TRACE( "(%d)\n", renderbuffer );
   return funcs->ext.p_glIsRenderbuffer( renderbuffer );
 }
 
-static GLboolean WINAPI glIsRenderbufferEXT( GLuint renderbuffer ) {
+static GLboolean WINAPI glIsRenderbufferEXT( GLuint renderbuffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", renderbuffer );
+  TRACE( "(%d)\n", renderbuffer );
   return funcs->ext.p_glIsRenderbufferEXT( renderbuffer );
 }
 
-static GLboolean WINAPI glIsSampler( GLuint sampler ) {
+static GLboolean WINAPI glIsSampler( GLuint sampler )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", sampler );
+  TRACE( "(%d)\n", sampler );
   return funcs->ext.p_glIsSampler( sampler );
 }
 
-static GLboolean WINAPI glIsSemaphoreEXT( GLuint semaphore ) {
+static GLboolean WINAPI glIsSemaphoreEXT( GLuint semaphore )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", semaphore );
+  TRACE( "(%d)\n", semaphore );
   return funcs->ext.p_glIsSemaphoreEXT( semaphore );
 }
 
-static GLboolean WINAPI glIsShader( GLuint shader ) {
+static GLboolean WINAPI glIsShader( GLuint shader )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", shader );
+  TRACE( "(%d)\n", shader );
   return funcs->ext.p_glIsShader( shader );
 }
 
-static GLboolean WINAPI glIsStateNV( GLuint state ) {
+static GLboolean WINAPI glIsStateNV( GLuint state )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", state );
+  TRACE( "(%d)\n", state );
   return funcs->ext.p_glIsStateNV( state );
 }
 
-static GLboolean WINAPI glIsSync( GLsync sync ) {
+static GLboolean WINAPI glIsSync( GLsync sync )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", sync );
+  TRACE( "(%p)\n", sync );
   return funcs->ext.p_glIsSync( sync );
 }
 
-static GLboolean WINAPI glIsTextureEXT( GLuint texture ) {
+static GLboolean WINAPI glIsTextureEXT( GLuint texture )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", texture );
+  TRACE( "(%d)\n", texture );
   return funcs->ext.p_glIsTextureEXT( texture );
 }
 
-static GLboolean WINAPI glIsTextureHandleResidentARB( GLuint64 handle ) {
+static GLboolean WINAPI glIsTextureHandleResidentARB( GLuint64 handle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%s)\n", wine_dbgstr_longlong(handle) );
+  TRACE( "(%s)\n", wine_dbgstr_longlong(handle) );
   return funcs->ext.p_glIsTextureHandleResidentARB( handle );
 }
 
-static GLboolean WINAPI glIsTextureHandleResidentNV( GLuint64 handle ) {
+static GLboolean WINAPI glIsTextureHandleResidentNV( GLuint64 handle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%s)\n", wine_dbgstr_longlong(handle) );
+  TRACE( "(%s)\n", wine_dbgstr_longlong(handle) );
   return funcs->ext.p_glIsTextureHandleResidentNV( handle );
 }
 
-static GLboolean WINAPI glIsTransformFeedback( GLuint id ) {
+static GLboolean WINAPI glIsTransformFeedback( GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", id );
+  TRACE( "(%d)\n", id );
   return funcs->ext.p_glIsTransformFeedback( id );
 }
 
-static GLboolean WINAPI glIsTransformFeedbackNV( GLuint id ) {
+static GLboolean WINAPI glIsTransformFeedbackNV( GLuint id )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", id );
+  TRACE( "(%d)\n", id );
   return funcs->ext.p_glIsTransformFeedbackNV( id );
 }
 
-static GLboolean WINAPI glIsVariantEnabledEXT( GLuint id, GLenum cap ) {
+static GLboolean WINAPI glIsVariantEnabledEXT( GLuint id, GLenum cap )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", id, cap );
+  TRACE( "(%d, %d)\n", id, cap );
   return funcs->ext.p_glIsVariantEnabledEXT( id, cap );
 }
 
-static GLboolean WINAPI glIsVertexArray( GLuint array ) {
+static GLboolean WINAPI glIsVertexArray( GLuint array )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", array );
+  TRACE( "(%d)\n", array );
   return funcs->ext.p_glIsVertexArray( array );
 }
 
-static GLboolean WINAPI glIsVertexArrayAPPLE( GLuint array ) {
+static GLboolean WINAPI glIsVertexArrayAPPLE( GLuint array )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", array );
+  TRACE( "(%d)\n", array );
   return funcs->ext.p_glIsVertexArrayAPPLE( array );
 }
 
-static GLboolean WINAPI glIsVertexAttribEnabledAPPLE( GLuint index, GLenum pname ) {
+static GLboolean WINAPI glIsVertexAttribEnabledAPPLE( GLuint index, GLenum pname )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", index, pname );
+  TRACE( "(%d, %d)\n", index, pname );
   return funcs->ext.p_glIsVertexAttribEnabledAPPLE( index, pname );
 }
 
-static void WINAPI glLGPUCopyImageSubDataNVX( GLuint sourceGpu, GLbitfield destinationGpuMask, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srxY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth ) {
+static void WINAPI glLGPUCopyImageSubDataNVX( GLuint sourceGpu, GLbitfield destinationGpuMask, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srxY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", sourceGpu, destinationGpuMask, srcName, srcTarget, srcLevel, srcX, srxY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", sourceGpu, destinationGpuMask, srcName, srcTarget, srcLevel, srcX, srxY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth );
   funcs->ext.p_glLGPUCopyImageSubDataNVX( sourceGpu, destinationGpuMask, srcName, srcTarget, srcLevel, srcX, srxY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth );
 }
 
-static void WINAPI glLGPUInterlockNVX( void ) {
+static void WINAPI glLGPUInterlockNVX(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glLGPUInterlockNVX( );
+  TRACE( "()\n" );
+  funcs->ext.p_glLGPUInterlockNVX();
 }
 
-static void WINAPI glLGPUNamedBufferSubDataNVX( GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, const void* data ) {
+static void WINAPI glLGPUNamedBufferSubDataNVX( GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %ld, %ld, %p)\n", gpuMask, buffer, offset, size, data );
+  TRACE( "(%d, %d, %ld, %ld, %p)\n", gpuMask, buffer, offset, size, data );
   funcs->ext.p_glLGPUNamedBufferSubDataNVX( gpuMask, buffer, offset, size, data );
 }
 
-static void WINAPI glLabelObjectEXT( GLenum type, GLuint object, GLsizei length, const GLchar* label ) {
+static void WINAPI glLabelObjectEXT( GLenum type, GLuint object, GLsizei length, const GLchar *label )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", type, object, length, label );
+  TRACE( "(%d, %d, %d, %p)\n", type, object, length, label );
   funcs->ext.p_glLabelObjectEXT( type, object, length, label );
 }
 
-static void WINAPI glLightEnviSGIX( GLenum pname, GLint param ) {
+static void WINAPI glLightEnviSGIX( GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->ext.p_glLightEnviSGIX( pname, param );
 }
 
-static void WINAPI glLightModelxOES( GLenum pname, GLfixed param ) {
+static void WINAPI glLightModelxOES( GLenum pname, GLfixed param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->ext.p_glLightModelxOES( pname, param );
 }
 
-static void WINAPI glLightModelxvOES( GLenum pname, const GLfixed* param ) {
+static void WINAPI glLightModelxvOES( GLenum pname, const GLfixed *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, param );
+  TRACE( "(%d, %p)\n", pname, param );
   funcs->ext.p_glLightModelxvOES( pname, param );
 }
 
-static void WINAPI glLightxOES( GLenum light, GLenum pname, GLfixed param ) {
+static void WINAPI glLightxOES( GLenum light, GLenum pname, GLfixed param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", light, pname, param );
+  TRACE( "(%d, %d, %d)\n", light, pname, param );
   funcs->ext.p_glLightxOES( light, pname, param );
 }
 
-static void WINAPI glLightxvOES( GLenum light, GLenum pname, const GLfixed* params ) {
+static void WINAPI glLightxvOES( GLenum light, GLenum pname, const GLfixed *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", light, pname, params );
+  TRACE( "(%d, %d, %p)\n", light, pname, params );
   funcs->ext.p_glLightxvOES( light, pname, params );
 }
 
-static void WINAPI glLineWidthxOES( GLfixed width ) {
+static void WINAPI glLineWidthxOES( GLfixed width )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", width );
+  TRACE( "(%d)\n", width );
   funcs->ext.p_glLineWidthxOES( width );
 }
 
-static void WINAPI glLinkProgram( GLuint program ) {
+static void WINAPI glLinkProgram( GLuint program )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", program );
+  TRACE( "(%d)\n", program );
   funcs->ext.p_glLinkProgram( program );
 }
 
-static void WINAPI glLinkProgramARB( GLhandleARB programObj ) {
+static void WINAPI glLinkProgramARB( GLhandleARB programObj )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", programObj );
+  TRACE( "(%d)\n", programObj );
   funcs->ext.p_glLinkProgramARB( programObj );
 }
 
-static void WINAPI glListDrawCommandsStatesClientNV( GLuint list, GLuint segment, const void** indirects, const GLsizei* sizes, const GLuint* states, const GLuint* fbos, GLuint count ) {
+static void WINAPI glListDrawCommandsStatesClientNV( GLuint list, GLuint segment, const void **indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p, %p, %p, %d)\n", list, segment, indirects, sizes, states, fbos, count );
+  TRACE( "(%d, %d, %p, %p, %p, %p, %d)\n", list, segment, indirects, sizes, states, fbos, count );
   funcs->ext.p_glListDrawCommandsStatesClientNV( list, segment, indirects, sizes, states, fbos, count );
 }
 
-static void WINAPI glListParameterfSGIX( GLuint list, GLenum pname, GLfloat param ) {
+static void WINAPI glListParameterfSGIX( GLuint list, GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", list, pname, param );
+  TRACE( "(%d, %d, %f)\n", list, pname, param );
   funcs->ext.p_glListParameterfSGIX( list, pname, param );
 }
 
-static void WINAPI glListParameterfvSGIX( GLuint list, GLenum pname, const GLfloat* params ) {
+static void WINAPI glListParameterfvSGIX( GLuint list, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", list, pname, params );
+  TRACE( "(%d, %d, %p)\n", list, pname, params );
   funcs->ext.p_glListParameterfvSGIX( list, pname, params );
 }
 
-static void WINAPI glListParameteriSGIX( GLuint list, GLenum pname, GLint param ) {
+static void WINAPI glListParameteriSGIX( GLuint list, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", list, pname, param );
+  TRACE( "(%d, %d, %d)\n", list, pname, param );
   funcs->ext.p_glListParameteriSGIX( list, pname, param );
 }
 
-static void WINAPI glListParameterivSGIX( GLuint list, GLenum pname, const GLint* params ) {
+static void WINAPI glListParameterivSGIX( GLuint list, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", list, pname, params );
+  TRACE( "(%d, %d, %p)\n", list, pname, params );
   funcs->ext.p_glListParameterivSGIX( list, pname, params );
 }
 
-static void WINAPI glLoadIdentityDeformationMapSGIX( GLbitfield mask ) {
+static void WINAPI glLoadIdentityDeformationMapSGIX( GLbitfield mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mask );
+  TRACE( "(%d)\n", mask );
   funcs->ext.p_glLoadIdentityDeformationMapSGIX( mask );
 }
 
-static void WINAPI glLoadMatrixxOES( const GLfixed* m ) {
+static void WINAPI glLoadMatrixxOES( const GLfixed *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", m );
+  TRACE( "(%p)\n", m );
   funcs->ext.p_glLoadMatrixxOES( m );
 }
 
-static void WINAPI glLoadProgramNV( GLenum target, GLuint id, GLsizei len, const GLubyte* program ) {
+static void WINAPI glLoadProgramNV( GLenum target, GLuint id, GLsizei len, const GLubyte *program )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, id, len, program );
+  TRACE( "(%d, %d, %d, %p)\n", target, id, len, program );
   funcs->ext.p_glLoadProgramNV( target, id, len, program );
 }
 
-static void WINAPI glLoadTransposeMatrixd( const GLdouble* m ) {
+static void WINAPI glLoadTransposeMatrixd( const GLdouble *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", m );
+  TRACE( "(%p)\n", m );
   funcs->ext.p_glLoadTransposeMatrixd( m );
 }
 
-static void WINAPI glLoadTransposeMatrixdARB( const GLdouble* m ) {
+static void WINAPI glLoadTransposeMatrixdARB( const GLdouble *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", m );
+  TRACE( "(%p)\n", m );
   funcs->ext.p_glLoadTransposeMatrixdARB( m );
 }
 
-static void WINAPI glLoadTransposeMatrixf( const GLfloat* m ) {
+static void WINAPI glLoadTransposeMatrixf( const GLfloat *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", m );
+  TRACE( "(%p)\n", m );
   funcs->ext.p_glLoadTransposeMatrixf( m );
 }
 
-static void WINAPI glLoadTransposeMatrixfARB( const GLfloat* m ) {
+static void WINAPI glLoadTransposeMatrixfARB( const GLfloat *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", m );
+  TRACE( "(%p)\n", m );
   funcs->ext.p_glLoadTransposeMatrixfARB( m );
 }
 
-static void WINAPI glLoadTransposeMatrixxOES( const GLfixed* m ) {
+static void WINAPI glLoadTransposeMatrixxOES( const GLfixed *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", m );
+  TRACE( "(%p)\n", m );
   funcs->ext.p_glLoadTransposeMatrixxOES( m );
 }
 
-static void WINAPI glLockArraysEXT( GLint first, GLsizei count ) {
+static void WINAPI glLockArraysEXT( GLint first, GLsizei count )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", first, count );
+  TRACE( "(%d, %d)\n", first, count );
   funcs->ext.p_glLockArraysEXT( first, count );
 }
 
-static void WINAPI glMTexCoord2fSGIS( GLenum target, GLfloat s, GLfloat t ) {
+static void WINAPI glMTexCoord2fSGIS( GLenum target, GLfloat s, GLfloat t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", target, s, t );
+  TRACE( "(%d, %f, %f)\n", target, s, t );
   funcs->ext.p_glMTexCoord2fSGIS( target, s, t );
 }
 
-static void WINAPI glMTexCoord2fvSGIS( GLenum target, GLfloat* v ) {
+static void WINAPI glMTexCoord2fvSGIS( GLenum target, GLfloat * v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMTexCoord2fvSGIS( target, v );
 }
 
-static void WINAPI glMakeBufferNonResidentNV( GLenum target ) {
+static void WINAPI glMakeBufferNonResidentNV( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   funcs->ext.p_glMakeBufferNonResidentNV( target );
 }
 
-static void WINAPI glMakeBufferResidentNV( GLenum target, GLenum access ) {
+static void WINAPI glMakeBufferResidentNV( GLenum target, GLenum access )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, access );
+  TRACE( "(%d, %d)\n", target, access );
   funcs->ext.p_glMakeBufferResidentNV( target, access );
 }
 
-static void WINAPI glMakeImageHandleNonResidentARB( GLuint64 handle ) {
+static void WINAPI glMakeImageHandleNonResidentARB( GLuint64 handle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%s)\n", wine_dbgstr_longlong(handle) );
+  TRACE( "(%s)\n", wine_dbgstr_longlong(handle) );
   funcs->ext.p_glMakeImageHandleNonResidentARB( handle );
 }
 
-static void WINAPI glMakeImageHandleNonResidentNV( GLuint64 handle ) {
+static void WINAPI glMakeImageHandleNonResidentNV( GLuint64 handle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%s)\n", wine_dbgstr_longlong(handle) );
+  TRACE( "(%s)\n", wine_dbgstr_longlong(handle) );
   funcs->ext.p_glMakeImageHandleNonResidentNV( handle );
 }
 
-static void WINAPI glMakeImageHandleResidentARB( GLuint64 handle, GLenum access ) {
+static void WINAPI glMakeImageHandleResidentARB( GLuint64 handle, GLenum access )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%s, %d)\n", wine_dbgstr_longlong(handle), access );
+  TRACE( "(%s, %d)\n", wine_dbgstr_longlong(handle), access );
   funcs->ext.p_glMakeImageHandleResidentARB( handle, access );
 }
 
-static void WINAPI glMakeImageHandleResidentNV( GLuint64 handle, GLenum access ) {
+static void WINAPI glMakeImageHandleResidentNV( GLuint64 handle, GLenum access )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%s, %d)\n", wine_dbgstr_longlong(handle), access );
+  TRACE( "(%s, %d)\n", wine_dbgstr_longlong(handle), access );
   funcs->ext.p_glMakeImageHandleResidentNV( handle, access );
 }
 
-static void WINAPI glMakeNamedBufferNonResidentNV( GLuint buffer ) {
+static void WINAPI glMakeNamedBufferNonResidentNV( GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", buffer );
+  TRACE( "(%d)\n", buffer );
   funcs->ext.p_glMakeNamedBufferNonResidentNV( buffer );
 }
 
-static void WINAPI glMakeNamedBufferResidentNV( GLuint buffer, GLenum access ) {
+static void WINAPI glMakeNamedBufferResidentNV( GLuint buffer, GLenum access )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", buffer, access );
+  TRACE( "(%d, %d)\n", buffer, access );
   funcs->ext.p_glMakeNamedBufferResidentNV( buffer, access );
 }
 
-static void WINAPI glMakeTextureHandleNonResidentARB( GLuint64 handle ) {
+static void WINAPI glMakeTextureHandleNonResidentARB( GLuint64 handle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%s)\n", wine_dbgstr_longlong(handle) );
+  TRACE( "(%s)\n", wine_dbgstr_longlong(handle) );
   funcs->ext.p_glMakeTextureHandleNonResidentARB( handle );
 }
 
-static void WINAPI glMakeTextureHandleNonResidentNV( GLuint64 handle ) {
+static void WINAPI glMakeTextureHandleNonResidentNV( GLuint64 handle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%s)\n", wine_dbgstr_longlong(handle) );
+  TRACE( "(%s)\n", wine_dbgstr_longlong(handle) );
   funcs->ext.p_glMakeTextureHandleNonResidentNV( handle );
 }
 
-static void WINAPI glMakeTextureHandleResidentARB( GLuint64 handle ) {
+static void WINAPI glMakeTextureHandleResidentARB( GLuint64 handle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%s)\n", wine_dbgstr_longlong(handle) );
+  TRACE( "(%s)\n", wine_dbgstr_longlong(handle) );
   funcs->ext.p_glMakeTextureHandleResidentARB( handle );
 }
 
-static void WINAPI glMakeTextureHandleResidentNV( GLuint64 handle ) {
+static void WINAPI glMakeTextureHandleResidentNV( GLuint64 handle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%s)\n", wine_dbgstr_longlong(handle) );
+  TRACE( "(%s)\n", wine_dbgstr_longlong(handle) );
   funcs->ext.p_glMakeTextureHandleResidentNV( handle );
 }
 
-static void WINAPI glMap1xOES( GLenum target, GLfixed u1, GLfixed u2, GLint stride, GLint order, GLfixed points ) {
+static void WINAPI glMap1xOES( GLenum target, GLfixed u1, GLfixed u2, GLint stride, GLint order, GLfixed points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, u1, u2, stride, order, points );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", target, u1, u2, stride, order, points );
   funcs->ext.p_glMap1xOES( target, u1, u2, stride, order, points );
 }
 
-static void WINAPI glMap2xOES( GLenum target, GLfixed u1, GLfixed u2, GLint ustride, GLint uorder, GLfixed v1, GLfixed v2, GLint vstride, GLint vorder, GLfixed points ) {
+static void WINAPI glMap2xOES( GLenum target, GLfixed u1, GLfixed u2, GLint ustride, GLint uorder, GLfixed v1, GLfixed v2, GLint vstride, GLint vorder, GLfixed points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
   funcs->ext.p_glMap2xOES( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
 }
 
-static void* WINAPI glMapBuffer( GLenum target, GLenum access ) {
+static void * WINAPI glMapBuffer( GLenum target, GLenum access )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, access );
+  TRACE( "(%d, %d)\n", target, access );
   return funcs->ext.p_glMapBuffer( target, access );
 }
 
-static void* WINAPI glMapBufferARB( GLenum target, GLenum access ) {
+static void * WINAPI glMapBufferARB( GLenum target, GLenum access )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, access );
+  TRACE( "(%d, %d)\n", target, access );
   return funcs->ext.p_glMapBufferARB( target, access );
 }
 
-static void* WINAPI glMapBufferRange( GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access ) {
+static void * WINAPI glMapBufferRange( GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld, %d)\n", target, offset, length, access );
+  TRACE( "(%d, %ld, %ld, %d)\n", target, offset, length, access );
   return funcs->ext.p_glMapBufferRange( target, offset, length, access );
 }
 
-static void WINAPI glMapControlPointsNV( GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const void* points ) {
+static void WINAPI glMapControlPointsNV( GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const void *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, index, type, ustride, vstride, uorder, vorder, packed, points );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, index, type, ustride, vstride, uorder, vorder, packed, points );
   funcs->ext.p_glMapControlPointsNV( target, index, type, ustride, vstride, uorder, vorder, packed, points );
 }
 
-static void WINAPI glMapGrid1xOES( GLint n, GLfixed u1, GLfixed u2 ) {
+static void WINAPI glMapGrid1xOES( GLint n, GLfixed u1, GLfixed u2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", n, u1, u2 );
+  TRACE( "(%d, %d, %d)\n", n, u1, u2 );
   funcs->ext.p_glMapGrid1xOES( n, u1, u2 );
 }
 
-static void WINAPI glMapGrid2xOES( GLint n, GLfixed u1, GLfixed u2, GLfixed v1, GLfixed v2 ) {
+static void WINAPI glMapGrid2xOES( GLint n, GLfixed u1, GLfixed u2, GLfixed v1, GLfixed v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", n, u1, u2, v1, v2 );
+  TRACE( "(%d, %d, %d, %d, %d)\n", n, u1, u2, v1, v2 );
   funcs->ext.p_glMapGrid2xOES( n, u1, u2, v1, v2 );
 }
 
-static void* WINAPI glMapNamedBuffer( GLuint buffer, GLenum access ) {
+static void * WINAPI glMapNamedBuffer( GLuint buffer, GLenum access )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", buffer, access );
+  TRACE( "(%d, %d)\n", buffer, access );
   return funcs->ext.p_glMapNamedBuffer( buffer, access );
 }
 
-static void* WINAPI glMapNamedBufferEXT( GLuint buffer, GLenum access ) {
+static void * WINAPI glMapNamedBufferEXT( GLuint buffer, GLenum access )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", buffer, access );
+  TRACE( "(%d, %d)\n", buffer, access );
   return funcs->ext.p_glMapNamedBufferEXT( buffer, access );
 }
 
-static void* WINAPI glMapNamedBufferRange( GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access ) {
+static void * WINAPI glMapNamedBufferRange( GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld, %d)\n", buffer, offset, length, access );
+  TRACE( "(%d, %ld, %ld, %d)\n", buffer, offset, length, access );
   return funcs->ext.p_glMapNamedBufferRange( buffer, offset, length, access );
 }
 
-static void* WINAPI glMapNamedBufferRangeEXT( GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access ) {
+static void * WINAPI glMapNamedBufferRangeEXT( GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld, %d)\n", buffer, offset, length, access );
+  TRACE( "(%d, %ld, %ld, %d)\n", buffer, offset, length, access );
   return funcs->ext.p_glMapNamedBufferRangeEXT( buffer, offset, length, access );
 }
 
-static void* WINAPI glMapObjectBufferATI( GLuint buffer ) {
+static void * WINAPI glMapObjectBufferATI( GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", buffer );
+  TRACE( "(%d)\n", buffer );
   return funcs->ext.p_glMapObjectBufferATI( buffer );
 }
 
-static void WINAPI glMapParameterfvNV( GLenum target, GLenum pname, const GLfloat* params ) {
+static void WINAPI glMapParameterfvNV( GLenum target, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glMapParameterfvNV( target, pname, params );
 }
 
-static void WINAPI glMapParameterivNV( GLenum target, GLenum pname, const GLint* params ) {
+static void WINAPI glMapParameterivNV( GLenum target, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glMapParameterivNV( target, pname, params );
 }
 
-static void* WINAPI glMapTexture2DINTEL( GLuint texture, GLint level, GLbitfield access, GLint* stride, GLenum* layout ) {
+static void * WINAPI glMapTexture2DINTEL( GLuint texture, GLint level, GLbitfield access, GLint *stride, GLenum *layout )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p)\n", texture, level, access, stride, layout );
+  TRACE( "(%d, %d, %d, %p, %p)\n", texture, level, access, stride, layout );
   return funcs->ext.p_glMapTexture2DINTEL( texture, level, access, stride, layout );
 }
 
-static void WINAPI glMapVertexAttrib1dAPPLE( GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points ) {
+static void WINAPI glMapVertexAttrib1dAPPLE( GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %d, %d, %p)\n", index, size, u1, u2, stride, order, points );
+  TRACE( "(%d, %d, %f, %f, %d, %d, %p)\n", index, size, u1, u2, stride, order, points );
   funcs->ext.p_glMapVertexAttrib1dAPPLE( index, size, u1, u2, stride, order, points );
 }
 
-static void WINAPI glMapVertexAttrib1fAPPLE( GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points ) {
+static void WINAPI glMapVertexAttrib1fAPPLE( GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %d, %d, %p)\n", index, size, u1, u2, stride, order, points );
+  TRACE( "(%d, %d, %f, %f, %d, %d, %p)\n", index, size, u1, u2, stride, order, points );
   funcs->ext.p_glMapVertexAttrib1fAPPLE( index, size, u1, u2, stride, order, points );
 }
 
-static void WINAPI glMapVertexAttrib2dAPPLE( GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points ) {
+static void WINAPI glMapVertexAttrib2dAPPLE( GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
+  TRACE( "(%d, %d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
   funcs->ext.p_glMapVertexAttrib2dAPPLE( index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
 }
 
-static void WINAPI glMapVertexAttrib2fAPPLE( GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points ) {
+static void WINAPI glMapVertexAttrib2fAPPLE( GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
+  TRACE( "(%d, %d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
   funcs->ext.p_glMapVertexAttrib2fAPPLE( index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
 }
 
-static void WINAPI glMaterialxOES( GLenum face, GLenum pname, GLfixed param ) {
+static void WINAPI glMaterialxOES( GLenum face, GLenum pname, GLfixed param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", face, pname, param );
+  TRACE( "(%d, %d, %d)\n", face, pname, param );
   funcs->ext.p_glMaterialxOES( face, pname, param );
 }
 
-static void WINAPI glMaterialxvOES( GLenum face, GLenum pname, const GLfixed* param ) {
+static void WINAPI glMaterialxvOES( GLenum face, GLenum pname, const GLfixed *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", face, pname, param );
+  TRACE( "(%d, %d, %p)\n", face, pname, param );
   funcs->ext.p_glMaterialxvOES( face, pname, param );
 }
 
-static void WINAPI glMatrixFrustumEXT( GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar ) {
+static void WINAPI glMatrixFrustumEXT( GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f, %f, %f)\n", mode, left, right, bottom, top, zNear, zFar );
+  TRACE( "(%d, %f, %f, %f, %f, %f, %f)\n", mode, left, right, bottom, top, zNear, zFar );
   funcs->ext.p_glMatrixFrustumEXT( mode, left, right, bottom, top, zNear, zFar );
 }
 
-static void WINAPI glMatrixIndexPointerARB( GLint size, GLenum type, GLsizei stride, const void* pointer ) {
+static void WINAPI glMatrixIndexPointerARB( GLint size, GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer );
+  TRACE( "(%d, %d, %d, %p)\n", size, type, stride, pointer );
   funcs->ext.p_glMatrixIndexPointerARB( size, type, stride, pointer );
 }
 
-static void WINAPI glMatrixIndexubvARB( GLint size, const GLubyte* indices ) {
+static void WINAPI glMatrixIndexubvARB( GLint size, const GLubyte *indices )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", size, indices );
+  TRACE( "(%d, %p)\n", size, indices );
   funcs->ext.p_glMatrixIndexubvARB( size, indices );
 }
 
-static void WINAPI glMatrixIndexuivARB( GLint size, const GLuint* indices ) {
+static void WINAPI glMatrixIndexuivARB( GLint size, const GLuint *indices )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", size, indices );
+  TRACE( "(%d, %p)\n", size, indices );
   funcs->ext.p_glMatrixIndexuivARB( size, indices );
 }
 
-static void WINAPI glMatrixIndexusvARB( GLint size, const GLushort* indices ) {
+static void WINAPI glMatrixIndexusvARB( GLint size, const GLushort *indices )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", size, indices );
+  TRACE( "(%d, %p)\n", size, indices );
   funcs->ext.p_glMatrixIndexusvARB( size, indices );
 }
 
-static void WINAPI glMatrixLoad3x2fNV( GLenum matrixMode, const GLfloat* m ) {
+static void WINAPI glMatrixLoad3x2fNV( GLenum matrixMode, const GLfloat *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", matrixMode, m );
+  TRACE( "(%d, %p)\n", matrixMode, m );
   funcs->ext.p_glMatrixLoad3x2fNV( matrixMode, m );
 }
 
-static void WINAPI glMatrixLoad3x3fNV( GLenum matrixMode, const GLfloat* m ) {
+static void WINAPI glMatrixLoad3x3fNV( GLenum matrixMode, const GLfloat *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", matrixMode, m );
+  TRACE( "(%d, %p)\n", matrixMode, m );
   funcs->ext.p_glMatrixLoad3x3fNV( matrixMode, m );
 }
 
-static void WINAPI glMatrixLoadIdentityEXT( GLenum mode ) {
+static void WINAPI glMatrixLoadIdentityEXT( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   funcs->ext.p_glMatrixLoadIdentityEXT( mode );
 }
 
-static void WINAPI glMatrixLoadTranspose3x3fNV( GLenum matrixMode, const GLfloat* m ) {
+static void WINAPI glMatrixLoadTranspose3x3fNV( GLenum matrixMode, const GLfloat *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", matrixMode, m );
+  TRACE( "(%d, %p)\n", matrixMode, m );
   funcs->ext.p_glMatrixLoadTranspose3x3fNV( matrixMode, m );
 }
 
-static void WINAPI glMatrixLoadTransposedEXT( GLenum mode, const GLdouble* m ) {
+static void WINAPI glMatrixLoadTransposedEXT( GLenum mode, const GLdouble *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", mode, m );
+  TRACE( "(%d, %p)\n", mode, m );
   funcs->ext.p_glMatrixLoadTransposedEXT( mode, m );
 }
 
-static void WINAPI glMatrixLoadTransposefEXT( GLenum mode, const GLfloat* m ) {
+static void WINAPI glMatrixLoadTransposefEXT( GLenum mode, const GLfloat *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", mode, m );
+  TRACE( "(%d, %p)\n", mode, m );
   funcs->ext.p_glMatrixLoadTransposefEXT( mode, m );
 }
 
-static void WINAPI glMatrixLoaddEXT( GLenum mode, const GLdouble* m ) {
+static void WINAPI glMatrixLoaddEXT( GLenum mode, const GLdouble *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", mode, m );
+  TRACE( "(%d, %p)\n", mode, m );
   funcs->ext.p_glMatrixLoaddEXT( mode, m );
 }
 
-static void WINAPI glMatrixLoadfEXT( GLenum mode, const GLfloat* m ) {
+static void WINAPI glMatrixLoadfEXT( GLenum mode, const GLfloat *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", mode, m );
+  TRACE( "(%d, %p)\n", mode, m );
   funcs->ext.p_glMatrixLoadfEXT( mode, m );
 }
 
-static void WINAPI glMatrixMult3x2fNV( GLenum matrixMode, const GLfloat* m ) {
+static void WINAPI glMatrixMult3x2fNV( GLenum matrixMode, const GLfloat *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", matrixMode, m );
+  TRACE( "(%d, %p)\n", matrixMode, m );
   funcs->ext.p_glMatrixMult3x2fNV( matrixMode, m );
 }
 
-static void WINAPI glMatrixMult3x3fNV( GLenum matrixMode, const GLfloat* m ) {
+static void WINAPI glMatrixMult3x3fNV( GLenum matrixMode, const GLfloat *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", matrixMode, m );
+  TRACE( "(%d, %p)\n", matrixMode, m );
   funcs->ext.p_glMatrixMult3x3fNV( matrixMode, m );
 }
 
-static void WINAPI glMatrixMultTranspose3x3fNV( GLenum matrixMode, const GLfloat* m ) {
+static void WINAPI glMatrixMultTranspose3x3fNV( GLenum matrixMode, const GLfloat *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", matrixMode, m );
+  TRACE( "(%d, %p)\n", matrixMode, m );
   funcs->ext.p_glMatrixMultTranspose3x3fNV( matrixMode, m );
 }
 
-static void WINAPI glMatrixMultTransposedEXT( GLenum mode, const GLdouble* m ) {
+static void WINAPI glMatrixMultTransposedEXT( GLenum mode, const GLdouble *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", mode, m );
+  TRACE( "(%d, %p)\n", mode, m );
   funcs->ext.p_glMatrixMultTransposedEXT( mode, m );
 }
 
-static void WINAPI glMatrixMultTransposefEXT( GLenum mode, const GLfloat* m ) {
+static void WINAPI glMatrixMultTransposefEXT( GLenum mode, const GLfloat *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", mode, m );
+  TRACE( "(%d, %p)\n", mode, m );
   funcs->ext.p_glMatrixMultTransposefEXT( mode, m );
 }
 
-static void WINAPI glMatrixMultdEXT( GLenum mode, const GLdouble* m ) {
+static void WINAPI glMatrixMultdEXT( GLenum mode, const GLdouble *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", mode, m );
+  TRACE( "(%d, %p)\n", mode, m );
   funcs->ext.p_glMatrixMultdEXT( mode, m );
 }
 
-static void WINAPI glMatrixMultfEXT( GLenum mode, const GLfloat* m ) {
+static void WINAPI glMatrixMultfEXT( GLenum mode, const GLfloat *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", mode, m );
+  TRACE( "(%d, %p)\n", mode, m );
   funcs->ext.p_glMatrixMultfEXT( mode, m );
 }
 
-static void WINAPI glMatrixOrthoEXT( GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar ) {
+static void WINAPI glMatrixOrthoEXT( GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f, %f, %f)\n", mode, left, right, bottom, top, zNear, zFar );
+  TRACE( "(%d, %f, %f, %f, %f, %f, %f)\n", mode, left, right, bottom, top, zNear, zFar );
   funcs->ext.p_glMatrixOrthoEXT( mode, left, right, bottom, top, zNear, zFar );
 }
 
-static void WINAPI glMatrixPopEXT( GLenum mode ) {
+static void WINAPI glMatrixPopEXT( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   funcs->ext.p_glMatrixPopEXT( mode );
 }
 
-static void WINAPI glMatrixPushEXT( GLenum mode ) {
+static void WINAPI glMatrixPushEXT( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   funcs->ext.p_glMatrixPushEXT( mode );
 }
 
-static void WINAPI glMatrixRotatedEXT( GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z ) {
+static void WINAPI glMatrixRotatedEXT( GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", mode, angle, x, y, z );
+  TRACE( "(%d, %f, %f, %f, %f)\n", mode, angle, x, y, z );
   funcs->ext.p_glMatrixRotatedEXT( mode, angle, x, y, z );
 }
 
-static void WINAPI glMatrixRotatefEXT( GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glMatrixRotatefEXT( GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", mode, angle, x, y, z );
+  TRACE( "(%d, %f, %f, %f, %f)\n", mode, angle, x, y, z );
   funcs->ext.p_glMatrixRotatefEXT( mode, angle, x, y, z );
 }
 
-static void WINAPI glMatrixScaledEXT( GLenum mode, GLdouble x, GLdouble y, GLdouble z ) {
+static void WINAPI glMatrixScaledEXT( GLenum mode, GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", mode, x, y, z );
+  TRACE( "(%d, %f, %f, %f)\n", mode, x, y, z );
   funcs->ext.p_glMatrixScaledEXT( mode, x, y, z );
 }
 
-static void WINAPI glMatrixScalefEXT( GLenum mode, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glMatrixScalefEXT( GLenum mode, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", mode, x, y, z );
+  TRACE( "(%d, %f, %f, %f)\n", mode, x, y, z );
   funcs->ext.p_glMatrixScalefEXT( mode, x, y, z );
 }
 
-static void WINAPI glMatrixTranslatedEXT( GLenum mode, GLdouble x, GLdouble y, GLdouble z ) {
+static void WINAPI glMatrixTranslatedEXT( GLenum mode, GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", mode, x, y, z );
+  TRACE( "(%d, %f, %f, %f)\n", mode, x, y, z );
   funcs->ext.p_glMatrixTranslatedEXT( mode, x, y, z );
 }
 
-static void WINAPI glMatrixTranslatefEXT( GLenum mode, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glMatrixTranslatefEXT( GLenum mode, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", mode, x, y, z );
+  TRACE( "(%d, %f, %f, %f)\n", mode, x, y, z );
   funcs->ext.p_glMatrixTranslatefEXT( mode, x, y, z );
 }
 
-static void WINAPI glMaxShaderCompilerThreadsARB( GLuint count ) {
+static void WINAPI glMaxShaderCompilerThreadsARB( GLuint count )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", count );
+  TRACE( "(%d)\n", count );
   funcs->ext.p_glMaxShaderCompilerThreadsARB( count );
 }
 
-static void WINAPI glMaxShaderCompilerThreadsKHR( GLuint count ) {
+static void WINAPI glMaxShaderCompilerThreadsKHR( GLuint count )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", count );
+  TRACE( "(%d)\n", count );
   funcs->ext.p_glMaxShaderCompilerThreadsKHR( count );
 }
 
-static void WINAPI glMemoryBarrier( GLbitfield barriers ) {
+static void WINAPI glMemoryBarrier( GLbitfield barriers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", barriers );
+  TRACE( "(%d)\n", barriers );
   funcs->ext.p_glMemoryBarrier( barriers );
 }
 
-static void WINAPI glMemoryBarrierByRegion( GLbitfield barriers ) {
+static void WINAPI glMemoryBarrierByRegion( GLbitfield barriers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", barriers );
+  TRACE( "(%d)\n", barriers );
   funcs->ext.p_glMemoryBarrierByRegion( barriers );
 }
 
-static void WINAPI glMemoryBarrierEXT( GLbitfield barriers ) {
+static void WINAPI glMemoryBarrierEXT( GLbitfield barriers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", barriers );
+  TRACE( "(%d)\n", barriers );
   funcs->ext.p_glMemoryBarrierEXT( barriers );
 }
 
-static void WINAPI glMemoryObjectParameterivEXT( GLuint memoryObject, GLenum pname, const GLint* params ) {
+static void WINAPI glMemoryObjectParameterivEXT( GLuint memoryObject, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", memoryObject, pname, params );
+  TRACE( "(%d, %d, %p)\n", memoryObject, pname, params );
   funcs->ext.p_glMemoryObjectParameterivEXT( memoryObject, pname, params );
 }
 
-static void WINAPI glMinSampleShading( GLfloat value ) {
+static void WINAPI glMinSampleShading( GLfloat value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", value );
+  TRACE( "(%f)\n", value );
   funcs->ext.p_glMinSampleShading( value );
 }
 
-static void WINAPI glMinSampleShadingARB( GLfloat value ) {
+static void WINAPI glMinSampleShadingARB( GLfloat value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", value );
+  TRACE( "(%f)\n", value );
   funcs->ext.p_glMinSampleShadingARB( value );
 }
 
-static void WINAPI glMinmax( GLenum target, GLenum internalformat, GLboolean sink ) {
+static void WINAPI glMinmax( GLenum target, GLenum internalformat, GLboolean sink )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, internalformat, sink );
+  TRACE( "(%d, %d, %d)\n", target, internalformat, sink );
   funcs->ext.p_glMinmax( target, internalformat, sink );
 }
 
-static void WINAPI glMinmaxEXT( GLenum target, GLenum internalformat, GLboolean sink ) {
+static void WINAPI glMinmaxEXT( GLenum target, GLenum internalformat, GLboolean sink )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, internalformat, sink );
+  TRACE( "(%d, %d, %d)\n", target, internalformat, sink );
   funcs->ext.p_glMinmaxEXT( target, internalformat, sink );
 }
 
-static void WINAPI glMultMatrixxOES( const GLfixed* m ) {
+static void WINAPI glMultMatrixxOES( const GLfixed *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", m );
+  TRACE( "(%p)\n", m );
   funcs->ext.p_glMultMatrixxOES( m );
 }
 
-static void WINAPI glMultTransposeMatrixd( const GLdouble* m ) {
+static void WINAPI glMultTransposeMatrixd( const GLdouble *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", m );
+  TRACE( "(%p)\n", m );
   funcs->ext.p_glMultTransposeMatrixd( m );
 }
 
-static void WINAPI glMultTransposeMatrixdARB( const GLdouble* m ) {
+static void WINAPI glMultTransposeMatrixdARB( const GLdouble *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", m );
+  TRACE( "(%p)\n", m );
   funcs->ext.p_glMultTransposeMatrixdARB( m );
 }
 
-static void WINAPI glMultTransposeMatrixf( const GLfloat* m ) {
+static void WINAPI glMultTransposeMatrixf( const GLfloat *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", m );
+  TRACE( "(%p)\n", m );
   funcs->ext.p_glMultTransposeMatrixf( m );
 }
 
-static void WINAPI glMultTransposeMatrixfARB( const GLfloat* m ) {
+static void WINAPI glMultTransposeMatrixfARB( const GLfloat *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", m );
+  TRACE( "(%p)\n", m );
   funcs->ext.p_glMultTransposeMatrixfARB( m );
 }
 
-static void WINAPI glMultTransposeMatrixxOES( const GLfixed* m ) {
+static void WINAPI glMultTransposeMatrixxOES( const GLfixed *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", m );
+  TRACE( "(%p)\n", m );
   funcs->ext.p_glMultTransposeMatrixxOES( m );
 }
 
-static void WINAPI glMultiDrawArrays( GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount ) {
+static void WINAPI glMultiDrawArrays( GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %p, %d)\n", mode, first, count, drawcount );
+  TRACE( "(%d, %p, %p, %d)\n", mode, first, count, drawcount );
   funcs->ext.p_glMultiDrawArrays( mode, first, count, drawcount );
 }
 
-static void WINAPI glMultiDrawArraysEXT( GLenum mode, const GLint* first, const GLsizei* count, GLsizei primcount ) {
+static void WINAPI glMultiDrawArraysEXT( GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %p, %d)\n", mode, first, count, primcount );
+  TRACE( "(%d, %p, %p, %d)\n", mode, first, count, primcount );
   funcs->ext.p_glMultiDrawArraysEXT( mode, first, count, primcount );
 }
 
-static void WINAPI glMultiDrawArraysIndirect( GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride ) {
+static void WINAPI glMultiDrawArraysIndirect( GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %d, %d)\n", mode, indirect, drawcount, stride );
+  TRACE( "(%d, %p, %d, %d)\n", mode, indirect, drawcount, stride );
   funcs->ext.p_glMultiDrawArraysIndirect( mode, indirect, drawcount, stride );
 }
 
-static void WINAPI glMultiDrawArraysIndirectAMD( GLenum mode, const void* indirect, GLsizei primcount, GLsizei stride ) {
+static void WINAPI glMultiDrawArraysIndirectAMD( GLenum mode, const void *indirect, GLsizei primcount, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %d, %d)\n", mode, indirect, primcount, stride );
+  TRACE( "(%d, %p, %d, %d)\n", mode, indirect, primcount, stride );
   funcs->ext.p_glMultiDrawArraysIndirectAMD( mode, indirect, primcount, stride );
 }
 
-static void WINAPI glMultiDrawArraysIndirectBindlessCountNV( GLenum mode, const void* indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount ) {
+static void WINAPI glMultiDrawArraysIndirectBindlessCountNV( GLenum mode, const void *indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %d, %d, %d, %d)\n", mode, indirect, drawCount, maxDrawCount, stride, vertexBufferCount );
+  TRACE( "(%d, %p, %d, %d, %d, %d)\n", mode, indirect, drawCount, maxDrawCount, stride, vertexBufferCount );
   funcs->ext.p_glMultiDrawArraysIndirectBindlessCountNV( mode, indirect, drawCount, maxDrawCount, stride, vertexBufferCount );
 }
 
-static void WINAPI glMultiDrawArraysIndirectBindlessNV( GLenum mode, const void* indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount ) {
+static void WINAPI glMultiDrawArraysIndirectBindlessNV( GLenum mode, const void *indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %d, %d, %d)\n", mode, indirect, drawCount, stride, vertexBufferCount );
+  TRACE( "(%d, %p, %d, %d, %d)\n", mode, indirect, drawCount, stride, vertexBufferCount );
   funcs->ext.p_glMultiDrawArraysIndirectBindlessNV( mode, indirect, drawCount, stride, vertexBufferCount );
 }
 
-static void WINAPI glMultiDrawArraysIndirectCount( GLenum mode, const void* indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride ) {
+static void WINAPI glMultiDrawArraysIndirectCount( GLenum mode, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %ld, %d, %d)\n", mode, indirect, drawcount, maxdrawcount, stride );
+  TRACE( "(%d, %p, %ld, %d, %d)\n", mode, indirect, drawcount, maxdrawcount, stride );
   funcs->ext.p_glMultiDrawArraysIndirectCount( mode, indirect, drawcount, maxdrawcount, stride );
 }
 
-static void WINAPI glMultiDrawArraysIndirectCountARB( GLenum mode, const void* indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride ) {
+static void WINAPI glMultiDrawArraysIndirectCountARB( GLenum mode, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %ld, %d, %d)\n", mode, indirect, drawcount, maxdrawcount, stride );
+  TRACE( "(%d, %p, %ld, %d, %d)\n", mode, indirect, drawcount, maxdrawcount, stride );
   funcs->ext.p_glMultiDrawArraysIndirectCountARB( mode, indirect, drawcount, maxdrawcount, stride );
 }
 
-static void WINAPI glMultiDrawElementArrayAPPLE( GLenum mode, const GLint* first, const GLsizei* count, GLsizei primcount ) {
+static void WINAPI glMultiDrawElementArrayAPPLE( GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %p, %d)\n", mode, first, count, primcount );
+  TRACE( "(%d, %p, %p, %d)\n", mode, first, count, primcount );
   funcs->ext.p_glMultiDrawElementArrayAPPLE( mode, first, count, primcount );
 }
 
-static void WINAPI glMultiDrawElements( GLenum mode, const GLsizei* count, GLenum type, const void*const* indices, GLsizei drawcount ) {
+static void WINAPI glMultiDrawElements( GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %d, %p, %d)\n", mode, count, type, indices, drawcount );
+  TRACE( "(%d, %p, %d, %p, %d)\n", mode, count, type, indices, drawcount );
   funcs->ext.p_glMultiDrawElements( mode, count, type, indices, drawcount );
 }
 
-static void WINAPI glMultiDrawElementsBaseVertex( GLenum mode, const GLsizei* count, GLenum type, const void*const* indices, GLsizei drawcount, const GLint* basevertex ) {
+static void WINAPI glMultiDrawElementsBaseVertex( GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %d, %p, %d, %p)\n", mode, count, type, indices, drawcount, basevertex );
+  TRACE( "(%d, %p, %d, %p, %d, %p)\n", mode, count, type, indices, drawcount, basevertex );
   funcs->ext.p_glMultiDrawElementsBaseVertex( mode, count, type, indices, drawcount, basevertex );
 }
 
-static void WINAPI glMultiDrawElementsEXT( GLenum mode, const GLsizei* count, GLenum type, const void*const* indices, GLsizei primcount ) {
+static void WINAPI glMultiDrawElementsEXT( GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei primcount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %d, %p, %d)\n", mode, count, type, indices, primcount );
+  TRACE( "(%d, %p, %d, %p, %d)\n", mode, count, type, indices, primcount );
   funcs->ext.p_glMultiDrawElementsEXT( mode, count, type, indices, primcount );
 }
 
-static void WINAPI glMultiDrawElementsIndirect( GLenum mode, GLenum type, const void* indirect, GLsizei drawcount, GLsizei stride ) {
+static void WINAPI glMultiDrawElementsIndirect( GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %d)\n", mode, type, indirect, drawcount, stride );
+  TRACE( "(%d, %d, %p, %d, %d)\n", mode, type, indirect, drawcount, stride );
   funcs->ext.p_glMultiDrawElementsIndirect( mode, type, indirect, drawcount, stride );
 }
 
-static void WINAPI glMultiDrawElementsIndirectAMD( GLenum mode, GLenum type, const void* indirect, GLsizei primcount, GLsizei stride ) {
+static void WINAPI glMultiDrawElementsIndirectAMD( GLenum mode, GLenum type, const void *indirect, GLsizei primcount, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %d)\n", mode, type, indirect, primcount, stride );
+  TRACE( "(%d, %d, %p, %d, %d)\n", mode, type, indirect, primcount, stride );
   funcs->ext.p_glMultiDrawElementsIndirectAMD( mode, type, indirect, primcount, stride );
 }
 
-static void WINAPI glMultiDrawElementsIndirectBindlessCountNV( GLenum mode, GLenum type, const void* indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount ) {
+static void WINAPI glMultiDrawElementsIndirectBindlessCountNV( GLenum mode, GLenum type, const void *indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %d, %d, %d)\n", mode, type, indirect, drawCount, maxDrawCount, stride, vertexBufferCount );
+  TRACE( "(%d, %d, %p, %d, %d, %d, %d)\n", mode, type, indirect, drawCount, maxDrawCount, stride, vertexBufferCount );
   funcs->ext.p_glMultiDrawElementsIndirectBindlessCountNV( mode, type, indirect, drawCount, maxDrawCount, stride, vertexBufferCount );
 }
 
-static void WINAPI glMultiDrawElementsIndirectBindlessNV( GLenum mode, GLenum type, const void* indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount ) {
+static void WINAPI glMultiDrawElementsIndirectBindlessNV( GLenum mode, GLenum type, const void *indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %d, %d)\n", mode, type, indirect, drawCount, stride, vertexBufferCount );
+  TRACE( "(%d, %d, %p, %d, %d, %d)\n", mode, type, indirect, drawCount, stride, vertexBufferCount );
   funcs->ext.p_glMultiDrawElementsIndirectBindlessNV( mode, type, indirect, drawCount, stride, vertexBufferCount );
 }
 
-static void WINAPI glMultiDrawElementsIndirectCount( GLenum mode, GLenum type, const void* indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride ) {
+static void WINAPI glMultiDrawElementsIndirectCount( GLenum mode, GLenum type, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %ld, %d, %d)\n", mode, type, indirect, drawcount, maxdrawcount, stride );
+  TRACE( "(%d, %d, %p, %ld, %d, %d)\n", mode, type, indirect, drawcount, maxdrawcount, stride );
   funcs->ext.p_glMultiDrawElementsIndirectCount( mode, type, indirect, drawcount, maxdrawcount, stride );
 }
 
-static void WINAPI glMultiDrawElementsIndirectCountARB( GLenum mode, GLenum type, const void* indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride ) {
+static void WINAPI glMultiDrawElementsIndirectCountARB( GLenum mode, GLenum type, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %ld, %d, %d)\n", mode, type, indirect, drawcount, maxdrawcount, stride );
+  TRACE( "(%d, %d, %p, %ld, %d, %d)\n", mode, type, indirect, drawcount, maxdrawcount, stride );
   funcs->ext.p_glMultiDrawElementsIndirectCountARB( mode, type, indirect, drawcount, maxdrawcount, stride );
 }
 
-static void WINAPI glMultiDrawRangeElementArrayAPPLE( GLenum mode, GLuint start, GLuint end, const GLint* first, const GLsizei* count, GLsizei primcount ) {
+static void WINAPI glMultiDrawRangeElementArrayAPPLE( GLenum mode, GLuint start, GLuint end, const GLint *first, const GLsizei *count, GLsizei primcount )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p, %d)\n", mode, start, end, first, count, primcount );
+  TRACE( "(%d, %d, %d, %p, %p, %d)\n", mode, start, end, first, count, primcount );
   funcs->ext.p_glMultiDrawRangeElementArrayAPPLE( mode, start, end, first, count, primcount );
 }
 
-static void WINAPI glMultiModeDrawArraysIBM( const GLenum* mode, const GLint* first, const GLsizei* count, GLsizei primcount, GLint modestride ) {
+static void WINAPI glMultiModeDrawArraysIBM( const GLenum *mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p, %p, %d, %d)\n", mode, first, count, primcount, modestride );
+  TRACE( "(%p, %p, %p, %d, %d)\n", mode, first, count, primcount, modestride );
   funcs->ext.p_glMultiModeDrawArraysIBM( mode, first, count, primcount, modestride );
 }
 
-static void WINAPI glMultiModeDrawElementsIBM( const GLenum* mode, const GLsizei* count, GLenum type, const void*const* indices, GLsizei primcount, GLint modestride ) {
+static void WINAPI glMultiModeDrawElementsIBM( const GLenum *mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei primcount, GLint modestride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p, %d, %p, %d, %d)\n", mode, count, type, indices, primcount, modestride );
+  TRACE( "(%p, %p, %d, %p, %d, %d)\n", mode, count, type, indices, primcount, modestride );
   funcs->ext.p_glMultiModeDrawElementsIBM( mode, count, type, indices, primcount, modestride );
 }
 
-static void WINAPI glMultiTexBufferEXT( GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer ) {
+static void WINAPI glMultiTexBufferEXT( GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", texunit, target, internalformat, buffer );
+  TRACE( "(%d, %d, %d, %d)\n", texunit, target, internalformat, buffer );
   funcs->ext.p_glMultiTexBufferEXT( texunit, target, internalformat, buffer );
 }
 
-static void WINAPI glMultiTexCoord1bOES( GLenum texture, GLbyte s ) {
+static void WINAPI glMultiTexCoord1bOES( GLenum texture, GLbyte s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", texture, s );
+  TRACE( "(%d, %d)\n", texture, s );
   funcs->ext.p_glMultiTexCoord1bOES( texture, s );
 }
 
-static void WINAPI glMultiTexCoord1bvOES( GLenum texture, const GLbyte* coords ) {
+static void WINAPI glMultiTexCoord1bvOES( GLenum texture, const GLbyte *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", texture, coords );
+  TRACE( "(%d, %p)\n", texture, coords );
   funcs->ext.p_glMultiTexCoord1bvOES( texture, coords );
 }
 
-static void WINAPI glMultiTexCoord1d( GLenum target, GLdouble s ) {
+static void WINAPI glMultiTexCoord1d( GLenum target, GLdouble s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", target, s );
+  TRACE( "(%d, %f)\n", target, s );
   funcs->ext.p_glMultiTexCoord1d( target, s );
 }
 
-static void WINAPI glMultiTexCoord1dARB( GLenum target, GLdouble s ) {
+static void WINAPI glMultiTexCoord1dARB( GLenum target, GLdouble s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", target, s );
+  TRACE( "(%d, %f)\n", target, s );
   funcs->ext.p_glMultiTexCoord1dARB( target, s );
 }
 
-static void WINAPI glMultiTexCoord1dSGIS( GLenum target, GLdouble s ) {
+static void WINAPI glMultiTexCoord1dSGIS( GLenum target, GLdouble s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", target, s );
+  TRACE( "(%d, %f)\n", target, s );
   funcs->ext.p_glMultiTexCoord1dSGIS( target, s );
 }
 
-static void WINAPI glMultiTexCoord1dv( GLenum target, const GLdouble* v ) {
+static void WINAPI glMultiTexCoord1dv( GLenum target, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord1dv( target, v );
 }
 
-static void WINAPI glMultiTexCoord1dvARB( GLenum target, const GLdouble* v ) {
+static void WINAPI glMultiTexCoord1dvARB( GLenum target, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord1dvARB( target, v );
 }
 
-static void WINAPI glMultiTexCoord1dvSGIS( GLenum target, GLdouble* v ) {
+static void WINAPI glMultiTexCoord1dvSGIS( GLenum target, GLdouble * v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord1dvSGIS( target, v );
 }
 
-static void WINAPI glMultiTexCoord1f( GLenum target, GLfloat s ) {
+static void WINAPI glMultiTexCoord1f( GLenum target, GLfloat s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", target, s );
+  TRACE( "(%d, %f)\n", target, s );
   funcs->ext.p_glMultiTexCoord1f( target, s );
 }
 
-static void WINAPI glMultiTexCoord1fARB( GLenum target, GLfloat s ) {
+static void WINAPI glMultiTexCoord1fARB( GLenum target, GLfloat s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", target, s );
+  TRACE( "(%d, %f)\n", target, s );
   funcs->ext.p_glMultiTexCoord1fARB( target, s );
 }
 
-static void WINAPI glMultiTexCoord1fSGIS( GLenum target, GLfloat s ) {
+static void WINAPI glMultiTexCoord1fSGIS( GLenum target, GLfloat s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", target, s );
+  TRACE( "(%d, %f)\n", target, s );
   funcs->ext.p_glMultiTexCoord1fSGIS( target, s );
 }
 
-static void WINAPI glMultiTexCoord1fv( GLenum target, const GLfloat* v ) {
+static void WINAPI glMultiTexCoord1fv( GLenum target, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord1fv( target, v );
 }
 
-static void WINAPI glMultiTexCoord1fvARB( GLenum target, const GLfloat* v ) {
+static void WINAPI glMultiTexCoord1fvARB( GLenum target, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord1fvARB( target, v );
 }
 
-static void WINAPI glMultiTexCoord1fvSGIS( GLenum target, const GLfloat* v ) {
+static void WINAPI glMultiTexCoord1fvSGIS( GLenum target, const GLfloat * v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord1fvSGIS( target, v );
 }
 
-static void WINAPI glMultiTexCoord1hNV( GLenum target, GLhalfNV s ) {
+static void WINAPI glMultiTexCoord1hNV( GLenum target, GLhalfNV s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, s );
+  TRACE( "(%d, %d)\n", target, s );
   funcs->ext.p_glMultiTexCoord1hNV( target, s );
 }
 
-static void WINAPI glMultiTexCoord1hvNV( GLenum target, const GLhalfNV* v ) {
+static void WINAPI glMultiTexCoord1hvNV( GLenum target, const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord1hvNV( target, v );
 }
 
-static void WINAPI glMultiTexCoord1i( GLenum target, GLint s ) {
+static void WINAPI glMultiTexCoord1i( GLenum target, GLint s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, s );
+  TRACE( "(%d, %d)\n", target, s );
   funcs->ext.p_glMultiTexCoord1i( target, s );
 }
 
-static void WINAPI glMultiTexCoord1iARB( GLenum target, GLint s ) {
+static void WINAPI glMultiTexCoord1iARB( GLenum target, GLint s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, s );
+  TRACE( "(%d, %d)\n", target, s );
   funcs->ext.p_glMultiTexCoord1iARB( target, s );
 }
 
-static void WINAPI glMultiTexCoord1iSGIS( GLenum target, GLint s ) {
+static void WINAPI glMultiTexCoord1iSGIS( GLenum target, GLint s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, s );
+  TRACE( "(%d, %d)\n", target, s );
   funcs->ext.p_glMultiTexCoord1iSGIS( target, s );
 }
 
-static void WINAPI glMultiTexCoord1iv( GLenum target, const GLint* v ) {
+static void WINAPI glMultiTexCoord1iv( GLenum target, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord1iv( target, v );
 }
 
-static void WINAPI glMultiTexCoord1ivARB( GLenum target, const GLint* v ) {
+static void WINAPI glMultiTexCoord1ivARB( GLenum target, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord1ivARB( target, v );
 }
 
-static void WINAPI glMultiTexCoord1ivSGIS( GLenum target, GLint* v ) {
+static void WINAPI glMultiTexCoord1ivSGIS( GLenum target, GLint * v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord1ivSGIS( target, v );
 }
 
-static void WINAPI glMultiTexCoord1s( GLenum target, GLshort s ) {
+static void WINAPI glMultiTexCoord1s( GLenum target, GLshort s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, s );
+  TRACE( "(%d, %d)\n", target, s );
   funcs->ext.p_glMultiTexCoord1s( target, s );
 }
 
-static void WINAPI glMultiTexCoord1sARB( GLenum target, GLshort s ) {
+static void WINAPI glMultiTexCoord1sARB( GLenum target, GLshort s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, s );
+  TRACE( "(%d, %d)\n", target, s );
   funcs->ext.p_glMultiTexCoord1sARB( target, s );
 }
 
-static void WINAPI glMultiTexCoord1sSGIS( GLenum target, GLshort s ) {
+static void WINAPI glMultiTexCoord1sSGIS( GLenum target, GLshort s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, s );
+  TRACE( "(%d, %d)\n", target, s );
   funcs->ext.p_glMultiTexCoord1sSGIS( target, s );
 }
 
-static void WINAPI glMultiTexCoord1sv( GLenum target, const GLshort* v ) {
+static void WINAPI glMultiTexCoord1sv( GLenum target, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord1sv( target, v );
 }
 
-static void WINAPI glMultiTexCoord1svARB( GLenum target, const GLshort* v ) {
+static void WINAPI glMultiTexCoord1svARB( GLenum target, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord1svARB( target, v );
 }
 
-static void WINAPI glMultiTexCoord1svSGIS( GLenum target, GLshort* v ) {
+static void WINAPI glMultiTexCoord1svSGIS( GLenum target, GLshort * v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord1svSGIS( target, v );
 }
 
-static void WINAPI glMultiTexCoord1xOES( GLenum texture, GLfixed s ) {
+static void WINAPI glMultiTexCoord1xOES( GLenum texture, GLfixed s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", texture, s );
+  TRACE( "(%d, %d)\n", texture, s );
   funcs->ext.p_glMultiTexCoord1xOES( texture, s );
 }
 
-static void WINAPI glMultiTexCoord1xvOES( GLenum texture, const GLfixed* coords ) {
+static void WINAPI glMultiTexCoord1xvOES( GLenum texture, const GLfixed *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", texture, coords );
+  TRACE( "(%d, %p)\n", texture, coords );
   funcs->ext.p_glMultiTexCoord1xvOES( texture, coords );
 }
 
-static void WINAPI glMultiTexCoord2bOES( GLenum texture, GLbyte s, GLbyte t ) {
+static void WINAPI glMultiTexCoord2bOES( GLenum texture, GLbyte s, GLbyte t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", texture, s, t );
+  TRACE( "(%d, %d, %d)\n", texture, s, t );
   funcs->ext.p_glMultiTexCoord2bOES( texture, s, t );
 }
 
-static void WINAPI glMultiTexCoord2bvOES( GLenum texture, const GLbyte* coords ) {
+static void WINAPI glMultiTexCoord2bvOES( GLenum texture, const GLbyte *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", texture, coords );
+  TRACE( "(%d, %p)\n", texture, coords );
   funcs->ext.p_glMultiTexCoord2bvOES( texture, coords );
 }
 
-static void WINAPI glMultiTexCoord2d( GLenum target, GLdouble s, GLdouble t ) {
+static void WINAPI glMultiTexCoord2d( GLenum target, GLdouble s, GLdouble t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", target, s, t );
+  TRACE( "(%d, %f, %f)\n", target, s, t );
   funcs->ext.p_glMultiTexCoord2d( target, s, t );
 }
 
-static void WINAPI glMultiTexCoord2dARB( GLenum target, GLdouble s, GLdouble t ) {
+static void WINAPI glMultiTexCoord2dARB( GLenum target, GLdouble s, GLdouble t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", target, s, t );
+  TRACE( "(%d, %f, %f)\n", target, s, t );
   funcs->ext.p_glMultiTexCoord2dARB( target, s, t );
 }
 
-static void WINAPI glMultiTexCoord2dSGIS( GLenum target, GLdouble s, GLdouble t ) {
+static void WINAPI glMultiTexCoord2dSGIS( GLenum target, GLdouble s, GLdouble t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", target, s, t );
+  TRACE( "(%d, %f, %f)\n", target, s, t );
   funcs->ext.p_glMultiTexCoord2dSGIS( target, s, t );
 }
 
-static void WINAPI glMultiTexCoord2dv( GLenum target, const GLdouble* v ) {
+static void WINAPI glMultiTexCoord2dv( GLenum target, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord2dv( target, v );
 }
 
-static void WINAPI glMultiTexCoord2dvARB( GLenum target, const GLdouble* v ) {
+static void WINAPI glMultiTexCoord2dvARB( GLenum target, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord2dvARB( target, v );
 }
 
-static void WINAPI glMultiTexCoord2dvSGIS( GLenum target, GLdouble* v ) {
+static void WINAPI glMultiTexCoord2dvSGIS( GLenum target, GLdouble * v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord2dvSGIS( target, v );
 }
 
-static void WINAPI glMultiTexCoord2f( GLenum target, GLfloat s, GLfloat t ) {
+static void WINAPI glMultiTexCoord2f( GLenum target, GLfloat s, GLfloat t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", target, s, t );
+  TRACE( "(%d, %f, %f)\n", target, s, t );
   funcs->ext.p_glMultiTexCoord2f( target, s, t );
 }
 
-static void WINAPI glMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t ) {
+static void WINAPI glMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", target, s, t );
+  TRACE( "(%d, %f, %f)\n", target, s, t );
   funcs->ext.p_glMultiTexCoord2fARB( target, s, t );
 }
 
-static void WINAPI glMultiTexCoord2fSGIS( GLenum target, GLfloat s, GLfloat t ) {
+static void WINAPI glMultiTexCoord2fSGIS( GLenum target, GLfloat s, GLfloat t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", target, s, t );
+  TRACE( "(%d, %f, %f)\n", target, s, t );
   funcs->ext.p_glMultiTexCoord2fSGIS( target, s, t );
 }
 
-static void WINAPI glMultiTexCoord2fv( GLenum target, const GLfloat* v ) {
+static void WINAPI glMultiTexCoord2fv( GLenum target, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord2fv( target, v );
 }
 
-static void WINAPI glMultiTexCoord2fvARB( GLenum target, const GLfloat* v ) {
+static void WINAPI glMultiTexCoord2fvARB( GLenum target, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord2fvARB( target, v );
 }
 
-static void WINAPI glMultiTexCoord2fvSGIS( GLenum target, GLfloat* v ) {
+static void WINAPI glMultiTexCoord2fvSGIS( GLenum target, GLfloat * v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord2fvSGIS( target, v );
 }
 
-static void WINAPI glMultiTexCoord2hNV( GLenum target, GLhalfNV s, GLhalfNV t ) {
+static void WINAPI glMultiTexCoord2hNV( GLenum target, GLhalfNV s, GLhalfNV t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, s, t );
+  TRACE( "(%d, %d, %d)\n", target, s, t );
   funcs->ext.p_glMultiTexCoord2hNV( target, s, t );
 }
 
-static void WINAPI glMultiTexCoord2hvNV( GLenum target, const GLhalfNV* v ) {
+static void WINAPI glMultiTexCoord2hvNV( GLenum target, const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord2hvNV( target, v );
 }
 
-static void WINAPI glMultiTexCoord2i( GLenum target, GLint s, GLint t ) {
+static void WINAPI glMultiTexCoord2i( GLenum target, GLint s, GLint t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, s, t );
+  TRACE( "(%d, %d, %d)\n", target, s, t );
   funcs->ext.p_glMultiTexCoord2i( target, s, t );
 }
 
-static void WINAPI glMultiTexCoord2iARB( GLenum target, GLint s, GLint t ) {
+static void WINAPI glMultiTexCoord2iARB( GLenum target, GLint s, GLint t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, s, t );
+  TRACE( "(%d, %d, %d)\n", target, s, t );
   funcs->ext.p_glMultiTexCoord2iARB( target, s, t );
 }
 
-static void WINAPI glMultiTexCoord2iSGIS( GLenum target, GLint s, GLint t ) {
+static void WINAPI glMultiTexCoord2iSGIS( GLenum target, GLint s, GLint t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, s, t );
+  TRACE( "(%d, %d, %d)\n", target, s, t );
   funcs->ext.p_glMultiTexCoord2iSGIS( target, s, t );
 }
 
-static void WINAPI glMultiTexCoord2iv( GLenum target, const GLint* v ) {
+static void WINAPI glMultiTexCoord2iv( GLenum target, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord2iv( target, v );
 }
 
-static void WINAPI glMultiTexCoord2ivARB( GLenum target, const GLint* v ) {
+static void WINAPI glMultiTexCoord2ivARB( GLenum target, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord2ivARB( target, v );
 }
 
-static void WINAPI glMultiTexCoord2ivSGIS( GLenum target, GLint* v ) {
+static void WINAPI glMultiTexCoord2ivSGIS( GLenum target, GLint * v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord2ivSGIS( target, v );
 }
 
-static void WINAPI glMultiTexCoord2s( GLenum target, GLshort s, GLshort t ) {
+static void WINAPI glMultiTexCoord2s( GLenum target, GLshort s, GLshort t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, s, t );
+  TRACE( "(%d, %d, %d)\n", target, s, t );
   funcs->ext.p_glMultiTexCoord2s( target, s, t );
 }
 
-static void WINAPI glMultiTexCoord2sARB( GLenum target, GLshort s, GLshort t ) {
+static void WINAPI glMultiTexCoord2sARB( GLenum target, GLshort s, GLshort t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, s, t );
+  TRACE( "(%d, %d, %d)\n", target, s, t );
   funcs->ext.p_glMultiTexCoord2sARB( target, s, t );
 }
 
-static void WINAPI glMultiTexCoord2sSGIS( GLenum target, GLshort s, GLshort t ) {
+static void WINAPI glMultiTexCoord2sSGIS( GLenum target, GLshort s, GLshort t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, s, t );
+  TRACE( "(%d, %d, %d)\n", target, s, t );
   funcs->ext.p_glMultiTexCoord2sSGIS( target, s, t );
 }
 
-static void WINAPI glMultiTexCoord2sv( GLenum target, const GLshort* v ) {
+static void WINAPI glMultiTexCoord2sv( GLenum target, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord2sv( target, v );
 }
 
-static void WINAPI glMultiTexCoord2svARB( GLenum target, const GLshort* v ) {
+static void WINAPI glMultiTexCoord2svARB( GLenum target, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord2svARB( target, v );
 }
 
-static void WINAPI glMultiTexCoord2svSGIS( GLenum target, GLshort* v ) {
+static void WINAPI glMultiTexCoord2svSGIS( GLenum target, GLshort * v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord2svSGIS( target, v );
 }
 
-static void WINAPI glMultiTexCoord2xOES( GLenum texture, GLfixed s, GLfixed t ) {
+static void WINAPI glMultiTexCoord2xOES( GLenum texture, GLfixed s, GLfixed t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", texture, s, t );
+  TRACE( "(%d, %d, %d)\n", texture, s, t );
   funcs->ext.p_glMultiTexCoord2xOES( texture, s, t );
 }
 
-static void WINAPI glMultiTexCoord2xvOES( GLenum texture, const GLfixed* coords ) {
+static void WINAPI glMultiTexCoord2xvOES( GLenum texture, const GLfixed *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", texture, coords );
+  TRACE( "(%d, %p)\n", texture, coords );
   funcs->ext.p_glMultiTexCoord2xvOES( texture, coords );
 }
 
-static void WINAPI glMultiTexCoord3bOES( GLenum texture, GLbyte s, GLbyte t, GLbyte r ) {
+static void WINAPI glMultiTexCoord3bOES( GLenum texture, GLbyte s, GLbyte t, GLbyte r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", texture, s, t, r );
+  TRACE( "(%d, %d, %d, %d)\n", texture, s, t, r );
   funcs->ext.p_glMultiTexCoord3bOES( texture, s, t, r );
 }
 
-static void WINAPI glMultiTexCoord3bvOES( GLenum texture, const GLbyte* coords ) {
+static void WINAPI glMultiTexCoord3bvOES( GLenum texture, const GLbyte *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", texture, coords );
+  TRACE( "(%d, %p)\n", texture, coords );
   funcs->ext.p_glMultiTexCoord3bvOES( texture, coords );
 }
 
-static void WINAPI glMultiTexCoord3d( GLenum target, GLdouble s, GLdouble t, GLdouble r ) {
+static void WINAPI glMultiTexCoord3d( GLenum target, GLdouble s, GLdouble t, GLdouble r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", target, s, t, r );
+  TRACE( "(%d, %f, %f, %f)\n", target, s, t, r );
   funcs->ext.p_glMultiTexCoord3d( target, s, t, r );
 }
 
-static void WINAPI glMultiTexCoord3dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r ) {
+static void WINAPI glMultiTexCoord3dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", target, s, t, r );
+  TRACE( "(%d, %f, %f, %f)\n", target, s, t, r );
   funcs->ext.p_glMultiTexCoord3dARB( target, s, t, r );
 }
 
-static void WINAPI glMultiTexCoord3dSGIS( GLenum target, GLdouble s, GLdouble t, GLdouble r ) {
+static void WINAPI glMultiTexCoord3dSGIS( GLenum target, GLdouble s, GLdouble t, GLdouble r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", target, s, t, r );
+  TRACE( "(%d, %f, %f, %f)\n", target, s, t, r );
   funcs->ext.p_glMultiTexCoord3dSGIS( target, s, t, r );
 }
 
-static void WINAPI glMultiTexCoord3dv( GLenum target, const GLdouble* v ) {
+static void WINAPI glMultiTexCoord3dv( GLenum target, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord3dv( target, v );
 }
 
-static void WINAPI glMultiTexCoord3dvARB( GLenum target, const GLdouble* v ) {
+static void WINAPI glMultiTexCoord3dvARB( GLenum target, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord3dvARB( target, v );
 }
 
-static void WINAPI glMultiTexCoord3dvSGIS( GLenum target, GLdouble* v ) {
+static void WINAPI glMultiTexCoord3dvSGIS( GLenum target, GLdouble * v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord3dvSGIS( target, v );
 }
 
-static void WINAPI glMultiTexCoord3f( GLenum target, GLfloat s, GLfloat t, GLfloat r ) {
+static void WINAPI glMultiTexCoord3f( GLenum target, GLfloat s, GLfloat t, GLfloat r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", target, s, t, r );
+  TRACE( "(%d, %f, %f, %f)\n", target, s, t, r );
   funcs->ext.p_glMultiTexCoord3f( target, s, t, r );
 }
 
-static void WINAPI glMultiTexCoord3fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r ) {
+static void WINAPI glMultiTexCoord3fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", target, s, t, r );
+  TRACE( "(%d, %f, %f, %f)\n", target, s, t, r );
   funcs->ext.p_glMultiTexCoord3fARB( target, s, t, r );
 }
 
-static void WINAPI glMultiTexCoord3fSGIS( GLenum target, GLfloat s, GLfloat t, GLfloat r ) {
+static void WINAPI glMultiTexCoord3fSGIS( GLenum target, GLfloat s, GLfloat t, GLfloat r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", target, s, t, r );
+  TRACE( "(%d, %f, %f, %f)\n", target, s, t, r );
   funcs->ext.p_glMultiTexCoord3fSGIS( target, s, t, r );
 }
 
-static void WINAPI glMultiTexCoord3fv( GLenum target, const GLfloat* v ) {
+static void WINAPI glMultiTexCoord3fv( GLenum target, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord3fv( target, v );
 }
 
-static void WINAPI glMultiTexCoord3fvARB( GLenum target, const GLfloat* v ) {
+static void WINAPI glMultiTexCoord3fvARB( GLenum target, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord3fvARB( target, v );
 }
 
-static void WINAPI glMultiTexCoord3fvSGIS( GLenum target, GLfloat* v ) {
+static void WINAPI glMultiTexCoord3fvSGIS( GLenum target, GLfloat * v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord3fvSGIS( target, v );
 }
 
-static void WINAPI glMultiTexCoord3hNV( GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r ) {
+static void WINAPI glMultiTexCoord3hNV( GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, s, t, r );
+  TRACE( "(%d, %d, %d, %d)\n", target, s, t, r );
   funcs->ext.p_glMultiTexCoord3hNV( target, s, t, r );
 }
 
-static void WINAPI glMultiTexCoord3hvNV( GLenum target, const GLhalfNV* v ) {
+static void WINAPI glMultiTexCoord3hvNV( GLenum target, const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord3hvNV( target, v );
 }
 
-static void WINAPI glMultiTexCoord3i( GLenum target, GLint s, GLint t, GLint r ) {
+static void WINAPI glMultiTexCoord3i( GLenum target, GLint s, GLint t, GLint r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, s, t, r );
+  TRACE( "(%d, %d, %d, %d)\n", target, s, t, r );
   funcs->ext.p_glMultiTexCoord3i( target, s, t, r );
 }
 
-static void WINAPI glMultiTexCoord3iARB( GLenum target, GLint s, GLint t, GLint r ) {
+static void WINAPI glMultiTexCoord3iARB( GLenum target, GLint s, GLint t, GLint r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, s, t, r );
+  TRACE( "(%d, %d, %d, %d)\n", target, s, t, r );
   funcs->ext.p_glMultiTexCoord3iARB( target, s, t, r );
 }
 
-static void WINAPI glMultiTexCoord3iSGIS( GLenum target, GLint s, GLint t, GLint r ) {
+static void WINAPI glMultiTexCoord3iSGIS( GLenum target, GLint s, GLint t, GLint r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, s, t, r );
+  TRACE( "(%d, %d, %d, %d)\n", target, s, t, r );
   funcs->ext.p_glMultiTexCoord3iSGIS( target, s, t, r );
 }
 
-static void WINAPI glMultiTexCoord3iv( GLenum target, const GLint* v ) {
+static void WINAPI glMultiTexCoord3iv( GLenum target, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord3iv( target, v );
 }
 
-static void WINAPI glMultiTexCoord3ivARB( GLenum target, const GLint* v ) {
+static void WINAPI glMultiTexCoord3ivARB( GLenum target, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord3ivARB( target, v );
 }
 
-static void WINAPI glMultiTexCoord3ivSGIS( GLenum target, GLint* v ) {
+static void WINAPI glMultiTexCoord3ivSGIS( GLenum target, GLint * v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord3ivSGIS( target, v );
 }
 
-static void WINAPI glMultiTexCoord3s( GLenum target, GLshort s, GLshort t, GLshort r ) {
+static void WINAPI glMultiTexCoord3s( GLenum target, GLshort s, GLshort t, GLshort r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, s, t, r );
+  TRACE( "(%d, %d, %d, %d)\n", target, s, t, r );
   funcs->ext.p_glMultiTexCoord3s( target, s, t, r );
 }
 
-static void WINAPI glMultiTexCoord3sARB( GLenum target, GLshort s, GLshort t, GLshort r ) {
+static void WINAPI glMultiTexCoord3sARB( GLenum target, GLshort s, GLshort t, GLshort r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, s, t, r );
+  TRACE( "(%d, %d, %d, %d)\n", target, s, t, r );
   funcs->ext.p_glMultiTexCoord3sARB( target, s, t, r );
 }
 
-static void WINAPI glMultiTexCoord3sSGIS( GLenum target, GLshort s, GLshort t, GLshort r ) {
+static void WINAPI glMultiTexCoord3sSGIS( GLenum target, GLshort s, GLshort t, GLshort r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, s, t, r );
+  TRACE( "(%d, %d, %d, %d)\n", target, s, t, r );
   funcs->ext.p_glMultiTexCoord3sSGIS( target, s, t, r );
 }
 
-static void WINAPI glMultiTexCoord3sv( GLenum target, const GLshort* v ) {
+static void WINAPI glMultiTexCoord3sv( GLenum target, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord3sv( target, v );
 }
 
-static void WINAPI glMultiTexCoord3svARB( GLenum target, const GLshort* v ) {
+static void WINAPI glMultiTexCoord3svARB( GLenum target, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord3svARB( target, v );
 }
 
-static void WINAPI glMultiTexCoord3svSGIS( GLenum target, GLshort* v ) {
+static void WINAPI glMultiTexCoord3svSGIS( GLenum target, GLshort * v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord3svSGIS( target, v );
 }
 
-static void WINAPI glMultiTexCoord3xOES( GLenum texture, GLfixed s, GLfixed t, GLfixed r ) {
+static void WINAPI glMultiTexCoord3xOES( GLenum texture, GLfixed s, GLfixed t, GLfixed r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", texture, s, t, r );
+  TRACE( "(%d, %d, %d, %d)\n", texture, s, t, r );
   funcs->ext.p_glMultiTexCoord3xOES( texture, s, t, r );
 }
 
-static void WINAPI glMultiTexCoord3xvOES( GLenum texture, const GLfixed* coords ) {
+static void WINAPI glMultiTexCoord3xvOES( GLenum texture, const GLfixed *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", texture, coords );
+  TRACE( "(%d, %p)\n", texture, coords );
   funcs->ext.p_glMultiTexCoord3xvOES( texture, coords );
 }
 
-static void WINAPI glMultiTexCoord4bOES( GLenum texture, GLbyte s, GLbyte t, GLbyte r, GLbyte q ) {
+static void WINAPI glMultiTexCoord4bOES( GLenum texture, GLbyte s, GLbyte t, GLbyte r, GLbyte q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", texture, s, t, r, q );
+  TRACE( "(%d, %d, %d, %d, %d)\n", texture, s, t, r, q );
   funcs->ext.p_glMultiTexCoord4bOES( texture, s, t, r, q );
 }
 
-static void WINAPI glMultiTexCoord4bvOES( GLenum texture, const GLbyte* coords ) {
+static void WINAPI glMultiTexCoord4bvOES( GLenum texture, const GLbyte *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", texture, coords );
+  TRACE( "(%d, %p)\n", texture, coords );
   funcs->ext.p_glMultiTexCoord4bvOES( texture, coords );
 }
 
-static void WINAPI glMultiTexCoord4d( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q ) {
+static void WINAPI glMultiTexCoord4d( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", target, s, t, r, q );
+  TRACE( "(%d, %f, %f, %f, %f)\n", target, s, t, r, q );
   funcs->ext.p_glMultiTexCoord4d( target, s, t, r, q );
 }
 
-static void WINAPI glMultiTexCoord4dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q ) {
+static void WINAPI glMultiTexCoord4dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", target, s, t, r, q );
+  TRACE( "(%d, %f, %f, %f, %f)\n", target, s, t, r, q );
   funcs->ext.p_glMultiTexCoord4dARB( target, s, t, r, q );
 }
 
-static void WINAPI glMultiTexCoord4dSGIS( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q ) {
+static void WINAPI glMultiTexCoord4dSGIS( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", target, s, t, r, q );
+  TRACE( "(%d, %f, %f, %f, %f)\n", target, s, t, r, q );
   funcs->ext.p_glMultiTexCoord4dSGIS( target, s, t, r, q );
 }
 
-static void WINAPI glMultiTexCoord4dv( GLenum target, const GLdouble* v ) {
+static void WINAPI glMultiTexCoord4dv( GLenum target, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord4dv( target, v );
 }
 
-static void WINAPI glMultiTexCoord4dvARB( GLenum target, const GLdouble* v ) {
+static void WINAPI glMultiTexCoord4dvARB( GLenum target, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord4dvARB( target, v );
 }
 
-static void WINAPI glMultiTexCoord4dvSGIS( GLenum target, GLdouble* v ) {
+static void WINAPI glMultiTexCoord4dvSGIS( GLenum target, GLdouble * v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord4dvSGIS( target, v );
 }
 
-static void WINAPI glMultiTexCoord4f( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q ) {
+static void WINAPI glMultiTexCoord4f( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", target, s, t, r, q );
+  TRACE( "(%d, %f, %f, %f, %f)\n", target, s, t, r, q );
   funcs->ext.p_glMultiTexCoord4f( target, s, t, r, q );
 }
 
-static void WINAPI glMultiTexCoord4fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q ) {
+static void WINAPI glMultiTexCoord4fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", target, s, t, r, q );
+  TRACE( "(%d, %f, %f, %f, %f)\n", target, s, t, r, q );
   funcs->ext.p_glMultiTexCoord4fARB( target, s, t, r, q );
 }
 
-static void WINAPI glMultiTexCoord4fSGIS( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q ) {
+static void WINAPI glMultiTexCoord4fSGIS( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", target, s, t, r, q );
+  TRACE( "(%d, %f, %f, %f, %f)\n", target, s, t, r, q );
   funcs->ext.p_glMultiTexCoord4fSGIS( target, s, t, r, q );
 }
 
-static void WINAPI glMultiTexCoord4fv( GLenum target, const GLfloat* v ) {
+static void WINAPI glMultiTexCoord4fv( GLenum target, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord4fv( target, v );
 }
 
-static void WINAPI glMultiTexCoord4fvARB( GLenum target, const GLfloat* v ) {
+static void WINAPI glMultiTexCoord4fvARB( GLenum target, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord4fvARB( target, v );
 }
 
-static void WINAPI glMultiTexCoord4fvSGIS( GLenum target, GLfloat* v ) {
+static void WINAPI glMultiTexCoord4fvSGIS( GLenum target, GLfloat * v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord4fvSGIS( target, v );
 }
 
-static void WINAPI glMultiTexCoord4hNV( GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q ) {
+static void WINAPI glMultiTexCoord4hNV( GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, s, t, r, q );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, s, t, r, q );
   funcs->ext.p_glMultiTexCoord4hNV( target, s, t, r, q );
 }
 
-static void WINAPI glMultiTexCoord4hvNV( GLenum target, const GLhalfNV* v ) {
+static void WINAPI glMultiTexCoord4hvNV( GLenum target, const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord4hvNV( target, v );
 }
 
-static void WINAPI glMultiTexCoord4i( GLenum target, GLint s, GLint t, GLint r, GLint q ) {
+static void WINAPI glMultiTexCoord4i( GLenum target, GLint s, GLint t, GLint r, GLint q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, s, t, r, q );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, s, t, r, q );
   funcs->ext.p_glMultiTexCoord4i( target, s, t, r, q );
 }
 
-static void WINAPI glMultiTexCoord4iARB( GLenum target, GLint s, GLint t, GLint r, GLint q ) {
+static void WINAPI glMultiTexCoord4iARB( GLenum target, GLint s, GLint t, GLint r, GLint q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, s, t, r, q );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, s, t, r, q );
   funcs->ext.p_glMultiTexCoord4iARB( target, s, t, r, q );
 }
 
-static void WINAPI glMultiTexCoord4iSGIS( GLenum target, GLint s, GLint t, GLint r, GLint q ) {
+static void WINAPI glMultiTexCoord4iSGIS( GLenum target, GLint s, GLint t, GLint r, GLint q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, s, t, r, q );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, s, t, r, q );
   funcs->ext.p_glMultiTexCoord4iSGIS( target, s, t, r, q );
 }
 
-static void WINAPI glMultiTexCoord4iv( GLenum target, const GLint* v ) {
+static void WINAPI glMultiTexCoord4iv( GLenum target, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord4iv( target, v );
 }
 
-static void WINAPI glMultiTexCoord4ivARB( GLenum target, const GLint* v ) {
+static void WINAPI glMultiTexCoord4ivARB( GLenum target, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord4ivARB( target, v );
 }
 
-static void WINAPI glMultiTexCoord4ivSGIS( GLenum target, GLint* v ) {
+static void WINAPI glMultiTexCoord4ivSGIS( GLenum target, GLint * v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord4ivSGIS( target, v );
 }
 
-static void WINAPI glMultiTexCoord4s( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q ) {
+static void WINAPI glMultiTexCoord4s( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, s, t, r, q );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, s, t, r, q );
   funcs->ext.p_glMultiTexCoord4s( target, s, t, r, q );
 }
 
-static void WINAPI glMultiTexCoord4sARB( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q ) {
+static void WINAPI glMultiTexCoord4sARB( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, s, t, r, q );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, s, t, r, q );
   funcs->ext.p_glMultiTexCoord4sARB( target, s, t, r, q );
 }
 
-static void WINAPI glMultiTexCoord4sSGIS( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q ) {
+static void WINAPI glMultiTexCoord4sSGIS( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, s, t, r, q );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, s, t, r, q );
   funcs->ext.p_glMultiTexCoord4sSGIS( target, s, t, r, q );
 }
 
-static void WINAPI glMultiTexCoord4sv( GLenum target, const GLshort* v ) {
+static void WINAPI glMultiTexCoord4sv( GLenum target, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord4sv( target, v );
 }
 
-static void WINAPI glMultiTexCoord4svARB( GLenum target, const GLshort* v ) {
+static void WINAPI glMultiTexCoord4svARB( GLenum target, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord4svARB( target, v );
 }
 
-static void WINAPI glMultiTexCoord4svSGIS( GLenum target, GLshort* v ) {
+static void WINAPI glMultiTexCoord4svSGIS( GLenum target, GLshort * v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", target, v );
+  TRACE( "(%d, %p)\n", target, v );
   funcs->ext.p_glMultiTexCoord4svSGIS( target, v );
 }
 
-static void WINAPI glMultiTexCoord4xOES( GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q ) {
+static void WINAPI glMultiTexCoord4xOES( GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", texture, s, t, r, q );
+  TRACE( "(%d, %d, %d, %d, %d)\n", texture, s, t, r, q );
   funcs->ext.p_glMultiTexCoord4xOES( texture, s, t, r, q );
 }
 
-static void WINAPI glMultiTexCoord4xvOES( GLenum texture, const GLfixed* coords ) {
+static void WINAPI glMultiTexCoord4xvOES( GLenum texture, const GLfixed *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", texture, coords );
+  TRACE( "(%d, %p)\n", texture, coords );
   funcs->ext.p_glMultiTexCoord4xvOES( texture, coords );
 }
 
-static void WINAPI glMultiTexCoordP1ui( GLenum texture, GLenum type, GLuint coords ) {
+static void WINAPI glMultiTexCoordP1ui( GLenum texture, GLenum type, GLuint coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", texture, type, coords );
+  TRACE( "(%d, %d, %d)\n", texture, type, coords );
   funcs->ext.p_glMultiTexCoordP1ui( texture, type, coords );
 }
 
-static void WINAPI glMultiTexCoordP1uiv( GLenum texture, GLenum type, const GLuint* coords ) {
+static void WINAPI glMultiTexCoordP1uiv( GLenum texture, GLenum type, const GLuint *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", texture, type, coords );
+  TRACE( "(%d, %d, %p)\n", texture, type, coords );
   funcs->ext.p_glMultiTexCoordP1uiv( texture, type, coords );
 }
 
-static void WINAPI glMultiTexCoordP2ui( GLenum texture, GLenum type, GLuint coords ) {
+static void WINAPI glMultiTexCoordP2ui( GLenum texture, GLenum type, GLuint coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", texture, type, coords );
+  TRACE( "(%d, %d, %d)\n", texture, type, coords );
   funcs->ext.p_glMultiTexCoordP2ui( texture, type, coords );
 }
 
-static void WINAPI glMultiTexCoordP2uiv( GLenum texture, GLenum type, const GLuint* coords ) {
+static void WINAPI glMultiTexCoordP2uiv( GLenum texture, GLenum type, const GLuint *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", texture, type, coords );
+  TRACE( "(%d, %d, %p)\n", texture, type, coords );
   funcs->ext.p_glMultiTexCoordP2uiv( texture, type, coords );
 }
 
-static void WINAPI glMultiTexCoordP3ui( GLenum texture, GLenum type, GLuint coords ) {
+static void WINAPI glMultiTexCoordP3ui( GLenum texture, GLenum type, GLuint coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", texture, type, coords );
+  TRACE( "(%d, %d, %d)\n", texture, type, coords );
   funcs->ext.p_glMultiTexCoordP3ui( texture, type, coords );
 }
 
-static void WINAPI glMultiTexCoordP3uiv( GLenum texture, GLenum type, const GLuint* coords ) {
+static void WINAPI glMultiTexCoordP3uiv( GLenum texture, GLenum type, const GLuint *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", texture, type, coords );
+  TRACE( "(%d, %d, %p)\n", texture, type, coords );
   funcs->ext.p_glMultiTexCoordP3uiv( texture, type, coords );
 }
 
-static void WINAPI glMultiTexCoordP4ui( GLenum texture, GLenum type, GLuint coords ) {
+static void WINAPI glMultiTexCoordP4ui( GLenum texture, GLenum type, GLuint coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", texture, type, coords );
+  TRACE( "(%d, %d, %d)\n", texture, type, coords );
   funcs->ext.p_glMultiTexCoordP4ui( texture, type, coords );
 }
 
-static void WINAPI glMultiTexCoordP4uiv( GLenum texture, GLenum type, const GLuint* coords ) {
+static void WINAPI glMultiTexCoordP4uiv( GLenum texture, GLenum type, const GLuint *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", texture, type, coords );
+  TRACE( "(%d, %d, %p)\n", texture, type, coords );
   funcs->ext.p_glMultiTexCoordP4uiv( texture, type, coords );
 }
 
-static void WINAPI glMultiTexCoordPointerEXT( GLenum texunit, GLint size, GLenum type, GLsizei stride, const void* pointer ) {
+static void WINAPI glMultiTexCoordPointerEXT( GLenum texunit, GLint size, GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", texunit, size, type, stride, pointer );
+  TRACE( "(%d, %d, %d, %d, %p)\n", texunit, size, type, stride, pointer );
   funcs->ext.p_glMultiTexCoordPointerEXT( texunit, size, type, stride, pointer );
 }
 
-static void WINAPI glMultiTexCoordPointerSGIS( GLenum target, GLint size, GLenum type, GLsizei stride, GLvoid* pointer ) {
+static void WINAPI glMultiTexCoordPointerSGIS( GLenum target, GLint size, GLenum type, GLsizei stride, GLvoid * pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", target, size, type, stride, pointer );
+  TRACE( "(%d, %d, %d, %d, %p)\n", target, size, type, stride, pointer );
   funcs->ext.p_glMultiTexCoordPointerSGIS( target, size, type, stride, pointer );
 }
 
-static void WINAPI glMultiTexEnvfEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat param ) {
+static void WINAPI glMultiTexEnvfEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %f)\n", texunit, target, pname, param );
+  TRACE( "(%d, %d, %d, %f)\n", texunit, target, pname, param );
   funcs->ext.p_glMultiTexEnvfEXT( texunit, target, pname, param );
 }
 
-static void WINAPI glMultiTexEnvfvEXT( GLenum texunit, GLenum target, GLenum pname, const GLfloat* params ) {
+static void WINAPI glMultiTexEnvfvEXT( GLenum texunit, GLenum target, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, target, pname, params );
   funcs->ext.p_glMultiTexEnvfvEXT( texunit, target, pname, params );
 }
 
-static void WINAPI glMultiTexEnviEXT( GLenum texunit, GLenum target, GLenum pname, GLint param ) {
+static void WINAPI glMultiTexEnviEXT( GLenum texunit, GLenum target, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", texunit, target, pname, param );
+  TRACE( "(%d, %d, %d, %d)\n", texunit, target, pname, param );
   funcs->ext.p_glMultiTexEnviEXT( texunit, target, pname, param );
 }
 
-static void WINAPI glMultiTexEnvivEXT( GLenum texunit, GLenum target, GLenum pname, const GLint* params ) {
+static void WINAPI glMultiTexEnvivEXT( GLenum texunit, GLenum target, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, target, pname, params );
   funcs->ext.p_glMultiTexEnvivEXT( texunit, target, pname, params );
 }
 
-static void WINAPI glMultiTexGendEXT( GLenum texunit, GLenum coord, GLenum pname, GLdouble param ) {
+static void WINAPI glMultiTexGendEXT( GLenum texunit, GLenum coord, GLenum pname, GLdouble param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %f)\n", texunit, coord, pname, param );
+  TRACE( "(%d, %d, %d, %f)\n", texunit, coord, pname, param );
   funcs->ext.p_glMultiTexGendEXT( texunit, coord, pname, param );
 }
 
-static void WINAPI glMultiTexGendvEXT( GLenum texunit, GLenum coord, GLenum pname, const GLdouble* params ) {
+static void WINAPI glMultiTexGendvEXT( GLenum texunit, GLenum coord, GLenum pname, const GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, coord, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, coord, pname, params );
   funcs->ext.p_glMultiTexGendvEXT( texunit, coord, pname, params );
 }
 
-static void WINAPI glMultiTexGenfEXT( GLenum texunit, GLenum coord, GLenum pname, GLfloat param ) {
+static void WINAPI glMultiTexGenfEXT( GLenum texunit, GLenum coord, GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %f)\n", texunit, coord, pname, param );
+  TRACE( "(%d, %d, %d, %f)\n", texunit, coord, pname, param );
   funcs->ext.p_glMultiTexGenfEXT( texunit, coord, pname, param );
 }
 
-static void WINAPI glMultiTexGenfvEXT( GLenum texunit, GLenum coord, GLenum pname, const GLfloat* params ) {
+static void WINAPI glMultiTexGenfvEXT( GLenum texunit, GLenum coord, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, coord, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, coord, pname, params );
   funcs->ext.p_glMultiTexGenfvEXT( texunit, coord, pname, params );
 }
 
-static void WINAPI glMultiTexGeniEXT( GLenum texunit, GLenum coord, GLenum pname, GLint param ) {
+static void WINAPI glMultiTexGeniEXT( GLenum texunit, GLenum coord, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", texunit, coord, pname, param );
+  TRACE( "(%d, %d, %d, %d)\n", texunit, coord, pname, param );
   funcs->ext.p_glMultiTexGeniEXT( texunit, coord, pname, param );
 }
 
-static void WINAPI glMultiTexGenivEXT( GLenum texunit, GLenum coord, GLenum pname, const GLint* params ) {
+static void WINAPI glMultiTexGenivEXT( GLenum texunit, GLenum coord, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, coord, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, coord, pname, params );
   funcs->ext.p_glMultiTexGenivEXT( texunit, coord, pname, params );
 }
 
-static void WINAPI glMultiTexImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glMultiTexImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, border, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, border, format, type, pixels );
   funcs->ext.p_glMultiTexImage1DEXT( texunit, target, level, internalformat, width, border, format, type, pixels );
 }
 
-static void WINAPI glMultiTexImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glMultiTexImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, height, border, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, height, border, format, type, pixels );
   funcs->ext.p_glMultiTexImage2DEXT( texunit, target, level, internalformat, width, height, border, format, type, pixels );
 }
 
-static void WINAPI glMultiTexImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glMultiTexImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, height, depth, border, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, internalformat, width, height, depth, border, format, type, pixels );
   funcs->ext.p_glMultiTexImage3DEXT( texunit, target, level, internalformat, width, height, depth, border, format, type, pixels );
 }
 
-static void WINAPI glMultiTexParameterIivEXT( GLenum texunit, GLenum target, GLenum pname, const GLint* params ) {
+static void WINAPI glMultiTexParameterIivEXT( GLenum texunit, GLenum target, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, target, pname, params );
   funcs->ext.p_glMultiTexParameterIivEXT( texunit, target, pname, params );
 }
 
-static void WINAPI glMultiTexParameterIuivEXT( GLenum texunit, GLenum target, GLenum pname, const GLuint* params ) {
+static void WINAPI glMultiTexParameterIuivEXT( GLenum texunit, GLenum target, GLenum pname, const GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, target, pname, params );
   funcs->ext.p_glMultiTexParameterIuivEXT( texunit, target, pname, params );
 }
 
-static void WINAPI glMultiTexParameterfEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat param ) {
+static void WINAPI glMultiTexParameterfEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %f)\n", texunit, target, pname, param );
+  TRACE( "(%d, %d, %d, %f)\n", texunit, target, pname, param );
   funcs->ext.p_glMultiTexParameterfEXT( texunit, target, pname, param );
 }
 
-static void WINAPI glMultiTexParameterfvEXT( GLenum texunit, GLenum target, GLenum pname, const GLfloat* params ) {
+static void WINAPI glMultiTexParameterfvEXT( GLenum texunit, GLenum target, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, target, pname, params );
   funcs->ext.p_glMultiTexParameterfvEXT( texunit, target, pname, params );
 }
 
-static void WINAPI glMultiTexParameteriEXT( GLenum texunit, GLenum target, GLenum pname, GLint param ) {
+static void WINAPI glMultiTexParameteriEXT( GLenum texunit, GLenum target, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", texunit, target, pname, param );
+  TRACE( "(%d, %d, %d, %d)\n", texunit, target, pname, param );
   funcs->ext.p_glMultiTexParameteriEXT( texunit, target, pname, param );
 }
 
-static void WINAPI glMultiTexParameterivEXT( GLenum texunit, GLenum target, GLenum pname, const GLint* params ) {
+static void WINAPI glMultiTexParameterivEXT( GLenum texunit, GLenum target, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texunit, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texunit, target, pname, params );
   funcs->ext.p_glMultiTexParameterivEXT( texunit, target, pname, params );
 }
 
-static void WINAPI glMultiTexRenderbufferEXT( GLenum texunit, GLenum target, GLuint renderbuffer ) {
+static void WINAPI glMultiTexRenderbufferEXT( GLenum texunit, GLenum target, GLuint renderbuffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", texunit, target, renderbuffer );
+  TRACE( "(%d, %d, %d)\n", texunit, target, renderbuffer );
   funcs->ext.p_glMultiTexRenderbufferEXT( texunit, target, renderbuffer );
 }
 
-static void WINAPI glMultiTexSubImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glMultiTexSubImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, width, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, width, format, type, pixels );
   funcs->ext.p_glMultiTexSubImage1DEXT( texunit, target, level, xoffset, width, format, type, pixels );
 }
 
-static void WINAPI glMultiTexSubImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glMultiTexSubImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, yoffset, width, height, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, yoffset, width, height, format, type, pixels );
   funcs->ext.p_glMultiTexSubImage2DEXT( texunit, target, level, xoffset, yoffset, width, height, format, type, pixels );
 }
 
-static void WINAPI glMultiTexSubImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glMultiTexSubImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
   funcs->ext.p_glMultiTexSubImage3DEXT( texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
 }
 
-static void WINAPI glMulticastBarrierNV( void ) {
+static void WINAPI glMulticastBarrierNV(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glMulticastBarrierNV( );
+  TRACE( "()\n" );
+  funcs->ext.p_glMulticastBarrierNV();
 }
 
-static void WINAPI glMulticastBlitFramebufferNV( GLuint srcGpu, GLuint dstGpu, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter ) {
+static void WINAPI glMulticastBlitFramebufferNV( GLuint srcGpu, GLuint dstGpu, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", srcGpu, dstGpu, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", srcGpu, dstGpu, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
   funcs->ext.p_glMulticastBlitFramebufferNV( srcGpu, dstGpu, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter );
 }
 
-static void WINAPI glMulticastBufferSubDataNV( GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, const GLvoid* data ) {
+static void WINAPI glMulticastBufferSubDataNV( GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, const GLvoid *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %ld, %ld, %p)\n", gpuMask, buffer, offset, size, data );
+  TRACE( "(%d, %d, %ld, %ld, %p)\n", gpuMask, buffer, offset, size, data );
   funcs->ext.p_glMulticastBufferSubDataNV( gpuMask, buffer, offset, size, data );
 }
 
-static void WINAPI glMulticastCopyBufferSubDataNV( GLuint readGpu, GLbitfield writeGpuMask, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size ) {
+static void WINAPI glMulticastCopyBufferSubDataNV( GLuint readGpu, GLbitfield writeGpuMask, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %ld, %ld, %ld)\n", readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size );
+  TRACE( "(%d, %d, %d, %d, %ld, %ld, %ld)\n", readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size );
   funcs->ext.p_glMulticastCopyBufferSubDataNV( readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size );
 }
 
-static void WINAPI glMulticastCopyImageSubDataNV( GLuint srcGpu, GLbitfield dstGpuMask, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth ) {
+static void WINAPI glMulticastCopyImageSubDataNV( GLuint srcGpu, GLbitfield dstGpuMask, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth );
   funcs->ext.p_glMulticastCopyImageSubDataNV( srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth );
 }
 
-static void WINAPI glMulticastFramebufferSampleLocationsfvNV( GLuint gpu, GLuint framebuffer, GLuint start, GLsizei count, const GLfloat* v ) {
+static void WINAPI glMulticastFramebufferSampleLocationsfvNV( GLuint gpu, GLuint framebuffer, GLuint start, GLsizei count, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", gpu, framebuffer, start, count, v );
+  TRACE( "(%d, %d, %d, %d, %p)\n", gpu, framebuffer, start, count, v );
   funcs->ext.p_glMulticastFramebufferSampleLocationsfvNV( gpu, framebuffer, start, count, v );
 }
 
-static void WINAPI glMulticastGetQueryObjecti64vNV( GLuint gpu, GLuint id, GLenum pname, GLint64* params ) {
+static void WINAPI glMulticastGetQueryObjecti64vNV( GLuint gpu, GLuint id, GLenum pname, GLint64 *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", gpu, id, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", gpu, id, pname, params );
   funcs->ext.p_glMulticastGetQueryObjecti64vNV( gpu, id, pname, params );
 }
 
-static void WINAPI glMulticastGetQueryObjectivNV( GLuint gpu, GLuint id, GLenum pname, GLint* params ) {
+static void WINAPI glMulticastGetQueryObjectivNV( GLuint gpu, GLuint id, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", gpu, id, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", gpu, id, pname, params );
   funcs->ext.p_glMulticastGetQueryObjectivNV( gpu, id, pname, params );
 }
 
-static void WINAPI glMulticastGetQueryObjectui64vNV( GLuint gpu, GLuint id, GLenum pname, GLuint64* params ) {
+static void WINAPI glMulticastGetQueryObjectui64vNV( GLuint gpu, GLuint id, GLenum pname, GLuint64 *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", gpu, id, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", gpu, id, pname, params );
   funcs->ext.p_glMulticastGetQueryObjectui64vNV( gpu, id, pname, params );
 }
 
-static void WINAPI glMulticastGetQueryObjectuivNV( GLuint gpu, GLuint id, GLenum pname, GLuint* params ) {
+static void WINAPI glMulticastGetQueryObjectuivNV( GLuint gpu, GLuint id, GLenum pname, GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", gpu, id, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", gpu, id, pname, params );
   funcs->ext.p_glMulticastGetQueryObjectuivNV( gpu, id, pname, params );
 }
 
-static void WINAPI glMulticastWaitSyncNV( GLuint signalGpu, GLbitfield waitGpuMask ) {
+static void WINAPI glMulticastWaitSyncNV( GLuint signalGpu, GLbitfield waitGpuMask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", signalGpu, waitGpuMask );
+  TRACE( "(%d, %d)\n", signalGpu, waitGpuMask );
   funcs->ext.p_glMulticastWaitSyncNV( signalGpu, waitGpuMask );
 }
 
-static void WINAPI glNamedBufferData( GLuint buffer, GLsizeiptr size, const void* data, GLenum usage ) {
+static void WINAPI glNamedBufferData( GLuint buffer, GLsizeiptr size, const void *data, GLenum usage )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %p, %d)\n", buffer, size, data, usage );
+  TRACE( "(%d, %ld, %p, %d)\n", buffer, size, data, usage );
   funcs->ext.p_glNamedBufferData( buffer, size, data, usage );
 }
 
-static void WINAPI glNamedBufferDataEXT( GLuint buffer, GLsizeiptr size, const void* data, GLenum usage ) {
+static void WINAPI glNamedBufferDataEXT( GLuint buffer, GLsizeiptr size, const void *data, GLenum usage )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %p, %d)\n", buffer, size, data, usage );
+  TRACE( "(%d, %ld, %p, %d)\n", buffer, size, data, usage );
   funcs->ext.p_glNamedBufferDataEXT( buffer, size, data, usage );
 }
 
-static void WINAPI glNamedBufferPageCommitmentARB( GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit ) {
+static void WINAPI glNamedBufferPageCommitmentARB( GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld, %d)\n", buffer, offset, size, commit );
+  TRACE( "(%d, %ld, %ld, %d)\n", buffer, offset, size, commit );
   funcs->ext.p_glNamedBufferPageCommitmentARB( buffer, offset, size, commit );
 }
 
-static void WINAPI glNamedBufferPageCommitmentEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit ) {
+static void WINAPI glNamedBufferPageCommitmentEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld, %d)\n", buffer, offset, size, commit );
+  TRACE( "(%d, %ld, %ld, %d)\n", buffer, offset, size, commit );
   funcs->ext.p_glNamedBufferPageCommitmentEXT( buffer, offset, size, commit );
 }
 
-static void WINAPI glNamedBufferStorage( GLuint buffer, GLsizeiptr size, const void* data, GLbitfield flags ) {
+static void WINAPI glNamedBufferStorage( GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %p, %d)\n", buffer, size, data, flags );
+  TRACE( "(%d, %ld, %p, %d)\n", buffer, size, data, flags );
   funcs->ext.p_glNamedBufferStorage( buffer, size, data, flags );
 }
 
-static void WINAPI glNamedBufferStorageEXT( GLuint buffer, GLsizeiptr size, const void* data, GLbitfield flags ) {
+static void WINAPI glNamedBufferStorageEXT( GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %p, %d)\n", buffer, size, data, flags );
+  TRACE( "(%d, %ld, %p, %d)\n", buffer, size, data, flags );
   funcs->ext.p_glNamedBufferStorageEXT( buffer, size, data, flags );
 }
 
-static void WINAPI glNamedBufferStorageExternalEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, void * clientBuffer, GLbitfield flags ) {
+static void WINAPI glNamedBufferStorageExternalEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, void * clientBuffer, GLbitfield flags )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld, %p, %d)\n", buffer, offset, size, clientBuffer, flags );
+  TRACE( "(%d, %ld, %ld, %p, %d)\n", buffer, offset, size, clientBuffer, flags );
   funcs->ext.p_glNamedBufferStorageExternalEXT( buffer, offset, size, clientBuffer, flags );
 }
 
-static void WINAPI glNamedBufferStorageMemEXT( GLuint buffer, GLsizeiptr size, GLuint memory, GLuint64 offset ) {
+static void WINAPI glNamedBufferStorageMemEXT( GLuint buffer, GLsizeiptr size, GLuint memory, GLuint64 offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %d, %s)\n", buffer, size, memory, wine_dbgstr_longlong(offset) );
+  TRACE( "(%d, %ld, %d, %s)\n", buffer, size, memory, wine_dbgstr_longlong(offset) );
   funcs->ext.p_glNamedBufferStorageMemEXT( buffer, size, memory, offset );
 }
 
-static void WINAPI glNamedBufferSubData( GLuint buffer, GLintptr offset, GLsizeiptr size, const void* data ) {
+static void WINAPI glNamedBufferSubData( GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld, %p)\n", buffer, offset, size, data );
+  TRACE( "(%d, %ld, %ld, %p)\n", buffer, offset, size, data );
   funcs->ext.p_glNamedBufferSubData( buffer, offset, size, data );
 }
 
-static void WINAPI glNamedBufferSubDataEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, const void* data ) {
+static void WINAPI glNamedBufferSubDataEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %ld, %ld, %p)\n", buffer, offset, size, data );
+  TRACE( "(%d, %ld, %ld, %p)\n", buffer, offset, size, data );
   funcs->ext.p_glNamedBufferSubDataEXT( buffer, offset, size, data );
 }
 
-static void WINAPI glNamedCopyBufferSubDataEXT( GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size ) {
+static void WINAPI glNamedCopyBufferSubDataEXT( GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %ld, %ld, %ld)\n", readBuffer, writeBuffer, readOffset, writeOffset, size );
+  TRACE( "(%d, %d, %ld, %ld, %ld)\n", readBuffer, writeBuffer, readOffset, writeOffset, size );
   funcs->ext.p_glNamedCopyBufferSubDataEXT( readBuffer, writeBuffer, readOffset, writeOffset, size );
 }
 
-static void WINAPI glNamedFramebufferDrawBuffer( GLuint framebuffer, GLenum buf ) {
+static void WINAPI glNamedFramebufferDrawBuffer( GLuint framebuffer, GLenum buf )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", framebuffer, buf );
+  TRACE( "(%d, %d)\n", framebuffer, buf );
   funcs->ext.p_glNamedFramebufferDrawBuffer( framebuffer, buf );
 }
 
-static void WINAPI glNamedFramebufferDrawBuffers( GLuint framebuffer, GLsizei n, const GLenum* bufs ) {
+static void WINAPI glNamedFramebufferDrawBuffers( GLuint framebuffer, GLsizei n, const GLenum *bufs )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", framebuffer, n, bufs );
+  TRACE( "(%d, %d, %p)\n", framebuffer, n, bufs );
   funcs->ext.p_glNamedFramebufferDrawBuffers( framebuffer, n, bufs );
 }
 
-static void WINAPI glNamedFramebufferParameteri( GLuint framebuffer, GLenum pname, GLint param ) {
+static void WINAPI glNamedFramebufferParameteri( GLuint framebuffer, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", framebuffer, pname, param );
+  TRACE( "(%d, %d, %d)\n", framebuffer, pname, param );
   funcs->ext.p_glNamedFramebufferParameteri( framebuffer, pname, param );
 }
 
-static void WINAPI glNamedFramebufferParameteriEXT( GLuint framebuffer, GLenum pname, GLint param ) {
+static void WINAPI glNamedFramebufferParameteriEXT( GLuint framebuffer, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", framebuffer, pname, param );
+  TRACE( "(%d, %d, %d)\n", framebuffer, pname, param );
   funcs->ext.p_glNamedFramebufferParameteriEXT( framebuffer, pname, param );
 }
 
-static void WINAPI glNamedFramebufferReadBuffer( GLuint framebuffer, GLenum src ) {
+static void WINAPI glNamedFramebufferReadBuffer( GLuint framebuffer, GLenum src )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", framebuffer, src );
+  TRACE( "(%d, %d)\n", framebuffer, src );
   funcs->ext.p_glNamedFramebufferReadBuffer( framebuffer, src );
 }
 
-static void WINAPI glNamedFramebufferRenderbuffer( GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) {
+static void WINAPI glNamedFramebufferRenderbuffer( GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", framebuffer, attachment, renderbuffertarget, renderbuffer );
+  TRACE( "(%d, %d, %d, %d)\n", framebuffer, attachment, renderbuffertarget, renderbuffer );
   funcs->ext.p_glNamedFramebufferRenderbuffer( framebuffer, attachment, renderbuffertarget, renderbuffer );
 }
 
-static void WINAPI glNamedFramebufferRenderbufferEXT( GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) {
+static void WINAPI glNamedFramebufferRenderbufferEXT( GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", framebuffer, attachment, renderbuffertarget, renderbuffer );
+  TRACE( "(%d, %d, %d, %d)\n", framebuffer, attachment, renderbuffertarget, renderbuffer );
   funcs->ext.p_glNamedFramebufferRenderbufferEXT( framebuffer, attachment, renderbuffertarget, renderbuffer );
 }
 
-static void WINAPI glNamedFramebufferSampleLocationsfvARB( GLuint framebuffer, GLuint start, GLsizei count, const GLfloat* v ) {
+static void WINAPI glNamedFramebufferSampleLocationsfvARB( GLuint framebuffer, GLuint start, GLsizei count, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", framebuffer, start, count, v );
+  TRACE( "(%d, %d, %d, %p)\n", framebuffer, start, count, v );
   funcs->ext.p_glNamedFramebufferSampleLocationsfvARB( framebuffer, start, count, v );
 }
 
-static void WINAPI glNamedFramebufferSampleLocationsfvNV( GLuint framebuffer, GLuint start, GLsizei count, const GLfloat* v ) {
+static void WINAPI glNamedFramebufferSampleLocationsfvNV( GLuint framebuffer, GLuint start, GLsizei count, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", framebuffer, start, count, v );
+  TRACE( "(%d, %d, %d, %p)\n", framebuffer, start, count, v );
   funcs->ext.p_glNamedFramebufferSampleLocationsfvNV( framebuffer, start, count, v );
 }
 
-static void WINAPI glNamedFramebufferSamplePositionsfvAMD( GLuint framebuffer, GLuint numsamples, GLuint pixelindex, const GLfloat* values ) {
+static void WINAPI glNamedFramebufferSamplePositionsfvAMD( GLuint framebuffer, GLuint numsamples, GLuint pixelindex, const GLfloat *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", framebuffer, numsamples, pixelindex, values );
+  TRACE( "(%d, %d, %d, %p)\n", framebuffer, numsamples, pixelindex, values );
   funcs->ext.p_glNamedFramebufferSamplePositionsfvAMD( framebuffer, numsamples, pixelindex, values );
 }
 
-static void WINAPI glNamedFramebufferTexture( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level ) {
+static void WINAPI glNamedFramebufferTexture( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", framebuffer, attachment, texture, level );
+  TRACE( "(%d, %d, %d, %d)\n", framebuffer, attachment, texture, level );
   funcs->ext.p_glNamedFramebufferTexture( framebuffer, attachment, texture, level );
 }
 
-static void WINAPI glNamedFramebufferTexture1DEXT( GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) {
+static void WINAPI glNamedFramebufferTexture1DEXT( GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", framebuffer, attachment, textarget, texture, level );
+  TRACE( "(%d, %d, %d, %d, %d)\n", framebuffer, attachment, textarget, texture, level );
   funcs->ext.p_glNamedFramebufferTexture1DEXT( framebuffer, attachment, textarget, texture, level );
 }
 
-static void WINAPI glNamedFramebufferTexture2DEXT( GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) {
+static void WINAPI glNamedFramebufferTexture2DEXT( GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", framebuffer, attachment, textarget, texture, level );
+  TRACE( "(%d, %d, %d, %d, %d)\n", framebuffer, attachment, textarget, texture, level );
   funcs->ext.p_glNamedFramebufferTexture2DEXT( framebuffer, attachment, textarget, texture, level );
 }
 
-static void WINAPI glNamedFramebufferTexture3DEXT( GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset ) {
+static void WINAPI glNamedFramebufferTexture3DEXT( GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", framebuffer, attachment, textarget, texture, level, zoffset );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", framebuffer, attachment, textarget, texture, level, zoffset );
   funcs->ext.p_glNamedFramebufferTexture3DEXT( framebuffer, attachment, textarget, texture, level, zoffset );
 }
 
-static void WINAPI glNamedFramebufferTextureEXT( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level ) {
+static void WINAPI glNamedFramebufferTextureEXT( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", framebuffer, attachment, texture, level );
+  TRACE( "(%d, %d, %d, %d)\n", framebuffer, attachment, texture, level );
   funcs->ext.p_glNamedFramebufferTextureEXT( framebuffer, attachment, texture, level );
 }
 
-static void WINAPI glNamedFramebufferTextureFaceEXT( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face ) {
+static void WINAPI glNamedFramebufferTextureFaceEXT( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", framebuffer, attachment, texture, level, face );
+  TRACE( "(%d, %d, %d, %d, %d)\n", framebuffer, attachment, texture, level, face );
   funcs->ext.p_glNamedFramebufferTextureFaceEXT( framebuffer, attachment, texture, level, face );
 }
 
-static void WINAPI glNamedFramebufferTextureLayer( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer ) {
+static void WINAPI glNamedFramebufferTextureLayer( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", framebuffer, attachment, texture, level, layer );
+  TRACE( "(%d, %d, %d, %d, %d)\n", framebuffer, attachment, texture, level, layer );
   funcs->ext.p_glNamedFramebufferTextureLayer( framebuffer, attachment, texture, level, layer );
 }
 
-static void WINAPI glNamedFramebufferTextureLayerEXT( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer ) {
+static void WINAPI glNamedFramebufferTextureLayerEXT( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", framebuffer, attachment, texture, level, layer );
+  TRACE( "(%d, %d, %d, %d, %d)\n", framebuffer, attachment, texture, level, layer );
   funcs->ext.p_glNamedFramebufferTextureLayerEXT( framebuffer, attachment, texture, level, layer );
 }
 
-static void WINAPI glNamedProgramLocalParameter4dEXT( GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+static void WINAPI glNamedProgramLocalParameter4dEXT( GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %f, %f, %f, %f)\n", program, target, index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %f, %f, %f, %f)\n", program, target, index, x, y, z, w );
   funcs->ext.p_glNamedProgramLocalParameter4dEXT( program, target, index, x, y, z, w );
 }
 
-static void WINAPI glNamedProgramLocalParameter4dvEXT( GLuint program, GLenum target, GLuint index, const GLdouble* params ) {
+static void WINAPI glNamedProgramLocalParameter4dvEXT( GLuint program, GLenum target, GLuint index, const GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, target, index, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, target, index, params );
   funcs->ext.p_glNamedProgramLocalParameter4dvEXT( program, target, index, params );
 }
 
-static void WINAPI glNamedProgramLocalParameter4fEXT( GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+static void WINAPI glNamedProgramLocalParameter4fEXT( GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %f, %f, %f, %f)\n", program, target, index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %f, %f, %f, %f)\n", program, target, index, x, y, z, w );
   funcs->ext.p_glNamedProgramLocalParameter4fEXT( program, target, index, x, y, z, w );
 }
 
-static void WINAPI glNamedProgramLocalParameter4fvEXT( GLuint program, GLenum target, GLuint index, const GLfloat* params ) {
+static void WINAPI glNamedProgramLocalParameter4fvEXT( GLuint program, GLenum target, GLuint index, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, target, index, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, target, index, params );
   funcs->ext.p_glNamedProgramLocalParameter4fvEXT( program, target, index, params );
 }
 
-static void WINAPI glNamedProgramLocalParameterI4iEXT( GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w ) {
+static void WINAPI glNamedProgramLocalParameterI4iEXT( GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", program, target, index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", program, target, index, x, y, z, w );
   funcs->ext.p_glNamedProgramLocalParameterI4iEXT( program, target, index, x, y, z, w );
 }
 
-static void WINAPI glNamedProgramLocalParameterI4ivEXT( GLuint program, GLenum target, GLuint index, const GLint* params ) {
+static void WINAPI glNamedProgramLocalParameterI4ivEXT( GLuint program, GLenum target, GLuint index, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, target, index, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, target, index, params );
   funcs->ext.p_glNamedProgramLocalParameterI4ivEXT( program, target, index, params );
 }
 
-static void WINAPI glNamedProgramLocalParameterI4uiEXT( GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) {
+static void WINAPI glNamedProgramLocalParameterI4uiEXT( GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", program, target, index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", program, target, index, x, y, z, w );
   funcs->ext.p_glNamedProgramLocalParameterI4uiEXT( program, target, index, x, y, z, w );
 }
 
-static void WINAPI glNamedProgramLocalParameterI4uivEXT( GLuint program, GLenum target, GLuint index, const GLuint* params ) {
+static void WINAPI glNamedProgramLocalParameterI4uivEXT( GLuint program, GLenum target, GLuint index, const GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, target, index, params );
+  TRACE( "(%d, %d, %d, %p)\n", program, target, index, params );
   funcs->ext.p_glNamedProgramLocalParameterI4uivEXT( program, target, index, params );
 }
 
-static void WINAPI glNamedProgramLocalParameters4fvEXT( GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat* params ) {
+static void WINAPI glNamedProgramLocalParameters4fvEXT( GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, target, index, count, params );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, target, index, count, params );
   funcs->ext.p_glNamedProgramLocalParameters4fvEXT( program, target, index, count, params );
 }
 
-static void WINAPI glNamedProgramLocalParametersI4ivEXT( GLuint program, GLenum target, GLuint index, GLsizei count, const GLint* params ) {
+static void WINAPI glNamedProgramLocalParametersI4ivEXT( GLuint program, GLenum target, GLuint index, GLsizei count, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, target, index, count, params );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, target, index, count, params );
   funcs->ext.p_glNamedProgramLocalParametersI4ivEXT( program, target, index, count, params );
 }
 
-static void WINAPI glNamedProgramLocalParametersI4uivEXT( GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint* params ) {
+static void WINAPI glNamedProgramLocalParametersI4uivEXT( GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, target, index, count, params );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, target, index, count, params );
   funcs->ext.p_glNamedProgramLocalParametersI4uivEXT( program, target, index, count, params );
 }
 
-static void WINAPI glNamedProgramStringEXT( GLuint program, GLenum target, GLenum format, GLsizei len, const void* string ) {
+static void WINAPI glNamedProgramStringEXT( GLuint program, GLenum target, GLenum format, GLsizei len, const void *string )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, target, format, len, string );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, target, format, len, string );
   funcs->ext.p_glNamedProgramStringEXT( program, target, format, len, string );
 }
 
-static void WINAPI glNamedRenderbufferStorage( GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height ) {
+static void WINAPI glNamedRenderbufferStorage( GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", renderbuffer, internalformat, width, height );
+  TRACE( "(%d, %d, %d, %d)\n", renderbuffer, internalformat, width, height );
   funcs->ext.p_glNamedRenderbufferStorage( renderbuffer, internalformat, width, height );
 }
 
-static void WINAPI glNamedRenderbufferStorageEXT( GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height ) {
+static void WINAPI glNamedRenderbufferStorageEXT( GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", renderbuffer, internalformat, width, height );
+  TRACE( "(%d, %d, %d, %d)\n", renderbuffer, internalformat, width, height );
   funcs->ext.p_glNamedRenderbufferStorageEXT( renderbuffer, internalformat, width, height );
 }
 
-static void WINAPI glNamedRenderbufferStorageMultisample( GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height ) {
+static void WINAPI glNamedRenderbufferStorageMultisample( GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", renderbuffer, samples, internalformat, width, height );
+  TRACE( "(%d, %d, %d, %d, %d)\n", renderbuffer, samples, internalformat, width, height );
   funcs->ext.p_glNamedRenderbufferStorageMultisample( renderbuffer, samples, internalformat, width, height );
 }
 
-static void WINAPI glNamedRenderbufferStorageMultisampleCoverageEXT( GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height ) {
+static void WINAPI glNamedRenderbufferStorageMultisampleCoverageEXT( GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", renderbuffer, coverageSamples, colorSamples, internalformat, width, height );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", renderbuffer, coverageSamples, colorSamples, internalformat, width, height );
   funcs->ext.p_glNamedRenderbufferStorageMultisampleCoverageEXT( renderbuffer, coverageSamples, colorSamples, internalformat, width, height );
 }
 
-static void WINAPI glNamedRenderbufferStorageMultisampleEXT( GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height ) {
+static void WINAPI glNamedRenderbufferStorageMultisampleEXT( GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", renderbuffer, samples, internalformat, width, height );
+  TRACE( "(%d, %d, %d, %d, %d)\n", renderbuffer, samples, internalformat, width, height );
   funcs->ext.p_glNamedRenderbufferStorageMultisampleEXT( renderbuffer, samples, internalformat, width, height );
 }
 
-static void WINAPI glNamedStringARB( GLenum type, GLint namelen, const GLchar* name, GLint stringlen, const GLchar* string ) {
+static void WINAPI glNamedStringARB( GLenum type, GLint namelen, const GLchar *name, GLint stringlen, const GLchar *string )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %p)\n", type, namelen, name, stringlen, string );
+  TRACE( "(%d, %d, %p, %d, %p)\n", type, namelen, name, stringlen, string );
   funcs->ext.p_glNamedStringARB( type, namelen, name, stringlen, string );
 }
 
-static GLuint WINAPI glNewBufferRegion( GLenum type ) {
+static GLuint WINAPI glNewBufferRegion( GLenum type )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", type );
+  TRACE( "(%d)\n", type );
   return funcs->ext.p_glNewBufferRegion( type );
 }
 
-static GLuint WINAPI glNewObjectBufferATI( GLsizei size, const void* pointer, GLenum usage ) {
+static GLuint WINAPI glNewObjectBufferATI( GLsizei size, const void *pointer, GLenum usage )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %d)\n", size, pointer, usage );
+  TRACE( "(%d, %p, %d)\n", size, pointer, usage );
   return funcs->ext.p_glNewObjectBufferATI( size, pointer, usage );
 }
 
-static void WINAPI glNormal3fVertex3fSUN( GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glNormal3fVertex3fSUN( GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f, %f, %f)\n", nx, ny, nz, x, y, z );
+  TRACE( "(%f, %f, %f, %f, %f, %f)\n", nx, ny, nz, x, y, z );
   funcs->ext.p_glNormal3fVertex3fSUN( nx, ny, nz, x, y, z );
 }
 
-static void WINAPI glNormal3fVertex3fvSUN( const GLfloat* n, const GLfloat* v ) {
+static void WINAPI glNormal3fVertex3fvSUN( const GLfloat *n, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", n, v );
+  TRACE( "(%p, %p)\n", n, v );
   funcs->ext.p_glNormal3fVertex3fvSUN( n, v );
 }
 
-static void WINAPI glNormal3hNV( GLhalfNV nx, GLhalfNV ny, GLhalfNV nz ) {
+static void WINAPI glNormal3hNV( GLhalfNV nx, GLhalfNV ny, GLhalfNV nz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", nx, ny, nz );
+  TRACE( "(%d, %d, %d)\n", nx, ny, nz );
   funcs->ext.p_glNormal3hNV( nx, ny, nz );
 }
 
-static void WINAPI glNormal3hvNV( const GLhalfNV* v ) {
+static void WINAPI glNormal3hvNV( const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glNormal3hvNV( v );
 }
 
-static void WINAPI glNormal3xOES( GLfixed nx, GLfixed ny, GLfixed nz ) {
+static void WINAPI glNormal3xOES( GLfixed nx, GLfixed ny, GLfixed nz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", nx, ny, nz );
+  TRACE( "(%d, %d, %d)\n", nx, ny, nz );
   funcs->ext.p_glNormal3xOES( nx, ny, nz );
 }
 
-static void WINAPI glNormal3xvOES( const GLfixed* coords ) {
+static void WINAPI glNormal3xvOES( const GLfixed *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glNormal3xvOES( coords );
 }
 
-static void WINAPI glNormalFormatNV( GLenum type, GLsizei stride ) {
+static void WINAPI glNormalFormatNV( GLenum type, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", type, stride );
+  TRACE( "(%d, %d)\n", type, stride );
   funcs->ext.p_glNormalFormatNV( type, stride );
 }
 
-static void WINAPI glNormalP3ui( GLenum type, GLuint coords ) {
+static void WINAPI glNormalP3ui( GLenum type, GLuint coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", type, coords );
+  TRACE( "(%d, %d)\n", type, coords );
   funcs->ext.p_glNormalP3ui( type, coords );
 }
 
-static void WINAPI glNormalP3uiv( GLenum type, const GLuint* coords ) {
+static void WINAPI glNormalP3uiv( GLenum type, const GLuint *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", type, coords );
+  TRACE( "(%d, %p)\n", type, coords );
   funcs->ext.p_glNormalP3uiv( type, coords );
 }
 
-static void WINAPI glNormalPointerEXT( GLenum type, GLsizei stride, GLsizei count, const void* pointer ) {
+static void WINAPI glNormalPointerEXT( GLenum type, GLsizei stride, GLsizei count, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", type, stride, count, pointer );
+  TRACE( "(%d, %d, %d, %p)\n", type, stride, count, pointer );
   funcs->ext.p_glNormalPointerEXT( type, stride, count, pointer );
 }
 
-static void WINAPI glNormalPointerListIBM( GLenum type, GLint stride, const void** pointer, GLint ptrstride ) {
+static void WINAPI glNormalPointerListIBM( GLenum type, GLint stride, const void **pointer, GLint ptrstride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d)\n", type, stride, pointer, ptrstride );
+  TRACE( "(%d, %d, %p, %d)\n", type, stride, pointer, ptrstride );
   funcs->ext.p_glNormalPointerListIBM( type, stride, pointer, ptrstride );
 }
 
-static void WINAPI glNormalPointervINTEL( GLenum type, const void** pointer ) {
+static void WINAPI glNormalPointervINTEL( GLenum type, const void **pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", type, pointer );
+  TRACE( "(%d, %p)\n", type, pointer );
   funcs->ext.p_glNormalPointervINTEL( type, pointer );
 }
 
-static void WINAPI glNormalStream3bATI( GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz ) {
+static void WINAPI glNormalStream3bATI( GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", stream, nx, ny, nz );
+  TRACE( "(%d, %d, %d, %d)\n", stream, nx, ny, nz );
   funcs->ext.p_glNormalStream3bATI( stream, nx, ny, nz );
 }
 
-static void WINAPI glNormalStream3bvATI( GLenum stream, const GLbyte* coords ) {
+static void WINAPI glNormalStream3bvATI( GLenum stream, const GLbyte *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glNormalStream3bvATI( stream, coords );
 }
 
-static void WINAPI glNormalStream3dATI( GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz ) {
+static void WINAPI glNormalStream3dATI( GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", stream, nx, ny, nz );
+  TRACE( "(%d, %f, %f, %f)\n", stream, nx, ny, nz );
   funcs->ext.p_glNormalStream3dATI( stream, nx, ny, nz );
 }
 
-static void WINAPI glNormalStream3dvATI( GLenum stream, const GLdouble* coords ) {
+static void WINAPI glNormalStream3dvATI( GLenum stream, const GLdouble *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glNormalStream3dvATI( stream, coords );
 }
 
-static void WINAPI glNormalStream3fATI( GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz ) {
+static void WINAPI glNormalStream3fATI( GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", stream, nx, ny, nz );
+  TRACE( "(%d, %f, %f, %f)\n", stream, nx, ny, nz );
   funcs->ext.p_glNormalStream3fATI( stream, nx, ny, nz );
 }
 
-static void WINAPI glNormalStream3fvATI( GLenum stream, const GLfloat* coords ) {
+static void WINAPI glNormalStream3fvATI( GLenum stream, const GLfloat *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glNormalStream3fvATI( stream, coords );
 }
 
-static void WINAPI glNormalStream3iATI( GLenum stream, GLint nx, GLint ny, GLint nz ) {
+static void WINAPI glNormalStream3iATI( GLenum stream, GLint nx, GLint ny, GLint nz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", stream, nx, ny, nz );
+  TRACE( "(%d, %d, %d, %d)\n", stream, nx, ny, nz );
   funcs->ext.p_glNormalStream3iATI( stream, nx, ny, nz );
 }
 
-static void WINAPI glNormalStream3ivATI( GLenum stream, const GLint* coords ) {
+static void WINAPI glNormalStream3ivATI( GLenum stream, const GLint *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glNormalStream3ivATI( stream, coords );
 }
 
-static void WINAPI glNormalStream3sATI( GLenum stream, GLshort nx, GLshort ny, GLshort nz ) {
+static void WINAPI glNormalStream3sATI( GLenum stream, GLshort nx, GLshort ny, GLshort nz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", stream, nx, ny, nz );
+  TRACE( "(%d, %d, %d, %d)\n", stream, nx, ny, nz );
   funcs->ext.p_glNormalStream3sATI( stream, nx, ny, nz );
 }
 
-static void WINAPI glNormalStream3svATI( GLenum stream, const GLshort* coords ) {
+static void WINAPI glNormalStream3svATI( GLenum stream, const GLshort *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glNormalStream3svATI( stream, coords );
 }
 
-static void WINAPI glObjectLabel( GLenum identifier, GLuint name, GLsizei length, const GLchar* label ) {
+static void WINAPI glObjectLabel( GLenum identifier, GLuint name, GLsizei length, const GLchar *label )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", identifier, name, length, label );
+  TRACE( "(%d, %d, %d, %p)\n", identifier, name, length, label );
   funcs->ext.p_glObjectLabel( identifier, name, length, label );
 }
 
-static void WINAPI glObjectPtrLabel( const void* ptr, GLsizei length, const GLchar* label ) {
+static void WINAPI glObjectPtrLabel( const void *ptr, GLsizei length, const GLchar *label )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %d, %p)\n", ptr, length, label );
+  TRACE( "(%p, %d, %p)\n", ptr, length, label );
   funcs->ext.p_glObjectPtrLabel( ptr, length, label );
 }
 
-static GLenum WINAPI glObjectPurgeableAPPLE( GLenum objectType, GLuint name, GLenum option ) {
+static GLenum WINAPI glObjectPurgeableAPPLE( GLenum objectType, GLuint name, GLenum option )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", objectType, name, option );
+  TRACE( "(%d, %d, %d)\n", objectType, name, option );
   return funcs->ext.p_glObjectPurgeableAPPLE( objectType, name, option );
 }
 
-static GLenum WINAPI glObjectUnpurgeableAPPLE( GLenum objectType, GLuint name, GLenum option ) {
+static GLenum WINAPI glObjectUnpurgeableAPPLE( GLenum objectType, GLuint name, GLenum option )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", objectType, name, option );
+  TRACE( "(%d, %d, %d)\n", objectType, name, option );
   return funcs->ext.p_glObjectUnpurgeableAPPLE( objectType, name, option );
 }
 
-static void WINAPI glOrthofOES( GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f ) {
+static void WINAPI glOrthofOES( GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f, %f, %f)\n", l, r, b, t, n, f );
+  TRACE( "(%f, %f, %f, %f, %f, %f)\n", l, r, b, t, n, f );
   funcs->ext.p_glOrthofOES( l, r, b, t, n, f );
 }
 
-static void WINAPI glOrthoxOES( GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f ) {
+static void WINAPI glOrthoxOES( GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", l, r, b, t, n, f );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", l, r, b, t, n, f );
   funcs->ext.p_glOrthoxOES( l, r, b, t, n, f );
 }
 
-static void WINAPI glPNTrianglesfATI( GLenum pname, GLfloat param ) {
+static void WINAPI glPNTrianglesfATI( GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", pname, param );
+  TRACE( "(%d, %f)\n", pname, param );
   funcs->ext.p_glPNTrianglesfATI( pname, param );
 }
 
-static void WINAPI glPNTrianglesiATI( GLenum pname, GLint param ) {
+static void WINAPI glPNTrianglesiATI( GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->ext.p_glPNTrianglesiATI( pname, param );
 }
 
-static void WINAPI glPassTexCoordATI( GLuint dst, GLuint coord, GLenum swizzle ) {
+static void WINAPI glPassTexCoordATI( GLuint dst, GLuint coord, GLenum swizzle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", dst, coord, swizzle );
+  TRACE( "(%d, %d, %d)\n", dst, coord, swizzle );
   funcs->ext.p_glPassTexCoordATI( dst, coord, swizzle );
 }
 
-static void WINAPI glPassThroughxOES( GLfixed token ) {
+static void WINAPI glPassThroughxOES( GLfixed token )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", token );
+  TRACE( "(%d)\n", token );
   funcs->ext.p_glPassThroughxOES( token );
 }
 
-static void WINAPI glPatchParameterfv( GLenum pname, const GLfloat* values ) {
+static void WINAPI glPatchParameterfv( GLenum pname, const GLfloat *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, values );
+  TRACE( "(%d, %p)\n", pname, values );
   funcs->ext.p_glPatchParameterfv( pname, values );
 }
 
-static void WINAPI glPatchParameteri( GLenum pname, GLint value ) {
+static void WINAPI glPatchParameteri( GLenum pname, GLint value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, value );
+  TRACE( "(%d, %d)\n", pname, value );
   funcs->ext.p_glPatchParameteri( pname, value );
 }
 
-static void WINAPI glPathColorGenNV( GLenum color, GLenum genMode, GLenum colorFormat, const GLfloat* coeffs ) {
+static void WINAPI glPathColorGenNV( GLenum color, GLenum genMode, GLenum colorFormat, const GLfloat *coeffs )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", color, genMode, colorFormat, coeffs );
+  TRACE( "(%d, %d, %d, %p)\n", color, genMode, colorFormat, coeffs );
   funcs->ext.p_glPathColorGenNV( color, genMode, colorFormat, coeffs );
 }
 
-static void WINAPI glPathCommandsNV( GLuint path, GLsizei numCommands, const GLubyte* commands, GLsizei numCoords, GLenum coordType, const void* coords ) {
+static void WINAPI glPathCommandsNV( GLuint path, GLsizei numCommands, const GLubyte *commands, GLsizei numCoords, GLenum coordType, const void *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %d, %p)\n", path, numCommands, commands, numCoords, coordType, coords );
+  TRACE( "(%d, %d, %p, %d, %d, %p)\n", path, numCommands, commands, numCoords, coordType, coords );
   funcs->ext.p_glPathCommandsNV( path, numCommands, commands, numCoords, coordType, coords );
 }
 
-static void WINAPI glPathCoordsNV( GLuint path, GLsizei numCoords, GLenum coordType, const void* coords ) {
+static void WINAPI glPathCoordsNV( GLuint path, GLsizei numCoords, GLenum coordType, const void *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", path, numCoords, coordType, coords );
+  TRACE( "(%d, %d, %d, %p)\n", path, numCoords, coordType, coords );
   funcs->ext.p_glPathCoordsNV( path, numCoords, coordType, coords );
 }
 
-static void WINAPI glPathCoverDepthFuncNV( GLenum func ) {
+static void WINAPI glPathCoverDepthFuncNV( GLenum func )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", func );
+  TRACE( "(%d)\n", func );
   funcs->ext.p_glPathCoverDepthFuncNV( func );
 }
 
-static void WINAPI glPathDashArrayNV( GLuint path, GLsizei dashCount, const GLfloat* dashArray ) {
+static void WINAPI glPathDashArrayNV( GLuint path, GLsizei dashCount, const GLfloat *dashArray )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", path, dashCount, dashArray );
+  TRACE( "(%d, %d, %p)\n", path, dashCount, dashArray );
   funcs->ext.p_glPathDashArrayNV( path, dashCount, dashArray );
 }
 
-static void WINAPI glPathFogGenNV( GLenum genMode ) {
+static void WINAPI glPathFogGenNV( GLenum genMode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", genMode );
+  TRACE( "(%d)\n", genMode );
   funcs->ext.p_glPathFogGenNV( genMode );
 }
 
-static GLenum WINAPI glPathGlyphIndexArrayNV( GLuint firstPathName, GLenum fontTarget, const void* fontName, GLbitfield fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale ) {
+static GLenum WINAPI glPathGlyphIndexArrayNV( GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %d, %d, %d, %f)\n", firstPathName, fontTarget, fontName, fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale );
+  TRACE( "(%d, %d, %p, %d, %d, %d, %d, %f)\n", firstPathName, fontTarget, fontName, fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale );
   return funcs->ext.p_glPathGlyphIndexArrayNV( firstPathName, fontTarget, fontName, fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale );
 }
 
-static GLenum WINAPI glPathGlyphIndexRangeNV( GLenum fontTarget, const void* fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint baseAndCount[2] ) {
+static GLenum WINAPI glPathGlyphIndexRangeNV( GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint baseAndCount[2] )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %d, %d, %f, %p)\n", fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount );
+  TRACE( "(%d, %p, %d, %d, %f, %p)\n", fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount );
   return funcs->ext.p_glPathGlyphIndexRangeNV( fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount );
 }
 
-static void WINAPI glPathGlyphRangeNV( GLuint firstPathName, GLenum fontTarget, const void* fontName, GLbitfield fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale ) {
+static void WINAPI glPathGlyphRangeNV( GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %d, %d, %d, %d, %f)\n", firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale );
+  TRACE( "(%d, %d, %p, %d, %d, %d, %d, %d, %f)\n", firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale );
   funcs->ext.p_glPathGlyphRangeNV( firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale );
 }
 
-static void WINAPI glPathGlyphsNV( GLuint firstPathName, GLenum fontTarget, const void* fontName, GLbitfield fontStyle, GLsizei numGlyphs, GLenum type, const void* charcodes, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale ) {
+static void WINAPI glPathGlyphsNV( GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLsizei numGlyphs, GLenum type, const void *charcodes, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %d, %d, %p, %d, %d, %f)\n", firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale );
+  TRACE( "(%d, %d, %p, %d, %d, %d, %p, %d, %d, %f)\n", firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale );
   funcs->ext.p_glPathGlyphsNV( firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale );
 }
 
-static GLenum WINAPI glPathMemoryGlyphIndexArrayNV( GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, const void* fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale ) {
+static GLenum WINAPI glPathMemoryGlyphIndexArrayNV( GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, const void *fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %ld, %p, %d, %d, %d, %d, %f)\n", firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale );
+  TRACE( "(%d, %d, %ld, %p, %d, %d, %d, %d, %f)\n", firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale );
   return funcs->ext.p_glPathMemoryGlyphIndexArrayNV( firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale );
 }
 
-static void WINAPI glPathParameterfNV( GLuint path, GLenum pname, GLfloat value ) {
+static void WINAPI glPathParameterfNV( GLuint path, GLenum pname, GLfloat value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", path, pname, value );
+  TRACE( "(%d, %d, %f)\n", path, pname, value );
   funcs->ext.p_glPathParameterfNV( path, pname, value );
 }
 
-static void WINAPI glPathParameterfvNV( GLuint path, GLenum pname, const GLfloat* value ) {
+static void WINAPI glPathParameterfvNV( GLuint path, GLenum pname, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", path, pname, value );
+  TRACE( "(%d, %d, %p)\n", path, pname, value );
   funcs->ext.p_glPathParameterfvNV( path, pname, value );
 }
 
-static void WINAPI glPathParameteriNV( GLuint path, GLenum pname, GLint value ) {
+static void WINAPI glPathParameteriNV( GLuint path, GLenum pname, GLint value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", path, pname, value );
+  TRACE( "(%d, %d, %d)\n", path, pname, value );
   funcs->ext.p_glPathParameteriNV( path, pname, value );
 }
 
-static void WINAPI glPathParameterivNV( GLuint path, GLenum pname, const GLint* value ) {
+static void WINAPI glPathParameterivNV( GLuint path, GLenum pname, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", path, pname, value );
+  TRACE( "(%d, %d, %p)\n", path, pname, value );
   funcs->ext.p_glPathParameterivNV( path, pname, value );
 }
 
-static void WINAPI glPathStencilDepthOffsetNV( GLfloat factor, GLfloat units ) {
+static void WINAPI glPathStencilDepthOffsetNV( GLfloat factor, GLfloat units )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", factor, units );
+  TRACE( "(%f, %f)\n", factor, units );
   funcs->ext.p_glPathStencilDepthOffsetNV( factor, units );
 }
 
-static void WINAPI glPathStencilFuncNV( GLenum func, GLint ref, GLuint mask ) {
+static void WINAPI glPathStencilFuncNV( GLenum func, GLint ref, GLuint mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", func, ref, mask );
+  TRACE( "(%d, %d, %d)\n", func, ref, mask );
   funcs->ext.p_glPathStencilFuncNV( func, ref, mask );
 }
 
-static void WINAPI glPathStringNV( GLuint path, GLenum format, GLsizei length, const void* pathString ) {
+static void WINAPI glPathStringNV( GLuint path, GLenum format, GLsizei length, const void *pathString )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", path, format, length, pathString );
+  TRACE( "(%d, %d, %d, %p)\n", path, format, length, pathString );
   funcs->ext.p_glPathStringNV( path, format, length, pathString );
 }
 
-static void WINAPI glPathSubCommandsNV( GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, const GLubyte* commands, GLsizei numCoords, GLenum coordType, const void* coords ) {
+static void WINAPI glPathSubCommandsNV( GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, const GLubyte *commands, GLsizei numCoords, GLenum coordType, const void *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p, %d, %d, %p)\n", path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords );
+  TRACE( "(%d, %d, %d, %d, %p, %d, %d, %p)\n", path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords );
   funcs->ext.p_glPathSubCommandsNV( path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords );
 }
 
-static void WINAPI glPathSubCoordsNV( GLuint path, GLsizei coordStart, GLsizei numCoords, GLenum coordType, const void* coords ) {
+static void WINAPI glPathSubCoordsNV( GLuint path, GLsizei coordStart, GLsizei numCoords, GLenum coordType, const void *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", path, coordStart, numCoords, coordType, coords );
+  TRACE( "(%d, %d, %d, %d, %p)\n", path, coordStart, numCoords, coordType, coords );
   funcs->ext.p_glPathSubCoordsNV( path, coordStart, numCoords, coordType, coords );
 }
 
-static void WINAPI glPathTexGenNV( GLenum texCoordSet, GLenum genMode, GLint components, const GLfloat* coeffs ) {
+static void WINAPI glPathTexGenNV( GLenum texCoordSet, GLenum genMode, GLint components, const GLfloat *coeffs )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texCoordSet, genMode, components, coeffs );
+  TRACE( "(%d, %d, %d, %p)\n", texCoordSet, genMode, components, coeffs );
   funcs->ext.p_glPathTexGenNV( texCoordSet, genMode, components, coeffs );
 }
 
-static void WINAPI glPauseTransformFeedback( void ) {
+static void WINAPI glPauseTransformFeedback(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glPauseTransformFeedback( );
+  TRACE( "()\n" );
+  funcs->ext.p_glPauseTransformFeedback();
 }
 
-static void WINAPI glPauseTransformFeedbackNV( void ) {
+static void WINAPI glPauseTransformFeedbackNV(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glPauseTransformFeedbackNV( );
+  TRACE( "()\n" );
+  funcs->ext.p_glPauseTransformFeedbackNV();
 }
 
-static void WINAPI glPixelDataRangeNV( GLenum target, GLsizei length, const void* pointer ) {
+static void WINAPI glPixelDataRangeNV( GLenum target, GLsizei length, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, length, pointer );
+  TRACE( "(%d, %d, %p)\n", target, length, pointer );
   funcs->ext.p_glPixelDataRangeNV( target, length, pointer );
 }
 
-static void WINAPI glPixelMapx( GLenum map, GLint size, const GLfixed* values ) {
+static void WINAPI glPixelMapx( GLenum map, GLint size, const GLfixed *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", map, size, values );
+  TRACE( "(%d, %d, %p)\n", map, size, values );
   funcs->ext.p_glPixelMapx( map, size, values );
 }
 
-static void WINAPI glPixelStorex( GLenum pname, GLfixed param ) {
+static void WINAPI glPixelStorex( GLenum pname, GLfixed param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->ext.p_glPixelStorex( pname, param );
 }
 
-static void WINAPI glPixelTexGenParameterfSGIS( GLenum pname, GLfloat param ) {
+static void WINAPI glPixelTexGenParameterfSGIS( GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", pname, param );
+  TRACE( "(%d, %f)\n", pname, param );
   funcs->ext.p_glPixelTexGenParameterfSGIS( pname, param );
 }
 
-static void WINAPI glPixelTexGenParameterfvSGIS( GLenum pname, const GLfloat* params ) {
+static void WINAPI glPixelTexGenParameterfvSGIS( GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glPixelTexGenParameterfvSGIS( pname, params );
 }
 
-static void WINAPI glPixelTexGenParameteriSGIS( GLenum pname, GLint param ) {
+static void WINAPI glPixelTexGenParameteriSGIS( GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->ext.p_glPixelTexGenParameteriSGIS( pname, param );
 }
 
-static void WINAPI glPixelTexGenParameterivSGIS( GLenum pname, const GLint* params ) {
+static void WINAPI glPixelTexGenParameterivSGIS( GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glPixelTexGenParameterivSGIS( pname, params );
 }
 
-static void WINAPI glPixelTexGenSGIX( GLenum mode ) {
+static void WINAPI glPixelTexGenSGIX( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   funcs->ext.p_glPixelTexGenSGIX( mode );
 }
 
-static void WINAPI glPixelTransferxOES( GLenum pname, GLfixed param ) {
+static void WINAPI glPixelTransferxOES( GLenum pname, GLfixed param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->ext.p_glPixelTransferxOES( pname, param );
 }
 
-static void WINAPI glPixelTransformParameterfEXT( GLenum target, GLenum pname, GLfloat param ) {
+static void WINAPI glPixelTransformParameterfEXT( GLenum target, GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", target, pname, param );
+  TRACE( "(%d, %d, %f)\n", target, pname, param );
   funcs->ext.p_glPixelTransformParameterfEXT( target, pname, param );
 }
 
-static void WINAPI glPixelTransformParameterfvEXT( GLenum target, GLenum pname, const GLfloat* params ) {
+static void WINAPI glPixelTransformParameterfvEXT( GLenum target, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glPixelTransformParameterfvEXT( target, pname, params );
 }
 
-static void WINAPI glPixelTransformParameteriEXT( GLenum target, GLenum pname, GLint param ) {
+static void WINAPI glPixelTransformParameteriEXT( GLenum target, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, pname, param );
+  TRACE( "(%d, %d, %d)\n", target, pname, param );
   funcs->ext.p_glPixelTransformParameteriEXT( target, pname, param );
 }
 
-static void WINAPI glPixelTransformParameterivEXT( GLenum target, GLenum pname, const GLint* params ) {
+static void WINAPI glPixelTransformParameterivEXT( GLenum target, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glPixelTransformParameterivEXT( target, pname, params );
 }
 
-static void WINAPI glPixelZoomxOES( GLfixed xfactor, GLfixed yfactor ) {
+static void WINAPI glPixelZoomxOES( GLfixed xfactor, GLfixed yfactor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", xfactor, yfactor );
+  TRACE( "(%d, %d)\n", xfactor, yfactor );
   funcs->ext.p_glPixelZoomxOES( xfactor, yfactor );
 }
 
-static GLboolean WINAPI glPointAlongPathNV( GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat* x, GLfloat* y, GLfloat* tangentX, GLfloat* tangentY ) {
+static GLboolean WINAPI glPointAlongPathNV( GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat *x, GLfloat *y, GLfloat *tangentX, GLfloat *tangentY )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %f, %p, %p, %p, %p)\n", path, startSegment, numSegments, distance, x, y, tangentX, tangentY );
+  TRACE( "(%d, %d, %d, %f, %p, %p, %p, %p)\n", path, startSegment, numSegments, distance, x, y, tangentX, tangentY );
   return funcs->ext.p_glPointAlongPathNV( path, startSegment, numSegments, distance, x, y, tangentX, tangentY );
 }
 
-static void WINAPI glPointParameterf( GLenum pname, GLfloat param ) {
+static void WINAPI glPointParameterf( GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", pname, param );
+  TRACE( "(%d, %f)\n", pname, param );
   funcs->ext.p_glPointParameterf( pname, param );
 }
 
-static void WINAPI glPointParameterfARB( GLenum pname, GLfloat param ) {
+static void WINAPI glPointParameterfARB( GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", pname, param );
+  TRACE( "(%d, %f)\n", pname, param );
   funcs->ext.p_glPointParameterfARB( pname, param );
 }
 
-static void WINAPI glPointParameterfEXT( GLenum pname, GLfloat param ) {
+static void WINAPI glPointParameterfEXT( GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", pname, param );
+  TRACE( "(%d, %f)\n", pname, param );
   funcs->ext.p_glPointParameterfEXT( pname, param );
 }
 
-static void WINAPI glPointParameterfSGIS( GLenum pname, GLfloat param ) {
+static void WINAPI glPointParameterfSGIS( GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", pname, param );
+  TRACE( "(%d, %f)\n", pname, param );
   funcs->ext.p_glPointParameterfSGIS( pname, param );
 }
 
-static void WINAPI glPointParameterfv( GLenum pname, const GLfloat* params ) {
+static void WINAPI glPointParameterfv( GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glPointParameterfv( pname, params );
 }
 
-static void WINAPI glPointParameterfvARB( GLenum pname, const GLfloat* params ) {
+static void WINAPI glPointParameterfvARB( GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glPointParameterfvARB( pname, params );
 }
 
-static void WINAPI glPointParameterfvEXT( GLenum pname, const GLfloat* params ) {
+static void WINAPI glPointParameterfvEXT( GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glPointParameterfvEXT( pname, params );
 }
 
-static void WINAPI glPointParameterfvSGIS( GLenum pname, const GLfloat* params ) {
+static void WINAPI glPointParameterfvSGIS( GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glPointParameterfvSGIS( pname, params );
 }
 
-static void WINAPI glPointParameteri( GLenum pname, GLint param ) {
+static void WINAPI glPointParameteri( GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->ext.p_glPointParameteri( pname, param );
 }
 
-static void WINAPI glPointParameteriNV( GLenum pname, GLint param ) {
+static void WINAPI glPointParameteriNV( GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->ext.p_glPointParameteriNV( pname, param );
 }
 
-static void WINAPI glPointParameteriv( GLenum pname, const GLint* params ) {
+static void WINAPI glPointParameteriv( GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glPointParameteriv( pname, params );
 }
 
-static void WINAPI glPointParameterivNV( GLenum pname, const GLint* params ) {
+static void WINAPI glPointParameterivNV( GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glPointParameterivNV( pname, params );
 }
 
-static void WINAPI glPointParameterxvOES( GLenum pname, const GLfixed* params ) {
+static void WINAPI glPointParameterxvOES( GLenum pname, const GLfixed *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glPointParameterxvOES( pname, params );
 }
 
-static void WINAPI glPointSizexOES( GLfixed size ) {
+static void WINAPI glPointSizexOES( GLfixed size )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", size );
+  TRACE( "(%d)\n", size );
   funcs->ext.p_glPointSizexOES( size );
 }
 
-static GLint WINAPI glPollAsyncSGIX( GLuint* markerp ) {
+static GLint WINAPI glPollAsyncSGIX( GLuint *markerp )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", markerp );
+  TRACE( "(%p)\n", markerp );
   return funcs->ext.p_glPollAsyncSGIX( markerp );
 }
 
-static GLint WINAPI glPollInstrumentsSGIX( GLint* marker_p ) {
+static GLint WINAPI glPollInstrumentsSGIX( GLint *marker_p )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", marker_p );
+  TRACE( "(%p)\n", marker_p );
   return funcs->ext.p_glPollInstrumentsSGIX( marker_p );
 }
 
-static void WINAPI glPolygonOffsetClamp( GLfloat factor, GLfloat units, GLfloat clamp ) {
+static void WINAPI glPolygonOffsetClamp( GLfloat factor, GLfloat units, GLfloat clamp )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", factor, units, clamp );
+  TRACE( "(%f, %f, %f)\n", factor, units, clamp );
   funcs->ext.p_glPolygonOffsetClamp( factor, units, clamp );
 }
 
-static void WINAPI glPolygonOffsetClampEXT( GLfloat factor, GLfloat units, GLfloat clamp ) {
+static void WINAPI glPolygonOffsetClampEXT( GLfloat factor, GLfloat units, GLfloat clamp )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", factor, units, clamp );
+  TRACE( "(%f, %f, %f)\n", factor, units, clamp );
   funcs->ext.p_glPolygonOffsetClampEXT( factor, units, clamp );
 }
 
-static void WINAPI glPolygonOffsetEXT( GLfloat factor, GLfloat bias ) {
+static void WINAPI glPolygonOffsetEXT( GLfloat factor, GLfloat bias )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", factor, bias );
+  TRACE( "(%f, %f)\n", factor, bias );
   funcs->ext.p_glPolygonOffsetEXT( factor, bias );
 }
 
-static void WINAPI glPolygonOffsetxOES( GLfixed factor, GLfixed units ) {
+static void WINAPI glPolygonOffsetxOES( GLfixed factor, GLfixed units )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", factor, units );
+  TRACE( "(%d, %d)\n", factor, units );
   funcs->ext.p_glPolygonOffsetxOES( factor, units );
 }
 
-static void WINAPI glPopDebugGroup( void ) {
+static void WINAPI glPopDebugGroup(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glPopDebugGroup( );
+  TRACE( "()\n" );
+  funcs->ext.p_glPopDebugGroup();
 }
 
-static void WINAPI glPopGroupMarkerEXT( void ) {
+static void WINAPI glPopGroupMarkerEXT(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glPopGroupMarkerEXT( );
+  TRACE( "()\n" );
+  funcs->ext.p_glPopGroupMarkerEXT();
 }
 
-static void WINAPI glPresentFrameDualFillNV( GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLenum target1, GLuint fill1, GLenum target2, GLuint fill2, GLenum target3, GLuint fill3 ) {
+static void WINAPI glPresentFrameDualFillNV( GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLenum target1, GLuint fill1, GLenum target2, GLuint fill2, GLenum target3, GLuint fill3 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", video_slot, wine_dbgstr_longlong(minPresentTime), beginPresentTimeId, presentDurationId, type, target0, fill0, target1, fill1, target2, fill2, target3, fill3 );
+  TRACE( "(%d, %s, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", video_slot, wine_dbgstr_longlong(minPresentTime), beginPresentTimeId, presentDurationId, type, target0, fill0, target1, fill1, target2, fill2, target3, fill3 );
   funcs->ext.p_glPresentFrameDualFillNV( video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, target1, fill1, target2, fill2, target3, fill3 );
 }
 
-static void WINAPI glPresentFrameKeyedNV( GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1 ) {
+static void WINAPI glPresentFrameKeyedNV( GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", video_slot, wine_dbgstr_longlong(minPresentTime), beginPresentTimeId, presentDurationId, type, target0, fill0, key0, target1, fill1, key1 );
+  TRACE( "(%d, %s, %d, %d, %d, %d, %d, %d, %d, %d, %d)\n", video_slot, wine_dbgstr_longlong(minPresentTime), beginPresentTimeId, presentDurationId, type, target0, fill0, key0, target1, fill1, key1 );
   funcs->ext.p_glPresentFrameKeyedNV( video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, key0, target1, fill1, key1 );
 }
 
-static void WINAPI glPrimitiveBoundingBoxARB( GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW ) {
+static void WINAPI glPrimitiveBoundingBoxARB( GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f, %f, %f, %f, %f)\n", minX, minY, minZ, minW, maxX, maxY, maxZ, maxW );
+  TRACE( "(%f, %f, %f, %f, %f, %f, %f, %f)\n", minX, minY, minZ, minW, maxX, maxY, maxZ, maxW );
   funcs->ext.p_glPrimitiveBoundingBoxARB( minX, minY, minZ, minW, maxX, maxY, maxZ, maxW );
 }
 
-static void WINAPI glPrimitiveRestartIndex( GLuint index ) {
+static void WINAPI glPrimitiveRestartIndex( GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", index );
+  TRACE( "(%d)\n", index );
   funcs->ext.p_glPrimitiveRestartIndex( index );
 }
 
-static void WINAPI glPrimitiveRestartIndexNV( GLuint index ) {
+static void WINAPI glPrimitiveRestartIndexNV( GLuint index )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", index );
+  TRACE( "(%d)\n", index );
   funcs->ext.p_glPrimitiveRestartIndexNV( index );
 }
 
-static void WINAPI glPrimitiveRestartNV( void ) {
+static void WINAPI glPrimitiveRestartNV(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glPrimitiveRestartNV( );
+  TRACE( "()\n" );
+  funcs->ext.p_glPrimitiveRestartNV();
 }
 
-static void WINAPI glPrioritizeTexturesEXT( GLsizei n, const GLuint* textures, const GLclampf* priorities ) {
+static void WINAPI glPrioritizeTexturesEXT( GLsizei n, const GLuint *textures, const GLclampf *priorities )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %p)\n", n, textures, priorities );
+  TRACE( "(%d, %p, %p)\n", n, textures, priorities );
   funcs->ext.p_glPrioritizeTexturesEXT( n, textures, priorities );
 }
 
-static void WINAPI glPrioritizeTexturesxOES( GLsizei n, const GLuint* textures, const GLfixed* priorities ) {
+static void WINAPI glPrioritizeTexturesxOES( GLsizei n, const GLuint *textures, const GLfixed *priorities )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %p)\n", n, textures, priorities );
+  TRACE( "(%d, %p, %p)\n", n, textures, priorities );
   funcs->ext.p_glPrioritizeTexturesxOES( n, textures, priorities );
 }
 
-static void WINAPI glProgramBinary( GLuint program, GLenum binaryFormat, const void* binary, GLsizei length ) {
+static void WINAPI glProgramBinary( GLuint program, GLenum binaryFormat, const void *binary, GLsizei length )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d)\n", program, binaryFormat, binary, length );
+  TRACE( "(%d, %d, %p, %d)\n", program, binaryFormat, binary, length );
   funcs->ext.p_glProgramBinary( program, binaryFormat, binary, length );
 }
 
-static void WINAPI glProgramBufferParametersIivNV( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLint* params ) {
+static void WINAPI glProgramBufferParametersIivNV( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", target, bindingIndex, wordIndex, count, params );
+  TRACE( "(%d, %d, %d, %d, %p)\n", target, bindingIndex, wordIndex, count, params );
   funcs->ext.p_glProgramBufferParametersIivNV( target, bindingIndex, wordIndex, count, params );
 }
 
-static void WINAPI glProgramBufferParametersIuivNV( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLuint* params ) {
+static void WINAPI glProgramBufferParametersIuivNV( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", target, bindingIndex, wordIndex, count, params );
+  TRACE( "(%d, %d, %d, %d, %p)\n", target, bindingIndex, wordIndex, count, params );
   funcs->ext.p_glProgramBufferParametersIuivNV( target, bindingIndex, wordIndex, count, params );
 }
 
-static void WINAPI glProgramBufferParametersfvNV( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLfloat* params ) {
+static void WINAPI glProgramBufferParametersfvNV( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", target, bindingIndex, wordIndex, count, params );
+  TRACE( "(%d, %d, %d, %d, %p)\n", target, bindingIndex, wordIndex, count, params );
   funcs->ext.p_glProgramBufferParametersfvNV( target, bindingIndex, wordIndex, count, params );
 }
 
-static void WINAPI glProgramEnvParameter4dARB( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+static void WINAPI glProgramEnvParameter4dARB( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w );
+  TRACE( "(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w );
   funcs->ext.p_glProgramEnvParameter4dARB( target, index, x, y, z, w );
 }
 
-static void WINAPI glProgramEnvParameter4dvARB( GLenum target, GLuint index, const GLdouble* params ) {
+static void WINAPI glProgramEnvParameter4dvARB( GLenum target, GLuint index, const GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, params );
+  TRACE( "(%d, %d, %p)\n", target, index, params );
   funcs->ext.p_glProgramEnvParameter4dvARB( target, index, params );
 }
 
-static void WINAPI glProgramEnvParameter4fARB( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+static void WINAPI glProgramEnvParameter4fARB( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w );
+  TRACE( "(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w );
   funcs->ext.p_glProgramEnvParameter4fARB( target, index, x, y, z, w );
 }
 
-static void WINAPI glProgramEnvParameter4fvARB( GLenum target, GLuint index, const GLfloat* params ) {
+static void WINAPI glProgramEnvParameter4fvARB( GLenum target, GLuint index, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, params );
+  TRACE( "(%d, %d, %p)\n", target, index, params );
   funcs->ext.p_glProgramEnvParameter4fvARB( target, index, params );
 }
 
-static void WINAPI glProgramEnvParameterI4iNV( GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w ) {
+static void WINAPI glProgramEnvParameterI4iNV( GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", target, index, x, y, z, w );
   funcs->ext.p_glProgramEnvParameterI4iNV( target, index, x, y, z, w );
 }
 
-static void WINAPI glProgramEnvParameterI4ivNV( GLenum target, GLuint index, const GLint* params ) {
+static void WINAPI glProgramEnvParameterI4ivNV( GLenum target, GLuint index, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, params );
+  TRACE( "(%d, %d, %p)\n", target, index, params );
   funcs->ext.p_glProgramEnvParameterI4ivNV( target, index, params );
 }
 
-static void WINAPI glProgramEnvParameterI4uiNV( GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) {
+static void WINAPI glProgramEnvParameterI4uiNV( GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", target, index, x, y, z, w );
   funcs->ext.p_glProgramEnvParameterI4uiNV( target, index, x, y, z, w );
 }
 
-static void WINAPI glProgramEnvParameterI4uivNV( GLenum target, GLuint index, const GLuint* params ) {
+static void WINAPI glProgramEnvParameterI4uivNV( GLenum target, GLuint index, const GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, params );
+  TRACE( "(%d, %d, %p)\n", target, index, params );
   funcs->ext.p_glProgramEnvParameterI4uivNV( target, index, params );
 }
 
-static void WINAPI glProgramEnvParameters4fvEXT( GLenum target, GLuint index, GLsizei count, const GLfloat* params ) {
+static void WINAPI glProgramEnvParameters4fvEXT( GLenum target, GLuint index, GLsizei count, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, index, count, params );
+  TRACE( "(%d, %d, %d, %p)\n", target, index, count, params );
   funcs->ext.p_glProgramEnvParameters4fvEXT( target, index, count, params );
 }
 
-static void WINAPI glProgramEnvParametersI4ivNV( GLenum target, GLuint index, GLsizei count, const GLint* params ) {
+static void WINAPI glProgramEnvParametersI4ivNV( GLenum target, GLuint index, GLsizei count, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, index, count, params );
+  TRACE( "(%d, %d, %d, %p)\n", target, index, count, params );
   funcs->ext.p_glProgramEnvParametersI4ivNV( target, index, count, params );
 }
 
-static void WINAPI glProgramEnvParametersI4uivNV( GLenum target, GLuint index, GLsizei count, const GLuint* params ) {
+static void WINAPI glProgramEnvParametersI4uivNV( GLenum target, GLuint index, GLsizei count, const GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, index, count, params );
+  TRACE( "(%d, %d, %d, %p)\n", target, index, count, params );
   funcs->ext.p_glProgramEnvParametersI4uivNV( target, index, count, params );
 }
 
-static void WINAPI glProgramLocalParameter4dARB( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+static void WINAPI glProgramLocalParameter4dARB( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w );
+  TRACE( "(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w );
   funcs->ext.p_glProgramLocalParameter4dARB( target, index, x, y, z, w );
 }
 
-static void WINAPI glProgramLocalParameter4dvARB( GLenum target, GLuint index, const GLdouble* params ) {
+static void WINAPI glProgramLocalParameter4dvARB( GLenum target, GLuint index, const GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, params );
+  TRACE( "(%d, %d, %p)\n", target, index, params );
   funcs->ext.p_glProgramLocalParameter4dvARB( target, index, params );
 }
 
-static void WINAPI glProgramLocalParameter4fARB( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+static void WINAPI glProgramLocalParameter4fARB( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w );
+  TRACE( "(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w );
   funcs->ext.p_glProgramLocalParameter4fARB( target, index, x, y, z, w );
 }
 
-static void WINAPI glProgramLocalParameter4fvARB( GLenum target, GLuint index, const GLfloat* params ) {
+static void WINAPI glProgramLocalParameter4fvARB( GLenum target, GLuint index, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, params );
+  TRACE( "(%d, %d, %p)\n", target, index, params );
   funcs->ext.p_glProgramLocalParameter4fvARB( target, index, params );
 }
 
-static void WINAPI glProgramLocalParameterI4iNV( GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w ) {
+static void WINAPI glProgramLocalParameterI4iNV( GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", target, index, x, y, z, w );
   funcs->ext.p_glProgramLocalParameterI4iNV( target, index, x, y, z, w );
 }
 
-static void WINAPI glProgramLocalParameterI4ivNV( GLenum target, GLuint index, const GLint* params ) {
+static void WINAPI glProgramLocalParameterI4ivNV( GLenum target, GLuint index, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, params );
+  TRACE( "(%d, %d, %p)\n", target, index, params );
   funcs->ext.p_glProgramLocalParameterI4ivNV( target, index, params );
 }
 
-static void WINAPI glProgramLocalParameterI4uiNV( GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) {
+static void WINAPI glProgramLocalParameterI4uiNV( GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", target, index, x, y, z, w );
   funcs->ext.p_glProgramLocalParameterI4uiNV( target, index, x, y, z, w );
 }
 
-static void WINAPI glProgramLocalParameterI4uivNV( GLenum target, GLuint index, const GLuint* params ) {
+static void WINAPI glProgramLocalParameterI4uivNV( GLenum target, GLuint index, const GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, params );
+  TRACE( "(%d, %d, %p)\n", target, index, params );
   funcs->ext.p_glProgramLocalParameterI4uivNV( target, index, params );
 }
 
-static void WINAPI glProgramLocalParameters4fvEXT( GLenum target, GLuint index, GLsizei count, const GLfloat* params ) {
+static void WINAPI glProgramLocalParameters4fvEXT( GLenum target, GLuint index, GLsizei count, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, index, count, params );
+  TRACE( "(%d, %d, %d, %p)\n", target, index, count, params );
   funcs->ext.p_glProgramLocalParameters4fvEXT( target, index, count, params );
 }
 
-static void WINAPI glProgramLocalParametersI4ivNV( GLenum target, GLuint index, GLsizei count, const GLint* params ) {
+static void WINAPI glProgramLocalParametersI4ivNV( GLenum target, GLuint index, GLsizei count, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, index, count, params );
+  TRACE( "(%d, %d, %d, %p)\n", target, index, count, params );
   funcs->ext.p_glProgramLocalParametersI4ivNV( target, index, count, params );
 }
 
-static void WINAPI glProgramLocalParametersI4uivNV( GLenum target, GLuint index, GLsizei count, const GLuint* params ) {
+static void WINAPI glProgramLocalParametersI4uivNV( GLenum target, GLuint index, GLsizei count, const GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, index, count, params );
+  TRACE( "(%d, %d, %d, %p)\n", target, index, count, params );
   funcs->ext.p_glProgramLocalParametersI4uivNV( target, index, count, params );
 }
 
-static void WINAPI glProgramNamedParameter4dNV( GLuint id, GLsizei len, const GLubyte* name, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+static void WINAPI glProgramNamedParameter4dNV( GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %f, %f, %f, %f)\n", id, len, name, x, y, z, w );
+  TRACE( "(%d, %d, %p, %f, %f, %f, %f)\n", id, len, name, x, y, z, w );
   funcs->ext.p_glProgramNamedParameter4dNV( id, len, name, x, y, z, w );
 }
 
-static void WINAPI glProgramNamedParameter4dvNV( GLuint id, GLsizei len, const GLubyte* name, const GLdouble* v ) {
+static void WINAPI glProgramNamedParameter4dvNV( GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", id, len, name, v );
+  TRACE( "(%d, %d, %p, %p)\n", id, len, name, v );
   funcs->ext.p_glProgramNamedParameter4dvNV( id, len, name, v );
 }
 
-static void WINAPI glProgramNamedParameter4fNV( GLuint id, GLsizei len, const GLubyte* name, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+static void WINAPI glProgramNamedParameter4fNV( GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %f, %f, %f, %f)\n", id, len, name, x, y, z, w );
+  TRACE( "(%d, %d, %p, %f, %f, %f, %f)\n", id, len, name, x, y, z, w );
   funcs->ext.p_glProgramNamedParameter4fNV( id, len, name, x, y, z, w );
 }
 
-static void WINAPI glProgramNamedParameter4fvNV( GLuint id, GLsizei len, const GLubyte* name, const GLfloat* v ) {
+static void WINAPI glProgramNamedParameter4fvNV( GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", id, len, name, v );
+  TRACE( "(%d, %d, %p, %p)\n", id, len, name, v );
   funcs->ext.p_glProgramNamedParameter4fvNV( id, len, name, v );
 }
 
-static void WINAPI glProgramParameter4dNV( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+static void WINAPI glProgramParameter4dNV( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w );
+  TRACE( "(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w );
   funcs->ext.p_glProgramParameter4dNV( target, index, x, y, z, w );
 }
 
-static void WINAPI glProgramParameter4dvNV( GLenum target, GLuint index, const GLdouble* v ) {
+static void WINAPI glProgramParameter4dvNV( GLenum target, GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, v );
+  TRACE( "(%d, %d, %p)\n", target, index, v );
   funcs->ext.p_glProgramParameter4dvNV( target, index, v );
 }
 
-static void WINAPI glProgramParameter4fNV( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+static void WINAPI glProgramParameter4fNV( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w );
+  TRACE( "(%d, %d, %f, %f, %f, %f)\n", target, index, x, y, z, w );
   funcs->ext.p_glProgramParameter4fNV( target, index, x, y, z, w );
 }
 
-static void WINAPI glProgramParameter4fvNV( GLenum target, GLuint index, const GLfloat* v ) {
+static void WINAPI glProgramParameter4fvNV( GLenum target, GLuint index, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, index, v );
+  TRACE( "(%d, %d, %p)\n", target, index, v );
   funcs->ext.p_glProgramParameter4fvNV( target, index, v );
 }
 
-static void WINAPI glProgramParameteri( GLuint program, GLenum pname, GLint value ) {
+static void WINAPI glProgramParameteri( GLuint program, GLenum pname, GLint value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", program, pname, value );
+  TRACE( "(%d, %d, %d)\n", program, pname, value );
   funcs->ext.p_glProgramParameteri( program, pname, value );
 }
 
-static void WINAPI glProgramParameteriARB( GLuint program, GLenum pname, GLint value ) {
+static void WINAPI glProgramParameteriARB( GLuint program, GLenum pname, GLint value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", program, pname, value );
+  TRACE( "(%d, %d, %d)\n", program, pname, value );
   funcs->ext.p_glProgramParameteriARB( program, pname, value );
 }
 
-static void WINAPI glProgramParameteriEXT( GLuint program, GLenum pname, GLint value ) {
+static void WINAPI glProgramParameteriEXT( GLuint program, GLenum pname, GLint value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", program, pname, value );
+  TRACE( "(%d, %d, %d)\n", program, pname, value );
   funcs->ext.p_glProgramParameteriEXT( program, pname, value );
 }
 
-static void WINAPI glProgramParameters4dvNV( GLenum target, GLuint index, GLsizei count, const GLdouble* v ) {
+static void WINAPI glProgramParameters4dvNV( GLenum target, GLuint index, GLsizei count, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, index, count, v );
+  TRACE( "(%d, %d, %d, %p)\n", target, index, count, v );
   funcs->ext.p_glProgramParameters4dvNV( target, index, count, v );
 }
 
-static void WINAPI glProgramParameters4fvNV( GLenum target, GLuint index, GLsizei count, const GLfloat* v ) {
+static void WINAPI glProgramParameters4fvNV( GLenum target, GLuint index, GLsizei count, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, index, count, v );
+  TRACE( "(%d, %d, %d, %p)\n", target, index, count, v );
   funcs->ext.p_glProgramParameters4fvNV( target, index, count, v );
 }
 
-static void WINAPI glProgramPathFragmentInputGenNV( GLuint program, GLint location, GLenum genMode, GLint components, const GLfloat* coeffs ) {
+static void WINAPI glProgramPathFragmentInputGenNV( GLuint program, GLint location, GLenum genMode, GLint components, const GLfloat *coeffs )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, genMode, components, coeffs );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, genMode, components, coeffs );
   funcs->ext.p_glProgramPathFragmentInputGenNV( program, location, genMode, components, coeffs );
 }
 
-static void WINAPI glProgramStringARB( GLenum target, GLenum format, GLsizei len, const void* string ) {
+static void WINAPI glProgramStringARB( GLenum target, GLenum format, GLsizei len, const void *string )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, format, len, string );
+  TRACE( "(%d, %d, %d, %p)\n", target, format, len, string );
   funcs->ext.p_glProgramStringARB( target, format, len, string );
 }
 
-static void WINAPI glProgramSubroutineParametersuivNV( GLenum target, GLsizei count, const GLuint* params ) {
+static void WINAPI glProgramSubroutineParametersuivNV( GLenum target, GLsizei count, const GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, count, params );
+  TRACE( "(%d, %d, %p)\n", target, count, params );
   funcs->ext.p_glProgramSubroutineParametersuivNV( target, count, params );
 }
 
-static void WINAPI glProgramUniform1d( GLuint program, GLint location, GLdouble v0 ) {
+static void WINAPI glProgramUniform1d( GLuint program, GLint location, GLdouble v0 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", program, location, v0 );
+  TRACE( "(%d, %d, %f)\n", program, location, v0 );
   funcs->ext.p_glProgramUniform1d( program, location, v0 );
 }
 
-static void WINAPI glProgramUniform1dEXT( GLuint program, GLint location, GLdouble x ) {
+static void WINAPI glProgramUniform1dEXT( GLuint program, GLint location, GLdouble x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", program, location, x );
+  TRACE( "(%d, %d, %f)\n", program, location, x );
   funcs->ext.p_glProgramUniform1dEXT( program, location, x );
 }
 
-static void WINAPI glProgramUniform1dv( GLuint program, GLint location, GLsizei count, const GLdouble* value ) {
+static void WINAPI glProgramUniform1dv( GLuint program, GLint location, GLsizei count, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform1dv( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform1dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble* value ) {
+static void WINAPI glProgramUniform1dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform1dvEXT( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform1f( GLuint program, GLint location, GLfloat v0 ) {
+static void WINAPI glProgramUniform1f( GLuint program, GLint location, GLfloat v0 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", program, location, v0 );
+  TRACE( "(%d, %d, %f)\n", program, location, v0 );
   funcs->ext.p_glProgramUniform1f( program, location, v0 );
 }
 
-static void WINAPI glProgramUniform1fEXT( GLuint program, GLint location, GLfloat v0 ) {
+static void WINAPI glProgramUniform1fEXT( GLuint program, GLint location, GLfloat v0 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", program, location, v0 );
+  TRACE( "(%d, %d, %f)\n", program, location, v0 );
   funcs->ext.p_glProgramUniform1fEXT( program, location, v0 );
 }
 
-static void WINAPI glProgramUniform1fv( GLuint program, GLint location, GLsizei count, const GLfloat* value ) {
+static void WINAPI glProgramUniform1fv( GLuint program, GLint location, GLsizei count, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform1fv( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform1fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat* value ) {
+static void WINAPI glProgramUniform1fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform1fvEXT( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform1i( GLuint program, GLint location, GLint v0 ) {
+static void WINAPI glProgramUniform1i( GLuint program, GLint location, GLint v0 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", program, location, v0 );
+  TRACE( "(%d, %d, %d)\n", program, location, v0 );
   funcs->ext.p_glProgramUniform1i( program, location, v0 );
 }
 
-static void WINAPI glProgramUniform1i64ARB( GLuint program, GLint location, GLint64 x ) {
+static void WINAPI glProgramUniform1i64ARB( GLuint program, GLint location, GLint64 x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(x) );
+  TRACE( "(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(x) );
   funcs->ext.p_glProgramUniform1i64ARB( program, location, x );
 }
 
-static void WINAPI glProgramUniform1i64NV( GLuint program, GLint location, GLint64EXT x ) {
+static void WINAPI glProgramUniform1i64NV( GLuint program, GLint location, GLint64EXT x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(x) );
+  TRACE( "(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(x) );
   funcs->ext.p_glProgramUniform1i64NV( program, location, x );
 }
 
-static void WINAPI glProgramUniform1i64vARB( GLuint program, GLint location, GLsizei count, const GLint64* value ) {
+static void WINAPI glProgramUniform1i64vARB( GLuint program, GLint location, GLsizei count, const GLint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform1i64vARB( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform1i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT* value ) {
+static void WINAPI glProgramUniform1i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform1i64vNV( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform1iEXT( GLuint program, GLint location, GLint v0 ) {
+static void WINAPI glProgramUniform1iEXT( GLuint program, GLint location, GLint v0 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", program, location, v0 );
+  TRACE( "(%d, %d, %d)\n", program, location, v0 );
   funcs->ext.p_glProgramUniform1iEXT( program, location, v0 );
 }
 
-static void WINAPI glProgramUniform1iv( GLuint program, GLint location, GLsizei count, const GLint* value ) {
+static void WINAPI glProgramUniform1iv( GLuint program, GLint location, GLsizei count, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform1iv( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform1ivEXT( GLuint program, GLint location, GLsizei count, const GLint* value ) {
+static void WINAPI glProgramUniform1ivEXT( GLuint program, GLint location, GLsizei count, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform1ivEXT( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform1ui( GLuint program, GLint location, GLuint v0 ) {
+static void WINAPI glProgramUniform1ui( GLuint program, GLint location, GLuint v0 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", program, location, v0 );
+  TRACE( "(%d, %d, %d)\n", program, location, v0 );
   funcs->ext.p_glProgramUniform1ui( program, location, v0 );
 }
 
-static void WINAPI glProgramUniform1ui64ARB( GLuint program, GLint location, GLuint64 x ) {
+static void WINAPI glProgramUniform1ui64ARB( GLuint program, GLint location, GLuint64 x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(x) );
+  TRACE( "(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(x) );
   funcs->ext.p_glProgramUniform1ui64ARB( program, location, x );
 }
 
-static void WINAPI glProgramUniform1ui64NV( GLuint program, GLint location, GLuint64EXT x ) {
+static void WINAPI glProgramUniform1ui64NV( GLuint program, GLint location, GLuint64EXT x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(x) );
+  TRACE( "(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(x) );
   funcs->ext.p_glProgramUniform1ui64NV( program, location, x );
 }
 
-static void WINAPI glProgramUniform1ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64* value ) {
+static void WINAPI glProgramUniform1ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform1ui64vARB( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform1ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT* value ) {
+static void WINAPI glProgramUniform1ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform1ui64vNV( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform1uiEXT( GLuint program, GLint location, GLuint v0 ) {
+static void WINAPI glProgramUniform1uiEXT( GLuint program, GLint location, GLuint v0 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", program, location, v0 );
+  TRACE( "(%d, %d, %d)\n", program, location, v0 );
   funcs->ext.p_glProgramUniform1uiEXT( program, location, v0 );
 }
 
-static void WINAPI glProgramUniform1uiv( GLuint program, GLint location, GLsizei count, const GLuint* value ) {
+static void WINAPI glProgramUniform1uiv( GLuint program, GLint location, GLsizei count, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform1uiv( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform1uivEXT( GLuint program, GLint location, GLsizei count, const GLuint* value ) {
+static void WINAPI glProgramUniform1uivEXT( GLuint program, GLint location, GLsizei count, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform1uivEXT( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform2d( GLuint program, GLint location, GLdouble v0, GLdouble v1 ) {
+static void WINAPI glProgramUniform2d( GLuint program, GLint location, GLdouble v0, GLdouble v1 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f)\n", program, location, v0, v1 );
+  TRACE( "(%d, %d, %f, %f)\n", program, location, v0, v1 );
   funcs->ext.p_glProgramUniform2d( program, location, v0, v1 );
 }
 
-static void WINAPI glProgramUniform2dEXT( GLuint program, GLint location, GLdouble x, GLdouble y ) {
+static void WINAPI glProgramUniform2dEXT( GLuint program, GLint location, GLdouble x, GLdouble y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f)\n", program, location, x, y );
+  TRACE( "(%d, %d, %f, %f)\n", program, location, x, y );
   funcs->ext.p_glProgramUniform2dEXT( program, location, x, y );
 }
 
-static void WINAPI glProgramUniform2dv( GLuint program, GLint location, GLsizei count, const GLdouble* value ) {
+static void WINAPI glProgramUniform2dv( GLuint program, GLint location, GLsizei count, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform2dv( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform2dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble* value ) {
+static void WINAPI glProgramUniform2dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform2dvEXT( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform2f( GLuint program, GLint location, GLfloat v0, GLfloat v1 ) {
+static void WINAPI glProgramUniform2f( GLuint program, GLint location, GLfloat v0, GLfloat v1 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f)\n", program, location, v0, v1 );
+  TRACE( "(%d, %d, %f, %f)\n", program, location, v0, v1 );
   funcs->ext.p_glProgramUniform2f( program, location, v0, v1 );
 }
 
-static void WINAPI glProgramUniform2fEXT( GLuint program, GLint location, GLfloat v0, GLfloat v1 ) {
+static void WINAPI glProgramUniform2fEXT( GLuint program, GLint location, GLfloat v0, GLfloat v1 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f)\n", program, location, v0, v1 );
+  TRACE( "(%d, %d, %f, %f)\n", program, location, v0, v1 );
   funcs->ext.p_glProgramUniform2fEXT( program, location, v0, v1 );
 }
 
-static void WINAPI glProgramUniform2fv( GLuint program, GLint location, GLsizei count, const GLfloat* value ) {
+static void WINAPI glProgramUniform2fv( GLuint program, GLint location, GLsizei count, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform2fv( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform2fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat* value ) {
+static void WINAPI glProgramUniform2fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform2fvEXT( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform2i( GLuint program, GLint location, GLint v0, GLint v1 ) {
+static void WINAPI glProgramUniform2i( GLuint program, GLint location, GLint v0, GLint v1 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", program, location, v0, v1 );
+  TRACE( "(%d, %d, %d, %d)\n", program, location, v0, v1 );
   funcs->ext.p_glProgramUniform2i( program, location, v0, v1 );
 }
 
-static void WINAPI glProgramUniform2i64ARB( GLuint program, GLint location, GLint64 x, GLint64 y ) {
+static void WINAPI glProgramUniform2i64ARB( GLuint program, GLint location, GLint64 x, GLint64 y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
+  TRACE( "(%d, %d, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
   funcs->ext.p_glProgramUniform2i64ARB( program, location, x, y );
 }
 
-static void WINAPI glProgramUniform2i64NV( GLuint program, GLint location, GLint64EXT x, GLint64EXT y ) {
+static void WINAPI glProgramUniform2i64NV( GLuint program, GLint location, GLint64EXT x, GLint64EXT y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
+  TRACE( "(%d, %d, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
   funcs->ext.p_glProgramUniform2i64NV( program, location, x, y );
 }
 
-static void WINAPI glProgramUniform2i64vARB( GLuint program, GLint location, GLsizei count, const GLint64* value ) {
+static void WINAPI glProgramUniform2i64vARB( GLuint program, GLint location, GLsizei count, const GLint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform2i64vARB( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform2i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT* value ) {
+static void WINAPI glProgramUniform2i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform2i64vNV( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform2iEXT( GLuint program, GLint location, GLint v0, GLint v1 ) {
+static void WINAPI glProgramUniform2iEXT( GLuint program, GLint location, GLint v0, GLint v1 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", program, location, v0, v1 );
+  TRACE( "(%d, %d, %d, %d)\n", program, location, v0, v1 );
   funcs->ext.p_glProgramUniform2iEXT( program, location, v0, v1 );
 }
 
-static void WINAPI glProgramUniform2iv( GLuint program, GLint location, GLsizei count, const GLint* value ) {
+static void WINAPI glProgramUniform2iv( GLuint program, GLint location, GLsizei count, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform2iv( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform2ivEXT( GLuint program, GLint location, GLsizei count, const GLint* value ) {
+static void WINAPI glProgramUniform2ivEXT( GLuint program, GLint location, GLsizei count, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform2ivEXT( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform2ui( GLuint program, GLint location, GLuint v0, GLuint v1 ) {
+static void WINAPI glProgramUniform2ui( GLuint program, GLint location, GLuint v0, GLuint v1 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", program, location, v0, v1 );
+  TRACE( "(%d, %d, %d, %d)\n", program, location, v0, v1 );
   funcs->ext.p_glProgramUniform2ui( program, location, v0, v1 );
 }
 
-static void WINAPI glProgramUniform2ui64ARB( GLuint program, GLint location, GLuint64 x, GLuint64 y ) {
+static void WINAPI glProgramUniform2ui64ARB( GLuint program, GLint location, GLuint64 x, GLuint64 y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
+  TRACE( "(%d, %d, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
   funcs->ext.p_glProgramUniform2ui64ARB( program, location, x, y );
 }
 
-static void WINAPI glProgramUniform2ui64NV( GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y ) {
+static void WINAPI glProgramUniform2ui64NV( GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
+  TRACE( "(%d, %d, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
   funcs->ext.p_glProgramUniform2ui64NV( program, location, x, y );
 }
 
-static void WINAPI glProgramUniform2ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64* value ) {
+static void WINAPI glProgramUniform2ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform2ui64vARB( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform2ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT* value ) {
+static void WINAPI glProgramUniform2ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform2ui64vNV( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform2uiEXT( GLuint program, GLint location, GLuint v0, GLuint v1 ) {
+static void WINAPI glProgramUniform2uiEXT( GLuint program, GLint location, GLuint v0, GLuint v1 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", program, location, v0, v1 );
+  TRACE( "(%d, %d, %d, %d)\n", program, location, v0, v1 );
   funcs->ext.p_glProgramUniform2uiEXT( program, location, v0, v1 );
 }
 
-static void WINAPI glProgramUniform2uiv( GLuint program, GLint location, GLsizei count, const GLuint* value ) {
+static void WINAPI glProgramUniform2uiv( GLuint program, GLint location, GLsizei count, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform2uiv( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform2uivEXT( GLuint program, GLint location, GLsizei count, const GLuint* value ) {
+static void WINAPI glProgramUniform2uivEXT( GLuint program, GLint location, GLsizei count, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform2uivEXT( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform3d( GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2 ) {
+static void WINAPI glProgramUniform3d( GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %f)\n", program, location, v0, v1, v2 );
+  TRACE( "(%d, %d, %f, %f, %f)\n", program, location, v0, v1, v2 );
   funcs->ext.p_glProgramUniform3d( program, location, v0, v1, v2 );
 }
 
-static void WINAPI glProgramUniform3dEXT( GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z ) {
+static void WINAPI glProgramUniform3dEXT( GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %f)\n", program, location, x, y, z );
+  TRACE( "(%d, %d, %f, %f, %f)\n", program, location, x, y, z );
   funcs->ext.p_glProgramUniform3dEXT( program, location, x, y, z );
 }
 
-static void WINAPI glProgramUniform3dv( GLuint program, GLint location, GLsizei count, const GLdouble* value ) {
+static void WINAPI glProgramUniform3dv( GLuint program, GLint location, GLsizei count, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform3dv( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform3dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble* value ) {
+static void WINAPI glProgramUniform3dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform3dvEXT( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform3f( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 ) {
+static void WINAPI glProgramUniform3f( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %f)\n", program, location, v0, v1, v2 );
+  TRACE( "(%d, %d, %f, %f, %f)\n", program, location, v0, v1, v2 );
   funcs->ext.p_glProgramUniform3f( program, location, v0, v1, v2 );
 }
 
-static void WINAPI glProgramUniform3fEXT( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 ) {
+static void WINAPI glProgramUniform3fEXT( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %f)\n", program, location, v0, v1, v2 );
+  TRACE( "(%d, %d, %f, %f, %f)\n", program, location, v0, v1, v2 );
   funcs->ext.p_glProgramUniform3fEXT( program, location, v0, v1, v2 );
 }
 
-static void WINAPI glProgramUniform3fv( GLuint program, GLint location, GLsizei count, const GLfloat* value ) {
+static void WINAPI glProgramUniform3fv( GLuint program, GLint location, GLsizei count, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform3fv( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform3fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat* value ) {
+static void WINAPI glProgramUniform3fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform3fvEXT( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform3i( GLuint program, GLint location, GLint v0, GLint v1, GLint v2 ) {
+static void WINAPI glProgramUniform3i( GLuint program, GLint location, GLint v0, GLint v1, GLint v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", program, location, v0, v1, v2 );
+  TRACE( "(%d, %d, %d, %d, %d)\n", program, location, v0, v1, v2 );
   funcs->ext.p_glProgramUniform3i( program, location, v0, v1, v2 );
 }
 
-static void WINAPI glProgramUniform3i64ARB( GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z ) {
+static void WINAPI glProgramUniform3i64ARB( GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
+  TRACE( "(%d, %d, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
   funcs->ext.p_glProgramUniform3i64ARB( program, location, x, y, z );
 }
 
-static void WINAPI glProgramUniform3i64NV( GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z ) {
+static void WINAPI glProgramUniform3i64NV( GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
+  TRACE( "(%d, %d, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
   funcs->ext.p_glProgramUniform3i64NV( program, location, x, y, z );
 }
 
-static void WINAPI glProgramUniform3i64vARB( GLuint program, GLint location, GLsizei count, const GLint64* value ) {
+static void WINAPI glProgramUniform3i64vARB( GLuint program, GLint location, GLsizei count, const GLint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform3i64vARB( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform3i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT* value ) {
+static void WINAPI glProgramUniform3i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform3i64vNV( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform3iEXT( GLuint program, GLint location, GLint v0, GLint v1, GLint v2 ) {
+static void WINAPI glProgramUniform3iEXT( GLuint program, GLint location, GLint v0, GLint v1, GLint v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", program, location, v0, v1, v2 );
+  TRACE( "(%d, %d, %d, %d, %d)\n", program, location, v0, v1, v2 );
   funcs->ext.p_glProgramUniform3iEXT( program, location, v0, v1, v2 );
 }
 
-static void WINAPI glProgramUniform3iv( GLuint program, GLint location, GLsizei count, const GLint* value ) {
+static void WINAPI glProgramUniform3iv( GLuint program, GLint location, GLsizei count, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform3iv( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform3ivEXT( GLuint program, GLint location, GLsizei count, const GLint* value ) {
+static void WINAPI glProgramUniform3ivEXT( GLuint program, GLint location, GLsizei count, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform3ivEXT( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform3ui( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 ) {
+static void WINAPI glProgramUniform3ui( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", program, location, v0, v1, v2 );
+  TRACE( "(%d, %d, %d, %d, %d)\n", program, location, v0, v1, v2 );
   funcs->ext.p_glProgramUniform3ui( program, location, v0, v1, v2 );
 }
 
-static void WINAPI glProgramUniform3ui64ARB( GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z ) {
+static void WINAPI glProgramUniform3ui64ARB( GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
+  TRACE( "(%d, %d, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
   funcs->ext.p_glProgramUniform3ui64ARB( program, location, x, y, z );
 }
 
-static void WINAPI glProgramUniform3ui64NV( GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z ) {
+static void WINAPI glProgramUniform3ui64NV( GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
+  TRACE( "(%d, %d, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
   funcs->ext.p_glProgramUniform3ui64NV( program, location, x, y, z );
 }
 
-static void WINAPI glProgramUniform3ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64* value ) {
+static void WINAPI glProgramUniform3ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform3ui64vARB( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform3ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT* value ) {
+static void WINAPI glProgramUniform3ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform3ui64vNV( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform3uiEXT( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 ) {
+static void WINAPI glProgramUniform3uiEXT( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", program, location, v0, v1, v2 );
+  TRACE( "(%d, %d, %d, %d, %d)\n", program, location, v0, v1, v2 );
   funcs->ext.p_glProgramUniform3uiEXT( program, location, v0, v1, v2 );
 }
 
-static void WINAPI glProgramUniform3uiv( GLuint program, GLint location, GLsizei count, const GLuint* value ) {
+static void WINAPI glProgramUniform3uiv( GLuint program, GLint location, GLsizei count, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform3uiv( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform3uivEXT( GLuint program, GLint location, GLsizei count, const GLuint* value ) {
+static void WINAPI glProgramUniform3uivEXT( GLuint program, GLint location, GLsizei count, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform3uivEXT( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform4d( GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3 ) {
+static void WINAPI glProgramUniform4d( GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %f, %f)\n", program, location, v0, v1, v2, v3 );
+  TRACE( "(%d, %d, %f, %f, %f, %f)\n", program, location, v0, v1, v2, v3 );
   funcs->ext.p_glProgramUniform4d( program, location, v0, v1, v2, v3 );
 }
 
-static void WINAPI glProgramUniform4dEXT( GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+static void WINAPI glProgramUniform4dEXT( GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %f, %f)\n", program, location, x, y, z, w );
+  TRACE( "(%d, %d, %f, %f, %f, %f)\n", program, location, x, y, z, w );
   funcs->ext.p_glProgramUniform4dEXT( program, location, x, y, z, w );
 }
 
-static void WINAPI glProgramUniform4dv( GLuint program, GLint location, GLsizei count, const GLdouble* value ) {
+static void WINAPI glProgramUniform4dv( GLuint program, GLint location, GLsizei count, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform4dv( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform4dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble* value ) {
+static void WINAPI glProgramUniform4dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform4dvEXT( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform4f( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) {
+static void WINAPI glProgramUniform4f( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %f, %f)\n", program, location, v0, v1, v2, v3 );
+  TRACE( "(%d, %d, %f, %f, %f, %f)\n", program, location, v0, v1, v2, v3 );
   funcs->ext.p_glProgramUniform4f( program, location, v0, v1, v2, v3 );
 }
 
-static void WINAPI glProgramUniform4fEXT( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) {
+static void WINAPI glProgramUniform4fEXT( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %f, %f)\n", program, location, v0, v1, v2, v3 );
+  TRACE( "(%d, %d, %f, %f, %f, %f)\n", program, location, v0, v1, v2, v3 );
   funcs->ext.p_glProgramUniform4fEXT( program, location, v0, v1, v2, v3 );
 }
 
-static void WINAPI glProgramUniform4fv( GLuint program, GLint location, GLsizei count, const GLfloat* value ) {
+static void WINAPI glProgramUniform4fv( GLuint program, GLint location, GLsizei count, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform4fv( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform4fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat* value ) {
+static void WINAPI glProgramUniform4fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform4fvEXT( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform4i( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 ) {
+static void WINAPI glProgramUniform4i( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", program, location, v0, v1, v2, v3 );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", program, location, v0, v1, v2, v3 );
   funcs->ext.p_glProgramUniform4i( program, location, v0, v1, v2, v3 );
 }
 
-static void WINAPI glProgramUniform4i64ARB( GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w ) {
+static void WINAPI glProgramUniform4i64ARB( GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
+  TRACE( "(%d, %d, %s, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
   funcs->ext.p_glProgramUniform4i64ARB( program, location, x, y, z, w );
 }
 
-static void WINAPI glProgramUniform4i64NV( GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w ) {
+static void WINAPI glProgramUniform4i64NV( GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
+  TRACE( "(%d, %d, %s, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
   funcs->ext.p_glProgramUniform4i64NV( program, location, x, y, z, w );
 }
 
-static void WINAPI glProgramUniform4i64vARB( GLuint program, GLint location, GLsizei count, const GLint64* value ) {
+static void WINAPI glProgramUniform4i64vARB( GLuint program, GLint location, GLsizei count, const GLint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform4i64vARB( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform4i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT* value ) {
+static void WINAPI glProgramUniform4i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform4i64vNV( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform4iEXT( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 ) {
+static void WINAPI glProgramUniform4iEXT( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", program, location, v0, v1, v2, v3 );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", program, location, v0, v1, v2, v3 );
   funcs->ext.p_glProgramUniform4iEXT( program, location, v0, v1, v2, v3 );
 }
 
-static void WINAPI glProgramUniform4iv( GLuint program, GLint location, GLsizei count, const GLint* value ) {
+static void WINAPI glProgramUniform4iv( GLuint program, GLint location, GLsizei count, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform4iv( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform4ivEXT( GLuint program, GLint location, GLsizei count, const GLint* value ) {
+static void WINAPI glProgramUniform4ivEXT( GLuint program, GLint location, GLsizei count, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform4ivEXT( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform4ui( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) {
+static void WINAPI glProgramUniform4ui( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", program, location, v0, v1, v2, v3 );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", program, location, v0, v1, v2, v3 );
   funcs->ext.p_glProgramUniform4ui( program, location, v0, v1, v2, v3 );
 }
 
-static void WINAPI glProgramUniform4ui64ARB( GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w ) {
+static void WINAPI glProgramUniform4ui64ARB( GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
+  TRACE( "(%d, %d, %s, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
   funcs->ext.p_glProgramUniform4ui64ARB( program, location, x, y, z, w );
 }
 
-static void WINAPI glProgramUniform4ui64NV( GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w ) {
+static void WINAPI glProgramUniform4ui64NV( GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
+  TRACE( "(%d, %d, %s, %s, %s, %s)\n", program, location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
   funcs->ext.p_glProgramUniform4ui64NV( program, location, x, y, z, w );
 }
 
-static void WINAPI glProgramUniform4ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64* value ) {
+static void WINAPI glProgramUniform4ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform4ui64vARB( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform4ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT* value ) {
+static void WINAPI glProgramUniform4ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform4ui64vNV( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform4uiEXT( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) {
+static void WINAPI glProgramUniform4uiEXT( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", program, location, v0, v1, v2, v3 );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", program, location, v0, v1, v2, v3 );
   funcs->ext.p_glProgramUniform4uiEXT( program, location, v0, v1, v2, v3 );
 }
 
-static void WINAPI glProgramUniform4uiv( GLuint program, GLint location, GLsizei count, const GLuint* value ) {
+static void WINAPI glProgramUniform4uiv( GLuint program, GLint location, GLsizei count, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform4uiv( program, location, count, value );
 }
 
-static void WINAPI glProgramUniform4uivEXT( GLuint program, GLint location, GLsizei count, const GLuint* value ) {
+static void WINAPI glProgramUniform4uivEXT( GLuint program, GLint location, GLsizei count, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniform4uivEXT( program, location, count, value );
 }
 
-static void WINAPI glProgramUniformHandleui64ARB( GLuint program, GLint location, GLuint64 value ) {
+static void WINAPI glProgramUniformHandleui64ARB( GLuint program, GLint location, GLuint64 value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(value) );
+  TRACE( "(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(value) );
   funcs->ext.p_glProgramUniformHandleui64ARB( program, location, value );
 }
 
-static void WINAPI glProgramUniformHandleui64NV( GLuint program, GLint location, GLuint64 value ) {
+static void WINAPI glProgramUniformHandleui64NV( GLuint program, GLint location, GLuint64 value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(value) );
+  TRACE( "(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(value) );
   funcs->ext.p_glProgramUniformHandleui64NV( program, location, value );
 }
 
-static void WINAPI glProgramUniformHandleui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64* values ) {
+static void WINAPI glProgramUniformHandleui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64 *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, values );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, values );
   funcs->ext.p_glProgramUniformHandleui64vARB( program, location, count, values );
 }
 
-static void WINAPI glProgramUniformHandleui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64* values ) {
+static void WINAPI glProgramUniformHandleui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64 *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, values );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, values );
   funcs->ext.p_glProgramUniformHandleui64vNV( program, location, count, values );
 }
 
-static void WINAPI glProgramUniformMatrix2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix2dv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix2dvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix2fv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix2fvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix2x3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix2x3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix2x3dv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix2x3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix2x3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix2x3dvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix2x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix2x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix2x3fv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix2x3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix2x3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix2x3fvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix2x4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix2x4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix2x4dv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix2x4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix2x4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix2x4dvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix2x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix2x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix2x4fv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix2x4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix2x4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix2x4fvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix3dv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix3dvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix3fv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix3fvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix3x2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix3x2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix3x2dv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix3x2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix3x2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix3x2dvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix3x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix3x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix3x2fv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix3x2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix3x2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix3x2fvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix3x4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix3x4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix3x4dv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix3x4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix3x4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix3x4dvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix3x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix3x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix3x4fv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix3x4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix3x4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix3x4fvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix4dv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix4dvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix4fv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix4fvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix4x2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix4x2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix4x2dv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix4x2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix4x2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix4x2dvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix4x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix4x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix4x2fv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix4x2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix4x2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix4x2fvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix4x3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix4x3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix4x3dv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix4x3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glProgramUniformMatrix4x3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix4x3dvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix4x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix4x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix4x3fv( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformMatrix4x3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glProgramUniformMatrix4x3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %d, %p)\n", program, location, count, transpose, value );
   funcs->ext.p_glProgramUniformMatrix4x3fvEXT( program, location, count, transpose, value );
 }
 
-static void WINAPI glProgramUniformui64NV( GLuint program, GLint location, GLuint64EXT value ) {
+static void WINAPI glProgramUniformui64NV( GLuint program, GLint location, GLuint64EXT value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(value) );
+  TRACE( "(%d, %d, %s)\n", program, location, wine_dbgstr_longlong(value) );
   funcs->ext.p_glProgramUniformui64NV( program, location, value );
 }
 
-static void WINAPI glProgramUniformui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT* value ) {
+static void WINAPI glProgramUniformui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", program, location, count, value );
+  TRACE( "(%d, %d, %d, %p)\n", program, location, count, value );
   funcs->ext.p_glProgramUniformui64vNV( program, location, count, value );
 }
 
-static void WINAPI glProgramVertexLimitNV( GLenum target, GLint limit ) {
+static void WINAPI glProgramVertexLimitNV( GLenum target, GLint limit )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, limit );
+  TRACE( "(%d, %d)\n", target, limit );
   funcs->ext.p_glProgramVertexLimitNV( target, limit );
 }
 
-static void WINAPI glProvokingVertex( GLenum mode ) {
+static void WINAPI glProvokingVertex( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   funcs->ext.p_glProvokingVertex( mode );
 }
 
-static void WINAPI glProvokingVertexEXT( GLenum mode ) {
+static void WINAPI glProvokingVertexEXT( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   funcs->ext.p_glProvokingVertexEXT( mode );
 }
 
-static void WINAPI glPushClientAttribDefaultEXT( GLbitfield mask ) {
+static void WINAPI glPushClientAttribDefaultEXT( GLbitfield mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mask );
+  TRACE( "(%d)\n", mask );
   funcs->ext.p_glPushClientAttribDefaultEXT( mask );
 }
 
-static void WINAPI glPushDebugGroup( GLenum source, GLuint id, GLsizei length, const GLchar* message ) {
+static void WINAPI glPushDebugGroup( GLenum source, GLuint id, GLsizei length, const GLchar *message )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", source, id, length, message );
+  TRACE( "(%d, %d, %d, %p)\n", source, id, length, message );
   funcs->ext.p_glPushDebugGroup( source, id, length, message );
 }
 
-static void WINAPI glPushGroupMarkerEXT( GLsizei length, const GLchar* marker ) {
+static void WINAPI glPushGroupMarkerEXT( GLsizei length, const GLchar *marker )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", length, marker );
+  TRACE( "(%d, %p)\n", length, marker );
   funcs->ext.p_glPushGroupMarkerEXT( length, marker );
 }
 
-static void WINAPI glQueryCounter( GLuint id, GLenum target ) {
+static void WINAPI glQueryCounter( GLuint id, GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", id, target );
+  TRACE( "(%d, %d)\n", id, target );
   funcs->ext.p_glQueryCounter( id, target );
 }
 
-static GLbitfield WINAPI glQueryMatrixxOES( GLfixed* mantissa, GLint* exponent ) {
+static GLbitfield WINAPI glQueryMatrixxOES( GLfixed *mantissa, GLint *exponent )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", mantissa, exponent );
+  TRACE( "(%p, %p)\n", mantissa, exponent );
   return funcs->ext.p_glQueryMatrixxOES( mantissa, exponent );
 }
 
-static void WINAPI glQueryObjectParameteruiAMD( GLenum target, GLuint id, GLenum pname, GLuint param ) {
+static void WINAPI glQueryObjectParameteruiAMD( GLenum target, GLuint id, GLenum pname, GLuint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, id, pname, param );
+  TRACE( "(%d, %d, %d, %d)\n", target, id, pname, param );
   funcs->ext.p_glQueryObjectParameteruiAMD( target, id, pname, param );
 }
 
-static GLint WINAPI glQueryResourceNV( GLenum queryType, GLint tagId, GLuint bufSize, GLint* buffer ) {
+static GLint WINAPI glQueryResourceNV( GLenum queryType, GLint tagId, GLuint bufSize, GLint *buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", queryType, tagId, bufSize, buffer );
+  TRACE( "(%d, %d, %d, %p)\n", queryType, tagId, bufSize, buffer );
   return funcs->ext.p_glQueryResourceNV( queryType, tagId, bufSize, buffer );
 }
 
-static void WINAPI glQueryResourceTagNV( GLint tagId, const GLchar* tagString ) {
+static void WINAPI glQueryResourceTagNV( GLint tagId, const GLchar *tagString )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", tagId, tagString );
+  TRACE( "(%d, %p)\n", tagId, tagString );
   funcs->ext.p_glQueryResourceTagNV( tagId, tagString );
 }
 
-static void WINAPI glRasterPos2xOES( GLfixed x, GLfixed y ) {
+static void WINAPI glRasterPos2xOES( GLfixed x, GLfixed y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", x, y );
+  TRACE( "(%d, %d)\n", x, y );
   funcs->ext.p_glRasterPos2xOES( x, y );
 }
 
-static void WINAPI glRasterPos2xvOES( const GLfixed* coords ) {
+static void WINAPI glRasterPos2xvOES( const GLfixed *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glRasterPos2xvOES( coords );
 }
 
-static void WINAPI glRasterPos3xOES( GLfixed x, GLfixed y, GLfixed z ) {
+static void WINAPI glRasterPos3xOES( GLfixed x, GLfixed y, GLfixed z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", x, y, z );
+  TRACE( "(%d, %d, %d)\n", x, y, z );
   funcs->ext.p_glRasterPos3xOES( x, y, z );
 }
 
-static void WINAPI glRasterPos3xvOES( const GLfixed* coords ) {
+static void WINAPI glRasterPos3xvOES( const GLfixed *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glRasterPos3xvOES( coords );
 }
 
-static void WINAPI glRasterPos4xOES( GLfixed x, GLfixed y, GLfixed z, GLfixed w ) {
+static void WINAPI glRasterPos4xOES( GLfixed x, GLfixed y, GLfixed z, GLfixed w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
+  TRACE( "(%d, %d, %d, %d)\n", x, y, z, w );
   funcs->ext.p_glRasterPos4xOES( x, y, z, w );
 }
 
-static void WINAPI glRasterPos4xvOES( const GLfixed* coords ) {
+static void WINAPI glRasterPos4xvOES( const GLfixed *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glRasterPos4xvOES( coords );
 }
 
-static void WINAPI glRasterSamplesEXT( GLuint samples, GLboolean fixedsamplelocations ) {
+static void WINAPI glRasterSamplesEXT( GLuint samples, GLboolean fixedsamplelocations )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", samples, fixedsamplelocations );
+  TRACE( "(%d, %d)\n", samples, fixedsamplelocations );
   funcs->ext.p_glRasterSamplesEXT( samples, fixedsamplelocations );
 }
 
-static void WINAPI glReadBufferRegion( GLenum region, GLint x, GLint y, GLsizei width, GLsizei height ) {
+static void WINAPI glReadBufferRegion( GLenum region, GLint x, GLint y, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", region, x, y, width, height );
+  TRACE( "(%d, %d, %d, %d, %d)\n", region, x, y, width, height );
   funcs->ext.p_glReadBufferRegion( region, x, y, width, height );
 }
 
-static void WINAPI glReadInstrumentsSGIX( GLint marker ) {
+static void WINAPI glReadInstrumentsSGIX( GLint marker )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", marker );
+  TRACE( "(%d)\n", marker );
   funcs->ext.p_glReadInstrumentsSGIX( marker );
 }
 
-static void WINAPI glReadnPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void* data ) {
+static void WINAPI glReadnPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", x, y, width, height, format, type, bufSize, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %p)\n", x, y, width, height, format, type, bufSize, data );
   funcs->ext.p_glReadnPixels( x, y, width, height, format, type, bufSize, data );
 }
 
-static void WINAPI glReadnPixelsARB( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void* data ) {
+static void WINAPI glReadnPixelsARB( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", x, y, width, height, format, type, bufSize, data );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %p)\n", x, y, width, height, format, type, bufSize, data );
   funcs->ext.p_glReadnPixelsARB( x, y, width, height, format, type, bufSize, data );
 }
 
-static void WINAPI glRectxOES( GLfixed x1, GLfixed y1, GLfixed x2, GLfixed y2 ) {
+static void WINAPI glRectxOES( GLfixed x1, GLfixed y1, GLfixed x2, GLfixed y2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", x1, y1, x2, y2 );
+  TRACE( "(%d, %d, %d, %d)\n", x1, y1, x2, y2 );
   funcs->ext.p_glRectxOES( x1, y1, x2, y2 );
 }
 
-static void WINAPI glRectxvOES( const GLfixed* v1, const GLfixed* v2 ) {
+static void WINAPI glRectxvOES( const GLfixed *v1, const GLfixed *v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", v1, v2 );
+  TRACE( "(%p, %p)\n", v1, v2 );
   funcs->ext.p_glRectxvOES( v1, v2 );
 }
 
-static void WINAPI glReferencePlaneSGIX( const GLdouble* equation ) {
+static void WINAPI glReferencePlaneSGIX( const GLdouble *equation )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", equation );
+  TRACE( "(%p)\n", equation );
   funcs->ext.p_glReferencePlaneSGIX( equation );
 }
 
-static GLboolean WINAPI glReleaseKeyedMutexWin32EXT( GLuint memory, GLuint64 key ) {
+static GLboolean WINAPI glReleaseKeyedMutexWin32EXT( GLuint memory, GLuint64 key )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s)\n", memory, wine_dbgstr_longlong(key) );
+  TRACE( "(%d, %s)\n", memory, wine_dbgstr_longlong(key) );
   return funcs->ext.p_glReleaseKeyedMutexWin32EXT( memory, key );
 }
 
-static void WINAPI glReleaseShaderCompiler( void ) {
+static void WINAPI glReleaseShaderCompiler(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glReleaseShaderCompiler( );
+  TRACE( "()\n" );
+  funcs->ext.p_glReleaseShaderCompiler();
 }
 
-static void WINAPI glRenderGpuMaskNV( GLbitfield mask ) {
+static void WINAPI glRenderGpuMaskNV( GLbitfield mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mask );
+  TRACE( "(%d)\n", mask );
   funcs->ext.p_glRenderGpuMaskNV( mask );
 }
 
-static void WINAPI glRenderbufferStorage( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) {
+static void WINAPI glRenderbufferStorage( GLenum target, GLenum internalformat, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, internalformat, width, height );
+  TRACE( "(%d, %d, %d, %d)\n", target, internalformat, width, height );
   funcs->ext.p_glRenderbufferStorage( target, internalformat, width, height );
 }
 
-static void WINAPI glRenderbufferStorageEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) {
+static void WINAPI glRenderbufferStorageEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, internalformat, width, height );
+  TRACE( "(%d, %d, %d, %d)\n", target, internalformat, width, height );
   funcs->ext.p_glRenderbufferStorageEXT( target, internalformat, width, height );
 }
 
-static void WINAPI glRenderbufferStorageMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height ) {
+static void WINAPI glRenderbufferStorageMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, samples, internalformat, width, height );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, samples, internalformat, width, height );
   funcs->ext.p_glRenderbufferStorageMultisample( target, samples, internalformat, width, height );
 }
 
-static void WINAPI glRenderbufferStorageMultisampleCoverageNV( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height ) {
+static void WINAPI glRenderbufferStorageMultisampleCoverageNV( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, coverageSamples, colorSamples, internalformat, width, height );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", target, coverageSamples, colorSamples, internalformat, width, height );
   funcs->ext.p_glRenderbufferStorageMultisampleCoverageNV( target, coverageSamples, colorSamples, internalformat, width, height );
 }
 
-static void WINAPI glRenderbufferStorageMultisampleEXT( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height ) {
+static void WINAPI glRenderbufferStorageMultisampleEXT( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, samples, internalformat, width, height );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, samples, internalformat, width, height );
   funcs->ext.p_glRenderbufferStorageMultisampleEXT( target, samples, internalformat, width, height );
 }
 
-static void WINAPI glReplacementCodePointerSUN( GLenum type, GLsizei stride, const void** pointer ) {
+static void WINAPI glReplacementCodePointerSUN( GLenum type, GLsizei stride, const void **pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", type, stride, pointer );
+  TRACE( "(%d, %d, %p)\n", type, stride, pointer );
   funcs->ext.p_glReplacementCodePointerSUN( type, stride, pointer );
 }
 
-static void WINAPI glReplacementCodeubSUN( GLubyte code ) {
+static void WINAPI glReplacementCodeubSUN( GLubyte code )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", code );
+  TRACE( "(%d)\n", code );
   funcs->ext.p_glReplacementCodeubSUN( code );
 }
 
-static void WINAPI glReplacementCodeubvSUN( const GLubyte* code ) {
+static void WINAPI glReplacementCodeubvSUN( const GLubyte *code )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", code );
+  TRACE( "(%p)\n", code );
   funcs->ext.p_glReplacementCodeubvSUN( code );
 }
 
-static void WINAPI glReplacementCodeuiColor3fVertex3fSUN( GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glReplacementCodeuiColor3fVertex3fSUN( GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f, %f, %f)\n", rc, r, g, b, x, y, z );
+  TRACE( "(%d, %f, %f, %f, %f, %f, %f)\n", rc, r, g, b, x, y, z );
   funcs->ext.p_glReplacementCodeuiColor3fVertex3fSUN( rc, r, g, b, x, y, z );
 }
 
-static void WINAPI glReplacementCodeuiColor3fVertex3fvSUN( const GLuint* rc, const GLfloat* c, const GLfloat* v ) {
+static void WINAPI glReplacementCodeuiColor3fVertex3fvSUN( const GLuint *rc, const GLfloat *c, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p, %p)\n", rc, c, v );
+  TRACE( "(%p, %p, %p)\n", rc, c, v );
   funcs->ext.p_glReplacementCodeuiColor3fVertex3fvSUN( rc, c, v );
 }
 
-static void WINAPI glReplacementCodeuiColor4fNormal3fVertex3fSUN( GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glReplacementCodeuiColor4fNormal3fVertex3fSUN( GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", rc, r, g, b, a, nx, ny, nz, x, y, z );
+  TRACE( "(%d, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", rc, r, g, b, a, nx, ny, nz, x, y, z );
   funcs->ext.p_glReplacementCodeuiColor4fNormal3fVertex3fSUN( rc, r, g, b, a, nx, ny, nz, x, y, z );
 }
 
-static void WINAPI glReplacementCodeuiColor4fNormal3fVertex3fvSUN( const GLuint* rc, const GLfloat* c, const GLfloat* n, const GLfloat* v ) {
+static void WINAPI glReplacementCodeuiColor4fNormal3fVertex3fvSUN( const GLuint *rc, const GLfloat *c, const GLfloat *n, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p, %p, %p)\n", rc, c, n, v );
+  TRACE( "(%p, %p, %p, %p)\n", rc, c, n, v );
   funcs->ext.p_glReplacementCodeuiColor4fNormal3fVertex3fvSUN( rc, c, n, v );
 }
 
-static void WINAPI glReplacementCodeuiColor4ubVertex3fSUN( GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glReplacementCodeuiColor4ubVertex3fSUN( GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %f, %f, %f)\n", rc, r, g, b, a, x, y, z );
+  TRACE( "(%d, %d, %d, %d, %d, %f, %f, %f)\n", rc, r, g, b, a, x, y, z );
   funcs->ext.p_glReplacementCodeuiColor4ubVertex3fSUN( rc, r, g, b, a, x, y, z );
 }
 
-static void WINAPI glReplacementCodeuiColor4ubVertex3fvSUN( const GLuint* rc, const GLubyte* c, const GLfloat* v ) {
+static void WINAPI glReplacementCodeuiColor4ubVertex3fvSUN( const GLuint *rc, const GLubyte *c, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p, %p)\n", rc, c, v );
+  TRACE( "(%p, %p, %p)\n", rc, c, v );
   funcs->ext.p_glReplacementCodeuiColor4ubVertex3fvSUN( rc, c, v );
 }
 
-static void WINAPI glReplacementCodeuiNormal3fVertex3fSUN( GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glReplacementCodeuiNormal3fVertex3fSUN( GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f, %f, %f)\n", rc, nx, ny, nz, x, y, z );
+  TRACE( "(%d, %f, %f, %f, %f, %f, %f)\n", rc, nx, ny, nz, x, y, z );
   funcs->ext.p_glReplacementCodeuiNormal3fVertex3fSUN( rc, nx, ny, nz, x, y, z );
 }
 
-static void WINAPI glReplacementCodeuiNormal3fVertex3fvSUN( const GLuint* rc, const GLfloat* n, const GLfloat* v ) {
+static void WINAPI glReplacementCodeuiNormal3fVertex3fvSUN( const GLuint *rc, const GLfloat *n, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p, %p)\n", rc, n, v );
+  TRACE( "(%p, %p, %p)\n", rc, n, v );
   funcs->ext.p_glReplacementCodeuiNormal3fVertex3fvSUN( rc, n, v );
 }
 
-static void WINAPI glReplacementCodeuiSUN( GLuint code ) {
+static void WINAPI glReplacementCodeuiSUN( GLuint code )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", code );
+  TRACE( "(%d)\n", code );
   funcs->ext.p_glReplacementCodeuiSUN( code );
 }
 
-static void WINAPI glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN( GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN( GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", rc, s, t, r, g, b, a, nx, ny, nz, x, y, z );
+  TRACE( "(%d, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", rc, s, t, r, g, b, a, nx, ny, nz, x, y, z );
   funcs->ext.p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN( rc, s, t, r, g, b, a, nx, ny, nz, x, y, z );
 }
 
-static void WINAPI glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN( const GLuint* rc, const GLfloat* tc, const GLfloat* c, const GLfloat* n, const GLfloat* v ) {
+static void WINAPI glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN( const GLuint *rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p, %p, %p, %p)\n", rc, tc, c, n, v );
+  TRACE( "(%p, %p, %p, %p, %p)\n", rc, tc, c, n, v );
   funcs->ext.p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN( rc, tc, c, n, v );
 }
 
-static void WINAPI glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN( GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN( GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f, %f, %f, %f, %f)\n", rc, s, t, nx, ny, nz, x, y, z );
+  TRACE( "(%d, %f, %f, %f, %f, %f, %f, %f, %f)\n", rc, s, t, nx, ny, nz, x, y, z );
   funcs->ext.p_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN( rc, s, t, nx, ny, nz, x, y, z );
 }
 
-static void WINAPI glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN( const GLuint* rc, const GLfloat* tc, const GLfloat* n, const GLfloat* v ) {
+static void WINAPI glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN( const GLuint *rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p, %p, %p)\n", rc, tc, n, v );
+  TRACE( "(%p, %p, %p, %p)\n", rc, tc, n, v );
   funcs->ext.p_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN( rc, tc, n, v );
 }
 
-static void WINAPI glReplacementCodeuiTexCoord2fVertex3fSUN( GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glReplacementCodeuiTexCoord2fVertex3fSUN( GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f, %f)\n", rc, s, t, x, y, z );
+  TRACE( "(%d, %f, %f, %f, %f, %f)\n", rc, s, t, x, y, z );
   funcs->ext.p_glReplacementCodeuiTexCoord2fVertex3fSUN( rc, s, t, x, y, z );
 }
 
-static void WINAPI glReplacementCodeuiTexCoord2fVertex3fvSUN( const GLuint* rc, const GLfloat* tc, const GLfloat* v ) {
+static void WINAPI glReplacementCodeuiTexCoord2fVertex3fvSUN( const GLuint *rc, const GLfloat *tc, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p, %p)\n", rc, tc, v );
+  TRACE( "(%p, %p, %p)\n", rc, tc, v );
   funcs->ext.p_glReplacementCodeuiTexCoord2fVertex3fvSUN( rc, tc, v );
 }
 
-static void WINAPI glReplacementCodeuiVertex3fSUN( GLuint rc, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glReplacementCodeuiVertex3fSUN( GLuint rc, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", rc, x, y, z );
+  TRACE( "(%d, %f, %f, %f)\n", rc, x, y, z );
   funcs->ext.p_glReplacementCodeuiVertex3fSUN( rc, x, y, z );
 }
 
-static void WINAPI glReplacementCodeuiVertex3fvSUN( const GLuint* rc, const GLfloat* v ) {
+static void WINAPI glReplacementCodeuiVertex3fvSUN( const GLuint *rc, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", rc, v );
+  TRACE( "(%p, %p)\n", rc, v );
   funcs->ext.p_glReplacementCodeuiVertex3fvSUN( rc, v );
 }
 
-static void WINAPI glReplacementCodeuivSUN( const GLuint* code ) {
+static void WINAPI glReplacementCodeuivSUN( const GLuint *code )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", code );
+  TRACE( "(%p)\n", code );
   funcs->ext.p_glReplacementCodeuivSUN( code );
 }
 
-static void WINAPI glReplacementCodeusSUN( GLushort code ) {
+static void WINAPI glReplacementCodeusSUN( GLushort code )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", code );
+  TRACE( "(%d)\n", code );
   funcs->ext.p_glReplacementCodeusSUN( code );
 }
 
-static void WINAPI glReplacementCodeusvSUN( const GLushort* code ) {
+static void WINAPI glReplacementCodeusvSUN( const GLushort *code )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", code );
+  TRACE( "(%p)\n", code );
   funcs->ext.p_glReplacementCodeusvSUN( code );
 }
 
-static void WINAPI glRequestResidentProgramsNV( GLsizei n, const GLuint* programs ) {
+static void WINAPI glRequestResidentProgramsNV( GLsizei n, const GLuint *programs )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, programs );
+  TRACE( "(%d, %p)\n", n, programs );
   funcs->ext.p_glRequestResidentProgramsNV( n, programs );
 }
 
-static void WINAPI glResetHistogram( GLenum target ) {
+static void WINAPI glResetHistogram( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   funcs->ext.p_glResetHistogram( target );
 }
 
-static void WINAPI glResetHistogramEXT( GLenum target ) {
+static void WINAPI glResetHistogramEXT( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   funcs->ext.p_glResetHistogramEXT( target );
 }
 
-static void WINAPI glResetMinmax( GLenum target ) {
+static void WINAPI glResetMinmax( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   funcs->ext.p_glResetMinmax( target );
 }
 
-static void WINAPI glResetMinmaxEXT( GLenum target ) {
+static void WINAPI glResetMinmaxEXT( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   funcs->ext.p_glResetMinmaxEXT( target );
 }
 
-static void WINAPI glResizeBuffersMESA( void ) {
+static void WINAPI glResizeBuffersMESA(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glResizeBuffersMESA( );
+  TRACE( "()\n" );
+  funcs->ext.p_glResizeBuffersMESA();
 }
 
-static void WINAPI glResolveDepthValuesNV( void ) {
+static void WINAPI glResolveDepthValuesNV(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glResolveDepthValuesNV( );
+  TRACE( "()\n" );
+  funcs->ext.p_glResolveDepthValuesNV();
 }
 
-static void WINAPI glResumeTransformFeedback( void ) {
+static void WINAPI glResumeTransformFeedback(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glResumeTransformFeedback( );
+  TRACE( "()\n" );
+  funcs->ext.p_glResumeTransformFeedback();
 }
 
-static void WINAPI glResumeTransformFeedbackNV( void ) {
+static void WINAPI glResumeTransformFeedbackNV(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glResumeTransformFeedbackNV( );
+  TRACE( "()\n" );
+  funcs->ext.p_glResumeTransformFeedbackNV();
 }
 
-static void WINAPI glRotatexOES( GLfixed angle, GLfixed x, GLfixed y, GLfixed z ) {
+static void WINAPI glRotatexOES( GLfixed angle, GLfixed x, GLfixed y, GLfixed z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", angle, x, y, z );
+  TRACE( "(%d, %d, %d, %d)\n", angle, x, y, z );
   funcs->ext.p_glRotatexOES( angle, x, y, z );
 }
 
-static void WINAPI glSampleCoverage( GLfloat value, GLboolean invert ) {
+static void WINAPI glSampleCoverage( GLfloat value, GLboolean invert )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %d)\n", value, invert );
+  TRACE( "(%f, %d)\n", value, invert );
   funcs->ext.p_glSampleCoverage( value, invert );
 }
 
-static void WINAPI glSampleCoverageARB( GLfloat value, GLboolean invert ) {
+static void WINAPI glSampleCoverageARB( GLfloat value, GLboolean invert )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %d)\n", value, invert );
+  TRACE( "(%f, %d)\n", value, invert );
   funcs->ext.p_glSampleCoverageARB( value, invert );
 }
 
-static void WINAPI glSampleMapATI( GLuint dst, GLuint interp, GLenum swizzle ) {
+static void WINAPI glSampleMapATI( GLuint dst, GLuint interp, GLenum swizzle )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", dst, interp, swizzle );
+  TRACE( "(%d, %d, %d)\n", dst, interp, swizzle );
   funcs->ext.p_glSampleMapATI( dst, interp, swizzle );
 }
 
-static void WINAPI glSampleMaskEXT( GLclampf value, GLboolean invert ) {
+static void WINAPI glSampleMaskEXT( GLclampf value, GLboolean invert )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %d)\n", value, invert );
+  TRACE( "(%f, %d)\n", value, invert );
   funcs->ext.p_glSampleMaskEXT( value, invert );
 }
 
-static void WINAPI glSampleMaskIndexedNV( GLuint index, GLbitfield mask ) {
+static void WINAPI glSampleMaskIndexedNV( GLuint index, GLbitfield mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", index, mask );
+  TRACE( "(%d, %d)\n", index, mask );
   funcs->ext.p_glSampleMaskIndexedNV( index, mask );
 }
 
-static void WINAPI glSampleMaskSGIS( GLclampf value, GLboolean invert ) {
+static void WINAPI glSampleMaskSGIS( GLclampf value, GLboolean invert )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %d)\n", value, invert );
+  TRACE( "(%f, %d)\n", value, invert );
   funcs->ext.p_glSampleMaskSGIS( value, invert );
 }
 
-static void WINAPI glSampleMaski( GLuint maskNumber, GLbitfield mask ) {
+static void WINAPI glSampleMaski( GLuint maskNumber, GLbitfield mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", maskNumber, mask );
+  TRACE( "(%d, %d)\n", maskNumber, mask );
   funcs->ext.p_glSampleMaski( maskNumber, mask );
 }
 
-static void WINAPI glSamplePatternEXT( GLenum pattern ) {
+static void WINAPI glSamplePatternEXT( GLenum pattern )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", pattern );
+  TRACE( "(%d)\n", pattern );
   funcs->ext.p_glSamplePatternEXT( pattern );
 }
 
-static void WINAPI glSamplePatternSGIS( GLenum pattern ) {
+static void WINAPI glSamplePatternSGIS( GLenum pattern )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", pattern );
+  TRACE( "(%d)\n", pattern );
   funcs->ext.p_glSamplePatternSGIS( pattern );
 }
 
-static void WINAPI glSamplerParameterIiv( GLuint sampler, GLenum pname, const GLint* param ) {
+static void WINAPI glSamplerParameterIiv( GLuint sampler, GLenum pname, const GLint *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", sampler, pname, param );
+  TRACE( "(%d, %d, %p)\n", sampler, pname, param );
   funcs->ext.p_glSamplerParameterIiv( sampler, pname, param );
 }
 
-static void WINAPI glSamplerParameterIuiv( GLuint sampler, GLenum pname, const GLuint* param ) {
+static void WINAPI glSamplerParameterIuiv( GLuint sampler, GLenum pname, const GLuint *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", sampler, pname, param );
+  TRACE( "(%d, %d, %p)\n", sampler, pname, param );
   funcs->ext.p_glSamplerParameterIuiv( sampler, pname, param );
 }
 
-static void WINAPI glSamplerParameterf( GLuint sampler, GLenum pname, GLfloat param ) {
+static void WINAPI glSamplerParameterf( GLuint sampler, GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", sampler, pname, param );
+  TRACE( "(%d, %d, %f)\n", sampler, pname, param );
   funcs->ext.p_glSamplerParameterf( sampler, pname, param );
 }
 
-static void WINAPI glSamplerParameterfv( GLuint sampler, GLenum pname, const GLfloat* param ) {
+static void WINAPI glSamplerParameterfv( GLuint sampler, GLenum pname, const GLfloat *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", sampler, pname, param );
+  TRACE( "(%d, %d, %p)\n", sampler, pname, param );
   funcs->ext.p_glSamplerParameterfv( sampler, pname, param );
 }
 
-static void WINAPI glSamplerParameteri( GLuint sampler, GLenum pname, GLint param ) {
+static void WINAPI glSamplerParameteri( GLuint sampler, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", sampler, pname, param );
+  TRACE( "(%d, %d, %d)\n", sampler, pname, param );
   funcs->ext.p_glSamplerParameteri( sampler, pname, param );
 }
 
-static void WINAPI glSamplerParameteriv( GLuint sampler, GLenum pname, const GLint* param ) {
+static void WINAPI glSamplerParameteriv( GLuint sampler, GLenum pname, const GLint *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", sampler, pname, param );
+  TRACE( "(%d, %d, %p)\n", sampler, pname, param );
   funcs->ext.p_glSamplerParameteriv( sampler, pname, param );
 }
 
-static void WINAPI glScalexOES( GLfixed x, GLfixed y, GLfixed z ) {
+static void WINAPI glScalexOES( GLfixed x, GLfixed y, GLfixed z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", x, y, z );
+  TRACE( "(%d, %d, %d)\n", x, y, z );
   funcs->ext.p_glScalexOES( x, y, z );
 }
 
-static void WINAPI glScissorArrayv( GLuint first, GLsizei count, const GLint* v ) {
+static void WINAPI glScissorArrayv( GLuint first, GLsizei count, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", first, count, v );
+  TRACE( "(%d, %d, %p)\n", first, count, v );
   funcs->ext.p_glScissorArrayv( first, count, v );
 }
 
-static void WINAPI glScissorIndexed( GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height ) {
+static void WINAPI glScissorIndexed( GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", index, left, bottom, width, height );
+  TRACE( "(%d, %d, %d, %d, %d)\n", index, left, bottom, width, height );
   funcs->ext.p_glScissorIndexed( index, left, bottom, width, height );
 }
 
-static void WINAPI glScissorIndexedv( GLuint index, const GLint* v ) {
+static void WINAPI glScissorIndexedv( GLuint index, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glScissorIndexedv( index, v );
 }
 
-static void WINAPI glSecondaryColor3b( GLbyte red, GLbyte green, GLbyte blue ) {
+static void WINAPI glSecondaryColor3b( GLbyte red, GLbyte green, GLbyte blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->ext.p_glSecondaryColor3b( red, green, blue );
 }
 
-static void WINAPI glSecondaryColor3bEXT( GLbyte red, GLbyte green, GLbyte blue ) {
+static void WINAPI glSecondaryColor3bEXT( GLbyte red, GLbyte green, GLbyte blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->ext.p_glSecondaryColor3bEXT( red, green, blue );
 }
 
-static void WINAPI glSecondaryColor3bv( const GLbyte* v ) {
+static void WINAPI glSecondaryColor3bv( const GLbyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glSecondaryColor3bv( v );
 }
 
-static void WINAPI glSecondaryColor3bvEXT( const GLbyte* v ) {
+static void WINAPI glSecondaryColor3bvEXT( const GLbyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glSecondaryColor3bvEXT( v );
 }
 
-static void WINAPI glSecondaryColor3d( GLdouble red, GLdouble green, GLdouble blue ) {
+static void WINAPI glSecondaryColor3d( GLdouble red, GLdouble green, GLdouble blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", red, green, blue );
+  TRACE( "(%f, %f, %f)\n", red, green, blue );
   funcs->ext.p_glSecondaryColor3d( red, green, blue );
 }
 
-static void WINAPI glSecondaryColor3dEXT( GLdouble red, GLdouble green, GLdouble blue ) {
+static void WINAPI glSecondaryColor3dEXT( GLdouble red, GLdouble green, GLdouble blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", red, green, blue );
+  TRACE( "(%f, %f, %f)\n", red, green, blue );
   funcs->ext.p_glSecondaryColor3dEXT( red, green, blue );
 }
 
-static void WINAPI glSecondaryColor3dv( const GLdouble* v ) {
+static void WINAPI glSecondaryColor3dv( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glSecondaryColor3dv( v );
 }
 
-static void WINAPI glSecondaryColor3dvEXT( const GLdouble* v ) {
+static void WINAPI glSecondaryColor3dvEXT( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glSecondaryColor3dvEXT( v );
 }
 
-static void WINAPI glSecondaryColor3f( GLfloat red, GLfloat green, GLfloat blue ) {
+static void WINAPI glSecondaryColor3f( GLfloat red, GLfloat green, GLfloat blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", red, green, blue );
+  TRACE( "(%f, %f, %f)\n", red, green, blue );
   funcs->ext.p_glSecondaryColor3f( red, green, blue );
 }
 
-static void WINAPI glSecondaryColor3fEXT( GLfloat red, GLfloat green, GLfloat blue ) {
+static void WINAPI glSecondaryColor3fEXT( GLfloat red, GLfloat green, GLfloat blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", red, green, blue );
+  TRACE( "(%f, %f, %f)\n", red, green, blue );
   funcs->ext.p_glSecondaryColor3fEXT( red, green, blue );
 }
 
-static void WINAPI glSecondaryColor3fv( const GLfloat* v ) {
+static void WINAPI glSecondaryColor3fv( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glSecondaryColor3fv( v );
 }
 
-static void WINAPI glSecondaryColor3fvEXT( const GLfloat* v ) {
+static void WINAPI glSecondaryColor3fvEXT( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glSecondaryColor3fvEXT( v );
 }
 
-static void WINAPI glSecondaryColor3hNV( GLhalfNV red, GLhalfNV green, GLhalfNV blue ) {
+static void WINAPI glSecondaryColor3hNV( GLhalfNV red, GLhalfNV green, GLhalfNV blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->ext.p_glSecondaryColor3hNV( red, green, blue );
 }
 
-static void WINAPI glSecondaryColor3hvNV( const GLhalfNV* v ) {
+static void WINAPI glSecondaryColor3hvNV( const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glSecondaryColor3hvNV( v );
 }
 
-static void WINAPI glSecondaryColor3i( GLint red, GLint green, GLint blue ) {
+static void WINAPI glSecondaryColor3i( GLint red, GLint green, GLint blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->ext.p_glSecondaryColor3i( red, green, blue );
 }
 
-static void WINAPI glSecondaryColor3iEXT( GLint red, GLint green, GLint blue ) {
+static void WINAPI glSecondaryColor3iEXT( GLint red, GLint green, GLint blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->ext.p_glSecondaryColor3iEXT( red, green, blue );
 }
 
-static void WINAPI glSecondaryColor3iv( const GLint* v ) {
+static void WINAPI glSecondaryColor3iv( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glSecondaryColor3iv( v );
 }
 
-static void WINAPI glSecondaryColor3ivEXT( const GLint* v ) {
+static void WINAPI glSecondaryColor3ivEXT( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glSecondaryColor3ivEXT( v );
 }
 
-static void WINAPI glSecondaryColor3s( GLshort red, GLshort green, GLshort blue ) {
+static void WINAPI glSecondaryColor3s( GLshort red, GLshort green, GLshort blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->ext.p_glSecondaryColor3s( red, green, blue );
 }
 
-static void WINAPI glSecondaryColor3sEXT( GLshort red, GLshort green, GLshort blue ) {
+static void WINAPI glSecondaryColor3sEXT( GLshort red, GLshort green, GLshort blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->ext.p_glSecondaryColor3sEXT( red, green, blue );
 }
 
-static void WINAPI glSecondaryColor3sv( const GLshort* v ) {
+static void WINAPI glSecondaryColor3sv( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glSecondaryColor3sv( v );
 }
 
-static void WINAPI glSecondaryColor3svEXT( const GLshort* v ) {
+static void WINAPI glSecondaryColor3svEXT( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glSecondaryColor3svEXT( v );
 }
 
-static void WINAPI glSecondaryColor3ub( GLubyte red, GLubyte green, GLubyte blue ) {
+static void WINAPI glSecondaryColor3ub( GLubyte red, GLubyte green, GLubyte blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->ext.p_glSecondaryColor3ub( red, green, blue );
 }
 
-static void WINAPI glSecondaryColor3ubEXT( GLubyte red, GLubyte green, GLubyte blue ) {
+static void WINAPI glSecondaryColor3ubEXT( GLubyte red, GLubyte green, GLubyte blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->ext.p_glSecondaryColor3ubEXT( red, green, blue );
 }
 
-static void WINAPI glSecondaryColor3ubv( const GLubyte* v ) {
+static void WINAPI glSecondaryColor3ubv( const GLubyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glSecondaryColor3ubv( v );
 }
 
-static void WINAPI glSecondaryColor3ubvEXT( const GLubyte* v ) {
+static void WINAPI glSecondaryColor3ubvEXT( const GLubyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glSecondaryColor3ubvEXT( v );
 }
 
-static void WINAPI glSecondaryColor3ui( GLuint red, GLuint green, GLuint blue ) {
+static void WINAPI glSecondaryColor3ui( GLuint red, GLuint green, GLuint blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->ext.p_glSecondaryColor3ui( red, green, blue );
 }
 
-static void WINAPI glSecondaryColor3uiEXT( GLuint red, GLuint green, GLuint blue ) {
+static void WINAPI glSecondaryColor3uiEXT( GLuint red, GLuint green, GLuint blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->ext.p_glSecondaryColor3uiEXT( red, green, blue );
 }
 
-static void WINAPI glSecondaryColor3uiv( const GLuint* v ) {
+static void WINAPI glSecondaryColor3uiv( const GLuint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glSecondaryColor3uiv( v );
 }
 
-static void WINAPI glSecondaryColor3uivEXT( const GLuint* v ) {
+static void WINAPI glSecondaryColor3uivEXT( const GLuint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glSecondaryColor3uivEXT( v );
 }
 
-static void WINAPI glSecondaryColor3us( GLushort red, GLushort green, GLushort blue ) {
+static void WINAPI glSecondaryColor3us( GLushort red, GLushort green, GLushort blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->ext.p_glSecondaryColor3us( red, green, blue );
 }
 
-static void WINAPI glSecondaryColor3usEXT( GLushort red, GLushort green, GLushort blue ) {
+static void WINAPI glSecondaryColor3usEXT( GLushort red, GLushort green, GLushort blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->ext.p_glSecondaryColor3usEXT( red, green, blue );
 }
 
-static void WINAPI glSecondaryColor3usv( const GLushort* v ) {
+static void WINAPI glSecondaryColor3usv( const GLushort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glSecondaryColor3usv( v );
 }
 
-static void WINAPI glSecondaryColor3usvEXT( const GLushort* v ) {
+static void WINAPI glSecondaryColor3usvEXT( const GLushort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glSecondaryColor3usvEXT( v );
 }
 
-static void WINAPI glSecondaryColorFormatNV( GLint size, GLenum type, GLsizei stride ) {
+static void WINAPI glSecondaryColorFormatNV( GLint size, GLenum type, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", size, type, stride );
+  TRACE( "(%d, %d, %d)\n", size, type, stride );
   funcs->ext.p_glSecondaryColorFormatNV( size, type, stride );
 }
 
-static void WINAPI glSecondaryColorP3ui( GLenum type, GLuint color ) {
+static void WINAPI glSecondaryColorP3ui( GLenum type, GLuint color )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", type, color );
+  TRACE( "(%d, %d)\n", type, color );
   funcs->ext.p_glSecondaryColorP3ui( type, color );
 }
 
-static void WINAPI glSecondaryColorP3uiv( GLenum type, const GLuint* color ) {
+static void WINAPI glSecondaryColorP3uiv( GLenum type, const GLuint *color )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", type, color );
+  TRACE( "(%d, %p)\n", type, color );
   funcs->ext.p_glSecondaryColorP3uiv( type, color );
 }
 
-static void WINAPI glSecondaryColorPointer( GLint size, GLenum type, GLsizei stride, const void* pointer ) {
+static void WINAPI glSecondaryColorPointer( GLint size, GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer );
+  TRACE( "(%d, %d, %d, %p)\n", size, type, stride, pointer );
   funcs->ext.p_glSecondaryColorPointer( size, type, stride, pointer );
 }
 
-static void WINAPI glSecondaryColorPointerEXT( GLint size, GLenum type, GLsizei stride, const void* pointer ) {
+static void WINAPI glSecondaryColorPointerEXT( GLint size, GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer );
+  TRACE( "(%d, %d, %d, %p)\n", size, type, stride, pointer );
   funcs->ext.p_glSecondaryColorPointerEXT( size, type, stride, pointer );
 }
 
-static void WINAPI glSecondaryColorPointerListIBM( GLint size, GLenum type, GLint stride, const void** pointer, GLint ptrstride ) {
+static void WINAPI glSecondaryColorPointerListIBM( GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %d)\n", size, type, stride, pointer, ptrstride );
+  TRACE( "(%d, %d, %d, %p, %d)\n", size, type, stride, pointer, ptrstride );
   funcs->ext.p_glSecondaryColorPointerListIBM( size, type, stride, pointer, ptrstride );
 }
 
-static void WINAPI glSelectPerfMonitorCountersAMD( GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* counterList ) {
+static void WINAPI glSelectPerfMonitorCountersAMD( GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint *counterList )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", monitor, enable, group, numCounters, counterList );
+  TRACE( "(%d, %d, %d, %d, %p)\n", monitor, enable, group, numCounters, counterList );
   funcs->ext.p_glSelectPerfMonitorCountersAMD( monitor, enable, group, numCounters, counterList );
 }
 
-static void WINAPI glSelectTextureCoordSetSGIS( GLenum target ) {
+static void WINAPI glSelectTextureCoordSetSGIS( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   funcs->ext.p_glSelectTextureCoordSetSGIS( target );
 }
 
-static void WINAPI glSelectTextureSGIS( GLenum target ) {
+static void WINAPI glSelectTextureSGIS( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   funcs->ext.p_glSelectTextureSGIS( target );
 }
 
-static void WINAPI glSemaphoreParameterui64vEXT( GLuint semaphore, GLenum pname, const GLuint64* params ) {
+static void WINAPI glSemaphoreParameterui64vEXT( GLuint semaphore, GLenum pname, const GLuint64 *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", semaphore, pname, params );
+  TRACE( "(%d, %d, %p)\n", semaphore, pname, params );
   funcs->ext.p_glSemaphoreParameterui64vEXT( semaphore, pname, params );
 }
 
-static void WINAPI glSeparableFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* row, const void* column ) {
+static void WINAPI glSeparableFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %p, %p)\n", target, internalformat, width, height, format, type, row, column );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %p, %p)\n", target, internalformat, width, height, format, type, row, column );
   funcs->ext.p_glSeparableFilter2D( target, internalformat, width, height, format, type, row, column );
 }
 
-static void WINAPI glSeparableFilter2DEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* row, const void* column ) {
+static void WINAPI glSeparableFilter2DEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %p, %p)\n", target, internalformat, width, height, format, type, row, column );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %p, %p)\n", target, internalformat, width, height, format, type, row, column );
   funcs->ext.p_glSeparableFilter2DEXT( target, internalformat, width, height, format, type, row, column );
 }
 
-static void WINAPI glSetFenceAPPLE( GLuint fence ) {
+static void WINAPI glSetFenceAPPLE( GLuint fence )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", fence );
+  TRACE( "(%d)\n", fence );
   funcs->ext.p_glSetFenceAPPLE( fence );
 }
 
-static void WINAPI glSetFenceNV( GLuint fence, GLenum condition ) {
+static void WINAPI glSetFenceNV( GLuint fence, GLenum condition )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", fence, condition );
+  TRACE( "(%d, %d)\n", fence, condition );
   funcs->ext.p_glSetFenceNV( fence, condition );
 }
 
-static void WINAPI glSetFragmentShaderConstantATI( GLuint dst, const GLfloat* value ) {
+static void WINAPI glSetFragmentShaderConstantATI( GLuint dst, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", dst, value );
+  TRACE( "(%d, %p)\n", dst, value );
   funcs->ext.p_glSetFragmentShaderConstantATI( dst, value );
 }
 
-static void WINAPI glSetInvariantEXT( GLuint id, GLenum type, const void* addr ) {
+static void WINAPI glSetInvariantEXT( GLuint id, GLenum type, const void *addr )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, type, addr );
+  TRACE( "(%d, %d, %p)\n", id, type, addr );
   funcs->ext.p_glSetInvariantEXT( id, type, addr );
 }
 
-static void WINAPI glSetLocalConstantEXT( GLuint id, GLenum type, const void* addr ) {
+static void WINAPI glSetLocalConstantEXT( GLuint id, GLenum type, const void *addr )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", id, type, addr );
+  TRACE( "(%d, %d, %p)\n", id, type, addr );
   funcs->ext.p_glSetLocalConstantEXT( id, type, addr );
 }
 
-static void WINAPI glSetMultisamplefvAMD( GLenum pname, GLuint index, const GLfloat* val ) {
+static void WINAPI glSetMultisamplefvAMD( GLenum pname, GLuint index, const GLfloat *val )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", pname, index, val );
+  TRACE( "(%d, %d, %p)\n", pname, index, val );
   funcs->ext.p_glSetMultisamplefvAMD( pname, index, val );
 }
 
-static void WINAPI glShaderBinary( GLsizei count, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length ) {
+static void WINAPI glShaderBinary( GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %d, %p, %d)\n", count, shaders, binaryformat, binary, length );
+  TRACE( "(%d, %p, %d, %p, %d)\n", count, shaders, binaryformat, binary, length );
   funcs->ext.p_glShaderBinary( count, shaders, binaryformat, binary, length );
 }
 
-static void WINAPI glShaderOp1EXT( GLenum op, GLuint res, GLuint arg1 ) {
+static void WINAPI glShaderOp1EXT( GLenum op, GLuint res, GLuint arg1 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", op, res, arg1 );
+  TRACE( "(%d, %d, %d)\n", op, res, arg1 );
   funcs->ext.p_glShaderOp1EXT( op, res, arg1 );
 }
 
-static void WINAPI glShaderOp2EXT( GLenum op, GLuint res, GLuint arg1, GLuint arg2 ) {
+static void WINAPI glShaderOp2EXT( GLenum op, GLuint res, GLuint arg1, GLuint arg2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", op, res, arg1, arg2 );
+  TRACE( "(%d, %d, %d, %d)\n", op, res, arg1, arg2 );
   funcs->ext.p_glShaderOp2EXT( op, res, arg1, arg2 );
 }
 
-static void WINAPI glShaderOp3EXT( GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3 ) {
+static void WINAPI glShaderOp3EXT( GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", op, res, arg1, arg2, arg3 );
+  TRACE( "(%d, %d, %d, %d, %d)\n", op, res, arg1, arg2, arg3 );
   funcs->ext.p_glShaderOp3EXT( op, res, arg1, arg2, arg3 );
 }
 
-static void WINAPI glShaderSource( GLuint shader, GLsizei count, const GLchar*const* string, const GLint* length ) {
+static void WINAPI glShaderSource( GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", shader, count, string, length );
+  TRACE( "(%d, %d, %p, %p)\n", shader, count, string, length );
   funcs->ext.p_glShaderSource( shader, count, string, length );
 }
 
-static void WINAPI glShaderSourceARB( GLhandleARB shaderObj, GLsizei count, const GLcharARB** string, const GLint* length ) {
+static void WINAPI glShaderSourceARB( GLhandleARB shaderObj, GLsizei count, const GLcharARB **string, const GLint *length )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", shaderObj, count, string, length );
+  TRACE( "(%d, %d, %p, %p)\n", shaderObj, count, string, length );
   funcs->ext.p_glShaderSourceARB( shaderObj, count, string, length );
 }
 
-static void WINAPI glShaderStorageBlockBinding( GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding ) {
+static void WINAPI glShaderStorageBlockBinding( GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", program, storageBlockIndex, storageBlockBinding );
+  TRACE( "(%d, %d, %d)\n", program, storageBlockIndex, storageBlockBinding );
   funcs->ext.p_glShaderStorageBlockBinding( program, storageBlockIndex, storageBlockBinding );
 }
 
-static void WINAPI glSharpenTexFuncSGIS( GLenum target, GLsizei n, const GLfloat* points ) {
+static void WINAPI glSharpenTexFuncSGIS( GLenum target, GLsizei n, const GLfloat *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, n, points );
+  TRACE( "(%d, %d, %p)\n", target, n, points );
   funcs->ext.p_glSharpenTexFuncSGIS( target, n, points );
 }
 
-static void WINAPI glSignalSemaphoreEXT( GLuint semaphore, GLuint numBufferBarriers, const GLuint* buffers, GLuint numTextureBarriers, const GLuint* textures, const GLenum* dstLayouts ) {
+static void WINAPI glSignalSemaphoreEXT( GLuint semaphore, GLuint numBufferBarriers, const GLuint *buffers, GLuint numTextureBarriers, const GLuint *textures, const GLenum *dstLayouts )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %p, %p)\n", semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts );
+  TRACE( "(%d, %d, %p, %d, %p, %p)\n", semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts );
   funcs->ext.p_glSignalSemaphoreEXT( semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts );
 }
 
-static void WINAPI glSignalVkFenceNV( GLuint64 vkFence ) {
+static void WINAPI glSignalVkFenceNV( GLuint64 vkFence )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%s)\n", wine_dbgstr_longlong(vkFence) );
+  TRACE( "(%s)\n", wine_dbgstr_longlong(vkFence) );
   funcs->ext.p_glSignalVkFenceNV( vkFence );
 }
 
-static void WINAPI glSignalVkSemaphoreNV( GLuint64 vkSemaphore ) {
+static void WINAPI glSignalVkSemaphoreNV( GLuint64 vkSemaphore )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%s)\n", wine_dbgstr_longlong(vkSemaphore) );
+  TRACE( "(%s)\n", wine_dbgstr_longlong(vkSemaphore) );
   funcs->ext.p_glSignalVkSemaphoreNV( vkSemaphore );
 }
 
-static void WINAPI glSpecializeShader( GLuint shader, const GLchar* pEntryPoint, GLuint numSpecializationConstants, const GLuint* pConstantIndex, const GLuint* pConstantValue ) {
+static void WINAPI glSpecializeShader( GLuint shader, const GLchar *pEntryPoint, GLuint numSpecializationConstants, const GLuint *pConstantIndex, const GLuint *pConstantValue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %d, %p, %p)\n", shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue );
+  TRACE( "(%d, %p, %d, %p, %p)\n", shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue );
   funcs->ext.p_glSpecializeShader( shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue );
 }
 
-static void WINAPI glSpecializeShaderARB( GLuint shader, const GLchar* pEntryPoint, GLuint numSpecializationConstants, const GLuint* pConstantIndex, const GLuint* pConstantValue ) {
+static void WINAPI glSpecializeShaderARB( GLuint shader, const GLchar *pEntryPoint, GLuint numSpecializationConstants, const GLuint *pConstantIndex, const GLuint *pConstantValue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %d, %p, %p)\n", shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue );
+  TRACE( "(%d, %p, %d, %p, %p)\n", shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue );
   funcs->ext.p_glSpecializeShaderARB( shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue );
 }
 
-static void WINAPI glSpriteParameterfSGIX( GLenum pname, GLfloat param ) {
+static void WINAPI glSpriteParameterfSGIX( GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", pname, param );
+  TRACE( "(%d, %f)\n", pname, param );
   funcs->ext.p_glSpriteParameterfSGIX( pname, param );
 }
 
-static void WINAPI glSpriteParameterfvSGIX( GLenum pname, const GLfloat* params ) {
+static void WINAPI glSpriteParameterfvSGIX( GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glSpriteParameterfvSGIX( pname, params );
 }
 
-static void WINAPI glSpriteParameteriSGIX( GLenum pname, GLint param ) {
+static void WINAPI glSpriteParameteriSGIX( GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->ext.p_glSpriteParameteriSGIX( pname, param );
 }
 
-static void WINAPI glSpriteParameterivSGIX( GLenum pname, const GLint* params ) {
+static void WINAPI glSpriteParameterivSGIX( GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->ext.p_glSpriteParameterivSGIX( pname, params );
 }
 
-static void WINAPI glStartInstrumentsSGIX( void ) {
+static void WINAPI glStartInstrumentsSGIX(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glStartInstrumentsSGIX( );
+  TRACE( "()\n" );
+  funcs->ext.p_glStartInstrumentsSGIX();
 }
 
-static void WINAPI glStateCaptureNV( GLuint state, GLenum mode ) {
+static void WINAPI glStateCaptureNV( GLuint state, GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", state, mode );
+  TRACE( "(%d, %d)\n", state, mode );
   funcs->ext.p_glStateCaptureNV( state, mode );
 }
 
-static void WINAPI glStencilClearTagEXT( GLsizei stencilTagBits, GLuint stencilClearTag ) {
+static void WINAPI glStencilClearTagEXT( GLsizei stencilTagBits, GLuint stencilClearTag )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", stencilTagBits, stencilClearTag );
+  TRACE( "(%d, %d)\n", stencilTagBits, stencilClearTag );
   funcs->ext.p_glStencilClearTagEXT( stencilTagBits, stencilClearTag );
 }
 
-static void WINAPI glStencilFillPathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, const GLfloat* transformValues ) {
+static void WINAPI glStencilFillPathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, const GLfloat *transformValues )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %d, %d, %d, %p)\n", numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues );
+  TRACE( "(%d, %d, %p, %d, %d, %d, %d, %p)\n", numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues );
   funcs->ext.p_glStencilFillPathInstancedNV( numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues );
 }
 
-static void WINAPI glStencilFillPathNV( GLuint path, GLenum fillMode, GLuint mask ) {
+static void WINAPI glStencilFillPathNV( GLuint path, GLenum fillMode, GLuint mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", path, fillMode, mask );
+  TRACE( "(%d, %d, %d)\n", path, fillMode, mask );
   funcs->ext.p_glStencilFillPathNV( path, fillMode, mask );
 }
 
-static void WINAPI glStencilFuncSeparate( GLenum face, GLenum func, GLint ref, GLuint mask ) {
+static void WINAPI glStencilFuncSeparate( GLenum face, GLenum func, GLint ref, GLuint mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", face, func, ref, mask );
+  TRACE( "(%d, %d, %d, %d)\n", face, func, ref, mask );
   funcs->ext.p_glStencilFuncSeparate( face, func, ref, mask );
 }
 
-static void WINAPI glStencilFuncSeparateATI( GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask ) {
+static void WINAPI glStencilFuncSeparateATI( GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", frontfunc, backfunc, ref, mask );
+  TRACE( "(%d, %d, %d, %d)\n", frontfunc, backfunc, ref, mask );
   funcs->ext.p_glStencilFuncSeparateATI( frontfunc, backfunc, ref, mask );
 }
 
-static void WINAPI glStencilMaskSeparate( GLenum face, GLuint mask ) {
+static void WINAPI glStencilMaskSeparate( GLenum face, GLuint mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", face, mask );
+  TRACE( "(%d, %d)\n", face, mask );
   funcs->ext.p_glStencilMaskSeparate( face, mask );
 }
 
-static void WINAPI glStencilOpSeparate( GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass ) {
+static void WINAPI glStencilOpSeparate( GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", face, sfail, dpfail, dppass );
+  TRACE( "(%d, %d, %d, %d)\n", face, sfail, dpfail, dppass );
   funcs->ext.p_glStencilOpSeparate( face, sfail, dpfail, dppass );
 }
 
-static void WINAPI glStencilOpSeparateATI( GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass ) {
+static void WINAPI glStencilOpSeparateATI( GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", face, sfail, dpfail, dppass );
+  TRACE( "(%d, %d, %d, %d)\n", face, sfail, dpfail, dppass );
   funcs->ext.p_glStencilOpSeparateATI( face, sfail, dpfail, dppass );
 }
 
-static void WINAPI glStencilOpValueAMD( GLenum face, GLuint value ) {
+static void WINAPI glStencilOpValueAMD( GLenum face, GLuint value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", face, value );
+  TRACE( "(%d, %d)\n", face, value );
   funcs->ext.p_glStencilOpValueAMD( face, value );
 }
 
-static void WINAPI glStencilStrokePathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, const GLfloat* transformValues ) {
+static void WINAPI glStencilStrokePathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, const GLfloat *transformValues )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %d, %d, %d, %p)\n", numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues );
+  TRACE( "(%d, %d, %p, %d, %d, %d, %d, %p)\n", numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues );
   funcs->ext.p_glStencilStrokePathInstancedNV( numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues );
 }
 
-static void WINAPI glStencilStrokePathNV( GLuint path, GLint reference, GLuint mask ) {
+static void WINAPI glStencilStrokePathNV( GLuint path, GLint reference, GLuint mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", path, reference, mask );
+  TRACE( "(%d, %d, %d)\n", path, reference, mask );
   funcs->ext.p_glStencilStrokePathNV( path, reference, mask );
 }
 
-static void WINAPI glStencilThenCoverFillPathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat* transformValues ) {
+static void WINAPI glStencilThenCoverFillPathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat *transformValues )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %d, %d, %d, %d, %p)\n", numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues );
+  TRACE( "(%d, %d, %p, %d, %d, %d, %d, %d, %p)\n", numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues );
   funcs->ext.p_glStencilThenCoverFillPathInstancedNV( numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues );
 }
 
-static void WINAPI glStencilThenCoverFillPathNV( GLuint path, GLenum fillMode, GLuint mask, GLenum coverMode ) {
+static void WINAPI glStencilThenCoverFillPathNV( GLuint path, GLenum fillMode, GLuint mask, GLenum coverMode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", path, fillMode, mask, coverMode );
+  TRACE( "(%d, %d, %d, %d)\n", path, fillMode, mask, coverMode );
   funcs->ext.p_glStencilThenCoverFillPathNV( path, fillMode, mask, coverMode );
 }
 
-static void WINAPI glStencilThenCoverStrokePathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLint reference, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat* transformValues ) {
+static void WINAPI glStencilThenCoverStrokePathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLint reference, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat *transformValues )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %d, %d, %d, %d, %p)\n", numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues );
+  TRACE( "(%d, %d, %p, %d, %d, %d, %d, %d, %p)\n", numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues );
   funcs->ext.p_glStencilThenCoverStrokePathInstancedNV( numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues );
 }
 
-static void WINAPI glStencilThenCoverStrokePathNV( GLuint path, GLint reference, GLuint mask, GLenum coverMode ) {
+static void WINAPI glStencilThenCoverStrokePathNV( GLuint path, GLint reference, GLuint mask, GLenum coverMode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", path, reference, mask, coverMode );
+  TRACE( "(%d, %d, %d, %d)\n", path, reference, mask, coverMode );
   funcs->ext.p_glStencilThenCoverStrokePathNV( path, reference, mask, coverMode );
 }
 
-static void WINAPI glStopInstrumentsSGIX( GLint marker ) {
+static void WINAPI glStopInstrumentsSGIX( GLint marker )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", marker );
+  TRACE( "(%d)\n", marker );
   funcs->ext.p_glStopInstrumentsSGIX( marker );
 }
 
-static void WINAPI glStringMarkerGREMEDY( GLsizei len, const void* string ) {
+static void WINAPI glStringMarkerGREMEDY( GLsizei len, const void *string )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", len, string );
+  TRACE( "(%d, %p)\n", len, string );
   funcs->ext.p_glStringMarkerGREMEDY( len, string );
 }
 
-static void WINAPI glSubpixelPrecisionBiasNV( GLuint xbits, GLuint ybits ) {
+static void WINAPI glSubpixelPrecisionBiasNV( GLuint xbits, GLuint ybits )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", xbits, ybits );
+  TRACE( "(%d, %d)\n", xbits, ybits );
   funcs->ext.p_glSubpixelPrecisionBiasNV( xbits, ybits );
 }
 
-static void WINAPI glSwizzleEXT( GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW ) {
+static void WINAPI glSwizzleEXT( GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", res, in, outX, outY, outZ, outW );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", res, in, outX, outY, outZ, outW );
   funcs->ext.p_glSwizzleEXT( res, in, outX, outY, outZ, outW );
 }
 
-static void WINAPI glSyncTextureINTEL( GLuint texture ) {
+static void WINAPI glSyncTextureINTEL( GLuint texture )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", texture );
+  TRACE( "(%d)\n", texture );
   funcs->ext.p_glSyncTextureINTEL( texture );
 }
 
-static void WINAPI glTagSampleBufferSGIX( void ) {
+static void WINAPI glTagSampleBufferSGIX(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glTagSampleBufferSGIX( );
+  TRACE( "()\n" );
+  funcs->ext.p_glTagSampleBufferSGIX();
 }
 
-static void WINAPI glTangent3bEXT( GLbyte tx, GLbyte ty, GLbyte tz ) {
+static void WINAPI glTangent3bEXT( GLbyte tx, GLbyte ty, GLbyte tz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", tx, ty, tz );
+  TRACE( "(%d, %d, %d)\n", tx, ty, tz );
   funcs->ext.p_glTangent3bEXT( tx, ty, tz );
 }
 
-static void WINAPI glTangent3bvEXT( const GLbyte* v ) {
+static void WINAPI glTangent3bvEXT( const GLbyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glTangent3bvEXT( v );
 }
 
-static void WINAPI glTangent3dEXT( GLdouble tx, GLdouble ty, GLdouble tz ) {
+static void WINAPI glTangent3dEXT( GLdouble tx, GLdouble ty, GLdouble tz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", tx, ty, tz );
+  TRACE( "(%f, %f, %f)\n", tx, ty, tz );
   funcs->ext.p_glTangent3dEXT( tx, ty, tz );
 }
 
-static void WINAPI glTangent3dvEXT( const GLdouble* v ) {
+static void WINAPI glTangent3dvEXT( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glTangent3dvEXT( v );
 }
 
-static void WINAPI glTangent3fEXT( GLfloat tx, GLfloat ty, GLfloat tz ) {
+static void WINAPI glTangent3fEXT( GLfloat tx, GLfloat ty, GLfloat tz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", tx, ty, tz );
+  TRACE( "(%f, %f, %f)\n", tx, ty, tz );
   funcs->ext.p_glTangent3fEXT( tx, ty, tz );
 }
 
-static void WINAPI glTangent3fvEXT( const GLfloat* v ) {
+static void WINAPI glTangent3fvEXT( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glTangent3fvEXT( v );
 }
 
-static void WINAPI glTangent3iEXT( GLint tx, GLint ty, GLint tz ) {
+static void WINAPI glTangent3iEXT( GLint tx, GLint ty, GLint tz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", tx, ty, tz );
+  TRACE( "(%d, %d, %d)\n", tx, ty, tz );
   funcs->ext.p_glTangent3iEXT( tx, ty, tz );
 }
 
-static void WINAPI glTangent3ivEXT( const GLint* v ) {
+static void WINAPI glTangent3ivEXT( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glTangent3ivEXT( v );
 }
 
-static void WINAPI glTangent3sEXT( GLshort tx, GLshort ty, GLshort tz ) {
+static void WINAPI glTangent3sEXT( GLshort tx, GLshort ty, GLshort tz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", tx, ty, tz );
+  TRACE( "(%d, %d, %d)\n", tx, ty, tz );
   funcs->ext.p_glTangent3sEXT( tx, ty, tz );
 }
 
-static void WINAPI glTangent3svEXT( const GLshort* v ) {
+static void WINAPI glTangent3svEXT( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glTangent3svEXT( v );
 }
 
-static void WINAPI glTangentPointerEXT( GLenum type, GLsizei stride, const void* pointer ) {
+static void WINAPI glTangentPointerEXT( GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", type, stride, pointer );
+  TRACE( "(%d, %d, %p)\n", type, stride, pointer );
   funcs->ext.p_glTangentPointerEXT( type, stride, pointer );
 }
 
-static void WINAPI glTbufferMask3DFX( GLuint mask ) {
+static void WINAPI glTbufferMask3DFX( GLuint mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mask );
+  TRACE( "(%d)\n", mask );
   funcs->ext.p_glTbufferMask3DFX( mask );
 }
 
-static void WINAPI glTessellationFactorAMD( GLfloat factor ) {
+static void WINAPI glTessellationFactorAMD( GLfloat factor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", factor );
+  TRACE( "(%f)\n", factor );
   funcs->ext.p_glTessellationFactorAMD( factor );
 }
 
-static void WINAPI glTessellationModeAMD( GLenum mode ) {
+static void WINAPI glTessellationModeAMD( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   funcs->ext.p_glTessellationModeAMD( mode );
 }
 
-static GLboolean WINAPI glTestFenceAPPLE( GLuint fence ) {
+static GLboolean WINAPI glTestFenceAPPLE( GLuint fence )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", fence );
+  TRACE( "(%d)\n", fence );
   return funcs->ext.p_glTestFenceAPPLE( fence );
 }
 
-static GLboolean WINAPI glTestFenceNV( GLuint fence ) {
+static GLboolean WINAPI glTestFenceNV( GLuint fence )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", fence );
+  TRACE( "(%d)\n", fence );
   return funcs->ext.p_glTestFenceNV( fence );
 }
 
-static GLboolean WINAPI glTestObjectAPPLE( GLenum object, GLuint name ) {
+static GLboolean WINAPI glTestObjectAPPLE( GLenum object, GLuint name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", object, name );
+  TRACE( "(%d, %d)\n", object, name );
   return funcs->ext.p_glTestObjectAPPLE( object, name );
 }
 
-static void WINAPI glTexBuffer( GLenum target, GLenum internalformat, GLuint buffer ) {
+static void WINAPI glTexBuffer( GLenum target, GLenum internalformat, GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, internalformat, buffer );
+  TRACE( "(%d, %d, %d)\n", target, internalformat, buffer );
   funcs->ext.p_glTexBuffer( target, internalformat, buffer );
 }
 
-static void WINAPI glTexBufferARB( GLenum target, GLenum internalformat, GLuint buffer ) {
+static void WINAPI glTexBufferARB( GLenum target, GLenum internalformat, GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, internalformat, buffer );
+  TRACE( "(%d, %d, %d)\n", target, internalformat, buffer );
   funcs->ext.p_glTexBufferARB( target, internalformat, buffer );
 }
 
-static void WINAPI glTexBufferEXT( GLenum target, GLenum internalformat, GLuint buffer ) {
+static void WINAPI glTexBufferEXT( GLenum target, GLenum internalformat, GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, internalformat, buffer );
+  TRACE( "(%d, %d, %d)\n", target, internalformat, buffer );
   funcs->ext.p_glTexBufferEXT( target, internalformat, buffer );
 }
 
-static void WINAPI glTexBufferRange( GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size ) {
+static void WINAPI glTexBufferRange( GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %ld, %ld)\n", target, internalformat, buffer, offset, size );
+  TRACE( "(%d, %d, %d, %ld, %ld)\n", target, internalformat, buffer, offset, size );
   funcs->ext.p_glTexBufferRange( target, internalformat, buffer, offset, size );
 }
 
-static void WINAPI glTexBumpParameterfvATI( GLenum pname, const GLfloat* param ) {
+static void WINAPI glTexBumpParameterfvATI( GLenum pname, const GLfloat *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, param );
+  TRACE( "(%d, %p)\n", pname, param );
   funcs->ext.p_glTexBumpParameterfvATI( pname, param );
 }
 
-static void WINAPI glTexBumpParameterivATI( GLenum pname, const GLint* param ) {
+static void WINAPI glTexBumpParameterivATI( GLenum pname, const GLint *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, param );
+  TRACE( "(%d, %p)\n", pname, param );
   funcs->ext.p_glTexBumpParameterivATI( pname, param );
 }
 
-static void WINAPI glTexCoord1bOES( GLbyte s ) {
+static void WINAPI glTexCoord1bOES( GLbyte s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", s );
+  TRACE( "(%d)\n", s );
   funcs->ext.p_glTexCoord1bOES( s );
 }
 
-static void WINAPI glTexCoord1bvOES( const GLbyte* coords ) {
+static void WINAPI glTexCoord1bvOES( const GLbyte *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glTexCoord1bvOES( coords );
 }
 
-static void WINAPI glTexCoord1hNV( GLhalfNV s ) {
+static void WINAPI glTexCoord1hNV( GLhalfNV s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", s );
+  TRACE( "(%d)\n", s );
   funcs->ext.p_glTexCoord1hNV( s );
 }
 
-static void WINAPI glTexCoord1hvNV( const GLhalfNV* v ) {
+static void WINAPI glTexCoord1hvNV( const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glTexCoord1hvNV( v );
 }
 
-static void WINAPI glTexCoord1xOES( GLfixed s ) {
+static void WINAPI glTexCoord1xOES( GLfixed s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", s );
+  TRACE( "(%d)\n", s );
   funcs->ext.p_glTexCoord1xOES( s );
 }
 
-static void WINAPI glTexCoord1xvOES( const GLfixed* coords ) {
+static void WINAPI glTexCoord1xvOES( const GLfixed *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glTexCoord1xvOES( coords );
 }
 
-static void WINAPI glTexCoord2bOES( GLbyte s, GLbyte t ) {
+static void WINAPI glTexCoord2bOES( GLbyte s, GLbyte t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", s, t );
+  TRACE( "(%d, %d)\n", s, t );
   funcs->ext.p_glTexCoord2bOES( s, t );
 }
 
-static void WINAPI glTexCoord2bvOES( const GLbyte* coords ) {
+static void WINAPI glTexCoord2bvOES( const GLbyte *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glTexCoord2bvOES( coords );
 }
 
-static void WINAPI glTexCoord2fColor3fVertex3fSUN( GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glTexCoord2fColor3fVertex3fSUN( GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, r, g, b, x, y, z );
+  TRACE( "(%f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, r, g, b, x, y, z );
   funcs->ext.p_glTexCoord2fColor3fVertex3fSUN( s, t, r, g, b, x, y, z );
 }
 
-static void WINAPI glTexCoord2fColor3fVertex3fvSUN( const GLfloat* tc, const GLfloat* c, const GLfloat* v ) {
+static void WINAPI glTexCoord2fColor3fVertex3fvSUN( const GLfloat *tc, const GLfloat *c, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p, %p)\n", tc, c, v );
+  TRACE( "(%p, %p, %p)\n", tc, c, v );
   funcs->ext.p_glTexCoord2fColor3fVertex3fvSUN( tc, c, v );
 }
 
-static void WINAPI glTexCoord2fColor4fNormal3fVertex3fSUN( GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glTexCoord2fColor4fNormal3fVertex3fSUN( GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, r, g, b, a, nx, ny, nz, x, y, z );
+  TRACE( "(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, r, g, b, a, nx, ny, nz, x, y, z );
   funcs->ext.p_glTexCoord2fColor4fNormal3fVertex3fSUN( s, t, r, g, b, a, nx, ny, nz, x, y, z );
 }
 
-static void WINAPI glTexCoord2fColor4fNormal3fVertex3fvSUN( const GLfloat* tc, const GLfloat* c, const GLfloat* n, const GLfloat* v ) {
+static void WINAPI glTexCoord2fColor4fNormal3fVertex3fvSUN( const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p, %p, %p)\n", tc, c, n, v );
+  TRACE( "(%p, %p, %p, %p)\n", tc, c, n, v );
   funcs->ext.p_glTexCoord2fColor4fNormal3fVertex3fvSUN( tc, c, n, v );
 }
 
-static void WINAPI glTexCoord2fColor4ubVertex3fSUN( GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glTexCoord2fColor4ubVertex3fSUN( GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %d, %d, %d, %d, %f, %f, %f)\n", s, t, r, g, b, a, x, y, z );
+  TRACE( "(%f, %f, %d, %d, %d, %d, %f, %f, %f)\n", s, t, r, g, b, a, x, y, z );
   funcs->ext.p_glTexCoord2fColor4ubVertex3fSUN( s, t, r, g, b, a, x, y, z );
 }
 
-static void WINAPI glTexCoord2fColor4ubVertex3fvSUN( const GLfloat* tc, const GLubyte* c, const GLfloat* v ) {
+static void WINAPI glTexCoord2fColor4ubVertex3fvSUN( const GLfloat *tc, const GLubyte *c, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p, %p)\n", tc, c, v );
+  TRACE( "(%p, %p, %p)\n", tc, c, v );
   funcs->ext.p_glTexCoord2fColor4ubVertex3fvSUN( tc, c, v );
 }
 
-static void WINAPI glTexCoord2fNormal3fVertex3fSUN( GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glTexCoord2fNormal3fVertex3fSUN( GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, nx, ny, nz, x, y, z );
+  TRACE( "(%f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, nx, ny, nz, x, y, z );
   funcs->ext.p_glTexCoord2fNormal3fVertex3fSUN( s, t, nx, ny, nz, x, y, z );
 }
 
-static void WINAPI glTexCoord2fNormal3fVertex3fvSUN( const GLfloat* tc, const GLfloat* n, const GLfloat* v ) {
+static void WINAPI glTexCoord2fNormal3fVertex3fvSUN( const GLfloat *tc, const GLfloat *n, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p, %p)\n", tc, n, v );
+  TRACE( "(%p, %p, %p)\n", tc, n, v );
   funcs->ext.p_glTexCoord2fNormal3fVertex3fvSUN( tc, n, v );
 }
 
-static void WINAPI glTexCoord2fVertex3fSUN( GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glTexCoord2fVertex3fSUN( GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f, %f)\n", s, t, x, y, z );
+  TRACE( "(%f, %f, %f, %f, %f)\n", s, t, x, y, z );
   funcs->ext.p_glTexCoord2fVertex3fSUN( s, t, x, y, z );
 }
 
-static void WINAPI glTexCoord2fVertex3fvSUN( const GLfloat* tc, const GLfloat* v ) {
+static void WINAPI glTexCoord2fVertex3fvSUN( const GLfloat *tc, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", tc, v );
+  TRACE( "(%p, %p)\n", tc, v );
   funcs->ext.p_glTexCoord2fVertex3fvSUN( tc, v );
 }
 
-static void WINAPI glTexCoord2hNV( GLhalfNV s, GLhalfNV t ) {
+static void WINAPI glTexCoord2hNV( GLhalfNV s, GLhalfNV t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", s, t );
+  TRACE( "(%d, %d)\n", s, t );
   funcs->ext.p_glTexCoord2hNV( s, t );
 }
 
-static void WINAPI glTexCoord2hvNV( const GLhalfNV* v ) {
+static void WINAPI glTexCoord2hvNV( const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glTexCoord2hvNV( v );
 }
 
-static void WINAPI glTexCoord2xOES( GLfixed s, GLfixed t ) {
+static void WINAPI glTexCoord2xOES( GLfixed s, GLfixed t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", s, t );
+  TRACE( "(%d, %d)\n", s, t );
   funcs->ext.p_glTexCoord2xOES( s, t );
 }
 
-static void WINAPI glTexCoord2xvOES( const GLfixed* coords ) {
+static void WINAPI glTexCoord2xvOES( const GLfixed *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glTexCoord2xvOES( coords );
 }
 
-static void WINAPI glTexCoord3bOES( GLbyte s, GLbyte t, GLbyte r ) {
+static void WINAPI glTexCoord3bOES( GLbyte s, GLbyte t, GLbyte r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", s, t, r );
+  TRACE( "(%d, %d, %d)\n", s, t, r );
   funcs->ext.p_glTexCoord3bOES( s, t, r );
 }
 
-static void WINAPI glTexCoord3bvOES( const GLbyte* coords ) {
+static void WINAPI glTexCoord3bvOES( const GLbyte *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glTexCoord3bvOES( coords );
 }
 
-static void WINAPI glTexCoord3hNV( GLhalfNV s, GLhalfNV t, GLhalfNV r ) {
+static void WINAPI glTexCoord3hNV( GLhalfNV s, GLhalfNV t, GLhalfNV r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", s, t, r );
+  TRACE( "(%d, %d, %d)\n", s, t, r );
   funcs->ext.p_glTexCoord3hNV( s, t, r );
 }
 
-static void WINAPI glTexCoord3hvNV( const GLhalfNV* v ) {
+static void WINAPI glTexCoord3hvNV( const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glTexCoord3hvNV( v );
 }
 
-static void WINAPI glTexCoord3xOES( GLfixed s, GLfixed t, GLfixed r ) {
+static void WINAPI glTexCoord3xOES( GLfixed s, GLfixed t, GLfixed r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", s, t, r );
+  TRACE( "(%d, %d, %d)\n", s, t, r );
   funcs->ext.p_glTexCoord3xOES( s, t, r );
 }
 
-static void WINAPI glTexCoord3xvOES( const GLfixed* coords ) {
+static void WINAPI glTexCoord3xvOES( const GLfixed *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glTexCoord3xvOES( coords );
 }
 
-static void WINAPI glTexCoord4bOES( GLbyte s, GLbyte t, GLbyte r, GLbyte q ) {
+static void WINAPI glTexCoord4bOES( GLbyte s, GLbyte t, GLbyte r, GLbyte q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", s, t, r, q );
+  TRACE( "(%d, %d, %d, %d)\n", s, t, r, q );
   funcs->ext.p_glTexCoord4bOES( s, t, r, q );
 }
 
-static void WINAPI glTexCoord4bvOES( const GLbyte* coords ) {
+static void WINAPI glTexCoord4bvOES( const GLbyte *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glTexCoord4bvOES( coords );
 }
 
-static void WINAPI glTexCoord4fColor4fNormal3fVertex4fSUN( GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+static void WINAPI glTexCoord4fColor4fNormal3fVertex4fSUN( GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w );
+  TRACE( "(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w );
   funcs->ext.p_glTexCoord4fColor4fNormal3fVertex4fSUN( s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w );
 }
 
-static void WINAPI glTexCoord4fColor4fNormal3fVertex4fvSUN( const GLfloat* tc, const GLfloat* c, const GLfloat* n, const GLfloat* v ) {
+static void WINAPI glTexCoord4fColor4fNormal3fVertex4fvSUN( const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p, %p, %p)\n", tc, c, n, v );
+  TRACE( "(%p, %p, %p, %p)\n", tc, c, n, v );
   funcs->ext.p_glTexCoord4fColor4fNormal3fVertex4fvSUN( tc, c, n, v );
 }
 
-static void WINAPI glTexCoord4fVertex4fSUN( GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+static void WINAPI glTexCoord4fVertex4fSUN( GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, p, q, x, y, z, w );
+  TRACE( "(%f, %f, %f, %f, %f, %f, %f, %f)\n", s, t, p, q, x, y, z, w );
   funcs->ext.p_glTexCoord4fVertex4fSUN( s, t, p, q, x, y, z, w );
 }
 
-static void WINAPI glTexCoord4fVertex4fvSUN( const GLfloat* tc, const GLfloat* v ) {
+static void WINAPI glTexCoord4fVertex4fvSUN( const GLfloat *tc, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", tc, v );
+  TRACE( "(%p, %p)\n", tc, v );
   funcs->ext.p_glTexCoord4fVertex4fvSUN( tc, v );
 }
 
-static void WINAPI glTexCoord4hNV( GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q ) {
+static void WINAPI glTexCoord4hNV( GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", s, t, r, q );
+  TRACE( "(%d, %d, %d, %d)\n", s, t, r, q );
   funcs->ext.p_glTexCoord4hNV( s, t, r, q );
 }
 
-static void WINAPI glTexCoord4hvNV( const GLhalfNV* v ) {
+static void WINAPI glTexCoord4hvNV( const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glTexCoord4hvNV( v );
 }
 
-static void WINAPI glTexCoord4xOES( GLfixed s, GLfixed t, GLfixed r, GLfixed q ) {
+static void WINAPI glTexCoord4xOES( GLfixed s, GLfixed t, GLfixed r, GLfixed q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", s, t, r, q );
+  TRACE( "(%d, %d, %d, %d)\n", s, t, r, q );
   funcs->ext.p_glTexCoord4xOES( s, t, r, q );
 }
 
-static void WINAPI glTexCoord4xvOES( const GLfixed* coords ) {
+static void WINAPI glTexCoord4xvOES( const GLfixed *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glTexCoord4xvOES( coords );
 }
 
-static void WINAPI glTexCoordFormatNV( GLint size, GLenum type, GLsizei stride ) {
+static void WINAPI glTexCoordFormatNV( GLint size, GLenum type, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", size, type, stride );
+  TRACE( "(%d, %d, %d)\n", size, type, stride );
   funcs->ext.p_glTexCoordFormatNV( size, type, stride );
 }
 
-static void WINAPI glTexCoordP1ui( GLenum type, GLuint coords ) {
+static void WINAPI glTexCoordP1ui( GLenum type, GLuint coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", type, coords );
+  TRACE( "(%d, %d)\n", type, coords );
   funcs->ext.p_glTexCoordP1ui( type, coords );
 }
 
-static void WINAPI glTexCoordP1uiv( GLenum type, const GLuint* coords ) {
+static void WINAPI glTexCoordP1uiv( GLenum type, const GLuint *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", type, coords );
+  TRACE( "(%d, %p)\n", type, coords );
   funcs->ext.p_glTexCoordP1uiv( type, coords );
 }
 
-static void WINAPI glTexCoordP2ui( GLenum type, GLuint coords ) {
+static void WINAPI glTexCoordP2ui( GLenum type, GLuint coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", type, coords );
+  TRACE( "(%d, %d)\n", type, coords );
   funcs->ext.p_glTexCoordP2ui( type, coords );
 }
 
-static void WINAPI glTexCoordP2uiv( GLenum type, const GLuint* coords ) {
+static void WINAPI glTexCoordP2uiv( GLenum type, const GLuint *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", type, coords );
+  TRACE( "(%d, %p)\n", type, coords );
   funcs->ext.p_glTexCoordP2uiv( type, coords );
 }
 
-static void WINAPI glTexCoordP3ui( GLenum type, GLuint coords ) {
+static void WINAPI glTexCoordP3ui( GLenum type, GLuint coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", type, coords );
+  TRACE( "(%d, %d)\n", type, coords );
   funcs->ext.p_glTexCoordP3ui( type, coords );
 }
 
-static void WINAPI glTexCoordP3uiv( GLenum type, const GLuint* coords ) {
+static void WINAPI glTexCoordP3uiv( GLenum type, const GLuint *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", type, coords );
+  TRACE( "(%d, %p)\n", type, coords );
   funcs->ext.p_glTexCoordP3uiv( type, coords );
 }
 
-static void WINAPI glTexCoordP4ui( GLenum type, GLuint coords ) {
+static void WINAPI glTexCoordP4ui( GLenum type, GLuint coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", type, coords );
+  TRACE( "(%d, %d)\n", type, coords );
   funcs->ext.p_glTexCoordP4ui( type, coords );
 }
 
-static void WINAPI glTexCoordP4uiv( GLenum type, const GLuint* coords ) {
+static void WINAPI glTexCoordP4uiv( GLenum type, const GLuint *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", type, coords );
+  TRACE( "(%d, %p)\n", type, coords );
   funcs->ext.p_glTexCoordP4uiv( type, coords );
 }
 
-static void WINAPI glTexCoordPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const void* pointer ) {
+static void WINAPI glTexCoordPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", size, type, stride, count, pointer );
+  TRACE( "(%d, %d, %d, %d, %p)\n", size, type, stride, count, pointer );
   funcs->ext.p_glTexCoordPointerEXT( size, type, stride, count, pointer );
 }
 
-static void WINAPI glTexCoordPointerListIBM( GLint size, GLenum type, GLint stride, const void** pointer, GLint ptrstride ) {
+static void WINAPI glTexCoordPointerListIBM( GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %d)\n", size, type, stride, pointer, ptrstride );
+  TRACE( "(%d, %d, %d, %p, %d)\n", size, type, stride, pointer, ptrstride );
   funcs->ext.p_glTexCoordPointerListIBM( size, type, stride, pointer, ptrstride );
 }
 
-static void WINAPI glTexCoordPointervINTEL( GLint size, GLenum type, const void** pointer ) {
+static void WINAPI glTexCoordPointervINTEL( GLint size, GLenum type, const void **pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", size, type, pointer );
+  TRACE( "(%d, %d, %p)\n", size, type, pointer );
   funcs->ext.p_glTexCoordPointervINTEL( size, type, pointer );
 }
 
-static void WINAPI glTexEnvxOES( GLenum target, GLenum pname, GLfixed param ) {
+static void WINAPI glTexEnvxOES( GLenum target, GLenum pname, GLfixed param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, pname, param );
+  TRACE( "(%d, %d, %d)\n", target, pname, param );
   funcs->ext.p_glTexEnvxOES( target, pname, param );
 }
 
-static void WINAPI glTexEnvxvOES( GLenum target, GLenum pname, const GLfixed* params ) {
+static void WINAPI glTexEnvxvOES( GLenum target, GLenum pname, const GLfixed *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glTexEnvxvOES( target, pname, params );
 }
 
-static void WINAPI glTexFilterFuncSGIS( GLenum target, GLenum filter, GLsizei n, const GLfloat* weights ) {
+static void WINAPI glTexFilterFuncSGIS( GLenum target, GLenum filter, GLsizei n, const GLfloat *weights )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, filter, n, weights );
+  TRACE( "(%d, %d, %d, %p)\n", target, filter, n, weights );
   funcs->ext.p_glTexFilterFuncSGIS( target, filter, n, weights );
 }
 
-static void WINAPI glTexGenxOES( GLenum coord, GLenum pname, GLfixed param ) {
+static void WINAPI glTexGenxOES( GLenum coord, GLenum pname, GLfixed param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", coord, pname, param );
+  TRACE( "(%d, %d, %d)\n", coord, pname, param );
   funcs->ext.p_glTexGenxOES( coord, pname, param );
 }
 
-static void WINAPI glTexGenxvOES( GLenum coord, GLenum pname, const GLfixed* params ) {
+static void WINAPI glTexGenxvOES( GLenum coord, GLenum pname, const GLfixed *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", coord, pname, params );
+  TRACE( "(%d, %d, %p)\n", coord, pname, params );
   funcs->ext.p_glTexGenxvOES( coord, pname, params );
 }
 
-static void WINAPI glTexImage2DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations ) {
+static void WINAPI glTexImage2DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, samples, internalformat, width, height, fixedsamplelocations );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", target, samples, internalformat, width, height, fixedsamplelocations );
   funcs->ext.p_glTexImage2DMultisample( target, samples, internalformat, width, height, fixedsamplelocations );
 }
 
-static void WINAPI glTexImage2DMultisampleCoverageNV( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations ) {
+static void WINAPI glTexImage2DMultisampleCoverageNV( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations );
   funcs->ext.p_glTexImage2DMultisampleCoverageNV( target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations );
 }
 
-static void WINAPI glTexImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glTexImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, border, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, border, format, type, pixels );
   funcs->ext.p_glTexImage3D( target, level, internalformat, width, height, depth, border, format, type, pixels );
 }
 
-static void WINAPI glTexImage3DEXT( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glTexImage3DEXT( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, border, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, border, format, type, pixels );
   funcs->ext.p_glTexImage3DEXT( target, level, internalformat, width, height, depth, border, format, type, pixels );
 }
 
-static void WINAPI glTexImage3DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations ) {
+static void WINAPI glTexImage3DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", target, samples, internalformat, width, height, depth, fixedsamplelocations );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", target, samples, internalformat, width, height, depth, fixedsamplelocations );
   funcs->ext.p_glTexImage3DMultisample( target, samples, internalformat, width, height, depth, fixedsamplelocations );
 }
 
-static void WINAPI glTexImage3DMultisampleCoverageNV( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations ) {
+static void WINAPI glTexImage3DMultisampleCoverageNV( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations );
   funcs->ext.p_glTexImage3DMultisampleCoverageNV( target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations );
 }
 
-static void WINAPI glTexImage4DSGIS( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glTexImage4DSGIS( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, size4d, border, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, depth, size4d, border, format, type, pixels );
   funcs->ext.p_glTexImage4DSGIS( target, level, internalformat, width, height, depth, size4d, border, format, type, pixels );
 }
 
-static void WINAPI glTexPageCommitmentARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit ) {
+static void WINAPI glTexPageCommitmentARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, commit );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, commit );
   funcs->ext.p_glTexPageCommitmentARB( target, level, xoffset, yoffset, zoffset, width, height, depth, commit );
 }
 
-static void WINAPI glTexParameterIiv( GLenum target, GLenum pname, const GLint* params ) {
+static void WINAPI glTexParameterIiv( GLenum target, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glTexParameterIiv( target, pname, params );
 }
 
-static void WINAPI glTexParameterIivEXT( GLenum target, GLenum pname, const GLint* params ) {
+static void WINAPI glTexParameterIivEXT( GLenum target, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glTexParameterIivEXT( target, pname, params );
 }
 
-static void WINAPI glTexParameterIuiv( GLenum target, GLenum pname, const GLuint* params ) {
+static void WINAPI glTexParameterIuiv( GLenum target, GLenum pname, const GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glTexParameterIuiv( target, pname, params );
 }
 
-static void WINAPI glTexParameterIuivEXT( GLenum target, GLenum pname, const GLuint* params ) {
+static void WINAPI glTexParameterIuivEXT( GLenum target, GLenum pname, const GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glTexParameterIuivEXT( target, pname, params );
 }
 
-static void WINAPI glTexParameterxOES( GLenum target, GLenum pname, GLfixed param ) {
+static void WINAPI glTexParameterxOES( GLenum target, GLenum pname, GLfixed param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, pname, param );
+  TRACE( "(%d, %d, %d)\n", target, pname, param );
   funcs->ext.p_glTexParameterxOES( target, pname, param );
 }
 
-static void WINAPI glTexParameterxvOES( GLenum target, GLenum pname, const GLfixed* params ) {
+static void WINAPI glTexParameterxvOES( GLenum target, GLenum pname, const GLfixed *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->ext.p_glTexParameterxvOES( target, pname, params );
 }
 
-static void WINAPI glTexRenderbufferNV( GLenum target, GLuint renderbuffer ) {
+static void WINAPI glTexRenderbufferNV( GLenum target, GLuint renderbuffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, renderbuffer );
+  TRACE( "(%d, %d)\n", target, renderbuffer );
   funcs->ext.p_glTexRenderbufferNV( target, renderbuffer );
 }
 
-static void WINAPI glTexStorage1D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width ) {
+static void WINAPI glTexStorage1D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, levels, internalformat, width );
+  TRACE( "(%d, %d, %d, %d)\n", target, levels, internalformat, width );
   funcs->ext.p_glTexStorage1D( target, levels, internalformat, width );
 }
 
-static void WINAPI glTexStorage2D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height ) {
+static void WINAPI glTexStorage2D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", target, levels, internalformat, width, height );
+  TRACE( "(%d, %d, %d, %d, %d)\n", target, levels, internalformat, width, height );
   funcs->ext.p_glTexStorage2D( target, levels, internalformat, width, height );
 }
 
-static void WINAPI glTexStorage2DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations ) {
+static void WINAPI glTexStorage2DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, samples, internalformat, width, height, fixedsamplelocations );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", target, samples, internalformat, width, height, fixedsamplelocations );
   funcs->ext.p_glTexStorage2DMultisample( target, samples, internalformat, width, height, fixedsamplelocations );
 }
 
-static void WINAPI glTexStorage3D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth ) {
+static void WINAPI glTexStorage3D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, levels, internalformat, width, height, depth );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", target, levels, internalformat, width, height, depth );
   funcs->ext.p_glTexStorage3D( target, levels, internalformat, width, height, depth );
 }
 
-static void WINAPI glTexStorage3DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations ) {
+static void WINAPI glTexStorage3DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", target, samples, internalformat, width, height, depth, fixedsamplelocations );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", target, samples, internalformat, width, height, depth, fixedsamplelocations );
   funcs->ext.p_glTexStorage3DMultisample( target, samples, internalformat, width, height, depth, fixedsamplelocations );
 }
 
-static void WINAPI glTexStorageMem1DEXT( GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLuint memory, GLuint64 offset ) {
+static void WINAPI glTexStorageMem1DEXT( GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLuint memory, GLuint64 offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %s)\n", target, levels, internalFormat, width, memory, wine_dbgstr_longlong(offset) );
+  TRACE( "(%d, %d, %d, %d, %d, %s)\n", target, levels, internalFormat, width, memory, wine_dbgstr_longlong(offset) );
   funcs->ext.p_glTexStorageMem1DEXT( target, levels, internalFormat, width, memory, offset );
 }
 
-static void WINAPI glTexStorageMem2DEXT( GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLuint memory, GLuint64 offset ) {
+static void WINAPI glTexStorageMem2DEXT( GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLuint memory, GLuint64 offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %s)\n", target, levels, internalFormat, width, height, memory, wine_dbgstr_longlong(offset) );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %s)\n", target, levels, internalFormat, width, height, memory, wine_dbgstr_longlong(offset) );
   funcs->ext.p_glTexStorageMem2DEXT( target, levels, internalFormat, width, height, memory, offset );
 }
 
-static void WINAPI glTexStorageMem2DMultisampleEXT( GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset ) {
+static void WINAPI glTexStorageMem2DMultisampleEXT( GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %s)\n", target, samples, internalFormat, width, height, fixedSampleLocations, memory, wine_dbgstr_longlong(offset) );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %s)\n", target, samples, internalFormat, width, height, fixedSampleLocations, memory, wine_dbgstr_longlong(offset) );
   funcs->ext.p_glTexStorageMem2DMultisampleEXT( target, samples, internalFormat, width, height, fixedSampleLocations, memory, offset );
 }
 
-static void WINAPI glTexStorageMem3DEXT( GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset ) {
+static void WINAPI glTexStorageMem3DEXT( GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %s)\n", target, levels, internalFormat, width, height, depth, memory, wine_dbgstr_longlong(offset) );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %s)\n", target, levels, internalFormat, width, height, depth, memory, wine_dbgstr_longlong(offset) );
   funcs->ext.p_glTexStorageMem3DEXT( target, levels, internalFormat, width, height, depth, memory, offset );
 }
 
-static void WINAPI glTexStorageMem3DMultisampleEXT( GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset ) {
+static void WINAPI glTexStorageMem3DMultisampleEXT( GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %s)\n", target, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, wine_dbgstr_longlong(offset) );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %s)\n", target, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, wine_dbgstr_longlong(offset) );
   funcs->ext.p_glTexStorageMem3DMultisampleEXT( target, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset );
 }
 
-static void WINAPI glTexStorageSparseAMD( GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags ) {
+static void WINAPI glTexStorageSparseAMD( GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", target, internalFormat, width, height, depth, layers, flags );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", target, internalFormat, width, height, depth, layers, flags );
   funcs->ext.p_glTexStorageSparseAMD( target, internalFormat, width, height, depth, layers, flags );
 }
 
-static void WINAPI glTexSubImage1DEXT( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glTexSubImage1DEXT( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, width, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, width, format, type, pixels );
   funcs->ext.p_glTexSubImage1DEXT( target, level, xoffset, width, format, type, pixels );
 }
 
-static void WINAPI glTexSubImage2DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glTexSubImage2DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, width, height, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, width, height, format, type, pixels );
   funcs->ext.p_glTexSubImage2DEXT( target, level, xoffset, yoffset, width, height, format, type, pixels );
 }
 
-static void WINAPI glTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
   funcs->ext.p_glTexSubImage3D( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
 }
 
-static void WINAPI glTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
   funcs->ext.p_glTexSubImage3DEXT( target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
 }
 
-static void WINAPI glTexSubImage4DSGIS( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glTexSubImage4DSGIS( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels );
   funcs->ext.p_glTexSubImage4DSGIS( target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels );
 }
 
-static void WINAPI glTextureBarrier( void ) {
+static void WINAPI glTextureBarrier(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glTextureBarrier( );
+  TRACE( "()\n" );
+  funcs->ext.p_glTextureBarrier();
 }
 
-static void WINAPI glTextureBarrierNV( void ) {
+static void WINAPI glTextureBarrierNV(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glTextureBarrierNV( );
+  TRACE( "()\n" );
+  funcs->ext.p_glTextureBarrierNV();
 }
 
-static void WINAPI glTextureBuffer( GLuint texture, GLenum internalformat, GLuint buffer ) {
+static void WINAPI glTextureBuffer( GLuint texture, GLenum internalformat, GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", texture, internalformat, buffer );
+  TRACE( "(%d, %d, %d)\n", texture, internalformat, buffer );
   funcs->ext.p_glTextureBuffer( texture, internalformat, buffer );
 }
 
-static void WINAPI glTextureBufferEXT( GLuint texture, GLenum target, GLenum internalformat, GLuint buffer ) {
+static void WINAPI glTextureBufferEXT( GLuint texture, GLenum target, GLenum internalformat, GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", texture, target, internalformat, buffer );
+  TRACE( "(%d, %d, %d, %d)\n", texture, target, internalformat, buffer );
   funcs->ext.p_glTextureBufferEXT( texture, target, internalformat, buffer );
 }
 
-static void WINAPI glTextureBufferRange( GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size ) {
+static void WINAPI glTextureBufferRange( GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %ld, %ld)\n", texture, internalformat, buffer, offset, size );
+  TRACE( "(%d, %d, %d, %ld, %ld)\n", texture, internalformat, buffer, offset, size );
   funcs->ext.p_glTextureBufferRange( texture, internalformat, buffer, offset, size );
 }
 
-static void WINAPI glTextureBufferRangeEXT( GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size ) {
+static void WINAPI glTextureBufferRangeEXT( GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %ld, %ld)\n", texture, target, internalformat, buffer, offset, size );
+  TRACE( "(%d, %d, %d, %d, %ld, %ld)\n", texture, target, internalformat, buffer, offset, size );
   funcs->ext.p_glTextureBufferRangeEXT( texture, target, internalformat, buffer, offset, size );
 }
 
-static void WINAPI glTextureColorMaskSGIS( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) {
+static void WINAPI glTextureColorMaskSGIS( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
+  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
   funcs->ext.p_glTextureColorMaskSGIS( red, green, blue, alpha );
 }
 
-static void WINAPI glTextureImage1DEXT( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glTextureImage1DEXT( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, border, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, border, format, type, pixels );
   funcs->ext.p_glTextureImage1DEXT( texture, target, level, internalformat, width, border, format, type, pixels );
 }
 
-static void WINAPI glTextureImage2DEXT( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glTextureImage2DEXT( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, height, border, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, height, border, format, type, pixels );
   funcs->ext.p_glTextureImage2DEXT( texture, target, level, internalformat, width, height, border, format, type, pixels );
 }
 
-static void WINAPI glTextureImage2DMultisampleCoverageNV( GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations ) {
+static void WINAPI glTextureImage2DMultisampleCoverageNV( GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations );
   funcs->ext.p_glTextureImage2DMultisampleCoverageNV( texture, target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations );
 }
 
-static void WINAPI glTextureImage2DMultisampleNV( GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations ) {
+static void WINAPI glTextureImage2DMultisampleNV( GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", texture, target, samples, internalFormat, width, height, fixedSampleLocations );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", texture, target, samples, internalFormat, width, height, fixedSampleLocations );
   funcs->ext.p_glTextureImage2DMultisampleNV( texture, target, samples, internalFormat, width, height, fixedSampleLocations );
 }
 
-static void WINAPI glTextureImage3DEXT( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glTextureImage3DEXT( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, height, depth, border, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, internalformat, width, height, depth, border, format, type, pixels );
   funcs->ext.p_glTextureImage3DEXT( texture, target, level, internalformat, width, height, depth, border, format, type, pixels );
 }
 
-static void WINAPI glTextureImage3DMultisampleCoverageNV( GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations ) {
+static void WINAPI glTextureImage3DMultisampleCoverageNV( GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations );
   funcs->ext.p_glTextureImage3DMultisampleCoverageNV( texture, target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations );
 }
 
-static void WINAPI glTextureImage3DMultisampleNV( GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations ) {
+static void WINAPI glTextureImage3DMultisampleNV( GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations );
   funcs->ext.p_glTextureImage3DMultisampleNV( texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations );
 }
 
-static void WINAPI glTextureLightEXT( GLenum pname ) {
+static void WINAPI glTextureLightEXT( GLenum pname )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", pname );
+  TRACE( "(%d)\n", pname );
   funcs->ext.p_glTextureLightEXT( pname );
 }
 
-static void WINAPI glTextureMaterialEXT( GLenum face, GLenum mode ) {
+static void WINAPI glTextureMaterialEXT( GLenum face, GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", face, mode );
+  TRACE( "(%d, %d)\n", face, mode );
   funcs->ext.p_glTextureMaterialEXT( face, mode );
 }
 
-static void WINAPI glTextureNormalEXT( GLenum mode ) {
+static void WINAPI glTextureNormalEXT( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   funcs->ext.p_glTextureNormalEXT( mode );
 }
 
-static void WINAPI glTexturePageCommitmentEXT( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit ) {
+static void WINAPI glTexturePageCommitmentEXT( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, commit );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d)\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, commit );
   funcs->ext.p_glTexturePageCommitmentEXT( texture, level, xoffset, yoffset, zoffset, width, height, depth, commit );
 }
 
-static void WINAPI glTextureParameterIiv( GLuint texture, GLenum pname, const GLint* params ) {
+static void WINAPI glTextureParameterIiv( GLuint texture, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", texture, pname, params );
+  TRACE( "(%d, %d, %p)\n", texture, pname, params );
   funcs->ext.p_glTextureParameterIiv( texture, pname, params );
 }
 
-static void WINAPI glTextureParameterIivEXT( GLuint texture, GLenum target, GLenum pname, const GLint* params ) {
+static void WINAPI glTextureParameterIivEXT( GLuint texture, GLenum target, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texture, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texture, target, pname, params );
   funcs->ext.p_glTextureParameterIivEXT( texture, target, pname, params );
 }
 
-static void WINAPI glTextureParameterIuiv( GLuint texture, GLenum pname, const GLuint* params ) {
+static void WINAPI glTextureParameterIuiv( GLuint texture, GLenum pname, const GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", texture, pname, params );
+  TRACE( "(%d, %d, %p)\n", texture, pname, params );
   funcs->ext.p_glTextureParameterIuiv( texture, pname, params );
 }
 
-static void WINAPI glTextureParameterIuivEXT( GLuint texture, GLenum target, GLenum pname, const GLuint* params ) {
+static void WINAPI glTextureParameterIuivEXT( GLuint texture, GLenum target, GLenum pname, const GLuint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texture, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texture, target, pname, params );
   funcs->ext.p_glTextureParameterIuivEXT( texture, target, pname, params );
 }
 
-static void WINAPI glTextureParameterf( GLuint texture, GLenum pname, GLfloat param ) {
+static void WINAPI glTextureParameterf( GLuint texture, GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", texture, pname, param );
+  TRACE( "(%d, %d, %f)\n", texture, pname, param );
   funcs->ext.p_glTextureParameterf( texture, pname, param );
 }
 
-static void WINAPI glTextureParameterfEXT( GLuint texture, GLenum target, GLenum pname, GLfloat param ) {
+static void WINAPI glTextureParameterfEXT( GLuint texture, GLenum target, GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %f)\n", texture, target, pname, param );
+  TRACE( "(%d, %d, %d, %f)\n", texture, target, pname, param );
   funcs->ext.p_glTextureParameterfEXT( texture, target, pname, param );
 }
 
-static void WINAPI glTextureParameterfv( GLuint texture, GLenum pname, const GLfloat* param ) {
+static void WINAPI glTextureParameterfv( GLuint texture, GLenum pname, const GLfloat *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", texture, pname, param );
+  TRACE( "(%d, %d, %p)\n", texture, pname, param );
   funcs->ext.p_glTextureParameterfv( texture, pname, param );
 }
 
-static void WINAPI glTextureParameterfvEXT( GLuint texture, GLenum target, GLenum pname, const GLfloat* params ) {
+static void WINAPI glTextureParameterfvEXT( GLuint texture, GLenum target, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texture, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texture, target, pname, params );
   funcs->ext.p_glTextureParameterfvEXT( texture, target, pname, params );
 }
 
-static void WINAPI glTextureParameteri( GLuint texture, GLenum pname, GLint param ) {
+static void WINAPI glTextureParameteri( GLuint texture, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", texture, pname, param );
+  TRACE( "(%d, %d, %d)\n", texture, pname, param );
   funcs->ext.p_glTextureParameteri( texture, pname, param );
 }
 
-static void WINAPI glTextureParameteriEXT( GLuint texture, GLenum target, GLenum pname, GLint param ) {
+static void WINAPI glTextureParameteriEXT( GLuint texture, GLenum target, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", texture, target, pname, param );
+  TRACE( "(%d, %d, %d, %d)\n", texture, target, pname, param );
   funcs->ext.p_glTextureParameteriEXT( texture, target, pname, param );
 }
 
-static void WINAPI glTextureParameteriv( GLuint texture, GLenum pname, const GLint* param ) {
+static void WINAPI glTextureParameteriv( GLuint texture, GLenum pname, const GLint *param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", texture, pname, param );
+  TRACE( "(%d, %d, %p)\n", texture, pname, param );
   funcs->ext.p_glTextureParameteriv( texture, pname, param );
 }
 
-static void WINAPI glTextureParameterivEXT( GLuint texture, GLenum target, GLenum pname, const GLint* params ) {
+static void WINAPI glTextureParameterivEXT( GLuint texture, GLenum target, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", texture, target, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", texture, target, pname, params );
   funcs->ext.p_glTextureParameterivEXT( texture, target, pname, params );
 }
 
-static void WINAPI glTextureRangeAPPLE( GLenum target, GLsizei length, const void* pointer ) {
+static void WINAPI glTextureRangeAPPLE( GLenum target, GLsizei length, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, length, pointer );
+  TRACE( "(%d, %d, %p)\n", target, length, pointer );
   funcs->ext.p_glTextureRangeAPPLE( target, length, pointer );
 }
 
-static void WINAPI glTextureRenderbufferEXT( GLuint texture, GLenum target, GLuint renderbuffer ) {
+static void WINAPI glTextureRenderbufferEXT( GLuint texture, GLenum target, GLuint renderbuffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", texture, target, renderbuffer );
+  TRACE( "(%d, %d, %d)\n", texture, target, renderbuffer );
   funcs->ext.p_glTextureRenderbufferEXT( texture, target, renderbuffer );
 }
 
-static void WINAPI glTextureStorage1D( GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width ) {
+static void WINAPI glTextureStorage1D( GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", texture, levels, internalformat, width );
+  TRACE( "(%d, %d, %d, %d)\n", texture, levels, internalformat, width );
   funcs->ext.p_glTextureStorage1D( texture, levels, internalformat, width );
 }
 
-static void WINAPI glTextureStorage1DEXT( GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width ) {
+static void WINAPI glTextureStorage1DEXT( GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", texture, target, levels, internalformat, width );
+  TRACE( "(%d, %d, %d, %d, %d)\n", texture, target, levels, internalformat, width );
   funcs->ext.p_glTextureStorage1DEXT( texture, target, levels, internalformat, width );
 }
 
-static void WINAPI glTextureStorage2D( GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height ) {
+static void WINAPI glTextureStorage2D( GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", texture, levels, internalformat, width, height );
+  TRACE( "(%d, %d, %d, %d, %d)\n", texture, levels, internalformat, width, height );
   funcs->ext.p_glTextureStorage2D( texture, levels, internalformat, width, height );
 }
 
-static void WINAPI glTextureStorage2DEXT( GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height ) {
+static void WINAPI glTextureStorage2DEXT( GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", texture, target, levels, internalformat, width, height );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", texture, target, levels, internalformat, width, height );
   funcs->ext.p_glTextureStorage2DEXT( texture, target, levels, internalformat, width, height );
 }
 
-static void WINAPI glTextureStorage2DMultisample( GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations ) {
+static void WINAPI glTextureStorage2DMultisample( GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", texture, samples, internalformat, width, height, fixedsamplelocations );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", texture, samples, internalformat, width, height, fixedsamplelocations );
   funcs->ext.p_glTextureStorage2DMultisample( texture, samples, internalformat, width, height, fixedsamplelocations );
 }
 
-static void WINAPI glTextureStorage2DMultisampleEXT( GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations ) {
+static void WINAPI glTextureStorage2DMultisampleEXT( GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", texture, target, samples, internalformat, width, height, fixedsamplelocations );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", texture, target, samples, internalformat, width, height, fixedsamplelocations );
   funcs->ext.p_glTextureStorage2DMultisampleEXT( texture, target, samples, internalformat, width, height, fixedsamplelocations );
 }
 
-static void WINAPI glTextureStorage3D( GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth ) {
+static void WINAPI glTextureStorage3D( GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", texture, levels, internalformat, width, height, depth );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", texture, levels, internalformat, width, height, depth );
   funcs->ext.p_glTextureStorage3D( texture, levels, internalformat, width, height, depth );
 }
 
-static void WINAPI glTextureStorage3DEXT( GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth ) {
+static void WINAPI glTextureStorage3DEXT( GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", texture, target, levels, internalformat, width, height, depth );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", texture, target, levels, internalformat, width, height, depth );
   funcs->ext.p_glTextureStorage3DEXT( texture, target, levels, internalformat, width, height, depth );
 }
 
-static void WINAPI glTextureStorage3DMultisample( GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations ) {
+static void WINAPI glTextureStorage3DMultisample( GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", texture, samples, internalformat, width, height, depth, fixedsamplelocations );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", texture, samples, internalformat, width, height, depth, fixedsamplelocations );
   funcs->ext.p_glTextureStorage3DMultisample( texture, samples, internalformat, width, height, depth, fixedsamplelocations );
 }
 
-static void WINAPI glTextureStorage3DMultisampleEXT( GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations ) {
+static void WINAPI glTextureStorage3DMultisampleEXT( GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, samples, internalformat, width, height, depth, fixedsamplelocations );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, samples, internalformat, width, height, depth, fixedsamplelocations );
   funcs->ext.p_glTextureStorage3DMultisampleEXT( texture, target, samples, internalformat, width, height, depth, fixedsamplelocations );
 }
 
-static void WINAPI glTextureStorageMem1DEXT( GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLuint memory, GLuint64 offset ) {
+static void WINAPI glTextureStorageMem1DEXT( GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLuint memory, GLuint64 offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %s)\n", texture, levels, internalFormat, width, memory, wine_dbgstr_longlong(offset) );
+  TRACE( "(%d, %d, %d, %d, %d, %s)\n", texture, levels, internalFormat, width, memory, wine_dbgstr_longlong(offset) );
   funcs->ext.p_glTextureStorageMem1DEXT( texture, levels, internalFormat, width, memory, offset );
 }
 
-static void WINAPI glTextureStorageMem2DEXT( GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLuint memory, GLuint64 offset ) {
+static void WINAPI glTextureStorageMem2DEXT( GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLuint memory, GLuint64 offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %s)\n", texture, levels, internalFormat, width, height, memory, wine_dbgstr_longlong(offset) );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %s)\n", texture, levels, internalFormat, width, height, memory, wine_dbgstr_longlong(offset) );
   funcs->ext.p_glTextureStorageMem2DEXT( texture, levels, internalFormat, width, height, memory, offset );
 }
 
-static void WINAPI glTextureStorageMem2DMultisampleEXT( GLuint texture, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset ) {
+static void WINAPI glTextureStorageMem2DMultisampleEXT( GLuint texture, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %s)\n", texture, samples, internalFormat, width, height, fixedSampleLocations, memory, wine_dbgstr_longlong(offset) );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %s)\n", texture, samples, internalFormat, width, height, fixedSampleLocations, memory, wine_dbgstr_longlong(offset) );
   funcs->ext.p_glTextureStorageMem2DMultisampleEXT( texture, samples, internalFormat, width, height, fixedSampleLocations, memory, offset );
 }
 
-static void WINAPI glTextureStorageMem3DEXT( GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset ) {
+static void WINAPI glTextureStorageMem3DEXT( GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %s)\n", texture, levels, internalFormat, width, height, depth, memory, wine_dbgstr_longlong(offset) );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %s)\n", texture, levels, internalFormat, width, height, depth, memory, wine_dbgstr_longlong(offset) );
   funcs->ext.p_glTextureStorageMem3DEXT( texture, levels, internalFormat, width, height, depth, memory, offset );
 }
 
-static void WINAPI glTextureStorageMem3DMultisampleEXT( GLuint texture, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset ) {
+static void WINAPI glTextureStorageMem3DMultisampleEXT( GLuint texture, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %s)\n", texture, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, wine_dbgstr_longlong(offset) );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %s)\n", texture, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, wine_dbgstr_longlong(offset) );
   funcs->ext.p_glTextureStorageMem3DMultisampleEXT( texture, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset );
 }
 
-static void WINAPI glTextureStorageSparseAMD( GLuint texture, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags ) {
+static void WINAPI glTextureStorageSparseAMD( GLuint texture, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, internalFormat, width, height, depth, layers, flags );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, internalFormat, width, height, depth, layers, flags );
   funcs->ext.p_glTextureStorageSparseAMD( texture, target, internalFormat, width, height, depth, layers, flags );
 }
 
-static void WINAPI glTextureSubImage1D( GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glTextureSubImage1D( GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, width, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, width, format, type, pixels );
   funcs->ext.p_glTextureSubImage1D( texture, level, xoffset, width, format, type, pixels );
 }
 
-static void WINAPI glTextureSubImage1DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glTextureSubImage1DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, width, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, width, format, type, pixels );
   funcs->ext.p_glTextureSubImage1DEXT( texture, target, level, xoffset, width, format, type, pixels );
 }
 
-static void WINAPI glTextureSubImage2D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glTextureSubImage2D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, yoffset, width, height, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, yoffset, width, height, format, type, pixels );
   funcs->ext.p_glTextureSubImage2D( texture, level, xoffset, yoffset, width, height, format, type, pixels );
 }
 
-static void WINAPI glTextureSubImage2DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glTextureSubImage2DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, yoffset, width, height, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, yoffset, width, height, format, type, pixels );
   funcs->ext.p_glTextureSubImage2DEXT( texture, target, level, xoffset, yoffset, width, height, format, type, pixels );
 }
 
-static void WINAPI glTextureSubImage3D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glTextureSubImage3D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
   funcs->ext.p_glTextureSubImage3D( texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
 }
 
-static void WINAPI glTextureSubImage3DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels ) {
+static void WINAPI glTextureSubImage3DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p)\n", texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
   funcs->ext.p_glTextureSubImage3DEXT( texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels );
 }
 
-static void WINAPI glTextureView( GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers ) {
+static void WINAPI glTextureView( GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d)\n", texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers );
   funcs->ext.p_glTextureView( texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers );
 }
 
-static void WINAPI glTrackMatrixNV( GLenum target, GLuint address, GLenum matrix, GLenum transform ) {
+static void WINAPI glTrackMatrixNV( GLenum target, GLuint address, GLenum matrix, GLenum transform )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", target, address, matrix, transform );
+  TRACE( "(%d, %d, %d, %d)\n", target, address, matrix, transform );
   funcs->ext.p_glTrackMatrixNV( target, address, matrix, transform );
 }
 
-static void WINAPI glTransformFeedbackAttribsNV( GLsizei count, const GLint* attribs, GLenum bufferMode ) {
+static void WINAPI glTransformFeedbackAttribsNV( GLsizei count, const GLint *attribs, GLenum bufferMode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %d)\n", count, attribs, bufferMode );
+  TRACE( "(%d, %p, %d)\n", count, attribs, bufferMode );
   funcs->ext.p_glTransformFeedbackAttribsNV( count, attribs, bufferMode );
 }
 
-static void WINAPI glTransformFeedbackBufferBase( GLuint xfb, GLuint index, GLuint buffer ) {
+static void WINAPI glTransformFeedbackBufferBase( GLuint xfb, GLuint index, GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", xfb, index, buffer );
+  TRACE( "(%d, %d, %d)\n", xfb, index, buffer );
   funcs->ext.p_glTransformFeedbackBufferBase( xfb, index, buffer );
 }
 
-static void WINAPI glTransformFeedbackBufferRange( GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size ) {
+static void WINAPI glTransformFeedbackBufferRange( GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %ld, %ld)\n", xfb, index, buffer, offset, size );
+  TRACE( "(%d, %d, %d, %ld, %ld)\n", xfb, index, buffer, offset, size );
   funcs->ext.p_glTransformFeedbackBufferRange( xfb, index, buffer, offset, size );
 }
 
-static void WINAPI glTransformFeedbackStreamAttribsNV( GLsizei count, const GLint* attribs, GLsizei nbuffers, const GLint* bufstreams, GLenum bufferMode ) {
+static void WINAPI glTransformFeedbackStreamAttribsNV( GLsizei count, const GLint *attribs, GLsizei nbuffers, const GLint *bufstreams, GLenum bufferMode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %d, %p, %d)\n", count, attribs, nbuffers, bufstreams, bufferMode );
+  TRACE( "(%d, %p, %d, %p, %d)\n", count, attribs, nbuffers, bufstreams, bufferMode );
   funcs->ext.p_glTransformFeedbackStreamAttribsNV( count, attribs, nbuffers, bufstreams, bufferMode );
 }
 
-static void WINAPI glTransformFeedbackVaryings( GLuint program, GLsizei count, const GLchar*const* varyings, GLenum bufferMode ) {
+static void WINAPI glTransformFeedbackVaryings( GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d)\n", program, count, varyings, bufferMode );
+  TRACE( "(%d, %d, %p, %d)\n", program, count, varyings, bufferMode );
   funcs->ext.p_glTransformFeedbackVaryings( program, count, varyings, bufferMode );
 }
 
-static void WINAPI glTransformFeedbackVaryingsEXT( GLuint program, GLsizei count, const GLchar*const* varyings, GLenum bufferMode ) {
+static void WINAPI glTransformFeedbackVaryingsEXT( GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d)\n", program, count, varyings, bufferMode );
+  TRACE( "(%d, %d, %p, %d)\n", program, count, varyings, bufferMode );
   funcs->ext.p_glTransformFeedbackVaryingsEXT( program, count, varyings, bufferMode );
 }
 
-static void WINAPI glTransformFeedbackVaryingsNV( GLuint program, GLsizei count, const GLint* locations, GLenum bufferMode ) {
+static void WINAPI glTransformFeedbackVaryingsNV( GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d)\n", program, count, locations, bufferMode );
+  TRACE( "(%d, %d, %p, %d)\n", program, count, locations, bufferMode );
   funcs->ext.p_glTransformFeedbackVaryingsNV( program, count, locations, bufferMode );
 }
 
-static void WINAPI glTransformPathNV( GLuint resultPath, GLuint srcPath, GLenum transformType, const GLfloat* transformValues ) {
+static void WINAPI glTransformPathNV( GLuint resultPath, GLuint srcPath, GLenum transformType, const GLfloat *transformValues )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", resultPath, srcPath, transformType, transformValues );
+  TRACE( "(%d, %d, %d, %p)\n", resultPath, srcPath, transformType, transformValues );
   funcs->ext.p_glTransformPathNV( resultPath, srcPath, transformType, transformValues );
 }
 
-static void WINAPI glTranslatexOES( GLfixed x, GLfixed y, GLfixed z ) {
+static void WINAPI glTranslatexOES( GLfixed x, GLfixed y, GLfixed z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", x, y, z );
+  TRACE( "(%d, %d, %d)\n", x, y, z );
   funcs->ext.p_glTranslatexOES( x, y, z );
 }
 
-static void WINAPI glUniform1d( GLint location, GLdouble x ) {
+static void WINAPI glUniform1d( GLint location, GLdouble x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", location, x );
+  TRACE( "(%d, %f)\n", location, x );
   funcs->ext.p_glUniform1d( location, x );
 }
 
-static void WINAPI glUniform1dv( GLint location, GLsizei count, const GLdouble* value ) {
+static void WINAPI glUniform1dv( GLint location, GLsizei count, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform1dv( location, count, value );
 }
 
-static void WINAPI glUniform1f( GLint location, GLfloat v0 ) {
+static void WINAPI glUniform1f( GLint location, GLfloat v0 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", location, v0 );
+  TRACE( "(%d, %f)\n", location, v0 );
   funcs->ext.p_glUniform1f( location, v0 );
 }
 
-static void WINAPI glUniform1fARB( GLint location, GLfloat v0 ) {
+static void WINAPI glUniform1fARB( GLint location, GLfloat v0 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", location, v0 );
+  TRACE( "(%d, %f)\n", location, v0 );
   funcs->ext.p_glUniform1fARB( location, v0 );
 }
 
-static void WINAPI glUniform1fv( GLint location, GLsizei count, const GLfloat* value ) {
+static void WINAPI glUniform1fv( GLint location, GLsizei count, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform1fv( location, count, value );
 }
 
-static void WINAPI glUniform1fvARB( GLint location, GLsizei count, const GLfloat* value ) {
+static void WINAPI glUniform1fvARB( GLint location, GLsizei count, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform1fvARB( location, count, value );
 }
 
-static void WINAPI glUniform1i( GLint location, GLint v0 ) {
+static void WINAPI glUniform1i( GLint location, GLint v0 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", location, v0 );
+  TRACE( "(%d, %d)\n", location, v0 );
   funcs->ext.p_glUniform1i( location, v0 );
 }
 
-static void WINAPI glUniform1i64ARB( GLint location, GLint64 x ) {
+static void WINAPI glUniform1i64ARB( GLint location, GLint64 x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s)\n", location, wine_dbgstr_longlong(x) );
+  TRACE( "(%d, %s)\n", location, wine_dbgstr_longlong(x) );
   funcs->ext.p_glUniform1i64ARB( location, x );
 }
 
-static void WINAPI glUniform1i64NV( GLint location, GLint64EXT x ) {
+static void WINAPI glUniform1i64NV( GLint location, GLint64EXT x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s)\n", location, wine_dbgstr_longlong(x) );
+  TRACE( "(%d, %s)\n", location, wine_dbgstr_longlong(x) );
   funcs->ext.p_glUniform1i64NV( location, x );
 }
 
-static void WINAPI glUniform1i64vARB( GLint location, GLsizei count, const GLint64* value ) {
+static void WINAPI glUniform1i64vARB( GLint location, GLsizei count, const GLint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform1i64vARB( location, count, value );
 }
 
-static void WINAPI glUniform1i64vNV( GLint location, GLsizei count, const GLint64EXT* value ) {
+static void WINAPI glUniform1i64vNV( GLint location, GLsizei count, const GLint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform1i64vNV( location, count, value );
 }
 
-static void WINAPI glUniform1iARB( GLint location, GLint v0 ) {
+static void WINAPI glUniform1iARB( GLint location, GLint v0 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", location, v0 );
+  TRACE( "(%d, %d)\n", location, v0 );
   funcs->ext.p_glUniform1iARB( location, v0 );
 }
 
-static void WINAPI glUniform1iv( GLint location, GLsizei count, const GLint* value ) {
+static void WINAPI glUniform1iv( GLint location, GLsizei count, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform1iv( location, count, value );
 }
 
-static void WINAPI glUniform1ivARB( GLint location, GLsizei count, const GLint* value ) {
+static void WINAPI glUniform1ivARB( GLint location, GLsizei count, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform1ivARB( location, count, value );
 }
 
-static void WINAPI glUniform1ui( GLint location, GLuint v0 ) {
+static void WINAPI glUniform1ui( GLint location, GLuint v0 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", location, v0 );
+  TRACE( "(%d, %d)\n", location, v0 );
   funcs->ext.p_glUniform1ui( location, v0 );
 }
 
-static void WINAPI glUniform1ui64ARB( GLint location, GLuint64 x ) {
+static void WINAPI glUniform1ui64ARB( GLint location, GLuint64 x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s)\n", location, wine_dbgstr_longlong(x) );
+  TRACE( "(%d, %s)\n", location, wine_dbgstr_longlong(x) );
   funcs->ext.p_glUniform1ui64ARB( location, x );
 }
 
-static void WINAPI glUniform1ui64NV( GLint location, GLuint64EXT x ) {
+static void WINAPI glUniform1ui64NV( GLint location, GLuint64EXT x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s)\n", location, wine_dbgstr_longlong(x) );
+  TRACE( "(%d, %s)\n", location, wine_dbgstr_longlong(x) );
   funcs->ext.p_glUniform1ui64NV( location, x );
 }
 
-static void WINAPI glUniform1ui64vARB( GLint location, GLsizei count, const GLuint64* value ) {
+static void WINAPI glUniform1ui64vARB( GLint location, GLsizei count, const GLuint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform1ui64vARB( location, count, value );
 }
 
-static void WINAPI glUniform1ui64vNV( GLint location, GLsizei count, const GLuint64EXT* value ) {
+static void WINAPI glUniform1ui64vNV( GLint location, GLsizei count, const GLuint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform1ui64vNV( location, count, value );
 }
 
-static void WINAPI glUniform1uiEXT( GLint location, GLuint v0 ) {
+static void WINAPI glUniform1uiEXT( GLint location, GLuint v0 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", location, v0 );
+  TRACE( "(%d, %d)\n", location, v0 );
   funcs->ext.p_glUniform1uiEXT( location, v0 );
 }
 
-static void WINAPI glUniform1uiv( GLint location, GLsizei count, const GLuint* value ) {
+static void WINAPI glUniform1uiv( GLint location, GLsizei count, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform1uiv( location, count, value );
 }
 
-static void WINAPI glUniform1uivEXT( GLint location, GLsizei count, const GLuint* value ) {
+static void WINAPI glUniform1uivEXT( GLint location, GLsizei count, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform1uivEXT( location, count, value );
 }
 
-static void WINAPI glUniform2d( GLint location, GLdouble x, GLdouble y ) {
+static void WINAPI glUniform2d( GLint location, GLdouble x, GLdouble y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", location, x, y );
+  TRACE( "(%d, %f, %f)\n", location, x, y );
   funcs->ext.p_glUniform2d( location, x, y );
 }
 
-static void WINAPI glUniform2dv( GLint location, GLsizei count, const GLdouble* value ) {
+static void WINAPI glUniform2dv( GLint location, GLsizei count, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform2dv( location, count, value );
 }
 
-static void WINAPI glUniform2f( GLint location, GLfloat v0, GLfloat v1 ) {
+static void WINAPI glUniform2f( GLint location, GLfloat v0, GLfloat v1 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", location, v0, v1 );
+  TRACE( "(%d, %f, %f)\n", location, v0, v1 );
   funcs->ext.p_glUniform2f( location, v0, v1 );
 }
 
-static void WINAPI glUniform2fARB( GLint location, GLfloat v0, GLfloat v1 ) {
+static void WINAPI glUniform2fARB( GLint location, GLfloat v0, GLfloat v1 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", location, v0, v1 );
+  TRACE( "(%d, %f, %f)\n", location, v0, v1 );
   funcs->ext.p_glUniform2fARB( location, v0, v1 );
 }
 
-static void WINAPI glUniform2fv( GLint location, GLsizei count, const GLfloat* value ) {
+static void WINAPI glUniform2fv( GLint location, GLsizei count, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform2fv( location, count, value );
 }
 
-static void WINAPI glUniform2fvARB( GLint location, GLsizei count, const GLfloat* value ) {
+static void WINAPI glUniform2fvARB( GLint location, GLsizei count, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform2fvARB( location, count, value );
 }
 
-static void WINAPI glUniform2i( GLint location, GLint v0, GLint v1 ) {
+static void WINAPI glUniform2i( GLint location, GLint v0, GLint v1 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", location, v0, v1 );
+  TRACE( "(%d, %d, %d)\n", location, v0, v1 );
   funcs->ext.p_glUniform2i( location, v0, v1 );
 }
 
-static void WINAPI glUniform2i64ARB( GLint location, GLint64 x, GLint64 y ) {
+static void WINAPI glUniform2i64ARB( GLint location, GLint64 x, GLint64 y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
+  TRACE( "(%d, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
   funcs->ext.p_glUniform2i64ARB( location, x, y );
 }
 
-static void WINAPI glUniform2i64NV( GLint location, GLint64EXT x, GLint64EXT y ) {
+static void WINAPI glUniform2i64NV( GLint location, GLint64EXT x, GLint64EXT y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
+  TRACE( "(%d, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
   funcs->ext.p_glUniform2i64NV( location, x, y );
 }
 
-static void WINAPI glUniform2i64vARB( GLint location, GLsizei count, const GLint64* value ) {
+static void WINAPI glUniform2i64vARB( GLint location, GLsizei count, const GLint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform2i64vARB( location, count, value );
 }
 
-static void WINAPI glUniform2i64vNV( GLint location, GLsizei count, const GLint64EXT* value ) {
+static void WINAPI glUniform2i64vNV( GLint location, GLsizei count, const GLint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform2i64vNV( location, count, value );
 }
 
-static void WINAPI glUniform2iARB( GLint location, GLint v0, GLint v1 ) {
+static void WINAPI glUniform2iARB( GLint location, GLint v0, GLint v1 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", location, v0, v1 );
+  TRACE( "(%d, %d, %d)\n", location, v0, v1 );
   funcs->ext.p_glUniform2iARB( location, v0, v1 );
 }
 
-static void WINAPI glUniform2iv( GLint location, GLsizei count, const GLint* value ) {
+static void WINAPI glUniform2iv( GLint location, GLsizei count, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform2iv( location, count, value );
 }
 
-static void WINAPI glUniform2ivARB( GLint location, GLsizei count, const GLint* value ) {
+static void WINAPI glUniform2ivARB( GLint location, GLsizei count, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform2ivARB( location, count, value );
 }
 
-static void WINAPI glUniform2ui( GLint location, GLuint v0, GLuint v1 ) {
+static void WINAPI glUniform2ui( GLint location, GLuint v0, GLuint v1 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", location, v0, v1 );
+  TRACE( "(%d, %d, %d)\n", location, v0, v1 );
   funcs->ext.p_glUniform2ui( location, v0, v1 );
 }
 
-static void WINAPI glUniform2ui64ARB( GLint location, GLuint64 x, GLuint64 y ) {
+static void WINAPI glUniform2ui64ARB( GLint location, GLuint64 x, GLuint64 y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
+  TRACE( "(%d, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
   funcs->ext.p_glUniform2ui64ARB( location, x, y );
 }
 
-static void WINAPI glUniform2ui64NV( GLint location, GLuint64EXT x, GLuint64EXT y ) {
+static void WINAPI glUniform2ui64NV( GLint location, GLuint64EXT x, GLuint64EXT y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
+  TRACE( "(%d, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
   funcs->ext.p_glUniform2ui64NV( location, x, y );
 }
 
-static void WINAPI glUniform2ui64vARB( GLint location, GLsizei count, const GLuint64* value ) {
+static void WINAPI glUniform2ui64vARB( GLint location, GLsizei count, const GLuint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform2ui64vARB( location, count, value );
 }
 
-static void WINAPI glUniform2ui64vNV( GLint location, GLsizei count, const GLuint64EXT* value ) {
+static void WINAPI glUniform2ui64vNV( GLint location, GLsizei count, const GLuint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform2ui64vNV( location, count, value );
 }
 
-static void WINAPI glUniform2uiEXT( GLint location, GLuint v0, GLuint v1 ) {
+static void WINAPI glUniform2uiEXT( GLint location, GLuint v0, GLuint v1 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", location, v0, v1 );
+  TRACE( "(%d, %d, %d)\n", location, v0, v1 );
   funcs->ext.p_glUniform2uiEXT( location, v0, v1 );
 }
 
-static void WINAPI glUniform2uiv( GLint location, GLsizei count, const GLuint* value ) {
+static void WINAPI glUniform2uiv( GLint location, GLsizei count, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform2uiv( location, count, value );
 }
 
-static void WINAPI glUniform2uivEXT( GLint location, GLsizei count, const GLuint* value ) {
+static void WINAPI glUniform2uivEXT( GLint location, GLsizei count, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform2uivEXT( location, count, value );
 }
 
-static void WINAPI glUniform3d( GLint location, GLdouble x, GLdouble y, GLdouble z ) {
+static void WINAPI glUniform3d( GLint location, GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", location, x, y, z );
+  TRACE( "(%d, %f, %f, %f)\n", location, x, y, z );
   funcs->ext.p_glUniform3d( location, x, y, z );
 }
 
-static void WINAPI glUniform3dv( GLint location, GLsizei count, const GLdouble* value ) {
+static void WINAPI glUniform3dv( GLint location, GLsizei count, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform3dv( location, count, value );
 }
 
-static void WINAPI glUniform3f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2 ) {
+static void WINAPI glUniform3f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", location, v0, v1, v2 );
+  TRACE( "(%d, %f, %f, %f)\n", location, v0, v1, v2 );
   funcs->ext.p_glUniform3f( location, v0, v1, v2 );
 }
 
-static void WINAPI glUniform3fARB( GLint location, GLfloat v0, GLfloat v1, GLfloat v2 ) {
+static void WINAPI glUniform3fARB( GLint location, GLfloat v0, GLfloat v1, GLfloat v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", location, v0, v1, v2 );
+  TRACE( "(%d, %f, %f, %f)\n", location, v0, v1, v2 );
   funcs->ext.p_glUniform3fARB( location, v0, v1, v2 );
 }
 
-static void WINAPI glUniform3fv( GLint location, GLsizei count, const GLfloat* value ) {
+static void WINAPI glUniform3fv( GLint location, GLsizei count, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform3fv( location, count, value );
 }
 
-static void WINAPI glUniform3fvARB( GLint location, GLsizei count, const GLfloat* value ) {
+static void WINAPI glUniform3fvARB( GLint location, GLsizei count, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform3fvARB( location, count, value );
 }
 
-static void WINAPI glUniform3i( GLint location, GLint v0, GLint v1, GLint v2 ) {
+static void WINAPI glUniform3i( GLint location, GLint v0, GLint v1, GLint v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", location, v0, v1, v2 );
+  TRACE( "(%d, %d, %d, %d)\n", location, v0, v1, v2 );
   funcs->ext.p_glUniform3i( location, v0, v1, v2 );
 }
 
-static void WINAPI glUniform3i64ARB( GLint location, GLint64 x, GLint64 y, GLint64 z ) {
+static void WINAPI glUniform3i64ARB( GLint location, GLint64 x, GLint64 y, GLint64 z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
+  TRACE( "(%d, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
   funcs->ext.p_glUniform3i64ARB( location, x, y, z );
 }
 
-static void WINAPI glUniform3i64NV( GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z ) {
+static void WINAPI glUniform3i64NV( GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
+  TRACE( "(%d, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
   funcs->ext.p_glUniform3i64NV( location, x, y, z );
 }
 
-static void WINAPI glUniform3i64vARB( GLint location, GLsizei count, const GLint64* value ) {
+static void WINAPI glUniform3i64vARB( GLint location, GLsizei count, const GLint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform3i64vARB( location, count, value );
 }
 
-static void WINAPI glUniform3i64vNV( GLint location, GLsizei count, const GLint64EXT* value ) {
+static void WINAPI glUniform3i64vNV( GLint location, GLsizei count, const GLint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform3i64vNV( location, count, value );
 }
 
-static void WINAPI glUniform3iARB( GLint location, GLint v0, GLint v1, GLint v2 ) {
+static void WINAPI glUniform3iARB( GLint location, GLint v0, GLint v1, GLint v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", location, v0, v1, v2 );
+  TRACE( "(%d, %d, %d, %d)\n", location, v0, v1, v2 );
   funcs->ext.p_glUniform3iARB( location, v0, v1, v2 );
 }
 
-static void WINAPI glUniform3iv( GLint location, GLsizei count, const GLint* value ) {
+static void WINAPI glUniform3iv( GLint location, GLsizei count, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform3iv( location, count, value );
 }
 
-static void WINAPI glUniform3ivARB( GLint location, GLsizei count, const GLint* value ) {
+static void WINAPI glUniform3ivARB( GLint location, GLsizei count, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform3ivARB( location, count, value );
 }
 
-static void WINAPI glUniform3ui( GLint location, GLuint v0, GLuint v1, GLuint v2 ) {
+static void WINAPI glUniform3ui( GLint location, GLuint v0, GLuint v1, GLuint v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", location, v0, v1, v2 );
+  TRACE( "(%d, %d, %d, %d)\n", location, v0, v1, v2 );
   funcs->ext.p_glUniform3ui( location, v0, v1, v2 );
 }
 
-static void WINAPI glUniform3ui64ARB( GLint location, GLuint64 x, GLuint64 y, GLuint64 z ) {
+static void WINAPI glUniform3ui64ARB( GLint location, GLuint64 x, GLuint64 y, GLuint64 z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
+  TRACE( "(%d, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
   funcs->ext.p_glUniform3ui64ARB( location, x, y, z );
 }
 
-static void WINAPI glUniform3ui64NV( GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z ) {
+static void WINAPI glUniform3ui64NV( GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
+  TRACE( "(%d, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
   funcs->ext.p_glUniform3ui64NV( location, x, y, z );
 }
 
-static void WINAPI glUniform3ui64vARB( GLint location, GLsizei count, const GLuint64* value ) {
+static void WINAPI glUniform3ui64vARB( GLint location, GLsizei count, const GLuint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform3ui64vARB( location, count, value );
 }
 
-static void WINAPI glUniform3ui64vNV( GLint location, GLsizei count, const GLuint64EXT* value ) {
+static void WINAPI glUniform3ui64vNV( GLint location, GLsizei count, const GLuint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform3ui64vNV( location, count, value );
 }
 
-static void WINAPI glUniform3uiEXT( GLint location, GLuint v0, GLuint v1, GLuint v2 ) {
+static void WINAPI glUniform3uiEXT( GLint location, GLuint v0, GLuint v1, GLuint v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", location, v0, v1, v2 );
+  TRACE( "(%d, %d, %d, %d)\n", location, v0, v1, v2 );
   funcs->ext.p_glUniform3uiEXT( location, v0, v1, v2 );
 }
 
-static void WINAPI glUniform3uiv( GLint location, GLsizei count, const GLuint* value ) {
+static void WINAPI glUniform3uiv( GLint location, GLsizei count, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform3uiv( location, count, value );
 }
 
-static void WINAPI glUniform3uivEXT( GLint location, GLsizei count, const GLuint* value ) {
+static void WINAPI glUniform3uivEXT( GLint location, GLsizei count, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform3uivEXT( location, count, value );
 }
 
-static void WINAPI glUniform4d( GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+static void WINAPI glUniform4d( GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", location, x, y, z, w );
+  TRACE( "(%d, %f, %f, %f, %f)\n", location, x, y, z, w );
   funcs->ext.p_glUniform4d( location, x, y, z, w );
 }
 
-static void WINAPI glUniform4dv( GLint location, GLsizei count, const GLdouble* value ) {
+static void WINAPI glUniform4dv( GLint location, GLsizei count, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform4dv( location, count, value );
 }
 
-static void WINAPI glUniform4f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) {
+static void WINAPI glUniform4f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", location, v0, v1, v2, v3 );
+  TRACE( "(%d, %f, %f, %f, %f)\n", location, v0, v1, v2, v3 );
   funcs->ext.p_glUniform4f( location, v0, v1, v2, v3 );
 }
 
-static void WINAPI glUniform4fARB( GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) {
+static void WINAPI glUniform4fARB( GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", location, v0, v1, v2, v3 );
+  TRACE( "(%d, %f, %f, %f, %f)\n", location, v0, v1, v2, v3 );
   funcs->ext.p_glUniform4fARB( location, v0, v1, v2, v3 );
 }
 
-static void WINAPI glUniform4fv( GLint location, GLsizei count, const GLfloat* value ) {
+static void WINAPI glUniform4fv( GLint location, GLsizei count, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform4fv( location, count, value );
 }
 
-static void WINAPI glUniform4fvARB( GLint location, GLsizei count, const GLfloat* value ) {
+static void WINAPI glUniform4fvARB( GLint location, GLsizei count, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform4fvARB( location, count, value );
 }
 
-static void WINAPI glUniform4i( GLint location, GLint v0, GLint v1, GLint v2, GLint v3 ) {
+static void WINAPI glUniform4i( GLint location, GLint v0, GLint v1, GLint v2, GLint v3 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", location, v0, v1, v2, v3 );
+  TRACE( "(%d, %d, %d, %d, %d)\n", location, v0, v1, v2, v3 );
   funcs->ext.p_glUniform4i( location, v0, v1, v2, v3 );
 }
 
-static void WINAPI glUniform4i64ARB( GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w ) {
+static void WINAPI glUniform4i64ARB( GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
+  TRACE( "(%d, %s, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
   funcs->ext.p_glUniform4i64ARB( location, x, y, z, w );
 }
 
-static void WINAPI glUniform4i64NV( GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w ) {
+static void WINAPI glUniform4i64NV( GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
+  TRACE( "(%d, %s, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
   funcs->ext.p_glUniform4i64NV( location, x, y, z, w );
 }
 
-static void WINAPI glUniform4i64vARB( GLint location, GLsizei count, const GLint64* value ) {
+static void WINAPI glUniform4i64vARB( GLint location, GLsizei count, const GLint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform4i64vARB( location, count, value );
 }
 
-static void WINAPI glUniform4i64vNV( GLint location, GLsizei count, const GLint64EXT* value ) {
+static void WINAPI glUniform4i64vNV( GLint location, GLsizei count, const GLint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform4i64vNV( location, count, value );
 }
 
-static void WINAPI glUniform4iARB( GLint location, GLint v0, GLint v1, GLint v2, GLint v3 ) {
+static void WINAPI glUniform4iARB( GLint location, GLint v0, GLint v1, GLint v2, GLint v3 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", location, v0, v1, v2, v3 );
+  TRACE( "(%d, %d, %d, %d, %d)\n", location, v0, v1, v2, v3 );
   funcs->ext.p_glUniform4iARB( location, v0, v1, v2, v3 );
 }
 
-static void WINAPI glUniform4iv( GLint location, GLsizei count, const GLint* value ) {
+static void WINAPI glUniform4iv( GLint location, GLsizei count, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform4iv( location, count, value );
 }
 
-static void WINAPI glUniform4ivARB( GLint location, GLsizei count, const GLint* value ) {
+static void WINAPI glUniform4ivARB( GLint location, GLsizei count, const GLint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform4ivARB( location, count, value );
 }
 
-static void WINAPI glUniform4ui( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) {
+static void WINAPI glUniform4ui( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", location, v0, v1, v2, v3 );
+  TRACE( "(%d, %d, %d, %d, %d)\n", location, v0, v1, v2, v3 );
   funcs->ext.p_glUniform4ui( location, v0, v1, v2, v3 );
 }
 
-static void WINAPI glUniform4ui64ARB( GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w ) {
+static void WINAPI glUniform4ui64ARB( GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
+  TRACE( "(%d, %s, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
   funcs->ext.p_glUniform4ui64ARB( location, x, y, z, w );
 }
 
-static void WINAPI glUniform4ui64NV( GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w ) {
+static void WINAPI glUniform4ui64NV( GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
+  TRACE( "(%d, %s, %s, %s, %s)\n", location, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
   funcs->ext.p_glUniform4ui64NV( location, x, y, z, w );
 }
 
-static void WINAPI glUniform4ui64vARB( GLint location, GLsizei count, const GLuint64* value ) {
+static void WINAPI glUniform4ui64vARB( GLint location, GLsizei count, const GLuint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform4ui64vARB( location, count, value );
 }
 
-static void WINAPI glUniform4ui64vNV( GLint location, GLsizei count, const GLuint64EXT* value ) {
+static void WINAPI glUniform4ui64vNV( GLint location, GLsizei count, const GLuint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform4ui64vNV( location, count, value );
 }
 
-static void WINAPI glUniform4uiEXT( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) {
+static void WINAPI glUniform4uiEXT( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", location, v0, v1, v2, v3 );
+  TRACE( "(%d, %d, %d, %d, %d)\n", location, v0, v1, v2, v3 );
   funcs->ext.p_glUniform4uiEXT( location, v0, v1, v2, v3 );
 }
 
-static void WINAPI glUniform4uiv( GLint location, GLsizei count, const GLuint* value ) {
+static void WINAPI glUniform4uiv( GLint location, GLsizei count, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform4uiv( location, count, value );
 }
 
-static void WINAPI glUniform4uivEXT( GLint location, GLsizei count, const GLuint* value ) {
+static void WINAPI glUniform4uivEXT( GLint location, GLsizei count, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniform4uivEXT( location, count, value );
 }
 
-static void WINAPI glUniformBlockBinding( GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding ) {
+static void WINAPI glUniformBlockBinding( GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", program, uniformBlockIndex, uniformBlockBinding );
+  TRACE( "(%d, %d, %d)\n", program, uniformBlockIndex, uniformBlockBinding );
   funcs->ext.p_glUniformBlockBinding( program, uniformBlockIndex, uniformBlockBinding );
 }
 
-static void WINAPI glUniformBufferEXT( GLuint program, GLint location, GLuint buffer ) {
+static void WINAPI glUniformBufferEXT( GLuint program, GLint location, GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", program, location, buffer );
+  TRACE( "(%d, %d, %d)\n", program, location, buffer );
   funcs->ext.p_glUniformBufferEXT( program, location, buffer );
 }
 
-static void WINAPI glUniformHandleui64ARB( GLint location, GLuint64 value ) {
+static void WINAPI glUniformHandleui64ARB( GLint location, GLuint64 value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s)\n", location, wine_dbgstr_longlong(value) );
+  TRACE( "(%d, %s)\n", location, wine_dbgstr_longlong(value) );
   funcs->ext.p_glUniformHandleui64ARB( location, value );
 }
 
-static void WINAPI glUniformHandleui64NV( GLint location, GLuint64 value ) {
+static void WINAPI glUniformHandleui64NV( GLint location, GLuint64 value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s)\n", location, wine_dbgstr_longlong(value) );
+  TRACE( "(%d, %s)\n", location, wine_dbgstr_longlong(value) );
   funcs->ext.p_glUniformHandleui64NV( location, value );
 }
 
-static void WINAPI glUniformHandleui64vARB( GLint location, GLsizei count, const GLuint64* value ) {
+static void WINAPI glUniformHandleui64vARB( GLint location, GLsizei count, const GLuint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniformHandleui64vARB( location, count, value );
 }
 
-static void WINAPI glUniformHandleui64vNV( GLint location, GLsizei count, const GLuint64* value ) {
+static void WINAPI glUniformHandleui64vNV( GLint location, GLsizei count, const GLuint64 *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniformHandleui64vNV( location, count, value );
 }
 
-static void WINAPI glUniformMatrix2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glUniformMatrix2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix2dv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glUniformMatrix2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix2fv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix2fvARB( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glUniformMatrix2fvARB( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix2fvARB( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix2x3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glUniformMatrix2x3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix2x3dv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix2x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glUniformMatrix2x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix2x3fv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix2x4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glUniformMatrix2x4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix2x4dv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix2x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glUniformMatrix2x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix2x4fv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glUniformMatrix3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix3dv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glUniformMatrix3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix3fv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix3fvARB( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glUniformMatrix3fvARB( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix3fvARB( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix3x2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glUniformMatrix3x2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix3x2dv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix3x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glUniformMatrix3x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix3x2fv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix3x4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glUniformMatrix3x4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix3x4dv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix3x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glUniformMatrix3x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix3x4fv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glUniformMatrix4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix4dv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glUniformMatrix4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix4fv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix4fvARB( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glUniformMatrix4fvARB( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix4fvARB( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix4x2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glUniformMatrix4x2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix4x2dv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix4x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glUniformMatrix4x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix4x2fv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix4x3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) {
+static void WINAPI glUniformMatrix4x3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix4x3dv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformMatrix4x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) {
+static void WINAPI glUniformMatrix4x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", location, count, transpose, value );
+  TRACE( "(%d, %d, %d, %p)\n", location, count, transpose, value );
   funcs->ext.p_glUniformMatrix4x3fv( location, count, transpose, value );
 }
 
-static void WINAPI glUniformSubroutinesuiv( GLenum shadertype, GLsizei count, const GLuint* indices ) {
+static void WINAPI glUniformSubroutinesuiv( GLenum shadertype, GLsizei count, const GLuint *indices )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", shadertype, count, indices );
+  TRACE( "(%d, %d, %p)\n", shadertype, count, indices );
   funcs->ext.p_glUniformSubroutinesuiv( shadertype, count, indices );
 }
 
-static void WINAPI glUniformui64NV( GLint location, GLuint64EXT value ) {
+static void WINAPI glUniformui64NV( GLint location, GLuint64EXT value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s)\n", location, wine_dbgstr_longlong(value) );
+  TRACE( "(%d, %s)\n", location, wine_dbgstr_longlong(value) );
   funcs->ext.p_glUniformui64NV( location, value );
 }
 
-static void WINAPI glUniformui64vNV( GLint location, GLsizei count, const GLuint64EXT* value ) {
+static void WINAPI glUniformui64vNV( GLint location, GLsizei count, const GLuint64EXT *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", location, count, value );
+  TRACE( "(%d, %d, %p)\n", location, count, value );
   funcs->ext.p_glUniformui64vNV( location, count, value );
 }
 
-static void WINAPI glUnlockArraysEXT( void ) {
+static void WINAPI glUnlockArraysEXT(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glUnlockArraysEXT( );
+  TRACE( "()\n" );
+  funcs->ext.p_glUnlockArraysEXT();
 }
 
-static GLboolean WINAPI glUnmapBuffer( GLenum target ) {
+static GLboolean WINAPI glUnmapBuffer( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   return funcs->ext.p_glUnmapBuffer( target );
 }
 
-static GLboolean WINAPI glUnmapBufferARB( GLenum target ) {
+static GLboolean WINAPI glUnmapBufferARB( GLenum target )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", target );
+  TRACE( "(%d)\n", target );
   return funcs->ext.p_glUnmapBufferARB( target );
 }
 
-static GLboolean WINAPI glUnmapNamedBuffer( GLuint buffer ) {
+static GLboolean WINAPI glUnmapNamedBuffer( GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", buffer );
+  TRACE( "(%d)\n", buffer );
   return funcs->ext.p_glUnmapNamedBuffer( buffer );
 }
 
-static GLboolean WINAPI glUnmapNamedBufferEXT( GLuint buffer ) {
+static GLboolean WINAPI glUnmapNamedBufferEXT( GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", buffer );
+  TRACE( "(%d)\n", buffer );
   return funcs->ext.p_glUnmapNamedBufferEXT( buffer );
 }
 
-static void WINAPI glUnmapObjectBufferATI( GLuint buffer ) {
+static void WINAPI glUnmapObjectBufferATI( GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", buffer );
+  TRACE( "(%d)\n", buffer );
   funcs->ext.p_glUnmapObjectBufferATI( buffer );
 }
 
-static void WINAPI glUnmapTexture2DINTEL( GLuint texture, GLint level ) {
+static void WINAPI glUnmapTexture2DINTEL( GLuint texture, GLint level )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", texture, level );
+  TRACE( "(%d, %d)\n", texture, level );
   funcs->ext.p_glUnmapTexture2DINTEL( texture, level );
 }
 
-static void WINAPI glUpdateObjectBufferATI( GLuint buffer, GLuint offset, GLsizei size, const void* pointer, GLenum preserve ) {
+static void WINAPI glUpdateObjectBufferATI( GLuint buffer, GLuint offset, GLsizei size, const void *pointer, GLenum preserve )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %d)\n", buffer, offset, size, pointer, preserve );
+  TRACE( "(%d, %d, %d, %p, %d)\n", buffer, offset, size, pointer, preserve );
   funcs->ext.p_glUpdateObjectBufferATI( buffer, offset, size, pointer, preserve );
 }
 
-static void WINAPI glUseProgram( GLuint program ) {
+static void WINAPI glUseProgram( GLuint program )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", program );
+  TRACE( "(%d)\n", program );
   funcs->ext.p_glUseProgram( program );
 }
 
-static void WINAPI glUseProgramObjectARB( GLhandleARB programObj ) {
+static void WINAPI glUseProgramObjectARB( GLhandleARB programObj )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", programObj );
+  TRACE( "(%d)\n", programObj );
   funcs->ext.p_glUseProgramObjectARB( programObj );
 }
 
-static void WINAPI glUseProgramStages( GLuint pipeline, GLbitfield stages, GLuint program ) {
+static void WINAPI glUseProgramStages( GLuint pipeline, GLbitfield stages, GLuint program )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", pipeline, stages, program );
+  TRACE( "(%d, %d, %d)\n", pipeline, stages, program );
   funcs->ext.p_glUseProgramStages( pipeline, stages, program );
 }
 
-static void WINAPI glUseShaderProgramEXT( GLenum type, GLuint program ) {
+static void WINAPI glUseShaderProgramEXT( GLenum type, GLuint program )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", type, program );
+  TRACE( "(%d, %d)\n", type, program );
   funcs->ext.p_glUseShaderProgramEXT( type, program );
 }
 
-static void WINAPI glVDPAUFiniNV( void ) {
+static void WINAPI glVDPAUFiniNV(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->ext.p_glVDPAUFiniNV( );
+  TRACE( "()\n" );
+  funcs->ext.p_glVDPAUFiniNV();
 }
 
-static void WINAPI glVDPAUGetSurfaceivNV( GLvdpauSurfaceNV surface, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values ) {
+static void WINAPI glVDPAUGetSurfaceivNV( GLvdpauSurfaceNV surface, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%ld, %d, %d, %p, %p)\n", surface, pname, bufSize, length, values );
+  TRACE( "(%ld, %d, %d, %p, %p)\n", surface, pname, bufSize, length, values );
   funcs->ext.p_glVDPAUGetSurfaceivNV( surface, pname, bufSize, length, values );
 }
 
-static void WINAPI glVDPAUInitNV( const void* vdpDevice, const void* getProcAddress ) {
+static void WINAPI glVDPAUInitNV( const void *vdpDevice, const void *getProcAddress )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", vdpDevice, getProcAddress );
+  TRACE( "(%p, %p)\n", vdpDevice, getProcAddress );
   funcs->ext.p_glVDPAUInitNV( vdpDevice, getProcAddress );
 }
 
-static GLboolean WINAPI glVDPAUIsSurfaceNV( GLvdpauSurfaceNV surface ) {
+static GLboolean WINAPI glVDPAUIsSurfaceNV( GLvdpauSurfaceNV surface )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%ld)\n", surface );
+  TRACE( "(%ld)\n", surface );
   return funcs->ext.p_glVDPAUIsSurfaceNV( surface );
 }
 
-static void WINAPI glVDPAUMapSurfacesNV( GLsizei numSurfaces, const GLvdpauSurfaceNV* surfaces ) {
+static void WINAPI glVDPAUMapSurfacesNV( GLsizei numSurfaces, const GLvdpauSurfaceNV *surfaces )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", numSurfaces, surfaces );
+  TRACE( "(%d, %p)\n", numSurfaces, surfaces );
   funcs->ext.p_glVDPAUMapSurfacesNV( numSurfaces, surfaces );
 }
 
-static GLvdpauSurfaceNV WINAPI glVDPAURegisterOutputSurfaceNV( const void* vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint* textureNames ) {
+static GLvdpauSurfaceNV WINAPI glVDPAURegisterOutputSurfaceNV( const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %d, %d, %p)\n", vdpSurface, target, numTextureNames, textureNames );
+  TRACE( "(%p, %d, %d, %p)\n", vdpSurface, target, numTextureNames, textureNames );
   return funcs->ext.p_glVDPAURegisterOutputSurfaceNV( vdpSurface, target, numTextureNames, textureNames );
 }
 
-static GLvdpauSurfaceNV WINAPI glVDPAURegisterVideoSurfaceNV( const void* vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint* textureNames ) {
+static GLvdpauSurfaceNV WINAPI glVDPAURegisterVideoSurfaceNV( const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %d, %d, %p)\n", vdpSurface, target, numTextureNames, textureNames );
+  TRACE( "(%p, %d, %d, %p)\n", vdpSurface, target, numTextureNames, textureNames );
   return funcs->ext.p_glVDPAURegisterVideoSurfaceNV( vdpSurface, target, numTextureNames, textureNames );
 }
 
-static void WINAPI glVDPAUSurfaceAccessNV( GLvdpauSurfaceNV surface, GLenum access ) {
+static void WINAPI glVDPAUSurfaceAccessNV( GLvdpauSurfaceNV surface, GLenum access )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%ld, %d)\n", surface, access );
+  TRACE( "(%ld, %d)\n", surface, access );
   funcs->ext.p_glVDPAUSurfaceAccessNV( surface, access );
 }
 
-static void WINAPI glVDPAUUnmapSurfacesNV( GLsizei numSurface, const GLvdpauSurfaceNV* surfaces ) {
+static void WINAPI glVDPAUUnmapSurfacesNV( GLsizei numSurface, const GLvdpauSurfaceNV *surfaces )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", numSurface, surfaces );
+  TRACE( "(%d, %p)\n", numSurface, surfaces );
   funcs->ext.p_glVDPAUUnmapSurfacesNV( numSurface, surfaces );
 }
 
-static void WINAPI glVDPAUUnregisterSurfaceNV( GLvdpauSurfaceNV surface ) {
+static void WINAPI glVDPAUUnregisterSurfaceNV( GLvdpauSurfaceNV surface )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%ld)\n", surface );
+  TRACE( "(%ld)\n", surface );
   funcs->ext.p_glVDPAUUnregisterSurfaceNV( surface );
 }
 
-static void WINAPI glValidateProgram( GLuint program ) {
+static void WINAPI glValidateProgram( GLuint program )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", program );
+  TRACE( "(%d)\n", program );
   funcs->ext.p_glValidateProgram( program );
 }
 
-static void WINAPI glValidateProgramARB( GLhandleARB programObj ) {
+static void WINAPI glValidateProgramARB( GLhandleARB programObj )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", programObj );
+  TRACE( "(%d)\n", programObj );
   funcs->ext.p_glValidateProgramARB( programObj );
 }
 
-static void WINAPI glValidateProgramPipeline( GLuint pipeline ) {
+static void WINAPI glValidateProgramPipeline( GLuint pipeline )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", pipeline );
+  TRACE( "(%d)\n", pipeline );
   funcs->ext.p_glValidateProgramPipeline( pipeline );
 }
 
-static void WINAPI glVariantArrayObjectATI( GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset ) {
+static void WINAPI glVariantArrayObjectATI( GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", id, type, stride, buffer, offset );
+  TRACE( "(%d, %d, %d, %d, %d)\n", id, type, stride, buffer, offset );
   funcs->ext.p_glVariantArrayObjectATI( id, type, stride, buffer, offset );
 }
 
-static void WINAPI glVariantPointerEXT( GLuint id, GLenum type, GLuint stride, const void* addr ) {
+static void WINAPI glVariantPointerEXT( GLuint id, GLenum type, GLuint stride, const void *addr )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", id, type, stride, addr );
+  TRACE( "(%d, %d, %d, %p)\n", id, type, stride, addr );
   funcs->ext.p_glVariantPointerEXT( id, type, stride, addr );
 }
 
-static void WINAPI glVariantbvEXT( GLuint id, const GLbyte* addr ) {
+static void WINAPI glVariantbvEXT( GLuint id, const GLbyte *addr )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", id, addr );
+  TRACE( "(%d, %p)\n", id, addr );
   funcs->ext.p_glVariantbvEXT( id, addr );
 }
 
-static void WINAPI glVariantdvEXT( GLuint id, const GLdouble* addr ) {
+static void WINAPI glVariantdvEXT( GLuint id, const GLdouble *addr )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", id, addr );
+  TRACE( "(%d, %p)\n", id, addr );
   funcs->ext.p_glVariantdvEXT( id, addr );
 }
 
-static void WINAPI glVariantfvEXT( GLuint id, const GLfloat* addr ) {
+static void WINAPI glVariantfvEXT( GLuint id, const GLfloat *addr )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", id, addr );
+  TRACE( "(%d, %p)\n", id, addr );
   funcs->ext.p_glVariantfvEXT( id, addr );
 }
 
-static void WINAPI glVariantivEXT( GLuint id, const GLint* addr ) {
+static void WINAPI glVariantivEXT( GLuint id, const GLint *addr )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", id, addr );
+  TRACE( "(%d, %p)\n", id, addr );
   funcs->ext.p_glVariantivEXT( id, addr );
 }
 
-static void WINAPI glVariantsvEXT( GLuint id, const GLshort* addr ) {
+static void WINAPI glVariantsvEXT( GLuint id, const GLshort *addr )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", id, addr );
+  TRACE( "(%d, %p)\n", id, addr );
   funcs->ext.p_glVariantsvEXT( id, addr );
 }
 
-static void WINAPI glVariantubvEXT( GLuint id, const GLubyte* addr ) {
+static void WINAPI glVariantubvEXT( GLuint id, const GLubyte *addr )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", id, addr );
+  TRACE( "(%d, %p)\n", id, addr );
   funcs->ext.p_glVariantubvEXT( id, addr );
 }
 
-static void WINAPI glVariantuivEXT( GLuint id, const GLuint* addr ) {
+static void WINAPI glVariantuivEXT( GLuint id, const GLuint *addr )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", id, addr );
+  TRACE( "(%d, %p)\n", id, addr );
   funcs->ext.p_glVariantuivEXT( id, addr );
 }
 
-static void WINAPI glVariantusvEXT( GLuint id, const GLushort* addr ) {
+static void WINAPI glVariantusvEXT( GLuint id, const GLushort *addr )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", id, addr );
+  TRACE( "(%d, %p)\n", id, addr );
   funcs->ext.p_glVariantusvEXT( id, addr );
 }
 
-static void WINAPI glVertex2bOES( GLbyte x, GLbyte y ) {
+static void WINAPI glVertex2bOES( GLbyte x, GLbyte y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", x, y );
+  TRACE( "(%d, %d)\n", x, y );
   funcs->ext.p_glVertex2bOES( x, y );
 }
 
-static void WINAPI glVertex2bvOES( const GLbyte* coords ) {
+static void WINAPI glVertex2bvOES( const GLbyte *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glVertex2bvOES( coords );
 }
 
-static void WINAPI glVertex2hNV( GLhalfNV x, GLhalfNV y ) {
+static void WINAPI glVertex2hNV( GLhalfNV x, GLhalfNV y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", x, y );
+  TRACE( "(%d, %d)\n", x, y );
   funcs->ext.p_glVertex2hNV( x, y );
 }
 
-static void WINAPI glVertex2hvNV( const GLhalfNV* v ) {
+static void WINAPI glVertex2hvNV( const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glVertex2hvNV( v );
 }
 
-static void WINAPI glVertex2xOES( GLfixed x ) {
+static void WINAPI glVertex2xOES( GLfixed x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", x );
+  TRACE( "(%d)\n", x );
   funcs->ext.p_glVertex2xOES( x );
 }
 
-static void WINAPI glVertex2xvOES( const GLfixed* coords ) {
+static void WINAPI glVertex2xvOES( const GLfixed *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glVertex2xvOES( coords );
 }
 
-static void WINAPI glVertex3bOES( GLbyte x, GLbyte y, GLbyte z ) {
+static void WINAPI glVertex3bOES( GLbyte x, GLbyte y, GLbyte z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", x, y, z );
+  TRACE( "(%d, %d, %d)\n", x, y, z );
   funcs->ext.p_glVertex3bOES( x, y, z );
 }
 
-static void WINAPI glVertex3bvOES( const GLbyte* coords ) {
+static void WINAPI glVertex3bvOES( const GLbyte *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glVertex3bvOES( coords );
 }
 
-static void WINAPI glVertex3hNV( GLhalfNV x, GLhalfNV y, GLhalfNV z ) {
+static void WINAPI glVertex3hNV( GLhalfNV x, GLhalfNV y, GLhalfNV z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", x, y, z );
+  TRACE( "(%d, %d, %d)\n", x, y, z );
   funcs->ext.p_glVertex3hNV( x, y, z );
 }
 
-static void WINAPI glVertex3hvNV( const GLhalfNV* v ) {
+static void WINAPI glVertex3hvNV( const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glVertex3hvNV( v );
 }
 
-static void WINAPI glVertex3xOES( GLfixed x, GLfixed y ) {
+static void WINAPI glVertex3xOES( GLfixed x, GLfixed y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", x, y );
+  TRACE( "(%d, %d)\n", x, y );
   funcs->ext.p_glVertex3xOES( x, y );
 }
 
-static void WINAPI glVertex3xvOES( const GLfixed* coords ) {
+static void WINAPI glVertex3xvOES( const GLfixed *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glVertex3xvOES( coords );
 }
 
-static void WINAPI glVertex4bOES( GLbyte x, GLbyte y, GLbyte z, GLbyte w ) {
+static void WINAPI glVertex4bOES( GLbyte x, GLbyte y, GLbyte z, GLbyte w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
+  TRACE( "(%d, %d, %d, %d)\n", x, y, z, w );
   funcs->ext.p_glVertex4bOES( x, y, z, w );
 }
 
-static void WINAPI glVertex4bvOES( const GLbyte* coords ) {
+static void WINAPI glVertex4bvOES( const GLbyte *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glVertex4bvOES( coords );
 }
 
-static void WINAPI glVertex4hNV( GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w ) {
+static void WINAPI glVertex4hNV( GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
+  TRACE( "(%d, %d, %d, %d)\n", x, y, z, w );
   funcs->ext.p_glVertex4hNV( x, y, z, w );
 }
 
-static void WINAPI glVertex4hvNV( const GLhalfNV* v ) {
+static void WINAPI glVertex4hvNV( const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glVertex4hvNV( v );
 }
 
-static void WINAPI glVertex4xOES( GLfixed x, GLfixed y, GLfixed z ) {
+static void WINAPI glVertex4xOES( GLfixed x, GLfixed y, GLfixed z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", x, y, z );
+  TRACE( "(%d, %d, %d)\n", x, y, z );
   funcs->ext.p_glVertex4xOES( x, y, z );
 }
 
-static void WINAPI glVertex4xvOES( const GLfixed* coords ) {
+static void WINAPI glVertex4xvOES( const GLfixed *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", coords );
+  TRACE( "(%p)\n", coords );
   funcs->ext.p_glVertex4xvOES( coords );
 }
 
-static void WINAPI glVertexArrayAttribBinding( GLuint vaobj, GLuint attribindex, GLuint bindingindex ) {
+static void WINAPI glVertexArrayAttribBinding( GLuint vaobj, GLuint attribindex, GLuint bindingindex )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", vaobj, attribindex, bindingindex );
+  TRACE( "(%d, %d, %d)\n", vaobj, attribindex, bindingindex );
   funcs->ext.p_glVertexArrayAttribBinding( vaobj, attribindex, bindingindex );
 }
 
-static void WINAPI glVertexArrayAttribFormat( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset ) {
+static void WINAPI glVertexArrayAttribFormat( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", vaobj, attribindex, size, type, normalized, relativeoffset );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", vaobj, attribindex, size, type, normalized, relativeoffset );
   funcs->ext.p_glVertexArrayAttribFormat( vaobj, attribindex, size, type, normalized, relativeoffset );
 }
 
-static void WINAPI glVertexArrayAttribIFormat( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset ) {
+static void WINAPI glVertexArrayAttribIFormat( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", vaobj, attribindex, size, type, relativeoffset );
+  TRACE( "(%d, %d, %d, %d, %d)\n", vaobj, attribindex, size, type, relativeoffset );
   funcs->ext.p_glVertexArrayAttribIFormat( vaobj, attribindex, size, type, relativeoffset );
 }
 
-static void WINAPI glVertexArrayAttribLFormat( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset ) {
+static void WINAPI glVertexArrayAttribLFormat( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", vaobj, attribindex, size, type, relativeoffset );
+  TRACE( "(%d, %d, %d, %d, %d)\n", vaobj, attribindex, size, type, relativeoffset );
   funcs->ext.p_glVertexArrayAttribLFormat( vaobj, attribindex, size, type, relativeoffset );
 }
 
-static void WINAPI glVertexArrayBindVertexBufferEXT( GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride ) {
+static void WINAPI glVertexArrayBindVertexBufferEXT( GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %ld, %d)\n", vaobj, bindingindex, buffer, offset, stride );
+  TRACE( "(%d, %d, %d, %ld, %d)\n", vaobj, bindingindex, buffer, offset, stride );
   funcs->ext.p_glVertexArrayBindVertexBufferEXT( vaobj, bindingindex, buffer, offset, stride );
 }
 
-static void WINAPI glVertexArrayBindingDivisor( GLuint vaobj, GLuint bindingindex, GLuint divisor ) {
+static void WINAPI glVertexArrayBindingDivisor( GLuint vaobj, GLuint bindingindex, GLuint divisor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", vaobj, bindingindex, divisor );
+  TRACE( "(%d, %d, %d)\n", vaobj, bindingindex, divisor );
   funcs->ext.p_glVertexArrayBindingDivisor( vaobj, bindingindex, divisor );
 }
 
-static void WINAPI glVertexArrayColorOffsetEXT( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset ) {
+static void WINAPI glVertexArrayColorOffsetEXT( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %ld)\n", vaobj, buffer, size, type, stride, offset );
+  TRACE( "(%d, %d, %d, %d, %d, %ld)\n", vaobj, buffer, size, type, stride, offset );
   funcs->ext.p_glVertexArrayColorOffsetEXT( vaobj, buffer, size, type, stride, offset );
 }
 
-static void WINAPI glVertexArrayEdgeFlagOffsetEXT( GLuint vaobj, GLuint buffer, GLsizei stride, GLintptr offset ) {
+static void WINAPI glVertexArrayEdgeFlagOffsetEXT( GLuint vaobj, GLuint buffer, GLsizei stride, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %ld)\n", vaobj, buffer, stride, offset );
+  TRACE( "(%d, %d, %d, %ld)\n", vaobj, buffer, stride, offset );
   funcs->ext.p_glVertexArrayEdgeFlagOffsetEXT( vaobj, buffer, stride, offset );
 }
 
-static void WINAPI glVertexArrayElementBuffer( GLuint vaobj, GLuint buffer ) {
+static void WINAPI glVertexArrayElementBuffer( GLuint vaobj, GLuint buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", vaobj, buffer );
+  TRACE( "(%d, %d)\n", vaobj, buffer );
   funcs->ext.p_glVertexArrayElementBuffer( vaobj, buffer );
 }
 
-static void WINAPI glVertexArrayFogCoordOffsetEXT( GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset ) {
+static void WINAPI glVertexArrayFogCoordOffsetEXT( GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %ld)\n", vaobj, buffer, type, stride, offset );
+  TRACE( "(%d, %d, %d, %d, %ld)\n", vaobj, buffer, type, stride, offset );
   funcs->ext.p_glVertexArrayFogCoordOffsetEXT( vaobj, buffer, type, stride, offset );
 }
 
-static void WINAPI glVertexArrayIndexOffsetEXT( GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset ) {
+static void WINAPI glVertexArrayIndexOffsetEXT( GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %ld)\n", vaobj, buffer, type, stride, offset );
+  TRACE( "(%d, %d, %d, %d, %ld)\n", vaobj, buffer, type, stride, offset );
   funcs->ext.p_glVertexArrayIndexOffsetEXT( vaobj, buffer, type, stride, offset );
 }
 
-static void WINAPI glVertexArrayMultiTexCoordOffsetEXT( GLuint vaobj, GLuint buffer, GLenum texunit, GLint size, GLenum type, GLsizei stride, GLintptr offset ) {
+static void WINAPI glVertexArrayMultiTexCoordOffsetEXT( GLuint vaobj, GLuint buffer, GLenum texunit, GLint size, GLenum type, GLsizei stride, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %ld)\n", vaobj, buffer, texunit, size, type, stride, offset );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %ld)\n", vaobj, buffer, texunit, size, type, stride, offset );
   funcs->ext.p_glVertexArrayMultiTexCoordOffsetEXT( vaobj, buffer, texunit, size, type, stride, offset );
 }
 
-static void WINAPI glVertexArrayNormalOffsetEXT( GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset ) {
+static void WINAPI glVertexArrayNormalOffsetEXT( GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %ld)\n", vaobj, buffer, type, stride, offset );
+  TRACE( "(%d, %d, %d, %d, %ld)\n", vaobj, buffer, type, stride, offset );
   funcs->ext.p_glVertexArrayNormalOffsetEXT( vaobj, buffer, type, stride, offset );
 }
 
-static void WINAPI glVertexArrayParameteriAPPLE( GLenum pname, GLint param ) {
+static void WINAPI glVertexArrayParameteriAPPLE( GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->ext.p_glVertexArrayParameteriAPPLE( pname, param );
 }
 
-static void WINAPI glVertexArrayRangeAPPLE( GLsizei length, void* pointer ) {
+static void WINAPI glVertexArrayRangeAPPLE( GLsizei length, void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", length, pointer );
+  TRACE( "(%d, %p)\n", length, pointer );
   funcs->ext.p_glVertexArrayRangeAPPLE( length, pointer );
 }
 
-static void WINAPI glVertexArrayRangeNV( GLsizei length, const void* pointer ) {
+static void WINAPI glVertexArrayRangeNV( GLsizei length, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", length, pointer );
+  TRACE( "(%d, %p)\n", length, pointer );
   funcs->ext.p_glVertexArrayRangeNV( length, pointer );
 }
 
-static void WINAPI glVertexArraySecondaryColorOffsetEXT( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset ) {
+static void WINAPI glVertexArraySecondaryColorOffsetEXT( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %ld)\n", vaobj, buffer, size, type, stride, offset );
+  TRACE( "(%d, %d, %d, %d, %d, %ld)\n", vaobj, buffer, size, type, stride, offset );
   funcs->ext.p_glVertexArraySecondaryColorOffsetEXT( vaobj, buffer, size, type, stride, offset );
 }
 
-static void WINAPI glVertexArrayTexCoordOffsetEXT( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset ) {
+static void WINAPI glVertexArrayTexCoordOffsetEXT( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %ld)\n", vaobj, buffer, size, type, stride, offset );
+  TRACE( "(%d, %d, %d, %d, %d, %ld)\n", vaobj, buffer, size, type, stride, offset );
   funcs->ext.p_glVertexArrayTexCoordOffsetEXT( vaobj, buffer, size, type, stride, offset );
 }
 
-static void WINAPI glVertexArrayVertexAttribBindingEXT( GLuint vaobj, GLuint attribindex, GLuint bindingindex ) {
+static void WINAPI glVertexArrayVertexAttribBindingEXT( GLuint vaobj, GLuint attribindex, GLuint bindingindex )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", vaobj, attribindex, bindingindex );
+  TRACE( "(%d, %d, %d)\n", vaobj, attribindex, bindingindex );
   funcs->ext.p_glVertexArrayVertexAttribBindingEXT( vaobj, attribindex, bindingindex );
 }
 
-static void WINAPI glVertexArrayVertexAttribDivisorEXT( GLuint vaobj, GLuint index, GLuint divisor ) {
+static void WINAPI glVertexArrayVertexAttribDivisorEXT( GLuint vaobj, GLuint index, GLuint divisor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", vaobj, index, divisor );
+  TRACE( "(%d, %d, %d)\n", vaobj, index, divisor );
   funcs->ext.p_glVertexArrayVertexAttribDivisorEXT( vaobj, index, divisor );
 }
 
-static void WINAPI glVertexArrayVertexAttribFormatEXT( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset ) {
+static void WINAPI glVertexArrayVertexAttribFormatEXT( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", vaobj, attribindex, size, type, normalized, relativeoffset );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", vaobj, attribindex, size, type, normalized, relativeoffset );
   funcs->ext.p_glVertexArrayVertexAttribFormatEXT( vaobj, attribindex, size, type, normalized, relativeoffset );
 }
 
-static void WINAPI glVertexArrayVertexAttribIFormatEXT( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset ) {
+static void WINAPI glVertexArrayVertexAttribIFormatEXT( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", vaobj, attribindex, size, type, relativeoffset );
+  TRACE( "(%d, %d, %d, %d, %d)\n", vaobj, attribindex, size, type, relativeoffset );
   funcs->ext.p_glVertexArrayVertexAttribIFormatEXT( vaobj, attribindex, size, type, relativeoffset );
 }
 
-static void WINAPI glVertexArrayVertexAttribIOffsetEXT( GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset ) {
+static void WINAPI glVertexArrayVertexAttribIOffsetEXT( GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %ld)\n", vaobj, buffer, index, size, type, stride, offset );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %ld)\n", vaobj, buffer, index, size, type, stride, offset );
   funcs->ext.p_glVertexArrayVertexAttribIOffsetEXT( vaobj, buffer, index, size, type, stride, offset );
 }
 
-static void WINAPI glVertexArrayVertexAttribLFormatEXT( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset ) {
+static void WINAPI glVertexArrayVertexAttribLFormatEXT( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", vaobj, attribindex, size, type, relativeoffset );
+  TRACE( "(%d, %d, %d, %d, %d)\n", vaobj, attribindex, size, type, relativeoffset );
   funcs->ext.p_glVertexArrayVertexAttribLFormatEXT( vaobj, attribindex, size, type, relativeoffset );
 }
 
-static void WINAPI glVertexArrayVertexAttribLOffsetEXT( GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset ) {
+static void WINAPI glVertexArrayVertexAttribLOffsetEXT( GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %ld)\n", vaobj, buffer, index, size, type, stride, offset );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %ld)\n", vaobj, buffer, index, size, type, stride, offset );
   funcs->ext.p_glVertexArrayVertexAttribLOffsetEXT( vaobj, buffer, index, size, type, stride, offset );
 }
 
-static void WINAPI glVertexArrayVertexAttribOffsetEXT( GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset ) {
+static void WINAPI glVertexArrayVertexAttribOffsetEXT( GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %ld)\n", vaobj, buffer, index, size, type, normalized, stride, offset );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %ld)\n", vaobj, buffer, index, size, type, normalized, stride, offset );
   funcs->ext.p_glVertexArrayVertexAttribOffsetEXT( vaobj, buffer, index, size, type, normalized, stride, offset );
 }
 
-static void WINAPI glVertexArrayVertexBindingDivisorEXT( GLuint vaobj, GLuint bindingindex, GLuint divisor ) {
+static void WINAPI glVertexArrayVertexBindingDivisorEXT( GLuint vaobj, GLuint bindingindex, GLuint divisor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", vaobj, bindingindex, divisor );
+  TRACE( "(%d, %d, %d)\n", vaobj, bindingindex, divisor );
   funcs->ext.p_glVertexArrayVertexBindingDivisorEXT( vaobj, bindingindex, divisor );
 }
 
-static void WINAPI glVertexArrayVertexBuffer( GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride ) {
+static void WINAPI glVertexArrayVertexBuffer( GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %ld, %d)\n", vaobj, bindingindex, buffer, offset, stride );
+  TRACE( "(%d, %d, %d, %ld, %d)\n", vaobj, bindingindex, buffer, offset, stride );
   funcs->ext.p_glVertexArrayVertexBuffer( vaobj, bindingindex, buffer, offset, stride );
 }
 
-static void WINAPI glVertexArrayVertexBuffers( GLuint vaobj, GLuint first, GLsizei count, const GLuint* buffers, const GLintptr* offsets, const GLsizei* strides ) {
+static void WINAPI glVertexArrayVertexBuffers( GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %p, %p)\n", vaobj, first, count, buffers, offsets, strides );
+  TRACE( "(%d, %d, %d, %p, %p, %p)\n", vaobj, first, count, buffers, offsets, strides );
   funcs->ext.p_glVertexArrayVertexBuffers( vaobj, first, count, buffers, offsets, strides );
 }
 
-static void WINAPI glVertexArrayVertexOffsetEXT( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset ) {
+static void WINAPI glVertexArrayVertexOffsetEXT( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %ld)\n", vaobj, buffer, size, type, stride, offset );
+  TRACE( "(%d, %d, %d, %d, %d, %ld)\n", vaobj, buffer, size, type, stride, offset );
   funcs->ext.p_glVertexArrayVertexOffsetEXT( vaobj, buffer, size, type, stride, offset );
 }
 
-static void WINAPI glVertexAttrib1d( GLuint index, GLdouble x ) {
+static void WINAPI glVertexAttrib1d( GLuint index, GLdouble x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", index, x );
+  TRACE( "(%d, %f)\n", index, x );
   funcs->ext.p_glVertexAttrib1d( index, x );
 }
 
-static void WINAPI glVertexAttrib1dARB( GLuint index, GLdouble x ) {
+static void WINAPI glVertexAttrib1dARB( GLuint index, GLdouble x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", index, x );
+  TRACE( "(%d, %f)\n", index, x );
   funcs->ext.p_glVertexAttrib1dARB( index, x );
 }
 
-static void WINAPI glVertexAttrib1dNV( GLuint index, GLdouble x ) {
+static void WINAPI glVertexAttrib1dNV( GLuint index, GLdouble x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", index, x );
+  TRACE( "(%d, %f)\n", index, x );
   funcs->ext.p_glVertexAttrib1dNV( index, x );
 }
 
-static void WINAPI glVertexAttrib1dv( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttrib1dv( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib1dv( index, v );
 }
 
-static void WINAPI glVertexAttrib1dvARB( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttrib1dvARB( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib1dvARB( index, v );
 }
 
-static void WINAPI glVertexAttrib1dvNV( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttrib1dvNV( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib1dvNV( index, v );
 }
 
-static void WINAPI glVertexAttrib1f( GLuint index, GLfloat x ) {
+static void WINAPI glVertexAttrib1f( GLuint index, GLfloat x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", index, x );
+  TRACE( "(%d, %f)\n", index, x );
   funcs->ext.p_glVertexAttrib1f( index, x );
 }
 
-static void WINAPI glVertexAttrib1fARB( GLuint index, GLfloat x ) {
+static void WINAPI glVertexAttrib1fARB( GLuint index, GLfloat x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", index, x );
+  TRACE( "(%d, %f)\n", index, x );
   funcs->ext.p_glVertexAttrib1fARB( index, x );
 }
 
-static void WINAPI glVertexAttrib1fNV( GLuint index, GLfloat x ) {
+static void WINAPI glVertexAttrib1fNV( GLuint index, GLfloat x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", index, x );
+  TRACE( "(%d, %f)\n", index, x );
   funcs->ext.p_glVertexAttrib1fNV( index, x );
 }
 
-static void WINAPI glVertexAttrib1fv( GLuint index, const GLfloat* v ) {
+static void WINAPI glVertexAttrib1fv( GLuint index, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib1fv( index, v );
 }
 
-static void WINAPI glVertexAttrib1fvARB( GLuint index, const GLfloat* v ) {
+static void WINAPI glVertexAttrib1fvARB( GLuint index, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib1fvARB( index, v );
 }
 
-static void WINAPI glVertexAttrib1fvNV( GLuint index, const GLfloat* v ) {
+static void WINAPI glVertexAttrib1fvNV( GLuint index, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib1fvNV( index, v );
 }
 
-static void WINAPI glVertexAttrib1hNV( GLuint index, GLhalfNV x ) {
+static void WINAPI glVertexAttrib1hNV( GLuint index, GLhalfNV x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", index, x );
+  TRACE( "(%d, %d)\n", index, x );
   funcs->ext.p_glVertexAttrib1hNV( index, x );
 }
 
-static void WINAPI glVertexAttrib1hvNV( GLuint index, const GLhalfNV* v ) {
+static void WINAPI glVertexAttrib1hvNV( GLuint index, const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib1hvNV( index, v );
 }
 
-static void WINAPI glVertexAttrib1s( GLuint index, GLshort x ) {
+static void WINAPI glVertexAttrib1s( GLuint index, GLshort x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", index, x );
+  TRACE( "(%d, %d)\n", index, x );
   funcs->ext.p_glVertexAttrib1s( index, x );
 }
 
-static void WINAPI glVertexAttrib1sARB( GLuint index, GLshort x ) {
+static void WINAPI glVertexAttrib1sARB( GLuint index, GLshort x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", index, x );
+  TRACE( "(%d, %d)\n", index, x );
   funcs->ext.p_glVertexAttrib1sARB( index, x );
 }
 
-static void WINAPI glVertexAttrib1sNV( GLuint index, GLshort x ) {
+static void WINAPI glVertexAttrib1sNV( GLuint index, GLshort x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", index, x );
+  TRACE( "(%d, %d)\n", index, x );
   funcs->ext.p_glVertexAttrib1sNV( index, x );
 }
 
-static void WINAPI glVertexAttrib1sv( GLuint index, const GLshort* v ) {
+static void WINAPI glVertexAttrib1sv( GLuint index, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib1sv( index, v );
 }
 
-static void WINAPI glVertexAttrib1svARB( GLuint index, const GLshort* v ) {
+static void WINAPI glVertexAttrib1svARB( GLuint index, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib1svARB( index, v );
 }
 
-static void WINAPI glVertexAttrib1svNV( GLuint index, const GLshort* v ) {
+static void WINAPI glVertexAttrib1svNV( GLuint index, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib1svNV( index, v );
 }
 
-static void WINAPI glVertexAttrib2d( GLuint index, GLdouble x, GLdouble y ) {
+static void WINAPI glVertexAttrib2d( GLuint index, GLdouble x, GLdouble y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", index, x, y );
+  TRACE( "(%d, %f, %f)\n", index, x, y );
   funcs->ext.p_glVertexAttrib2d( index, x, y );
 }
 
-static void WINAPI glVertexAttrib2dARB( GLuint index, GLdouble x, GLdouble y ) {
+static void WINAPI glVertexAttrib2dARB( GLuint index, GLdouble x, GLdouble y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", index, x, y );
+  TRACE( "(%d, %f, %f)\n", index, x, y );
   funcs->ext.p_glVertexAttrib2dARB( index, x, y );
 }
 
-static void WINAPI glVertexAttrib2dNV( GLuint index, GLdouble x, GLdouble y ) {
+static void WINAPI glVertexAttrib2dNV( GLuint index, GLdouble x, GLdouble y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", index, x, y );
+  TRACE( "(%d, %f, %f)\n", index, x, y );
   funcs->ext.p_glVertexAttrib2dNV( index, x, y );
 }
 
-static void WINAPI glVertexAttrib2dv( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttrib2dv( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib2dv( index, v );
 }
 
-static void WINAPI glVertexAttrib2dvARB( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttrib2dvARB( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib2dvARB( index, v );
 }
 
-static void WINAPI glVertexAttrib2dvNV( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttrib2dvNV( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib2dvNV( index, v );
 }
 
-static void WINAPI glVertexAttrib2f( GLuint index, GLfloat x, GLfloat y ) {
+static void WINAPI glVertexAttrib2f( GLuint index, GLfloat x, GLfloat y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", index, x, y );
+  TRACE( "(%d, %f, %f)\n", index, x, y );
   funcs->ext.p_glVertexAttrib2f( index, x, y );
 }
 
-static void WINAPI glVertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y ) {
+static void WINAPI glVertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", index, x, y );
+  TRACE( "(%d, %f, %f)\n", index, x, y );
   funcs->ext.p_glVertexAttrib2fARB( index, x, y );
 }
 
-static void WINAPI glVertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y ) {
+static void WINAPI glVertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", index, x, y );
+  TRACE( "(%d, %f, %f)\n", index, x, y );
   funcs->ext.p_glVertexAttrib2fNV( index, x, y );
 }
 
-static void WINAPI glVertexAttrib2fv( GLuint index, const GLfloat* v ) {
+static void WINAPI glVertexAttrib2fv( GLuint index, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib2fv( index, v );
 }
 
-static void WINAPI glVertexAttrib2fvARB( GLuint index, const GLfloat* v ) {
+static void WINAPI glVertexAttrib2fvARB( GLuint index, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib2fvARB( index, v );
 }
 
-static void WINAPI glVertexAttrib2fvNV( GLuint index, const GLfloat* v ) {
+static void WINAPI glVertexAttrib2fvNV( GLuint index, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib2fvNV( index, v );
 }
 
-static void WINAPI glVertexAttrib2hNV( GLuint index, GLhalfNV x, GLhalfNV y ) {
+static void WINAPI glVertexAttrib2hNV( GLuint index, GLhalfNV x, GLhalfNV y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", index, x, y );
+  TRACE( "(%d, %d, %d)\n", index, x, y );
   funcs->ext.p_glVertexAttrib2hNV( index, x, y );
 }
 
-static void WINAPI glVertexAttrib2hvNV( GLuint index, const GLhalfNV* v ) {
+static void WINAPI glVertexAttrib2hvNV( GLuint index, const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib2hvNV( index, v );
 }
 
-static void WINAPI glVertexAttrib2s( GLuint index, GLshort x, GLshort y ) {
+static void WINAPI glVertexAttrib2s( GLuint index, GLshort x, GLshort y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", index, x, y );
+  TRACE( "(%d, %d, %d)\n", index, x, y );
   funcs->ext.p_glVertexAttrib2s( index, x, y );
 }
 
-static void WINAPI glVertexAttrib2sARB( GLuint index, GLshort x, GLshort y ) {
+static void WINAPI glVertexAttrib2sARB( GLuint index, GLshort x, GLshort y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", index, x, y );
+  TRACE( "(%d, %d, %d)\n", index, x, y );
   funcs->ext.p_glVertexAttrib2sARB( index, x, y );
 }
 
-static void WINAPI glVertexAttrib2sNV( GLuint index, GLshort x, GLshort y ) {
+static void WINAPI glVertexAttrib2sNV( GLuint index, GLshort x, GLshort y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", index, x, y );
+  TRACE( "(%d, %d, %d)\n", index, x, y );
   funcs->ext.p_glVertexAttrib2sNV( index, x, y );
 }
 
-static void WINAPI glVertexAttrib2sv( GLuint index, const GLshort* v ) {
+static void WINAPI glVertexAttrib2sv( GLuint index, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib2sv( index, v );
 }
 
-static void WINAPI glVertexAttrib2svARB( GLuint index, const GLshort* v ) {
+static void WINAPI glVertexAttrib2svARB( GLuint index, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib2svARB( index, v );
 }
 
-static void WINAPI glVertexAttrib2svNV( GLuint index, const GLshort* v ) {
+static void WINAPI glVertexAttrib2svNV( GLuint index, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib2svNV( index, v );
 }
 
-static void WINAPI glVertexAttrib3d( GLuint index, GLdouble x, GLdouble y, GLdouble z ) {
+static void WINAPI glVertexAttrib3d( GLuint index, GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", index, x, y, z );
+  TRACE( "(%d, %f, %f, %f)\n", index, x, y, z );
   funcs->ext.p_glVertexAttrib3d( index, x, y, z );
 }
 
-static void WINAPI glVertexAttrib3dARB( GLuint index, GLdouble x, GLdouble y, GLdouble z ) {
+static void WINAPI glVertexAttrib3dARB( GLuint index, GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", index, x, y, z );
+  TRACE( "(%d, %f, %f, %f)\n", index, x, y, z );
   funcs->ext.p_glVertexAttrib3dARB( index, x, y, z );
 }
 
-static void WINAPI glVertexAttrib3dNV( GLuint index, GLdouble x, GLdouble y, GLdouble z ) {
+static void WINAPI glVertexAttrib3dNV( GLuint index, GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", index, x, y, z );
+  TRACE( "(%d, %f, %f, %f)\n", index, x, y, z );
   funcs->ext.p_glVertexAttrib3dNV( index, x, y, z );
 }
 
-static void WINAPI glVertexAttrib3dv( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttrib3dv( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib3dv( index, v );
 }
 
-static void WINAPI glVertexAttrib3dvARB( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttrib3dvARB( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib3dvARB( index, v );
 }
 
-static void WINAPI glVertexAttrib3dvNV( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttrib3dvNV( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib3dvNV( index, v );
 }
 
-static void WINAPI glVertexAttrib3f( GLuint index, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glVertexAttrib3f( GLuint index, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", index, x, y, z );
+  TRACE( "(%d, %f, %f, %f)\n", index, x, y, z );
   funcs->ext.p_glVertexAttrib3f( index, x, y, z );
 }
 
-static void WINAPI glVertexAttrib3fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glVertexAttrib3fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", index, x, y, z );
+  TRACE( "(%d, %f, %f, %f)\n", index, x, y, z );
   funcs->ext.p_glVertexAttrib3fARB( index, x, y, z );
 }
 
-static void WINAPI glVertexAttrib3fNV( GLuint index, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glVertexAttrib3fNV( GLuint index, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", index, x, y, z );
+  TRACE( "(%d, %f, %f, %f)\n", index, x, y, z );
   funcs->ext.p_glVertexAttrib3fNV( index, x, y, z );
 }
 
-static void WINAPI glVertexAttrib3fv( GLuint index, const GLfloat* v ) {
+static void WINAPI glVertexAttrib3fv( GLuint index, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib3fv( index, v );
 }
 
-static void WINAPI glVertexAttrib3fvARB( GLuint index, const GLfloat* v ) {
+static void WINAPI glVertexAttrib3fvARB( GLuint index, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib3fvARB( index, v );
 }
 
-static void WINAPI glVertexAttrib3fvNV( GLuint index, const GLfloat* v ) {
+static void WINAPI glVertexAttrib3fvNV( GLuint index, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib3fvNV( index, v );
 }
 
-static void WINAPI glVertexAttrib3hNV( GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z ) {
+static void WINAPI glVertexAttrib3hNV( GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", index, x, y, z );
+  TRACE( "(%d, %d, %d, %d)\n", index, x, y, z );
   funcs->ext.p_glVertexAttrib3hNV( index, x, y, z );
 }
 
-static void WINAPI glVertexAttrib3hvNV( GLuint index, const GLhalfNV* v ) {
+static void WINAPI glVertexAttrib3hvNV( GLuint index, const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib3hvNV( index, v );
 }
 
-static void WINAPI glVertexAttrib3s( GLuint index, GLshort x, GLshort y, GLshort z ) {
+static void WINAPI glVertexAttrib3s( GLuint index, GLshort x, GLshort y, GLshort z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", index, x, y, z );
+  TRACE( "(%d, %d, %d, %d)\n", index, x, y, z );
   funcs->ext.p_glVertexAttrib3s( index, x, y, z );
 }
 
-static void WINAPI glVertexAttrib3sARB( GLuint index, GLshort x, GLshort y, GLshort z ) {
+static void WINAPI glVertexAttrib3sARB( GLuint index, GLshort x, GLshort y, GLshort z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", index, x, y, z );
+  TRACE( "(%d, %d, %d, %d)\n", index, x, y, z );
   funcs->ext.p_glVertexAttrib3sARB( index, x, y, z );
 }
 
-static void WINAPI glVertexAttrib3sNV( GLuint index, GLshort x, GLshort y, GLshort z ) {
+static void WINAPI glVertexAttrib3sNV( GLuint index, GLshort x, GLshort y, GLshort z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", index, x, y, z );
+  TRACE( "(%d, %d, %d, %d)\n", index, x, y, z );
   funcs->ext.p_glVertexAttrib3sNV( index, x, y, z );
 }
 
-static void WINAPI glVertexAttrib3sv( GLuint index, const GLshort* v ) {
+static void WINAPI glVertexAttrib3sv( GLuint index, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib3sv( index, v );
 }
 
-static void WINAPI glVertexAttrib3svARB( GLuint index, const GLshort* v ) {
+static void WINAPI glVertexAttrib3svARB( GLuint index, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib3svARB( index, v );
 }
 
-static void WINAPI glVertexAttrib3svNV( GLuint index, const GLshort* v ) {
+static void WINAPI glVertexAttrib3svNV( GLuint index, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib3svNV( index, v );
 }
 
-static void WINAPI glVertexAttrib4Nbv( GLuint index, const GLbyte* v ) {
+static void WINAPI glVertexAttrib4Nbv( GLuint index, const GLbyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4Nbv( index, v );
 }
 
-static void WINAPI glVertexAttrib4NbvARB( GLuint index, const GLbyte* v ) {
+static void WINAPI glVertexAttrib4NbvARB( GLuint index, const GLbyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4NbvARB( index, v );
 }
 
-static void WINAPI glVertexAttrib4Niv( GLuint index, const GLint* v ) {
+static void WINAPI glVertexAttrib4Niv( GLuint index, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4Niv( index, v );
 }
 
-static void WINAPI glVertexAttrib4NivARB( GLuint index, const GLint* v ) {
+static void WINAPI glVertexAttrib4NivARB( GLuint index, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4NivARB( index, v );
 }
 
-static void WINAPI glVertexAttrib4Nsv( GLuint index, const GLshort* v ) {
+static void WINAPI glVertexAttrib4Nsv( GLuint index, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4Nsv( index, v );
 }
 
-static void WINAPI glVertexAttrib4NsvARB( GLuint index, const GLshort* v ) {
+static void WINAPI glVertexAttrib4NsvARB( GLuint index, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4NsvARB( index, v );
 }
 
-static void WINAPI glVertexAttrib4Nub( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w ) {
+static void WINAPI glVertexAttrib4Nub( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttrib4Nub( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttrib4NubARB( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w ) {
+static void WINAPI glVertexAttrib4NubARB( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttrib4NubARB( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttrib4Nubv( GLuint index, const GLubyte* v ) {
+static void WINAPI glVertexAttrib4Nubv( GLuint index, const GLubyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4Nubv( index, v );
 }
 
-static void WINAPI glVertexAttrib4NubvARB( GLuint index, const GLubyte* v ) {
+static void WINAPI glVertexAttrib4NubvARB( GLuint index, const GLubyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4NubvARB( index, v );
 }
 
-static void WINAPI glVertexAttrib4Nuiv( GLuint index, const GLuint* v ) {
+static void WINAPI glVertexAttrib4Nuiv( GLuint index, const GLuint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4Nuiv( index, v );
 }
 
-static void WINAPI glVertexAttrib4NuivARB( GLuint index, const GLuint* v ) {
+static void WINAPI glVertexAttrib4NuivARB( GLuint index, const GLuint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4NuivARB( index, v );
 }
 
-static void WINAPI glVertexAttrib4Nusv( GLuint index, const GLushort* v ) {
+static void WINAPI glVertexAttrib4Nusv( GLuint index, const GLushort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4Nusv( index, v );
 }
 
-static void WINAPI glVertexAttrib4NusvARB( GLuint index, const GLushort* v ) {
+static void WINAPI glVertexAttrib4NusvARB( GLuint index, const GLushort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4NusvARB( index, v );
 }
 
-static void WINAPI glVertexAttrib4bv( GLuint index, const GLbyte* v ) {
+static void WINAPI glVertexAttrib4bv( GLuint index, const GLbyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4bv( index, v );
 }
 
-static void WINAPI glVertexAttrib4bvARB( GLuint index, const GLbyte* v ) {
+static void WINAPI glVertexAttrib4bvARB( GLuint index, const GLbyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4bvARB( index, v );
 }
 
-static void WINAPI glVertexAttrib4d( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+static void WINAPI glVertexAttrib4d( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, z, w );
+  TRACE( "(%d, %f, %f, %f, %f)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttrib4d( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttrib4dARB( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+static void WINAPI glVertexAttrib4dARB( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, z, w );
+  TRACE( "(%d, %f, %f, %f, %f)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttrib4dARB( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttrib4dNV( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+static void WINAPI glVertexAttrib4dNV( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, z, w );
+  TRACE( "(%d, %f, %f, %f, %f)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttrib4dNV( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttrib4dv( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttrib4dv( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4dv( index, v );
 }
 
-static void WINAPI glVertexAttrib4dvARB( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttrib4dvARB( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4dvARB( index, v );
 }
 
-static void WINAPI glVertexAttrib4dvNV( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttrib4dvNV( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4dvNV( index, v );
 }
 
-static void WINAPI glVertexAttrib4f( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+static void WINAPI glVertexAttrib4f( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, z, w );
+  TRACE( "(%d, %f, %f, %f, %f)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttrib4f( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttrib4fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+static void WINAPI glVertexAttrib4fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, z, w );
+  TRACE( "(%d, %f, %f, %f, %f)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttrib4fARB( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttrib4fNV( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+static void WINAPI glVertexAttrib4fNV( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, z, w );
+  TRACE( "(%d, %f, %f, %f, %f)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttrib4fNV( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttrib4fv( GLuint index, const GLfloat* v ) {
+static void WINAPI glVertexAttrib4fv( GLuint index, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4fv( index, v );
 }
 
-static void WINAPI glVertexAttrib4fvARB( GLuint index, const GLfloat* v ) {
+static void WINAPI glVertexAttrib4fvARB( GLuint index, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4fvARB( index, v );
 }
 
-static void WINAPI glVertexAttrib4fvNV( GLuint index, const GLfloat* v ) {
+static void WINAPI glVertexAttrib4fvNV( GLuint index, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4fvNV( index, v );
 }
 
-static void WINAPI glVertexAttrib4hNV( GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w ) {
+static void WINAPI glVertexAttrib4hNV( GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttrib4hNV( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttrib4hvNV( GLuint index, const GLhalfNV* v ) {
+static void WINAPI glVertexAttrib4hvNV( GLuint index, const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4hvNV( index, v );
 }
 
-static void WINAPI glVertexAttrib4iv( GLuint index, const GLint* v ) {
+static void WINAPI glVertexAttrib4iv( GLuint index, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4iv( index, v );
 }
 
-static void WINAPI glVertexAttrib4ivARB( GLuint index, const GLint* v ) {
+static void WINAPI glVertexAttrib4ivARB( GLuint index, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4ivARB( index, v );
 }
 
-static void WINAPI glVertexAttrib4s( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w ) {
+static void WINAPI glVertexAttrib4s( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttrib4s( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttrib4sARB( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w ) {
+static void WINAPI glVertexAttrib4sARB( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttrib4sARB( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttrib4sNV( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w ) {
+static void WINAPI glVertexAttrib4sNV( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttrib4sNV( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttrib4sv( GLuint index, const GLshort* v ) {
+static void WINAPI glVertexAttrib4sv( GLuint index, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4sv( index, v );
 }
 
-static void WINAPI glVertexAttrib4svARB( GLuint index, const GLshort* v ) {
+static void WINAPI glVertexAttrib4svARB( GLuint index, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4svARB( index, v );
 }
 
-static void WINAPI glVertexAttrib4svNV( GLuint index, const GLshort* v ) {
+static void WINAPI glVertexAttrib4svNV( GLuint index, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4svNV( index, v );
 }
 
-static void WINAPI glVertexAttrib4ubNV( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w ) {
+static void WINAPI glVertexAttrib4ubNV( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttrib4ubNV( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttrib4ubv( GLuint index, const GLubyte* v ) {
+static void WINAPI glVertexAttrib4ubv( GLuint index, const GLubyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4ubv( index, v );
 }
 
-static void WINAPI glVertexAttrib4ubvARB( GLuint index, const GLubyte* v ) {
+static void WINAPI glVertexAttrib4ubvARB( GLuint index, const GLubyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4ubvARB( index, v );
 }
 
-static void WINAPI glVertexAttrib4ubvNV( GLuint index, const GLubyte* v ) {
+static void WINAPI glVertexAttrib4ubvNV( GLuint index, const GLubyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4ubvNV( index, v );
 }
 
-static void WINAPI glVertexAttrib4uiv( GLuint index, const GLuint* v ) {
+static void WINAPI glVertexAttrib4uiv( GLuint index, const GLuint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4uiv( index, v );
 }
 
-static void WINAPI glVertexAttrib4uivARB( GLuint index, const GLuint* v ) {
+static void WINAPI glVertexAttrib4uivARB( GLuint index, const GLuint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4uivARB( index, v );
 }
 
-static void WINAPI glVertexAttrib4usv( GLuint index, const GLushort* v ) {
+static void WINAPI glVertexAttrib4usv( GLuint index, const GLushort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4usv( index, v );
 }
 
-static void WINAPI glVertexAttrib4usvARB( GLuint index, const GLushort* v ) {
+static void WINAPI glVertexAttrib4usvARB( GLuint index, const GLushort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttrib4usvARB( index, v );
 }
 
-static void WINAPI glVertexAttribArrayObjectATI( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset ) {
+static void WINAPI glVertexAttribArrayObjectATI( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", index, size, type, normalized, stride, buffer, offset );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", index, size, type, normalized, stride, buffer, offset );
   funcs->ext.p_glVertexAttribArrayObjectATI( index, size, type, normalized, stride, buffer, offset );
 }
 
-static void WINAPI glVertexAttribBinding( GLuint attribindex, GLuint bindingindex ) {
+static void WINAPI glVertexAttribBinding( GLuint attribindex, GLuint bindingindex )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", attribindex, bindingindex );
+  TRACE( "(%d, %d)\n", attribindex, bindingindex );
   funcs->ext.p_glVertexAttribBinding( attribindex, bindingindex );
 }
 
-static void WINAPI glVertexAttribDivisor( GLuint index, GLuint divisor ) {
+static void WINAPI glVertexAttribDivisor( GLuint index, GLuint divisor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", index, divisor );
+  TRACE( "(%d, %d)\n", index, divisor );
   funcs->ext.p_glVertexAttribDivisor( index, divisor );
 }
 
-static void WINAPI glVertexAttribDivisorARB( GLuint index, GLuint divisor ) {
+static void WINAPI glVertexAttribDivisorARB( GLuint index, GLuint divisor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", index, divisor );
+  TRACE( "(%d, %d)\n", index, divisor );
   funcs->ext.p_glVertexAttribDivisorARB( index, divisor );
 }
 
-static void WINAPI glVertexAttribFormat( GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset ) {
+static void WINAPI glVertexAttribFormat( GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", attribindex, size, type, normalized, relativeoffset );
+  TRACE( "(%d, %d, %d, %d, %d)\n", attribindex, size, type, normalized, relativeoffset );
   funcs->ext.p_glVertexAttribFormat( attribindex, size, type, normalized, relativeoffset );
 }
 
-static void WINAPI glVertexAttribFormatNV( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride ) {
+static void WINAPI glVertexAttribFormatNV( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", index, size, type, normalized, stride );
+  TRACE( "(%d, %d, %d, %d, %d)\n", index, size, type, normalized, stride );
   funcs->ext.p_glVertexAttribFormatNV( index, size, type, normalized, stride );
 }
 
-static void WINAPI glVertexAttribI1i( GLuint index, GLint x ) {
+static void WINAPI glVertexAttribI1i( GLuint index, GLint x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", index, x );
+  TRACE( "(%d, %d)\n", index, x );
   funcs->ext.p_glVertexAttribI1i( index, x );
 }
 
-static void WINAPI glVertexAttribI1iEXT( GLuint index, GLint x ) {
+static void WINAPI glVertexAttribI1iEXT( GLuint index, GLint x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", index, x );
+  TRACE( "(%d, %d)\n", index, x );
   funcs->ext.p_glVertexAttribI1iEXT( index, x );
 }
 
-static void WINAPI glVertexAttribI1iv( GLuint index, const GLint* v ) {
+static void WINAPI glVertexAttribI1iv( GLuint index, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI1iv( index, v );
 }
 
-static void WINAPI glVertexAttribI1ivEXT( GLuint index, const GLint* v ) {
+static void WINAPI glVertexAttribI1ivEXT( GLuint index, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI1ivEXT( index, v );
 }
 
-static void WINAPI glVertexAttribI1ui( GLuint index, GLuint x ) {
+static void WINAPI glVertexAttribI1ui( GLuint index, GLuint x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", index, x );
+  TRACE( "(%d, %d)\n", index, x );
   funcs->ext.p_glVertexAttribI1ui( index, x );
 }
 
-static void WINAPI glVertexAttribI1uiEXT( GLuint index, GLuint x ) {
+static void WINAPI glVertexAttribI1uiEXT( GLuint index, GLuint x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", index, x );
+  TRACE( "(%d, %d)\n", index, x );
   funcs->ext.p_glVertexAttribI1uiEXT( index, x );
 }
 
-static void WINAPI glVertexAttribI1uiv( GLuint index, const GLuint* v ) {
+static void WINAPI glVertexAttribI1uiv( GLuint index, const GLuint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI1uiv( index, v );
 }
 
-static void WINAPI glVertexAttribI1uivEXT( GLuint index, const GLuint* v ) {
+static void WINAPI glVertexAttribI1uivEXT( GLuint index, const GLuint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI1uivEXT( index, v );
 }
 
-static void WINAPI glVertexAttribI2i( GLuint index, GLint x, GLint y ) {
+static void WINAPI glVertexAttribI2i( GLuint index, GLint x, GLint y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", index, x, y );
+  TRACE( "(%d, %d, %d)\n", index, x, y );
   funcs->ext.p_glVertexAttribI2i( index, x, y );
 }
 
-static void WINAPI glVertexAttribI2iEXT( GLuint index, GLint x, GLint y ) {
+static void WINAPI glVertexAttribI2iEXT( GLuint index, GLint x, GLint y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", index, x, y );
+  TRACE( "(%d, %d, %d)\n", index, x, y );
   funcs->ext.p_glVertexAttribI2iEXT( index, x, y );
 }
 
-static void WINAPI glVertexAttribI2iv( GLuint index, const GLint* v ) {
+static void WINAPI glVertexAttribI2iv( GLuint index, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI2iv( index, v );
 }
 
-static void WINAPI glVertexAttribI2ivEXT( GLuint index, const GLint* v ) {
+static void WINAPI glVertexAttribI2ivEXT( GLuint index, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI2ivEXT( index, v );
 }
 
-static void WINAPI glVertexAttribI2ui( GLuint index, GLuint x, GLuint y ) {
+static void WINAPI glVertexAttribI2ui( GLuint index, GLuint x, GLuint y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", index, x, y );
+  TRACE( "(%d, %d, %d)\n", index, x, y );
   funcs->ext.p_glVertexAttribI2ui( index, x, y );
 }
 
-static void WINAPI glVertexAttribI2uiEXT( GLuint index, GLuint x, GLuint y ) {
+static void WINAPI glVertexAttribI2uiEXT( GLuint index, GLuint x, GLuint y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", index, x, y );
+  TRACE( "(%d, %d, %d)\n", index, x, y );
   funcs->ext.p_glVertexAttribI2uiEXT( index, x, y );
 }
 
-static void WINAPI glVertexAttribI2uiv( GLuint index, const GLuint* v ) {
+static void WINAPI glVertexAttribI2uiv( GLuint index, const GLuint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI2uiv( index, v );
 }
 
-static void WINAPI glVertexAttribI2uivEXT( GLuint index, const GLuint* v ) {
+static void WINAPI glVertexAttribI2uivEXT( GLuint index, const GLuint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI2uivEXT( index, v );
 }
 
-static void WINAPI glVertexAttribI3i( GLuint index, GLint x, GLint y, GLint z ) {
+static void WINAPI glVertexAttribI3i( GLuint index, GLint x, GLint y, GLint z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", index, x, y, z );
+  TRACE( "(%d, %d, %d, %d)\n", index, x, y, z );
   funcs->ext.p_glVertexAttribI3i( index, x, y, z );
 }
 
-static void WINAPI glVertexAttribI3iEXT( GLuint index, GLint x, GLint y, GLint z ) {
+static void WINAPI glVertexAttribI3iEXT( GLuint index, GLint x, GLint y, GLint z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", index, x, y, z );
+  TRACE( "(%d, %d, %d, %d)\n", index, x, y, z );
   funcs->ext.p_glVertexAttribI3iEXT( index, x, y, z );
 }
 
-static void WINAPI glVertexAttribI3iv( GLuint index, const GLint* v ) {
+static void WINAPI glVertexAttribI3iv( GLuint index, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI3iv( index, v );
 }
 
-static void WINAPI glVertexAttribI3ivEXT( GLuint index, const GLint* v ) {
+static void WINAPI glVertexAttribI3ivEXT( GLuint index, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI3ivEXT( index, v );
 }
 
-static void WINAPI glVertexAttribI3ui( GLuint index, GLuint x, GLuint y, GLuint z ) {
+static void WINAPI glVertexAttribI3ui( GLuint index, GLuint x, GLuint y, GLuint z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", index, x, y, z );
+  TRACE( "(%d, %d, %d, %d)\n", index, x, y, z );
   funcs->ext.p_glVertexAttribI3ui( index, x, y, z );
 }
 
-static void WINAPI glVertexAttribI3uiEXT( GLuint index, GLuint x, GLuint y, GLuint z ) {
+static void WINAPI glVertexAttribI3uiEXT( GLuint index, GLuint x, GLuint y, GLuint z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", index, x, y, z );
+  TRACE( "(%d, %d, %d, %d)\n", index, x, y, z );
   funcs->ext.p_glVertexAttribI3uiEXT( index, x, y, z );
 }
 
-static void WINAPI glVertexAttribI3uiv( GLuint index, const GLuint* v ) {
+static void WINAPI glVertexAttribI3uiv( GLuint index, const GLuint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI3uiv( index, v );
 }
 
-static void WINAPI glVertexAttribI3uivEXT( GLuint index, const GLuint* v ) {
+static void WINAPI glVertexAttribI3uivEXT( GLuint index, const GLuint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI3uivEXT( index, v );
 }
 
-static void WINAPI glVertexAttribI4bv( GLuint index, const GLbyte* v ) {
+static void WINAPI glVertexAttribI4bv( GLuint index, const GLbyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI4bv( index, v );
 }
 
-static void WINAPI glVertexAttribI4bvEXT( GLuint index, const GLbyte* v ) {
+static void WINAPI glVertexAttribI4bvEXT( GLuint index, const GLbyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI4bvEXT( index, v );
 }
 
-static void WINAPI glVertexAttribI4i( GLuint index, GLint x, GLint y, GLint z, GLint w ) {
+static void WINAPI glVertexAttribI4i( GLuint index, GLint x, GLint y, GLint z, GLint w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttribI4i( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttribI4iEXT( GLuint index, GLint x, GLint y, GLint z, GLint w ) {
+static void WINAPI glVertexAttribI4iEXT( GLuint index, GLint x, GLint y, GLint z, GLint w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttribI4iEXT( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttribI4iv( GLuint index, const GLint* v ) {
+static void WINAPI glVertexAttribI4iv( GLuint index, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI4iv( index, v );
 }
 
-static void WINAPI glVertexAttribI4ivEXT( GLuint index, const GLint* v ) {
+static void WINAPI glVertexAttribI4ivEXT( GLuint index, const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI4ivEXT( index, v );
 }
 
-static void WINAPI glVertexAttribI4sv( GLuint index, const GLshort* v ) {
+static void WINAPI glVertexAttribI4sv( GLuint index, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI4sv( index, v );
 }
 
-static void WINAPI glVertexAttribI4svEXT( GLuint index, const GLshort* v ) {
+static void WINAPI glVertexAttribI4svEXT( GLuint index, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI4svEXT( index, v );
 }
 
-static void WINAPI glVertexAttribI4ubv( GLuint index, const GLubyte* v ) {
+static void WINAPI glVertexAttribI4ubv( GLuint index, const GLubyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI4ubv( index, v );
 }
 
-static void WINAPI glVertexAttribI4ubvEXT( GLuint index, const GLubyte* v ) {
+static void WINAPI glVertexAttribI4ubvEXT( GLuint index, const GLubyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI4ubvEXT( index, v );
 }
 
-static void WINAPI glVertexAttribI4ui( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) {
+static void WINAPI glVertexAttribI4ui( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttribI4ui( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttribI4uiEXT( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) {
+static void WINAPI glVertexAttribI4uiEXT( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttribI4uiEXT( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttribI4uiv( GLuint index, const GLuint* v ) {
+static void WINAPI glVertexAttribI4uiv( GLuint index, const GLuint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI4uiv( index, v );
 }
 
-static void WINAPI glVertexAttribI4uivEXT( GLuint index, const GLuint* v ) {
+static void WINAPI glVertexAttribI4uivEXT( GLuint index, const GLuint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI4uivEXT( index, v );
 }
 
-static void WINAPI glVertexAttribI4usv( GLuint index, const GLushort* v ) {
+static void WINAPI glVertexAttribI4usv( GLuint index, const GLushort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI4usv( index, v );
 }
 
-static void WINAPI glVertexAttribI4usvEXT( GLuint index, const GLushort* v ) {
+static void WINAPI glVertexAttribI4usvEXT( GLuint index, const GLushort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribI4usvEXT( index, v );
 }
 
-static void WINAPI glVertexAttribIFormat( GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset ) {
+static void WINAPI glVertexAttribIFormat( GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", attribindex, size, type, relativeoffset );
+  TRACE( "(%d, %d, %d, %d)\n", attribindex, size, type, relativeoffset );
   funcs->ext.p_glVertexAttribIFormat( attribindex, size, type, relativeoffset );
 }
 
-static void WINAPI glVertexAttribIFormatNV( GLuint index, GLint size, GLenum type, GLsizei stride ) {
+static void WINAPI glVertexAttribIFormatNV( GLuint index, GLint size, GLenum type, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", index, size, type, stride );
+  TRACE( "(%d, %d, %d, %d)\n", index, size, type, stride );
   funcs->ext.p_glVertexAttribIFormatNV( index, size, type, stride );
 }
 
-static void WINAPI glVertexAttribIPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer ) {
+static void WINAPI glVertexAttribIPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", index, size, type, stride, pointer );
+  TRACE( "(%d, %d, %d, %d, %p)\n", index, size, type, stride, pointer );
   funcs->ext.p_glVertexAttribIPointer( index, size, type, stride, pointer );
 }
 
-static void WINAPI glVertexAttribIPointerEXT( GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer ) {
+static void WINAPI glVertexAttribIPointerEXT( GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", index, size, type, stride, pointer );
+  TRACE( "(%d, %d, %d, %d, %p)\n", index, size, type, stride, pointer );
   funcs->ext.p_glVertexAttribIPointerEXT( index, size, type, stride, pointer );
 }
 
-static void WINAPI glVertexAttribL1d( GLuint index, GLdouble x ) {
+static void WINAPI glVertexAttribL1d( GLuint index, GLdouble x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", index, x );
+  TRACE( "(%d, %f)\n", index, x );
   funcs->ext.p_glVertexAttribL1d( index, x );
 }
 
-static void WINAPI glVertexAttribL1dEXT( GLuint index, GLdouble x ) {
+static void WINAPI glVertexAttribL1dEXT( GLuint index, GLdouble x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", index, x );
+  TRACE( "(%d, %f)\n", index, x );
   funcs->ext.p_glVertexAttribL1dEXT( index, x );
 }
 
-static void WINAPI glVertexAttribL1dv( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttribL1dv( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribL1dv( index, v );
 }
 
-static void WINAPI glVertexAttribL1dvEXT( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttribL1dvEXT( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribL1dvEXT( index, v );
 }
 
-static void WINAPI glVertexAttribL1i64NV( GLuint index, GLint64EXT x ) {
+static void WINAPI glVertexAttribL1i64NV( GLuint index, GLint64EXT x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s)\n", index, wine_dbgstr_longlong(x) );
+  TRACE( "(%d, %s)\n", index, wine_dbgstr_longlong(x) );
   funcs->ext.p_glVertexAttribL1i64NV( index, x );
 }
 
-static void WINAPI glVertexAttribL1i64vNV( GLuint index, const GLint64EXT* v ) {
+static void WINAPI glVertexAttribL1i64vNV( GLuint index, const GLint64EXT *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribL1i64vNV( index, v );
 }
 
-static void WINAPI glVertexAttribL1ui64ARB( GLuint index, GLuint64EXT x ) {
+static void WINAPI glVertexAttribL1ui64ARB( GLuint index, GLuint64EXT x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s)\n", index, wine_dbgstr_longlong(x) );
+  TRACE( "(%d, %s)\n", index, wine_dbgstr_longlong(x) );
   funcs->ext.p_glVertexAttribL1ui64ARB( index, x );
 }
 
-static void WINAPI glVertexAttribL1ui64NV( GLuint index, GLuint64EXT x ) {
+static void WINAPI glVertexAttribL1ui64NV( GLuint index, GLuint64EXT x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s)\n", index, wine_dbgstr_longlong(x) );
+  TRACE( "(%d, %s)\n", index, wine_dbgstr_longlong(x) );
   funcs->ext.p_glVertexAttribL1ui64NV( index, x );
 }
 
-static void WINAPI glVertexAttribL1ui64vARB( GLuint index, const GLuint64EXT* v ) {
+static void WINAPI glVertexAttribL1ui64vARB( GLuint index, const GLuint64EXT *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribL1ui64vARB( index, v );
 }
 
-static void WINAPI glVertexAttribL1ui64vNV( GLuint index, const GLuint64EXT* v ) {
+static void WINAPI glVertexAttribL1ui64vNV( GLuint index, const GLuint64EXT *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribL1ui64vNV( index, v );
 }
 
-static void WINAPI glVertexAttribL2d( GLuint index, GLdouble x, GLdouble y ) {
+static void WINAPI glVertexAttribL2d( GLuint index, GLdouble x, GLdouble y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", index, x, y );
+  TRACE( "(%d, %f, %f)\n", index, x, y );
   funcs->ext.p_glVertexAttribL2d( index, x, y );
 }
 
-static void WINAPI glVertexAttribL2dEXT( GLuint index, GLdouble x, GLdouble y ) {
+static void WINAPI glVertexAttribL2dEXT( GLuint index, GLdouble x, GLdouble y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", index, x, y );
+  TRACE( "(%d, %f, %f)\n", index, x, y );
   funcs->ext.p_glVertexAttribL2dEXT( index, x, y );
 }
 
-static void WINAPI glVertexAttribL2dv( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttribL2dv( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribL2dv( index, v );
 }
 
-static void WINAPI glVertexAttribL2dvEXT( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttribL2dvEXT( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribL2dvEXT( index, v );
 }
 
-static void WINAPI glVertexAttribL2i64NV( GLuint index, GLint64EXT x, GLint64EXT y ) {
+static void WINAPI glVertexAttribL2i64NV( GLuint index, GLint64EXT x, GLint64EXT y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
+  TRACE( "(%d, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
   funcs->ext.p_glVertexAttribL2i64NV( index, x, y );
 }
 
-static void WINAPI glVertexAttribL2i64vNV( GLuint index, const GLint64EXT* v ) {
+static void WINAPI glVertexAttribL2i64vNV( GLuint index, const GLint64EXT *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribL2i64vNV( index, v );
 }
 
-static void WINAPI glVertexAttribL2ui64NV( GLuint index, GLuint64EXT x, GLuint64EXT y ) {
+static void WINAPI glVertexAttribL2ui64NV( GLuint index, GLuint64EXT x, GLuint64EXT y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
+  TRACE( "(%d, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y) );
   funcs->ext.p_glVertexAttribL2ui64NV( index, x, y );
 }
 
-static void WINAPI glVertexAttribL2ui64vNV( GLuint index, const GLuint64EXT* v ) {
+static void WINAPI glVertexAttribL2ui64vNV( GLuint index, const GLuint64EXT *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribL2ui64vNV( index, v );
 }
 
-static void WINAPI glVertexAttribL3d( GLuint index, GLdouble x, GLdouble y, GLdouble z ) {
+static void WINAPI glVertexAttribL3d( GLuint index, GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", index, x, y, z );
+  TRACE( "(%d, %f, %f, %f)\n", index, x, y, z );
   funcs->ext.p_glVertexAttribL3d( index, x, y, z );
 }
 
-static void WINAPI glVertexAttribL3dEXT( GLuint index, GLdouble x, GLdouble y, GLdouble z ) {
+static void WINAPI glVertexAttribL3dEXT( GLuint index, GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", index, x, y, z );
+  TRACE( "(%d, %f, %f, %f)\n", index, x, y, z );
   funcs->ext.p_glVertexAttribL3dEXT( index, x, y, z );
 }
 
-static void WINAPI glVertexAttribL3dv( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttribL3dv( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribL3dv( index, v );
 }
 
-static void WINAPI glVertexAttribL3dvEXT( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttribL3dvEXT( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribL3dvEXT( index, v );
 }
 
-static void WINAPI glVertexAttribL3i64NV( GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z ) {
+static void WINAPI glVertexAttribL3i64NV( GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
+  TRACE( "(%d, %s, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
   funcs->ext.p_glVertexAttribL3i64NV( index, x, y, z );
 }
 
-static void WINAPI glVertexAttribL3i64vNV( GLuint index, const GLint64EXT* v ) {
+static void WINAPI glVertexAttribL3i64vNV( GLuint index, const GLint64EXT *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribL3i64vNV( index, v );
 }
 
-static void WINAPI glVertexAttribL3ui64NV( GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z ) {
+static void WINAPI glVertexAttribL3ui64NV( GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
+  TRACE( "(%d, %s, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z) );
   funcs->ext.p_glVertexAttribL3ui64NV( index, x, y, z );
 }
 
-static void WINAPI glVertexAttribL3ui64vNV( GLuint index, const GLuint64EXT* v ) {
+static void WINAPI glVertexAttribL3ui64vNV( GLuint index, const GLuint64EXT *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribL3ui64vNV( index, v );
 }
 
-static void WINAPI glVertexAttribL4d( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+static void WINAPI glVertexAttribL4d( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, z, w );
+  TRACE( "(%d, %f, %f, %f, %f)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttribL4d( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttribL4dEXT( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+static void WINAPI glVertexAttribL4dEXT( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, z, w );
+  TRACE( "(%d, %f, %f, %f, %f)\n", index, x, y, z, w );
   funcs->ext.p_glVertexAttribL4dEXT( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttribL4dv( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttribL4dv( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribL4dv( index, v );
 }
 
-static void WINAPI glVertexAttribL4dvEXT( GLuint index, const GLdouble* v ) {
+static void WINAPI glVertexAttribL4dvEXT( GLuint index, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribL4dvEXT( index, v );
 }
 
-static void WINAPI glVertexAttribL4i64NV( GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w ) {
+static void WINAPI glVertexAttribL4i64NV( GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
+  TRACE( "(%d, %s, %s, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
   funcs->ext.p_glVertexAttribL4i64NV( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttribL4i64vNV( GLuint index, const GLint64EXT* v ) {
+static void WINAPI glVertexAttribL4i64vNV( GLuint index, const GLint64EXT *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribL4i64vNV( index, v );
 }
 
-static void WINAPI glVertexAttribL4ui64NV( GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w ) {
+static void WINAPI glVertexAttribL4ui64NV( GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %s, %s, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
+  TRACE( "(%d, %s, %s, %s, %s)\n", index, wine_dbgstr_longlong(x), wine_dbgstr_longlong(y), wine_dbgstr_longlong(z), wine_dbgstr_longlong(w) );
   funcs->ext.p_glVertexAttribL4ui64NV( index, x, y, z, w );
 }
 
-static void WINAPI glVertexAttribL4ui64vNV( GLuint index, const GLuint64EXT* v ) {
+static void WINAPI glVertexAttribL4ui64vNV( GLuint index, const GLuint64EXT *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glVertexAttribL4ui64vNV( index, v );
 }
 
-static void WINAPI glVertexAttribLFormat( GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset ) {
+static void WINAPI glVertexAttribLFormat( GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", attribindex, size, type, relativeoffset );
+  TRACE( "(%d, %d, %d, %d)\n", attribindex, size, type, relativeoffset );
   funcs->ext.p_glVertexAttribLFormat( attribindex, size, type, relativeoffset );
 }
 
-static void WINAPI glVertexAttribLFormatNV( GLuint index, GLint size, GLenum type, GLsizei stride ) {
+static void WINAPI glVertexAttribLFormatNV( GLuint index, GLint size, GLenum type, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", index, size, type, stride );
+  TRACE( "(%d, %d, %d, %d)\n", index, size, type, stride );
   funcs->ext.p_glVertexAttribLFormatNV( index, size, type, stride );
 }
 
-static void WINAPI glVertexAttribLPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer ) {
+static void WINAPI glVertexAttribLPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", index, size, type, stride, pointer );
+  TRACE( "(%d, %d, %d, %d, %p)\n", index, size, type, stride, pointer );
   funcs->ext.p_glVertexAttribLPointer( index, size, type, stride, pointer );
 }
 
-static void WINAPI glVertexAttribLPointerEXT( GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer ) {
+static void WINAPI glVertexAttribLPointerEXT( GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", index, size, type, stride, pointer );
+  TRACE( "(%d, %d, %d, %d, %p)\n", index, size, type, stride, pointer );
   funcs->ext.p_glVertexAttribLPointerEXT( index, size, type, stride, pointer );
 }
 
-static void WINAPI glVertexAttribP1ui( GLuint index, GLenum type, GLboolean normalized, GLuint value ) {
+static void WINAPI glVertexAttribP1ui( GLuint index, GLenum type, GLboolean normalized, GLuint value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", index, type, normalized, value );
+  TRACE( "(%d, %d, %d, %d)\n", index, type, normalized, value );
   funcs->ext.p_glVertexAttribP1ui( index, type, normalized, value );
 }
 
-static void WINAPI glVertexAttribP1uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint* value ) {
+static void WINAPI glVertexAttribP1uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", index, type, normalized, value );
+  TRACE( "(%d, %d, %d, %p)\n", index, type, normalized, value );
   funcs->ext.p_glVertexAttribP1uiv( index, type, normalized, value );
 }
 
-static void WINAPI glVertexAttribP2ui( GLuint index, GLenum type, GLboolean normalized, GLuint value ) {
+static void WINAPI glVertexAttribP2ui( GLuint index, GLenum type, GLboolean normalized, GLuint value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", index, type, normalized, value );
+  TRACE( "(%d, %d, %d, %d)\n", index, type, normalized, value );
   funcs->ext.p_glVertexAttribP2ui( index, type, normalized, value );
 }
 
-static void WINAPI glVertexAttribP2uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint* value ) {
+static void WINAPI glVertexAttribP2uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", index, type, normalized, value );
+  TRACE( "(%d, %d, %d, %p)\n", index, type, normalized, value );
   funcs->ext.p_glVertexAttribP2uiv( index, type, normalized, value );
 }
 
-static void WINAPI glVertexAttribP3ui( GLuint index, GLenum type, GLboolean normalized, GLuint value ) {
+static void WINAPI glVertexAttribP3ui( GLuint index, GLenum type, GLboolean normalized, GLuint value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", index, type, normalized, value );
+  TRACE( "(%d, %d, %d, %d)\n", index, type, normalized, value );
   funcs->ext.p_glVertexAttribP3ui( index, type, normalized, value );
 }
 
-static void WINAPI glVertexAttribP3uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint* value ) {
+static void WINAPI glVertexAttribP3uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", index, type, normalized, value );
+  TRACE( "(%d, %d, %d, %p)\n", index, type, normalized, value );
   funcs->ext.p_glVertexAttribP3uiv( index, type, normalized, value );
 }
 
-static void WINAPI glVertexAttribP4ui( GLuint index, GLenum type, GLboolean normalized, GLuint value ) {
+static void WINAPI glVertexAttribP4ui( GLuint index, GLenum type, GLboolean normalized, GLuint value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", index, type, normalized, value );
+  TRACE( "(%d, %d, %d, %d)\n", index, type, normalized, value );
   funcs->ext.p_glVertexAttribP4ui( index, type, normalized, value );
 }
 
-static void WINAPI glVertexAttribP4uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint* value ) {
+static void WINAPI glVertexAttribP4uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", index, type, normalized, value );
+  TRACE( "(%d, %d, %d, %p)\n", index, type, normalized, value );
   funcs->ext.p_glVertexAttribP4uiv( index, type, normalized, value );
 }
 
-static void WINAPI glVertexAttribParameteriAMD( GLuint index, GLenum pname, GLint param ) {
+static void WINAPI glVertexAttribParameteriAMD( GLuint index, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", index, pname, param );
+  TRACE( "(%d, %d, %d)\n", index, pname, param );
   funcs->ext.p_glVertexAttribParameteriAMD( index, pname, param );
 }
 
-static void WINAPI glVertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer ) {
+static void WINAPI glVertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", index, size, type, normalized, stride, pointer );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", index, size, type, normalized, stride, pointer );
   funcs->ext.p_glVertexAttribPointer( index, size, type, normalized, stride, pointer );
 }
 
-static void WINAPI glVertexAttribPointerARB( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer ) {
+static void WINAPI glVertexAttribPointerARB( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %p)\n", index, size, type, normalized, stride, pointer );
+  TRACE( "(%d, %d, %d, %d, %d, %p)\n", index, size, type, normalized, stride, pointer );
   funcs->ext.p_glVertexAttribPointerARB( index, size, type, normalized, stride, pointer );
 }
 
-static void WINAPI glVertexAttribPointerNV( GLuint index, GLint fsize, GLenum type, GLsizei stride, const void* pointer ) {
+static void WINAPI glVertexAttribPointerNV( GLuint index, GLint fsize, GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", index, fsize, type, stride, pointer );
+  TRACE( "(%d, %d, %d, %d, %p)\n", index, fsize, type, stride, pointer );
   funcs->ext.p_glVertexAttribPointerNV( index, fsize, type, stride, pointer );
 }
 
-static void WINAPI glVertexAttribs1dvNV( GLuint index, GLsizei count, const GLdouble* v ) {
+static void WINAPI glVertexAttribs1dvNV( GLuint index, GLsizei count, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, count, v );
+  TRACE( "(%d, %d, %p)\n", index, count, v );
   funcs->ext.p_glVertexAttribs1dvNV( index, count, v );
 }
 
-static void WINAPI glVertexAttribs1fvNV( GLuint index, GLsizei count, const GLfloat* v ) {
+static void WINAPI glVertexAttribs1fvNV( GLuint index, GLsizei count, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, count, v );
+  TRACE( "(%d, %d, %p)\n", index, count, v );
   funcs->ext.p_glVertexAttribs1fvNV( index, count, v );
 }
 
-static void WINAPI glVertexAttribs1hvNV( GLuint index, GLsizei n, const GLhalfNV* v ) {
+static void WINAPI glVertexAttribs1hvNV( GLuint index, GLsizei n, const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, n, v );
+  TRACE( "(%d, %d, %p)\n", index, n, v );
   funcs->ext.p_glVertexAttribs1hvNV( index, n, v );
 }
 
-static void WINAPI glVertexAttribs1svNV( GLuint index, GLsizei count, const GLshort* v ) {
+static void WINAPI glVertexAttribs1svNV( GLuint index, GLsizei count, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, count, v );
+  TRACE( "(%d, %d, %p)\n", index, count, v );
   funcs->ext.p_glVertexAttribs1svNV( index, count, v );
 }
 
-static void WINAPI glVertexAttribs2dvNV( GLuint index, GLsizei count, const GLdouble* v ) {
+static void WINAPI glVertexAttribs2dvNV( GLuint index, GLsizei count, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, count, v );
+  TRACE( "(%d, %d, %p)\n", index, count, v );
   funcs->ext.p_glVertexAttribs2dvNV( index, count, v );
 }
 
-static void WINAPI glVertexAttribs2fvNV( GLuint index, GLsizei count, const GLfloat* v ) {
+static void WINAPI glVertexAttribs2fvNV( GLuint index, GLsizei count, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, count, v );
+  TRACE( "(%d, %d, %p)\n", index, count, v );
   funcs->ext.p_glVertexAttribs2fvNV( index, count, v );
 }
 
-static void WINAPI glVertexAttribs2hvNV( GLuint index, GLsizei n, const GLhalfNV* v ) {
+static void WINAPI glVertexAttribs2hvNV( GLuint index, GLsizei n, const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, n, v );
+  TRACE( "(%d, %d, %p)\n", index, n, v );
   funcs->ext.p_glVertexAttribs2hvNV( index, n, v );
 }
 
-static void WINAPI glVertexAttribs2svNV( GLuint index, GLsizei count, const GLshort* v ) {
+static void WINAPI glVertexAttribs2svNV( GLuint index, GLsizei count, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, count, v );
+  TRACE( "(%d, %d, %p)\n", index, count, v );
   funcs->ext.p_glVertexAttribs2svNV( index, count, v );
 }
 
-static void WINAPI glVertexAttribs3dvNV( GLuint index, GLsizei count, const GLdouble* v ) {
+static void WINAPI glVertexAttribs3dvNV( GLuint index, GLsizei count, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, count, v );
+  TRACE( "(%d, %d, %p)\n", index, count, v );
   funcs->ext.p_glVertexAttribs3dvNV( index, count, v );
 }
 
-static void WINAPI glVertexAttribs3fvNV( GLuint index, GLsizei count, const GLfloat* v ) {
+static void WINAPI glVertexAttribs3fvNV( GLuint index, GLsizei count, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, count, v );
+  TRACE( "(%d, %d, %p)\n", index, count, v );
   funcs->ext.p_glVertexAttribs3fvNV( index, count, v );
 }
 
-static void WINAPI glVertexAttribs3hvNV( GLuint index, GLsizei n, const GLhalfNV* v ) {
+static void WINAPI glVertexAttribs3hvNV( GLuint index, GLsizei n, const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, n, v );
+  TRACE( "(%d, %d, %p)\n", index, n, v );
   funcs->ext.p_glVertexAttribs3hvNV( index, n, v );
 }
 
-static void WINAPI glVertexAttribs3svNV( GLuint index, GLsizei count, const GLshort* v ) {
+static void WINAPI glVertexAttribs3svNV( GLuint index, GLsizei count, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, count, v );
+  TRACE( "(%d, %d, %p)\n", index, count, v );
   funcs->ext.p_glVertexAttribs3svNV( index, count, v );
 }
 
-static void WINAPI glVertexAttribs4dvNV( GLuint index, GLsizei count, const GLdouble* v ) {
+static void WINAPI glVertexAttribs4dvNV( GLuint index, GLsizei count, const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, count, v );
+  TRACE( "(%d, %d, %p)\n", index, count, v );
   funcs->ext.p_glVertexAttribs4dvNV( index, count, v );
 }
 
-static void WINAPI glVertexAttribs4fvNV( GLuint index, GLsizei count, const GLfloat* v ) {
+static void WINAPI glVertexAttribs4fvNV( GLuint index, GLsizei count, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, count, v );
+  TRACE( "(%d, %d, %p)\n", index, count, v );
   funcs->ext.p_glVertexAttribs4fvNV( index, count, v );
 }
 
-static void WINAPI glVertexAttribs4hvNV( GLuint index, GLsizei n, const GLhalfNV* v ) {
+static void WINAPI glVertexAttribs4hvNV( GLuint index, GLsizei n, const GLhalfNV *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, n, v );
+  TRACE( "(%d, %d, %p)\n", index, n, v );
   funcs->ext.p_glVertexAttribs4hvNV( index, n, v );
 }
 
-static void WINAPI glVertexAttribs4svNV( GLuint index, GLsizei count, const GLshort* v ) {
+static void WINAPI glVertexAttribs4svNV( GLuint index, GLsizei count, const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, count, v );
+  TRACE( "(%d, %d, %p)\n", index, count, v );
   funcs->ext.p_glVertexAttribs4svNV( index, count, v );
 }
 
-static void WINAPI glVertexAttribs4ubvNV( GLuint index, GLsizei count, const GLubyte* v ) {
+static void WINAPI glVertexAttribs4ubvNV( GLuint index, GLsizei count, const GLubyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", index, count, v );
+  TRACE( "(%d, %d, %p)\n", index, count, v );
   funcs->ext.p_glVertexAttribs4ubvNV( index, count, v );
 }
 
-static void WINAPI glVertexBindingDivisor( GLuint bindingindex, GLuint divisor ) {
+static void WINAPI glVertexBindingDivisor( GLuint bindingindex, GLuint divisor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", bindingindex, divisor );
+  TRACE( "(%d, %d)\n", bindingindex, divisor );
   funcs->ext.p_glVertexBindingDivisor( bindingindex, divisor );
 }
 
-static void WINAPI glVertexBlendARB( GLint count ) {
+static void WINAPI glVertexBlendARB( GLint count )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", count );
+  TRACE( "(%d)\n", count );
   funcs->ext.p_glVertexBlendARB( count );
 }
 
-static void WINAPI glVertexBlendEnvfATI( GLenum pname, GLfloat param ) {
+static void WINAPI glVertexBlendEnvfATI( GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", pname, param );
+  TRACE( "(%d, %f)\n", pname, param );
   funcs->ext.p_glVertexBlendEnvfATI( pname, param );
 }
 
-static void WINAPI glVertexBlendEnviATI( GLenum pname, GLint param ) {
+static void WINAPI glVertexBlendEnviATI( GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->ext.p_glVertexBlendEnviATI( pname, param );
 }
 
-static void WINAPI glVertexFormatNV( GLint size, GLenum type, GLsizei stride ) {
+static void WINAPI glVertexFormatNV( GLint size, GLenum type, GLsizei stride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", size, type, stride );
+  TRACE( "(%d, %d, %d)\n", size, type, stride );
   funcs->ext.p_glVertexFormatNV( size, type, stride );
 }
 
-static void WINAPI glVertexP2ui( GLenum type, GLuint value ) {
+static void WINAPI glVertexP2ui( GLenum type, GLuint value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", type, value );
+  TRACE( "(%d, %d)\n", type, value );
   funcs->ext.p_glVertexP2ui( type, value );
 }
 
-static void WINAPI glVertexP2uiv( GLenum type, const GLuint* value ) {
+static void WINAPI glVertexP2uiv( GLenum type, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", type, value );
+  TRACE( "(%d, %p)\n", type, value );
   funcs->ext.p_glVertexP2uiv( type, value );
 }
 
-static void WINAPI glVertexP3ui( GLenum type, GLuint value ) {
+static void WINAPI glVertexP3ui( GLenum type, GLuint value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", type, value );
+  TRACE( "(%d, %d)\n", type, value );
   funcs->ext.p_glVertexP3ui( type, value );
 }
 
-static void WINAPI glVertexP3uiv( GLenum type, const GLuint* value ) {
+static void WINAPI glVertexP3uiv( GLenum type, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", type, value );
+  TRACE( "(%d, %p)\n", type, value );
   funcs->ext.p_glVertexP3uiv( type, value );
 }
 
-static void WINAPI glVertexP4ui( GLenum type, GLuint value ) {
+static void WINAPI glVertexP4ui( GLenum type, GLuint value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", type, value );
+  TRACE( "(%d, %d)\n", type, value );
   funcs->ext.p_glVertexP4ui( type, value );
 }
 
-static void WINAPI glVertexP4uiv( GLenum type, const GLuint* value ) {
+static void WINAPI glVertexP4uiv( GLenum type, const GLuint *value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", type, value );
+  TRACE( "(%d, %p)\n", type, value );
   funcs->ext.p_glVertexP4uiv( type, value );
 }
 
-static void WINAPI glVertexPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const void* pointer ) {
+static void WINAPI glVertexPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", size, type, stride, count, pointer );
+  TRACE( "(%d, %d, %d, %d, %p)\n", size, type, stride, count, pointer );
   funcs->ext.p_glVertexPointerEXT( size, type, stride, count, pointer );
 }
 
-static void WINAPI glVertexPointerListIBM( GLint size, GLenum type, GLint stride, const void** pointer, GLint ptrstride ) {
+static void WINAPI glVertexPointerListIBM( GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p, %d)\n", size, type, stride, pointer, ptrstride );
+  TRACE( "(%d, %d, %d, %p, %d)\n", size, type, stride, pointer, ptrstride );
   funcs->ext.p_glVertexPointerListIBM( size, type, stride, pointer, ptrstride );
 }
 
-static void WINAPI glVertexPointervINTEL( GLint size, GLenum type, const void** pointer ) {
+static void WINAPI glVertexPointervINTEL( GLint size, GLenum type, const void **pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", size, type, pointer );
+  TRACE( "(%d, %d, %p)\n", size, type, pointer );
   funcs->ext.p_glVertexPointervINTEL( size, type, pointer );
 }
 
-static void WINAPI glVertexStream1dATI( GLenum stream, GLdouble x ) {
+static void WINAPI glVertexStream1dATI( GLenum stream, GLdouble x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", stream, x );
+  TRACE( "(%d, %f)\n", stream, x );
   funcs->ext.p_glVertexStream1dATI( stream, x );
 }
 
-static void WINAPI glVertexStream1dvATI( GLenum stream, const GLdouble* coords ) {
+static void WINAPI glVertexStream1dvATI( GLenum stream, const GLdouble *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glVertexStream1dvATI( stream, coords );
 }
 
-static void WINAPI glVertexStream1fATI( GLenum stream, GLfloat x ) {
+static void WINAPI glVertexStream1fATI( GLenum stream, GLfloat x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", stream, x );
+  TRACE( "(%d, %f)\n", stream, x );
   funcs->ext.p_glVertexStream1fATI( stream, x );
 }
 
-static void WINAPI glVertexStream1fvATI( GLenum stream, const GLfloat* coords ) {
+static void WINAPI glVertexStream1fvATI( GLenum stream, const GLfloat *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glVertexStream1fvATI( stream, coords );
 }
 
-static void WINAPI glVertexStream1iATI( GLenum stream, GLint x ) {
+static void WINAPI glVertexStream1iATI( GLenum stream, GLint x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", stream, x );
+  TRACE( "(%d, %d)\n", stream, x );
   funcs->ext.p_glVertexStream1iATI( stream, x );
 }
 
-static void WINAPI glVertexStream1ivATI( GLenum stream, const GLint* coords ) {
+static void WINAPI glVertexStream1ivATI( GLenum stream, const GLint *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glVertexStream1ivATI( stream, coords );
 }
 
-static void WINAPI glVertexStream1sATI( GLenum stream, GLshort x ) {
+static void WINAPI glVertexStream1sATI( GLenum stream, GLshort x )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", stream, x );
+  TRACE( "(%d, %d)\n", stream, x );
   funcs->ext.p_glVertexStream1sATI( stream, x );
 }
 
-static void WINAPI glVertexStream1svATI( GLenum stream, const GLshort* coords ) {
+static void WINAPI glVertexStream1svATI( GLenum stream, const GLshort *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glVertexStream1svATI( stream, coords );
 }
 
-static void WINAPI glVertexStream2dATI( GLenum stream, GLdouble x, GLdouble y ) {
+static void WINAPI glVertexStream2dATI( GLenum stream, GLdouble x, GLdouble y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", stream, x, y );
+  TRACE( "(%d, %f, %f)\n", stream, x, y );
   funcs->ext.p_glVertexStream2dATI( stream, x, y );
 }
 
-static void WINAPI glVertexStream2dvATI( GLenum stream, const GLdouble* coords ) {
+static void WINAPI glVertexStream2dvATI( GLenum stream, const GLdouble *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glVertexStream2dvATI( stream, coords );
 }
 
-static void WINAPI glVertexStream2fATI( GLenum stream, GLfloat x, GLfloat y ) {
+static void WINAPI glVertexStream2fATI( GLenum stream, GLfloat x, GLfloat y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", stream, x, y );
+  TRACE( "(%d, %f, %f)\n", stream, x, y );
   funcs->ext.p_glVertexStream2fATI( stream, x, y );
 }
 
-static void WINAPI glVertexStream2fvATI( GLenum stream, const GLfloat* coords ) {
+static void WINAPI glVertexStream2fvATI( GLenum stream, const GLfloat *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glVertexStream2fvATI( stream, coords );
 }
 
-static void WINAPI glVertexStream2iATI( GLenum stream, GLint x, GLint y ) {
+static void WINAPI glVertexStream2iATI( GLenum stream, GLint x, GLint y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", stream, x, y );
+  TRACE( "(%d, %d, %d)\n", stream, x, y );
   funcs->ext.p_glVertexStream2iATI( stream, x, y );
 }
 
-static void WINAPI glVertexStream2ivATI( GLenum stream, const GLint* coords ) {
+static void WINAPI glVertexStream2ivATI( GLenum stream, const GLint *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glVertexStream2ivATI( stream, coords );
 }
 
-static void WINAPI glVertexStream2sATI( GLenum stream, GLshort x, GLshort y ) {
+static void WINAPI glVertexStream2sATI( GLenum stream, GLshort x, GLshort y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", stream, x, y );
+  TRACE( "(%d, %d, %d)\n", stream, x, y );
   funcs->ext.p_glVertexStream2sATI( stream, x, y );
 }
 
-static void WINAPI glVertexStream2svATI( GLenum stream, const GLshort* coords ) {
+static void WINAPI glVertexStream2svATI( GLenum stream, const GLshort *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glVertexStream2svATI( stream, coords );
 }
 
-static void WINAPI glVertexStream3dATI( GLenum stream, GLdouble x, GLdouble y, GLdouble z ) {
+static void WINAPI glVertexStream3dATI( GLenum stream, GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", stream, x, y, z );
+  TRACE( "(%d, %f, %f, %f)\n", stream, x, y, z );
   funcs->ext.p_glVertexStream3dATI( stream, x, y, z );
 }
 
-static void WINAPI glVertexStream3dvATI( GLenum stream, const GLdouble* coords ) {
+static void WINAPI glVertexStream3dvATI( GLenum stream, const GLdouble *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glVertexStream3dvATI( stream, coords );
 }
 
-static void WINAPI glVertexStream3fATI( GLenum stream, GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glVertexStream3fATI( GLenum stream, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f)\n", stream, x, y, z );
+  TRACE( "(%d, %f, %f, %f)\n", stream, x, y, z );
   funcs->ext.p_glVertexStream3fATI( stream, x, y, z );
 }
 
-static void WINAPI glVertexStream3fvATI( GLenum stream, const GLfloat* coords ) {
+static void WINAPI glVertexStream3fvATI( GLenum stream, const GLfloat *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glVertexStream3fvATI( stream, coords );
 }
 
-static void WINAPI glVertexStream3iATI( GLenum stream, GLint x, GLint y, GLint z ) {
+static void WINAPI glVertexStream3iATI( GLenum stream, GLint x, GLint y, GLint z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", stream, x, y, z );
+  TRACE( "(%d, %d, %d, %d)\n", stream, x, y, z );
   funcs->ext.p_glVertexStream3iATI( stream, x, y, z );
 }
 
-static void WINAPI glVertexStream3ivATI( GLenum stream, const GLint* coords ) {
+static void WINAPI glVertexStream3ivATI( GLenum stream, const GLint *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glVertexStream3ivATI( stream, coords );
 }
 
-static void WINAPI glVertexStream3sATI( GLenum stream, GLshort x, GLshort y, GLshort z ) {
+static void WINAPI glVertexStream3sATI( GLenum stream, GLshort x, GLshort y, GLshort z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", stream, x, y, z );
+  TRACE( "(%d, %d, %d, %d)\n", stream, x, y, z );
   funcs->ext.p_glVertexStream3sATI( stream, x, y, z );
 }
 
-static void WINAPI glVertexStream3svATI( GLenum stream, const GLshort* coords ) {
+static void WINAPI glVertexStream3svATI( GLenum stream, const GLshort *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glVertexStream3svATI( stream, coords );
 }
 
-static void WINAPI glVertexStream4dATI( GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+static void WINAPI glVertexStream4dATI( GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", stream, x, y, z, w );
+  TRACE( "(%d, %f, %f, %f, %f)\n", stream, x, y, z, w );
   funcs->ext.p_glVertexStream4dATI( stream, x, y, z, w );
 }
 
-static void WINAPI glVertexStream4dvATI( GLenum stream, const GLdouble* coords ) {
+static void WINAPI glVertexStream4dvATI( GLenum stream, const GLdouble *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glVertexStream4dvATI( stream, coords );
 }
 
-static void WINAPI glVertexStream4fATI( GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+static void WINAPI glVertexStream4fATI( GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", stream, x, y, z, w );
+  TRACE( "(%d, %f, %f, %f, %f)\n", stream, x, y, z, w );
   funcs->ext.p_glVertexStream4fATI( stream, x, y, z, w );
 }
 
-static void WINAPI glVertexStream4fvATI( GLenum stream, const GLfloat* coords ) {
+static void WINAPI glVertexStream4fvATI( GLenum stream, const GLfloat *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glVertexStream4fvATI( stream, coords );
 }
 
-static void WINAPI glVertexStream4iATI( GLenum stream, GLint x, GLint y, GLint z, GLint w ) {
+static void WINAPI glVertexStream4iATI( GLenum stream, GLint x, GLint y, GLint z, GLint w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", stream, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d)\n", stream, x, y, z, w );
   funcs->ext.p_glVertexStream4iATI( stream, x, y, z, w );
 }
 
-static void WINAPI glVertexStream4ivATI( GLenum stream, const GLint* coords ) {
+static void WINAPI glVertexStream4ivATI( GLenum stream, const GLint *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glVertexStream4ivATI( stream, coords );
 }
 
-static void WINAPI glVertexStream4sATI( GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w ) {
+static void WINAPI glVertexStream4sATI( GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", stream, x, y, z, w );
+  TRACE( "(%d, %d, %d, %d, %d)\n", stream, x, y, z, w );
   funcs->ext.p_glVertexStream4sATI( stream, x, y, z, w );
 }
 
-static void WINAPI glVertexStream4svATI( GLenum stream, const GLshort* coords ) {
+static void WINAPI glVertexStream4svATI( GLenum stream, const GLshort *coords )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stream, coords );
+  TRACE( "(%d, %p)\n", stream, coords );
   funcs->ext.p_glVertexStream4svATI( stream, coords );
 }
 
-static void WINAPI glVertexWeightPointerEXT( GLint size, GLenum type, GLsizei stride, const void* pointer ) {
+static void WINAPI glVertexWeightPointerEXT( GLint size, GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer );
+  TRACE( "(%d, %d, %d, %p)\n", size, type, stride, pointer );
   funcs->ext.p_glVertexWeightPointerEXT( size, type, stride, pointer );
 }
 
-static void WINAPI glVertexWeightfEXT( GLfloat weight ) {
+static void WINAPI glVertexWeightfEXT( GLfloat weight )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", weight );
+  TRACE( "(%f)\n", weight );
   funcs->ext.p_glVertexWeightfEXT( weight );
 }
 
-static void WINAPI glVertexWeightfvEXT( const GLfloat* weight ) {
+static void WINAPI glVertexWeightfvEXT( const GLfloat *weight )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", weight );
+  TRACE( "(%p)\n", weight );
   funcs->ext.p_glVertexWeightfvEXT( weight );
 }
 
-static void WINAPI glVertexWeighthNV( GLhalfNV weight ) {
+static void WINAPI glVertexWeighthNV( GLhalfNV weight )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", weight );
+  TRACE( "(%d)\n", weight );
   funcs->ext.p_glVertexWeighthNV( weight );
 }
 
-static void WINAPI glVertexWeighthvNV( const GLhalfNV* weight ) {
+static void WINAPI glVertexWeighthvNV( const GLhalfNV *weight )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", weight );
+  TRACE( "(%p)\n", weight );
   funcs->ext.p_glVertexWeighthvNV( weight );
 }
 
-static GLenum WINAPI glVideoCaptureNV( GLuint video_capture_slot, GLuint* sequence_num, GLuint64EXT* capture_time ) {
+static GLenum WINAPI glVideoCaptureNV( GLuint video_capture_slot, GLuint *sequence_num, GLuint64EXT *capture_time )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %p)\n", video_capture_slot, sequence_num, capture_time );
+  TRACE( "(%d, %p, %p)\n", video_capture_slot, sequence_num, capture_time );
   return funcs->ext.p_glVideoCaptureNV( video_capture_slot, sequence_num, capture_time );
 }
 
-static void WINAPI glVideoCaptureStreamParameterdvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLdouble* params ) {
+static void WINAPI glVideoCaptureStreamParameterdvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params );
   funcs->ext.p_glVideoCaptureStreamParameterdvNV( video_capture_slot, stream, pname, params );
 }
 
-static void WINAPI glVideoCaptureStreamParameterfvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLfloat* params ) {
+static void WINAPI glVideoCaptureStreamParameterfvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params );
   funcs->ext.p_glVideoCaptureStreamParameterfvNV( video_capture_slot, stream, pname, params );
 }
 
-static void WINAPI glVideoCaptureStreamParameterivNV( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLint* params ) {
+static void WINAPI glVideoCaptureStreamParameterivNV( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", video_capture_slot, stream, pname, params );
   funcs->ext.p_glVideoCaptureStreamParameterivNV( video_capture_slot, stream, pname, params );
 }
 
-static void WINAPI glViewportArrayv( GLuint first, GLsizei count, const GLfloat* v ) {
+static void WINAPI glViewportArrayv( GLuint first, GLsizei count, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", first, count, v );
+  TRACE( "(%d, %d, %p)\n", first, count, v );
   funcs->ext.p_glViewportArrayv( first, count, v );
 }
 
-static void WINAPI glViewportIndexedf( GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h ) {
+static void WINAPI glViewportIndexedf( GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %f, %f)\n", index, x, y, w, h );
+  TRACE( "(%d, %f, %f, %f, %f)\n", index, x, y, w, h );
   funcs->ext.p_glViewportIndexedf( index, x, y, w, h );
 }
 
-static void WINAPI glViewportIndexedfv( GLuint index, const GLfloat* v ) {
+static void WINAPI glViewportIndexedfv( GLuint index, const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", index, v );
+  TRACE( "(%d, %p)\n", index, v );
   funcs->ext.p_glViewportIndexedfv( index, v );
 }
 
-static void WINAPI glViewportPositionWScaleNV( GLuint index, GLfloat xcoeff, GLfloat ycoeff ) {
+static void WINAPI glViewportPositionWScaleNV( GLuint index, GLfloat xcoeff, GLfloat ycoeff )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", index, xcoeff, ycoeff );
+  TRACE( "(%d, %f, %f)\n", index, xcoeff, ycoeff );
   funcs->ext.p_glViewportPositionWScaleNV( index, xcoeff, ycoeff );
 }
 
-static void WINAPI glViewportSwizzleNV( GLuint index, GLenum swizzlex, GLenum swizzley, GLenum swizzlez, GLenum swizzlew ) {
+static void WINAPI glViewportSwizzleNV( GLuint index, GLenum swizzlex, GLenum swizzley, GLenum swizzlez, GLenum swizzlew )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", index, swizzlex, swizzley, swizzlez, swizzlew );
+  TRACE( "(%d, %d, %d, %d, %d)\n", index, swizzlex, swizzley, swizzlez, swizzlew );
   funcs->ext.p_glViewportSwizzleNV( index, swizzlex, swizzley, swizzlez, swizzlew );
 }
 
-static void WINAPI glWaitSemaphoreEXT( GLuint semaphore, GLuint numBufferBarriers, const GLuint* buffers, GLuint numTextureBarriers, const GLuint* textures, const GLenum* srcLayouts ) {
+static void WINAPI glWaitSemaphoreEXT( GLuint semaphore, GLuint numBufferBarriers, const GLuint *buffers, GLuint numTextureBarriers, const GLuint *textures, const GLenum *srcLayouts )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %d, %p, %p)\n", semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts );
+  TRACE( "(%d, %d, %p, %d, %p, %p)\n", semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts );
   funcs->ext.p_glWaitSemaphoreEXT( semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts );
 }
 
-static void WINAPI glWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout ) {
+static void WINAPI glWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %d, %s)\n", sync, flags, wine_dbgstr_longlong(timeout) );
+  TRACE( "(%p, %d, %s)\n", sync, flags, wine_dbgstr_longlong(timeout) );
   funcs->ext.p_glWaitSync( sync, flags, timeout );
 }
 
-static void WINAPI glWaitVkSemaphoreNV( GLuint64 vkSemaphore ) {
+static void WINAPI glWaitVkSemaphoreNV( GLuint64 vkSemaphore )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%s)\n", wine_dbgstr_longlong(vkSemaphore) );
+  TRACE( "(%s)\n", wine_dbgstr_longlong(vkSemaphore) );
   funcs->ext.p_glWaitVkSemaphoreNV( vkSemaphore );
 }
 
-static void WINAPI glWeightPathsNV( GLuint resultPath, GLsizei numPaths, const GLuint* paths, const GLfloat* weights ) {
+static void WINAPI glWeightPathsNV( GLuint resultPath, GLsizei numPaths, const GLuint *paths, const GLfloat *weights )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p, %p)\n", resultPath, numPaths, paths, weights );
+  TRACE( "(%d, %d, %p, %p)\n", resultPath, numPaths, paths, weights );
   funcs->ext.p_glWeightPathsNV( resultPath, numPaths, paths, weights );
 }
 
-static void WINAPI glWeightPointerARB( GLint size, GLenum type, GLsizei stride, const void* pointer ) {
+static void WINAPI glWeightPointerARB( GLint size, GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer );
+  TRACE( "(%d, %d, %d, %p)\n", size, type, stride, pointer );
   funcs->ext.p_glWeightPointerARB( size, type, stride, pointer );
 }
 
-static void WINAPI glWeightbvARB( GLint size, const GLbyte* weights ) {
+static void WINAPI glWeightbvARB( GLint size, const GLbyte *weights )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", size, weights );
+  TRACE( "(%d, %p)\n", size, weights );
   funcs->ext.p_glWeightbvARB( size, weights );
 }
 
-static void WINAPI glWeightdvARB( GLint size, const GLdouble* weights ) {
+static void WINAPI glWeightdvARB( GLint size, const GLdouble *weights )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", size, weights );
+  TRACE( "(%d, %p)\n", size, weights );
   funcs->ext.p_glWeightdvARB( size, weights );
 }
 
-static void WINAPI glWeightfvARB( GLint size, const GLfloat* weights ) {
+static void WINAPI glWeightfvARB( GLint size, const GLfloat *weights )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", size, weights );
+  TRACE( "(%d, %p)\n", size, weights );
   funcs->ext.p_glWeightfvARB( size, weights );
 }
 
-static void WINAPI glWeightivARB( GLint size, const GLint* weights ) {
+static void WINAPI glWeightivARB( GLint size, const GLint *weights )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", size, weights );
+  TRACE( "(%d, %p)\n", size, weights );
   funcs->ext.p_glWeightivARB( size, weights );
 }
 
-static void WINAPI glWeightsvARB( GLint size, const GLshort* weights ) {
+static void WINAPI glWeightsvARB( GLint size, const GLshort *weights )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", size, weights );
+  TRACE( "(%d, %p)\n", size, weights );
   funcs->ext.p_glWeightsvARB( size, weights );
 }
 
-static void WINAPI glWeightubvARB( GLint size, const GLubyte* weights ) {
+static void WINAPI glWeightubvARB( GLint size, const GLubyte *weights )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", size, weights );
+  TRACE( "(%d, %p)\n", size, weights );
   funcs->ext.p_glWeightubvARB( size, weights );
 }
 
-static void WINAPI glWeightuivARB( GLint size, const GLuint* weights ) {
+static void WINAPI glWeightuivARB( GLint size, const GLuint *weights )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", size, weights );
+  TRACE( "(%d, %p)\n", size, weights );
   funcs->ext.p_glWeightuivARB( size, weights );
 }
 
-static void WINAPI glWeightusvARB( GLint size, const GLushort* weights ) {
+static void WINAPI glWeightusvARB( GLint size, const GLushort *weights )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", size, weights );
+  TRACE( "(%d, %p)\n", size, weights );
   funcs->ext.p_glWeightusvARB( size, weights );
 }
 
-static void WINAPI glWindowPos2d( GLdouble x, GLdouble y ) {
+static void WINAPI glWindowPos2d( GLdouble x, GLdouble y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", x, y );
+  TRACE( "(%f, %f)\n", x, y );
   funcs->ext.p_glWindowPos2d( x, y );
 }
 
-static void WINAPI glWindowPos2dARB( GLdouble x, GLdouble y ) {
+static void WINAPI glWindowPos2dARB( GLdouble x, GLdouble y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", x, y );
+  TRACE( "(%f, %f)\n", x, y );
   funcs->ext.p_glWindowPos2dARB( x, y );
 }
 
-static void WINAPI glWindowPos2dMESA( GLdouble x, GLdouble y ) {
+static void WINAPI glWindowPos2dMESA( GLdouble x, GLdouble y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", x, y );
+  TRACE( "(%f, %f)\n", x, y );
   funcs->ext.p_glWindowPos2dMESA( x, y );
 }
 
-static void WINAPI glWindowPos2dv( const GLdouble* v ) {
+static void WINAPI glWindowPos2dv( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos2dv( v );
 }
 
-static void WINAPI glWindowPos2dvARB( const GLdouble* v ) {
+static void WINAPI glWindowPos2dvARB( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos2dvARB( v );
 }
 
-static void WINAPI glWindowPos2dvMESA( const GLdouble* v ) {
+static void WINAPI glWindowPos2dvMESA( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos2dvMESA( v );
 }
 
-static void WINAPI glWindowPos2f( GLfloat x, GLfloat y ) {
+static void WINAPI glWindowPos2f( GLfloat x, GLfloat y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", x, y );
+  TRACE( "(%f, %f)\n", x, y );
   funcs->ext.p_glWindowPos2f( x, y );
 }
 
-static void WINAPI glWindowPos2fARB( GLfloat x, GLfloat y ) {
+static void WINAPI glWindowPos2fARB( GLfloat x, GLfloat y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", x, y );
+  TRACE( "(%f, %f)\n", x, y );
   funcs->ext.p_glWindowPos2fARB( x, y );
 }
 
-static void WINAPI glWindowPos2fMESA( GLfloat x, GLfloat y ) {
+static void WINAPI glWindowPos2fMESA( GLfloat x, GLfloat y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", x, y );
+  TRACE( "(%f, %f)\n", x, y );
   funcs->ext.p_glWindowPos2fMESA( x, y );
 }
 
-static void WINAPI glWindowPos2fv( const GLfloat* v ) {
+static void WINAPI glWindowPos2fv( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos2fv( v );
 }
 
-static void WINAPI glWindowPos2fvARB( const GLfloat* v ) {
+static void WINAPI glWindowPos2fvARB( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos2fvARB( v );
 }
 
-static void WINAPI glWindowPos2fvMESA( const GLfloat* v ) {
+static void WINAPI glWindowPos2fvMESA( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos2fvMESA( v );
 }
 
-static void WINAPI glWindowPos2i( GLint x, GLint y ) {
+static void WINAPI glWindowPos2i( GLint x, GLint y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", x, y );
+  TRACE( "(%d, %d)\n", x, y );
   funcs->ext.p_glWindowPos2i( x, y );
 }
 
-static void WINAPI glWindowPos2iARB( GLint x, GLint y ) {
+static void WINAPI glWindowPos2iARB( GLint x, GLint y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", x, y );
+  TRACE( "(%d, %d)\n", x, y );
   funcs->ext.p_glWindowPos2iARB( x, y );
 }
 
-static void WINAPI glWindowPos2iMESA( GLint x, GLint y ) {
+static void WINAPI glWindowPos2iMESA( GLint x, GLint y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", x, y );
+  TRACE( "(%d, %d)\n", x, y );
   funcs->ext.p_glWindowPos2iMESA( x, y );
 }
 
-static void WINAPI glWindowPos2iv( const GLint* v ) {
+static void WINAPI glWindowPos2iv( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos2iv( v );
 }
 
-static void WINAPI glWindowPos2ivARB( const GLint* v ) {
+static void WINAPI glWindowPos2ivARB( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos2ivARB( v );
 }
 
-static void WINAPI glWindowPos2ivMESA( const GLint* v ) {
+static void WINAPI glWindowPos2ivMESA( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos2ivMESA( v );
 }
 
-static void WINAPI glWindowPos2s( GLshort x, GLshort y ) {
+static void WINAPI glWindowPos2s( GLshort x, GLshort y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", x, y );
+  TRACE( "(%d, %d)\n", x, y );
   funcs->ext.p_glWindowPos2s( x, y );
 }
 
-static void WINAPI glWindowPos2sARB( GLshort x, GLshort y ) {
+static void WINAPI glWindowPos2sARB( GLshort x, GLshort y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", x, y );
+  TRACE( "(%d, %d)\n", x, y );
   funcs->ext.p_glWindowPos2sARB( x, y );
 }
 
-static void WINAPI glWindowPos2sMESA( GLshort x, GLshort y ) {
+static void WINAPI glWindowPos2sMESA( GLshort x, GLshort y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", x, y );
+  TRACE( "(%d, %d)\n", x, y );
   funcs->ext.p_glWindowPos2sMESA( x, y );
 }
 
-static void WINAPI glWindowPos2sv( const GLshort* v ) {
+static void WINAPI glWindowPos2sv( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos2sv( v );
 }
 
-static void WINAPI glWindowPos2svARB( const GLshort* v ) {
+static void WINAPI glWindowPos2svARB( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos2svARB( v );
 }
 
-static void WINAPI glWindowPos2svMESA( const GLshort* v ) {
+static void WINAPI glWindowPos2svMESA( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos2svMESA( v );
 }
 
-static void WINAPI glWindowPos3d( GLdouble x, GLdouble y, GLdouble z ) {
+static void WINAPI glWindowPos3d( GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", x, y, z );
+  TRACE( "(%f, %f, %f)\n", x, y, z );
   funcs->ext.p_glWindowPos3d( x, y, z );
 }
 
-static void WINAPI glWindowPos3dARB( GLdouble x, GLdouble y, GLdouble z ) {
+static void WINAPI glWindowPos3dARB( GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", x, y, z );
+  TRACE( "(%f, %f, %f)\n", x, y, z );
   funcs->ext.p_glWindowPos3dARB( x, y, z );
 }
 
-static void WINAPI glWindowPos3dMESA( GLdouble x, GLdouble y, GLdouble z ) {
+static void WINAPI glWindowPos3dMESA( GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", x, y, z );
+  TRACE( "(%f, %f, %f)\n", x, y, z );
   funcs->ext.p_glWindowPos3dMESA( x, y, z );
 }
 
-static void WINAPI glWindowPos3dv( const GLdouble* v ) {
+static void WINAPI glWindowPos3dv( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos3dv( v );
 }
 
-static void WINAPI glWindowPos3dvARB( const GLdouble* v ) {
+static void WINAPI glWindowPos3dvARB( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos3dvARB( v );
 }
 
-static void WINAPI glWindowPos3dvMESA( const GLdouble* v ) {
+static void WINAPI glWindowPos3dvMESA( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos3dvMESA( v );
 }
 
-static void WINAPI glWindowPos3f( GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glWindowPos3f( GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", x, y, z );
+  TRACE( "(%f, %f, %f)\n", x, y, z );
   funcs->ext.p_glWindowPos3f( x, y, z );
 }
 
-static void WINAPI glWindowPos3fARB( GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glWindowPos3fARB( GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", x, y, z );
+  TRACE( "(%f, %f, %f)\n", x, y, z );
   funcs->ext.p_glWindowPos3fARB( x, y, z );
 }
 
-static void WINAPI glWindowPos3fMESA( GLfloat x, GLfloat y, GLfloat z ) {
+static void WINAPI glWindowPos3fMESA( GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", x, y, z );
+  TRACE( "(%f, %f, %f)\n", x, y, z );
   funcs->ext.p_glWindowPos3fMESA( x, y, z );
 }
 
-static void WINAPI glWindowPos3fv( const GLfloat* v ) {
+static void WINAPI glWindowPos3fv( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos3fv( v );
 }
 
-static void WINAPI glWindowPos3fvARB( const GLfloat* v ) {
+static void WINAPI glWindowPos3fvARB( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos3fvARB( v );
 }
 
-static void WINAPI glWindowPos3fvMESA( const GLfloat* v ) {
+static void WINAPI glWindowPos3fvMESA( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos3fvMESA( v );
 }
 
-static void WINAPI glWindowPos3i( GLint x, GLint y, GLint z ) {
+static void WINAPI glWindowPos3i( GLint x, GLint y, GLint z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", x, y, z );
+  TRACE( "(%d, %d, %d)\n", x, y, z );
   funcs->ext.p_glWindowPos3i( x, y, z );
 }
 
-static void WINAPI glWindowPos3iARB( GLint x, GLint y, GLint z ) {
+static void WINAPI glWindowPos3iARB( GLint x, GLint y, GLint z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", x, y, z );
+  TRACE( "(%d, %d, %d)\n", x, y, z );
   funcs->ext.p_glWindowPos3iARB( x, y, z );
 }
 
-static void WINAPI glWindowPos3iMESA( GLint x, GLint y, GLint z ) {
+static void WINAPI glWindowPos3iMESA( GLint x, GLint y, GLint z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", x, y, z );
+  TRACE( "(%d, %d, %d)\n", x, y, z );
   funcs->ext.p_glWindowPos3iMESA( x, y, z );
 }
 
-static void WINAPI glWindowPos3iv( const GLint* v ) {
+static void WINAPI glWindowPos3iv( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos3iv( v );
 }
 
-static void WINAPI glWindowPos3ivARB( const GLint* v ) {
+static void WINAPI glWindowPos3ivARB( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos3ivARB( v );
 }
 
-static void WINAPI glWindowPos3ivMESA( const GLint* v ) {
+static void WINAPI glWindowPos3ivMESA( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos3ivMESA( v );
 }
 
-static void WINAPI glWindowPos3s( GLshort x, GLshort y, GLshort z ) {
+static void WINAPI glWindowPos3s( GLshort x, GLshort y, GLshort z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", x, y, z );
+  TRACE( "(%d, %d, %d)\n", x, y, z );
   funcs->ext.p_glWindowPos3s( x, y, z );
 }
 
-static void WINAPI glWindowPos3sARB( GLshort x, GLshort y, GLshort z ) {
+static void WINAPI glWindowPos3sARB( GLshort x, GLshort y, GLshort z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", x, y, z );
+  TRACE( "(%d, %d, %d)\n", x, y, z );
   funcs->ext.p_glWindowPos3sARB( x, y, z );
 }
 
-static void WINAPI glWindowPos3sMESA( GLshort x, GLshort y, GLshort z ) {
+static void WINAPI glWindowPos3sMESA( GLshort x, GLshort y, GLshort z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", x, y, z );
+  TRACE( "(%d, %d, %d)\n", x, y, z );
   funcs->ext.p_glWindowPos3sMESA( x, y, z );
 }
 
-static void WINAPI glWindowPos3sv( const GLshort* v ) {
+static void WINAPI glWindowPos3sv( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos3sv( v );
 }
 
-static void WINAPI glWindowPos3svARB( const GLshort* v ) {
+static void WINAPI glWindowPos3svARB( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos3svARB( v );
 }
 
-static void WINAPI glWindowPos3svMESA( const GLshort* v ) {
+static void WINAPI glWindowPos3svMESA( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos3svMESA( v );
 }
 
-static void WINAPI glWindowPos4dMESA( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+static void WINAPI glWindowPos4dMESA( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", x, y, z, w );
+  TRACE( "(%f, %f, %f, %f)\n", x, y, z, w );
   funcs->ext.p_glWindowPos4dMESA( x, y, z, w );
 }
 
-static void WINAPI glWindowPos4dvMESA( const GLdouble* v ) {
+static void WINAPI glWindowPos4dvMESA( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos4dvMESA( v );
 }
 
-static void WINAPI glWindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+static void WINAPI glWindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", x, y, z, w );
+  TRACE( "(%f, %f, %f, %f)\n", x, y, z, w );
   funcs->ext.p_glWindowPos4fMESA( x, y, z, w );
 }
 
-static void WINAPI glWindowPos4fvMESA( const GLfloat* v ) {
+static void WINAPI glWindowPos4fvMESA( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos4fvMESA( v );
 }
 
-static void WINAPI glWindowPos4iMESA( GLint x, GLint y, GLint z, GLint w ) {
+static void WINAPI glWindowPos4iMESA( GLint x, GLint y, GLint z, GLint w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
+  TRACE( "(%d, %d, %d, %d)\n", x, y, z, w );
   funcs->ext.p_glWindowPos4iMESA( x, y, z, w );
 }
 
-static void WINAPI glWindowPos4ivMESA( const GLint* v ) {
+static void WINAPI glWindowPos4ivMESA( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos4ivMESA( v );
 }
 
-static void WINAPI glWindowPos4sMESA( GLshort x, GLshort y, GLshort z, GLshort w ) {
+static void WINAPI glWindowPos4sMESA( GLshort x, GLshort y, GLshort z, GLshort w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
+  TRACE( "(%d, %d, %d, %d)\n", x, y, z, w );
   funcs->ext.p_glWindowPos4sMESA( x, y, z, w );
 }
 
-static void WINAPI glWindowPos4svMESA( const GLshort* v ) {
+static void WINAPI glWindowPos4svMESA( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->ext.p_glWindowPos4svMESA( v );
 }
 
-static void WINAPI glWindowRectanglesEXT( GLenum mode, GLsizei count, const GLint* box ) {
+static void WINAPI glWindowRectanglesEXT( GLenum mode, GLsizei count, const GLint *box )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", mode, count, box );
+  TRACE( "(%d, %d, %p)\n", mode, count, box );
   funcs->ext.p_glWindowRectanglesEXT( mode, count, box );
 }
 
-static void WINAPI glWriteMaskEXT( GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW ) {
+static void WINAPI glWriteMaskEXT( GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", res, in, outX, outY, outZ, outW );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", res, in, outX, outY, outZ, outW );
   funcs->ext.p_glWriteMaskEXT( res, in, outX, outY, outZ, outW );
 }
 
diff --git a/dlls/opengl32/opengl_norm.c b/dlls/opengl32/opengl_norm.c
index 1640b17..ca0a3ac 100644
--- a/dlls/opengl32/opengl_norm.c
+++ b/dlls/opengl32/opengl_norm.c
@@ -11,2071 +11,2405 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(opengl);
 
-void WINAPI glAccum( GLenum op, GLfloat value ) {
+void WINAPI glAccum( GLenum op, GLfloat value )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", op, value );
+  TRACE( "(%d, %f)\n", op, value );
   funcs->gl.p_glAccum( op, value );
 }
 
-void WINAPI glAlphaFunc( GLenum func, GLfloat ref ) {
+void WINAPI glAlphaFunc( GLenum func, GLfloat ref )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", func, ref );
+  TRACE( "(%d, %f)\n", func, ref );
   funcs->gl.p_glAlphaFunc( func, ref );
 }
 
-GLboolean WINAPI glAreTexturesResident( GLsizei n, const GLuint* textures, GLboolean* residences ) {
+GLboolean WINAPI glAreTexturesResident( GLsizei n, const GLuint *textures, GLboolean *residences )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %p)\n", n, textures, residences );
+  TRACE( "(%d, %p, %p)\n", n, textures, residences );
   return funcs->gl.p_glAreTexturesResident( n, textures, residences );
 }
 
-void WINAPI glArrayElement( GLint i ) {
+void WINAPI glArrayElement( GLint i )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", i );
+  TRACE( "(%d)\n", i );
   funcs->gl.p_glArrayElement( i );
 }
 
-void WINAPI glBegin( GLenum mode ) {
+void WINAPI glBegin( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   funcs->gl.p_glBegin( mode );
 }
 
-void WINAPI glBindTexture( GLenum target, GLuint texture ) {
+void WINAPI glBindTexture( GLenum target, GLuint texture )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, texture );
+  TRACE( "(%d, %d)\n", target, texture );
   funcs->gl.p_glBindTexture( target, texture );
 }
 
-void WINAPI glBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap ) {
+void WINAPI glBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f, %f, %f, %f, %p)\n", width, height, xorig, yorig, xmove, ymove, bitmap );
+  TRACE( "(%d, %d, %f, %f, %f, %f, %p)\n", width, height, xorig, yorig, xmove, ymove, bitmap );
   funcs->gl.p_glBitmap( width, height, xorig, yorig, xmove, ymove, bitmap );
 }
 
-void WINAPI glBlendFunc( GLenum sfactor, GLenum dfactor ) {
+void WINAPI glBlendFunc( GLenum sfactor, GLenum dfactor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", sfactor, dfactor );
+  TRACE( "(%d, %d)\n", sfactor, dfactor );
   funcs->gl.p_glBlendFunc( sfactor, dfactor );
 }
 
-void WINAPI glCallList( GLuint list ) {
+void WINAPI glCallList( GLuint list )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", list );
+  TRACE( "(%d)\n", list );
   funcs->gl.p_glCallList( list );
 }
 
-void WINAPI glCallLists( GLsizei n, GLenum type, const void* lists ) {
+void WINAPI glCallLists( GLsizei n, GLenum type, const void *lists )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", n, type, lists );
+  TRACE( "(%d, %d, %p)\n", n, type, lists );
   funcs->gl.p_glCallLists( n, type, lists );
 }
 
-void WINAPI glClear( GLbitfield mask ) {
+void WINAPI glClear( GLbitfield mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mask );
+  TRACE( "(%d)\n", mask );
   funcs->gl.p_glClear( mask );
 }
 
-void WINAPI glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) {
+void WINAPI glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha );
+  TRACE( "(%f, %f, %f, %f)\n", red, green, blue, alpha );
   funcs->gl.p_glClearAccum( red, green, blue, alpha );
 }
 
-void WINAPI glClearColor( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) {
+void WINAPI glClearColor( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha );
+  TRACE( "(%f, %f, %f, %f)\n", red, green, blue, alpha );
   funcs->gl.p_glClearColor( red, green, blue, alpha );
 }
 
-void WINAPI glClearDepth( GLdouble depth ) {
+void WINAPI glClearDepth( GLdouble depth )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", depth );
+  TRACE( "(%f)\n", depth );
   funcs->gl.p_glClearDepth( depth );
 }
 
-void WINAPI glClearIndex( GLfloat c ) {
+void WINAPI glClearIndex( GLfloat c )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", c );
+  TRACE( "(%f)\n", c );
   funcs->gl.p_glClearIndex( c );
 }
 
-void WINAPI glClearStencil( GLint s ) {
+void WINAPI glClearStencil( GLint s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", s );
+  TRACE( "(%d)\n", s );
   funcs->gl.p_glClearStencil( s );
 }
 
-void WINAPI glClipPlane( GLenum plane, const GLdouble* equation ) {
+void WINAPI glClipPlane( GLenum plane, const GLdouble *equation )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", plane, equation );
+  TRACE( "(%d, %p)\n", plane, equation );
   funcs->gl.p_glClipPlane( plane, equation );
 }
 
-void WINAPI glColor3b( GLbyte red, GLbyte green, GLbyte blue ) {
+void WINAPI glColor3b( GLbyte red, GLbyte green, GLbyte blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->gl.p_glColor3b( red, green, blue );
 }
 
-void WINAPI glColor3bv( const GLbyte* v ) {
+void WINAPI glColor3bv( const GLbyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glColor3bv( v );
 }
 
-void WINAPI glColor3d( GLdouble red, GLdouble green, GLdouble blue ) {
+void WINAPI glColor3d( GLdouble red, GLdouble green, GLdouble blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", red, green, blue );
+  TRACE( "(%f, %f, %f)\n", red, green, blue );
   funcs->gl.p_glColor3d( red, green, blue );
 }
 
-void WINAPI glColor3dv( const GLdouble* v ) {
+void WINAPI glColor3dv( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glColor3dv( v );
 }
 
-void WINAPI glColor3f( GLfloat red, GLfloat green, GLfloat blue ) {
+void WINAPI glColor3f( GLfloat red, GLfloat green, GLfloat blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", red, green, blue );
+  TRACE( "(%f, %f, %f)\n", red, green, blue );
   funcs->gl.p_glColor3f( red, green, blue );
 }
 
-void WINAPI glColor3fv( const GLfloat* v ) {
+void WINAPI glColor3fv( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glColor3fv( v );
 }
 
-void WINAPI glColor3i( GLint red, GLint green, GLint blue ) {
+void WINAPI glColor3i( GLint red, GLint green, GLint blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->gl.p_glColor3i( red, green, blue );
 }
 
-void WINAPI glColor3iv( const GLint* v ) {
+void WINAPI glColor3iv( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glColor3iv( v );
 }
 
-void WINAPI glColor3s( GLshort red, GLshort green, GLshort blue ) {
+void WINAPI glColor3s( GLshort red, GLshort green, GLshort blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->gl.p_glColor3s( red, green, blue );
 }
 
-void WINAPI glColor3sv( const GLshort* v ) {
+void WINAPI glColor3sv( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glColor3sv( v );
 }
 
-void WINAPI glColor3ub( GLubyte red, GLubyte green, GLubyte blue ) {
+void WINAPI glColor3ub( GLubyte red, GLubyte green, GLubyte blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->gl.p_glColor3ub( red, green, blue );
 }
 
-void WINAPI glColor3ubv( const GLubyte* v ) {
+void WINAPI glColor3ubv( const GLubyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glColor3ubv( v );
 }
 
-void WINAPI glColor3ui( GLuint red, GLuint green, GLuint blue ) {
+void WINAPI glColor3ui( GLuint red, GLuint green, GLuint blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->gl.p_glColor3ui( red, green, blue );
 }
 
-void WINAPI glColor3uiv( const GLuint* v ) {
+void WINAPI glColor3uiv( const GLuint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glColor3uiv( v );
 }
 
-void WINAPI glColor3us( GLushort red, GLushort green, GLushort blue ) {
+void WINAPI glColor3us( GLushort red, GLushort green, GLushort blue )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", red, green, blue );
+  TRACE( "(%d, %d, %d)\n", red, green, blue );
   funcs->gl.p_glColor3us( red, green, blue );
 }
 
-void WINAPI glColor3usv( const GLushort* v ) {
+void WINAPI glColor3usv( const GLushort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glColor3usv( v );
 }
 
-void WINAPI glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha ) {
+void WINAPI glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
+  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
   funcs->gl.p_glColor4b( red, green, blue, alpha );
 }
 
-void WINAPI glColor4bv( const GLbyte* v ) {
+void WINAPI glColor4bv( const GLbyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glColor4bv( v );
 }
 
-void WINAPI glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha ) {
+void WINAPI glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha );
+  TRACE( "(%f, %f, %f, %f)\n", red, green, blue, alpha );
   funcs->gl.p_glColor4d( red, green, blue, alpha );
 }
 
-void WINAPI glColor4dv( const GLdouble* v ) {
+void WINAPI glColor4dv( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glColor4dv( v );
 }
 
-void WINAPI glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) {
+void WINAPI glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", red, green, blue, alpha );
+  TRACE( "(%f, %f, %f, %f)\n", red, green, blue, alpha );
   funcs->gl.p_glColor4f( red, green, blue, alpha );
 }
 
-void WINAPI glColor4fv( const GLfloat* v ) {
+void WINAPI glColor4fv( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glColor4fv( v );
 }
 
-void WINAPI glColor4i( GLint red, GLint green, GLint blue, GLint alpha ) {
+void WINAPI glColor4i( GLint red, GLint green, GLint blue, GLint alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
+  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
   funcs->gl.p_glColor4i( red, green, blue, alpha );
 }
 
-void WINAPI glColor4iv( const GLint* v ) {
+void WINAPI glColor4iv( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glColor4iv( v );
 }
 
-void WINAPI glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha ) {
+void WINAPI glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
+  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
   funcs->gl.p_glColor4s( red, green, blue, alpha );
 }
 
-void WINAPI glColor4sv( const GLshort* v ) {
+void WINAPI glColor4sv( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glColor4sv( v );
 }
 
-void WINAPI glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha ) {
+void WINAPI glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
+  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
   funcs->gl.p_glColor4ub( red, green, blue, alpha );
 }
 
-void WINAPI glColor4ubv( const GLubyte* v ) {
+void WINAPI glColor4ubv( const GLubyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glColor4ubv( v );
 }
 
-void WINAPI glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha ) {
+void WINAPI glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
+  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
   funcs->gl.p_glColor4ui( red, green, blue, alpha );
 }
 
-void WINAPI glColor4uiv( const GLuint* v ) {
+void WINAPI glColor4uiv( const GLuint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glColor4uiv( v );
 }
 
-void WINAPI glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha ) {
+void WINAPI glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
+  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
   funcs->gl.p_glColor4us( red, green, blue, alpha );
 }
 
-void WINAPI glColor4usv( const GLushort* v ) {
+void WINAPI glColor4usv( const GLushort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glColor4usv( v );
 }
 
-void WINAPI glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) {
+void WINAPI glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", red, green, blue, alpha );
+  TRACE( "(%d, %d, %d, %d)\n", red, green, blue, alpha );
   funcs->gl.p_glColorMask( red, green, blue, alpha );
 }
 
-void WINAPI glColorMaterial( GLenum face, GLenum mode ) {
+void WINAPI glColorMaterial( GLenum face, GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", face, mode );
+  TRACE( "(%d, %d)\n", face, mode );
   funcs->gl.p_glColorMaterial( face, mode );
 }
 
-void WINAPI glColorPointer( GLint size, GLenum type, GLsizei stride, const void* pointer ) {
+void WINAPI glColorPointer( GLint size, GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer );
+  TRACE( "(%d, %d, %d, %p)\n", size, type, stride, pointer );
   funcs->gl.p_glColorPointer( size, type, stride, pointer );
 }
 
-void WINAPI glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type ) {
+void WINAPI glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", x, y, width, height, type );
+  TRACE( "(%d, %d, %d, %d, %d)\n", x, y, width, height, type );
   funcs->gl.p_glCopyPixels( x, y, width, height, type );
 }
 
-void WINAPI glCopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border ) {
+void WINAPI glCopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, border );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, border );
   funcs->gl.p_glCopyTexImage1D( target, level, internalformat, x, y, width, border );
 }
 
-void WINAPI glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) {
+void WINAPI glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, height, border );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, internalformat, x, y, width, height, border );
   funcs->gl.p_glCopyTexImage2D( target, level, internalformat, x, y, width, height, border );
 }
 
-void WINAPI glCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width ) {
+void WINAPI glCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d)\n", target, level, xoffset, x, y, width );
+  TRACE( "(%d, %d, %d, %d, %d, %d)\n", target, level, xoffset, x, y, width );
   funcs->gl.p_glCopyTexSubImage1D( target, level, xoffset, x, y, width );
 }
 
-void WINAPI glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) {
+void WINAPI glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, x, y, width, height );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d)\n", target, level, xoffset, yoffset, x, y, width, height );
   funcs->gl.p_glCopyTexSubImage2D( target, level, xoffset, yoffset, x, y, width, height );
 }
 
-void WINAPI glCullFace( GLenum mode ) {
+void WINAPI glCullFace( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   funcs->gl.p_glCullFace( mode );
 }
 
-void WINAPI glDeleteLists( GLuint list, GLsizei range ) {
+void WINAPI glDeleteLists( GLuint list, GLsizei range )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", list, range );
+  TRACE( "(%d, %d)\n", list, range );
   funcs->gl.p_glDeleteLists( list, range );
 }
 
-void WINAPI glDeleteTextures( GLsizei n, const GLuint* textures ) {
+void WINAPI glDeleteTextures( GLsizei n, const GLuint *textures )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, textures );
+  TRACE( "(%d, %p)\n", n, textures );
   funcs->gl.p_glDeleteTextures( n, textures );
 }
 
-void WINAPI glDepthFunc( GLenum func ) {
+void WINAPI glDepthFunc( GLenum func )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", func );
+  TRACE( "(%d)\n", func );
   funcs->gl.p_glDepthFunc( func );
 }
 
-void WINAPI glDepthMask( GLboolean flag ) {
+void WINAPI glDepthMask( GLboolean flag )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", flag );
+  TRACE( "(%d)\n", flag );
   funcs->gl.p_glDepthMask( flag );
 }
 
-void WINAPI glDepthRange( GLdouble nearParam, GLdouble farParam ) {
+void WINAPI glDepthRange( GLdouble near, GLdouble far )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", nearParam, farParam );
-  funcs->gl.p_glDepthRange( nearParam, farParam );
+  TRACE( "(%f, %f)\n", near, far );
+  funcs->gl.p_glDepthRange( near, far );
 }
 
-void WINAPI glDisable( GLenum cap ) {
+void WINAPI glDisable( GLenum cap )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", cap );
+  TRACE( "(%d)\n", cap );
   funcs->gl.p_glDisable( cap );
 }
 
-void WINAPI glDisableClientState( GLenum array ) {
+void WINAPI glDisableClientState( GLenum array )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", array );
+  TRACE( "(%d)\n", array );
   funcs->gl.p_glDisableClientState( array );
 }
 
-void WINAPI glDrawArrays( GLenum mode, GLint first, GLsizei count ) {
+void WINAPI glDrawArrays( GLenum mode, GLint first, GLsizei count )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", mode, first, count );
+  TRACE( "(%d, %d, %d)\n", mode, first, count );
   funcs->gl.p_glDrawArrays( mode, first, count );
 }
 
-void WINAPI glDrawBuffer( GLenum buf ) {
+void WINAPI glDrawBuffer( GLenum buf )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", buf );
+  TRACE( "(%d)\n", buf );
   funcs->gl.p_glDrawBuffer( buf );
 }
 
-void WINAPI glDrawElements( GLenum mode, GLsizei count, GLenum type, const void* indices ) {
+void WINAPI glDrawElements( GLenum mode, GLsizei count, GLenum type, const void *indices )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", mode, count, type, indices );
+  TRACE( "(%d, %d, %d, %p)\n", mode, count, type, indices );
   funcs->gl.p_glDrawElements( mode, count, type, indices );
 }
 
-void WINAPI glDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels ) {
+void WINAPI glDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", width, height, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %p)\n", width, height, format, type, pixels );
   funcs->gl.p_glDrawPixels( width, height, format, type, pixels );
 }
 
-void WINAPI glEdgeFlag( GLboolean flag ) {
+void WINAPI glEdgeFlag( GLboolean flag )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", flag );
+  TRACE( "(%d)\n", flag );
   funcs->gl.p_glEdgeFlag( flag );
 }
 
-void WINAPI glEdgeFlagPointer( GLsizei stride, const void* pointer ) {
+void WINAPI glEdgeFlagPointer( GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", stride, pointer );
+  TRACE( "(%d, %p)\n", stride, pointer );
   funcs->gl.p_glEdgeFlagPointer( stride, pointer );
 }
 
-void WINAPI glEdgeFlagv( const GLboolean* flag ) {
+void WINAPI glEdgeFlagv( const GLboolean *flag )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", flag );
+  TRACE( "(%p)\n", flag );
   funcs->gl.p_glEdgeFlagv( flag );
 }
 
-void WINAPI glEnable( GLenum cap ) {
+void WINAPI glEnable( GLenum cap )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", cap );
+  TRACE( "(%d)\n", cap );
   funcs->gl.p_glEnable( cap );
 }
 
-void WINAPI glEnableClientState( GLenum array ) {
+void WINAPI glEnableClientState( GLenum array )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", array );
+  TRACE( "(%d)\n", array );
   funcs->gl.p_glEnableClientState( array );
 }
 
-void WINAPI glEnd( void ) {
+void WINAPI glEnd(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->gl.p_glEnd( );
+  TRACE( "()\n" );
+  funcs->gl.p_glEnd();
 }
 
-void WINAPI glEndList( void ) {
+void WINAPI glEndList(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->gl.p_glEndList( );
+  TRACE( "()\n" );
+  funcs->gl.p_glEndList();
 }
 
-void WINAPI glEvalCoord1d( GLdouble u ) {
+void WINAPI glEvalCoord1d( GLdouble u )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", u );
+  TRACE( "(%f)\n", u );
   funcs->gl.p_glEvalCoord1d( u );
 }
 
-void WINAPI glEvalCoord1dv( const GLdouble* u ) {
+void WINAPI glEvalCoord1dv( const GLdouble *u )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", u );
+  TRACE( "(%p)\n", u );
   funcs->gl.p_glEvalCoord1dv( u );
 }
 
-void WINAPI glEvalCoord1f( GLfloat u ) {
+void WINAPI glEvalCoord1f( GLfloat u )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", u );
+  TRACE( "(%f)\n", u );
   funcs->gl.p_glEvalCoord1f( u );
 }
 
-void WINAPI glEvalCoord1fv( const GLfloat* u ) {
+void WINAPI glEvalCoord1fv( const GLfloat *u )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", u );
+  TRACE( "(%p)\n", u );
   funcs->gl.p_glEvalCoord1fv( u );
 }
 
-void WINAPI glEvalCoord2d( GLdouble u, GLdouble v ) {
+void WINAPI glEvalCoord2d( GLdouble u, GLdouble v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", u, v );
+  TRACE( "(%f, %f)\n", u, v );
   funcs->gl.p_glEvalCoord2d( u, v );
 }
 
-void WINAPI glEvalCoord2dv( const GLdouble* u ) {
+void WINAPI glEvalCoord2dv( const GLdouble *u )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", u );
+  TRACE( "(%p)\n", u );
   funcs->gl.p_glEvalCoord2dv( u );
 }
 
-void WINAPI glEvalCoord2f( GLfloat u, GLfloat v ) {
+void WINAPI glEvalCoord2f( GLfloat u, GLfloat v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", u, v );
+  TRACE( "(%f, %f)\n", u, v );
   funcs->gl.p_glEvalCoord2f( u, v );
 }
 
-void WINAPI glEvalCoord2fv( const GLfloat* u ) {
+void WINAPI glEvalCoord2fv( const GLfloat *u )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", u );
+  TRACE( "(%p)\n", u );
   funcs->gl.p_glEvalCoord2fv( u );
 }
 
-void WINAPI glEvalMesh1( GLenum mode, GLint i1, GLint i2 ) {
+void WINAPI glEvalMesh1( GLenum mode, GLint i1, GLint i2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", mode, i1, i2 );
+  TRACE( "(%d, %d, %d)\n", mode, i1, i2 );
   funcs->gl.p_glEvalMesh1( mode, i1, i2 );
 }
 
-void WINAPI glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 ) {
+void WINAPI glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d)\n", mode, i1, i2, j1, j2 );
+  TRACE( "(%d, %d, %d, %d, %d)\n", mode, i1, i2, j1, j2 );
   funcs->gl.p_glEvalMesh2( mode, i1, i2, j1, j2 );
 }
 
-void WINAPI glEvalPoint1( GLint i ) {
+void WINAPI glEvalPoint1( GLint i )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", i );
+  TRACE( "(%d)\n", i );
   funcs->gl.p_glEvalPoint1( i );
 }
 
-void WINAPI glEvalPoint2( GLint i, GLint j ) {
+void WINAPI glEvalPoint2( GLint i, GLint j )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", i, j );
+  TRACE( "(%d, %d)\n", i, j );
   funcs->gl.p_glEvalPoint2( i, j );
 }
 
-void WINAPI glFeedbackBuffer( GLsizei size, GLenum type, GLfloat* buffer ) {
+void WINAPI glFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", size, type, buffer );
+  TRACE( "(%d, %d, %p)\n", size, type, buffer );
   funcs->gl.p_glFeedbackBuffer( size, type, buffer );
 }
 
-void WINAPI glFinish( void ) {
+void WINAPI glFinish(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->gl.p_glFinish( );
+  TRACE( "()\n" );
+  funcs->gl.p_glFinish();
 }
 
-void WINAPI glFlush( void ) {
+void WINAPI glFlush(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->gl.p_glFlush( );
+  TRACE( "()\n" );
+  funcs->gl.p_glFlush();
 }
 
-void WINAPI glFogf( GLenum pname, GLfloat param ) {
+void WINAPI glFogf( GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", pname, param );
+  TRACE( "(%d, %f)\n", pname, param );
   funcs->gl.p_glFogf( pname, param );
 }
 
-void WINAPI glFogfv( GLenum pname, const GLfloat* params ) {
+void WINAPI glFogfv( GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->gl.p_glFogfv( pname, params );
 }
 
-void WINAPI glFogi( GLenum pname, GLint param ) {
+void WINAPI glFogi( GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->gl.p_glFogi( pname, param );
 }
 
-void WINAPI glFogiv( GLenum pname, const GLint* params ) {
+void WINAPI glFogiv( GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->gl.p_glFogiv( pname, params );
 }
 
-void WINAPI glFrontFace( GLenum mode ) {
+void WINAPI glFrontFace( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   funcs->gl.p_glFrontFace( mode );
 }
 
-void WINAPI glFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar ) {
+void WINAPI glFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f, %f, %f)\n", left, right, bottom, top, zNear, zFar );
+  TRACE( "(%f, %f, %f, %f, %f, %f)\n", left, right, bottom, top, zNear, zFar );
   funcs->gl.p_glFrustum( left, right, bottom, top, zNear, zFar );
 }
 
-GLuint WINAPI glGenLists( GLsizei range ) {
+GLuint WINAPI glGenLists( GLsizei range )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", range );
+  TRACE( "(%d)\n", range );
   return funcs->gl.p_glGenLists( range );
 }
 
-void WINAPI glGenTextures( GLsizei n, GLuint* textures ) {
+void WINAPI glGenTextures( GLsizei n, GLuint *textures )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", n, textures );
+  TRACE( "(%d, %p)\n", n, textures );
   funcs->gl.p_glGenTextures( n, textures );
 }
 
-void WINAPI glGetBooleanv( GLenum pname, GLboolean* data ) {
+void WINAPI glGetBooleanv( GLenum pname, GLboolean *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, data );
+  TRACE( "(%d, %p)\n", pname, data );
   funcs->gl.p_glGetBooleanv( pname, data );
 }
 
-void WINAPI glGetClipPlane( GLenum plane, GLdouble* equation ) {
+void WINAPI glGetClipPlane( GLenum plane, GLdouble *equation )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", plane, equation );
+  TRACE( "(%d, %p)\n", plane, equation );
   funcs->gl.p_glGetClipPlane( plane, equation );
 }
 
-void WINAPI glGetDoublev( GLenum pname, GLdouble* data ) {
+void WINAPI glGetDoublev( GLenum pname, GLdouble *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, data );
+  TRACE( "(%d, %p)\n", pname, data );
   funcs->gl.p_glGetDoublev( pname, data );
 }
 
-GLenum WINAPI glGetError( void ) {
+GLenum WINAPI glGetError(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  return funcs->gl.p_glGetError( );
+  TRACE( "()\n" );
+  return funcs->gl.p_glGetError();
 }
 
-void WINAPI glGetFloatv( GLenum pname, GLfloat* data ) {
+void WINAPI glGetFloatv( GLenum pname, GLfloat *data )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, data );
+  TRACE( "(%d, %p)\n", pname, data );
   funcs->gl.p_glGetFloatv( pname, data );
 }
 
-void WINAPI glGetLightfv( GLenum light, GLenum pname, GLfloat* params ) {
+void WINAPI glGetLightfv( GLenum light, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", light, pname, params );
+  TRACE( "(%d, %d, %p)\n", light, pname, params );
   funcs->gl.p_glGetLightfv( light, pname, params );
 }
 
-void WINAPI glGetLightiv( GLenum light, GLenum pname, GLint* params ) {
+void WINAPI glGetLightiv( GLenum light, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", light, pname, params );
+  TRACE( "(%d, %d, %p)\n", light, pname, params );
   funcs->gl.p_glGetLightiv( light, pname, params );
 }
 
-void WINAPI glGetMapdv( GLenum target, GLenum query, GLdouble* v ) {
+void WINAPI glGetMapdv( GLenum target, GLenum query, GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, query, v );
+  TRACE( "(%d, %d, %p)\n", target, query, v );
   funcs->gl.p_glGetMapdv( target, query, v );
 }
 
-void WINAPI glGetMapfv( GLenum target, GLenum query, GLfloat* v ) {
+void WINAPI glGetMapfv( GLenum target, GLenum query, GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, query, v );
+  TRACE( "(%d, %d, %p)\n", target, query, v );
   funcs->gl.p_glGetMapfv( target, query, v );
 }
 
-void WINAPI glGetMapiv( GLenum target, GLenum query, GLint* v ) {
+void WINAPI glGetMapiv( GLenum target, GLenum query, GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, query, v );
+  TRACE( "(%d, %d, %p)\n", target, query, v );
   funcs->gl.p_glGetMapiv( target, query, v );
 }
 
-void WINAPI glGetMaterialfv( GLenum face, GLenum pname, GLfloat* params ) {
+void WINAPI glGetMaterialfv( GLenum face, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", face, pname, params );
+  TRACE( "(%d, %d, %p)\n", face, pname, params );
   funcs->gl.p_glGetMaterialfv( face, pname, params );
 }
 
-void WINAPI glGetMaterialiv( GLenum face, GLenum pname, GLint* params ) {
+void WINAPI glGetMaterialiv( GLenum face, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", face, pname, params );
+  TRACE( "(%d, %d, %p)\n", face, pname, params );
   funcs->gl.p_glGetMaterialiv( face, pname, params );
 }
 
-void WINAPI glGetPixelMapfv( GLenum map, GLfloat* values ) {
+void WINAPI glGetPixelMapfv( GLenum map, GLfloat *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", map, values );
+  TRACE( "(%d, %p)\n", map, values );
   funcs->gl.p_glGetPixelMapfv( map, values );
 }
 
-void WINAPI glGetPixelMapuiv( GLenum map, GLuint* values ) {
+void WINAPI glGetPixelMapuiv( GLenum map, GLuint *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", map, values );
+  TRACE( "(%d, %p)\n", map, values );
   funcs->gl.p_glGetPixelMapuiv( map, values );
 }
 
-void WINAPI glGetPixelMapusv( GLenum map, GLushort* values ) {
+void WINAPI glGetPixelMapusv( GLenum map, GLushort *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", map, values );
+  TRACE( "(%d, %p)\n", map, values );
   funcs->gl.p_glGetPixelMapusv( map, values );
 }
 
-void WINAPI glGetPointerv( GLenum pname, void** params ) {
+void WINAPI glGetPointerv( GLenum pname, void **params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->gl.p_glGetPointerv( pname, params );
 }
 
-void WINAPI glGetPolygonStipple( GLubyte* mask ) {
+void WINAPI glGetPolygonStipple( GLubyte *mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", mask );
+  TRACE( "(%p)\n", mask );
   funcs->gl.p_glGetPolygonStipple( mask );
 }
 
-void WINAPI glGetTexEnvfv( GLenum target, GLenum pname, GLfloat* params ) {
+void WINAPI glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->gl.p_glGetTexEnvfv( target, pname, params );
 }
 
-void WINAPI glGetTexEnviv( GLenum target, GLenum pname, GLint* params ) {
+void WINAPI glGetTexEnviv( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->gl.p_glGetTexEnviv( target, pname, params );
 }
 
-void WINAPI glGetTexGendv( GLenum coord, GLenum pname, GLdouble* params ) {
+void WINAPI glGetTexGendv( GLenum coord, GLenum pname, GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", coord, pname, params );
+  TRACE( "(%d, %d, %p)\n", coord, pname, params );
   funcs->gl.p_glGetTexGendv( coord, pname, params );
 }
 
-void WINAPI glGetTexGenfv( GLenum coord, GLenum pname, GLfloat* params ) {
+void WINAPI glGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", coord, pname, params );
+  TRACE( "(%d, %d, %p)\n", coord, pname, params );
   funcs->gl.p_glGetTexGenfv( coord, pname, params );
 }
 
-void WINAPI glGetTexGeniv( GLenum coord, GLenum pname, GLint* params ) {
+void WINAPI glGetTexGeniv( GLenum coord, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", coord, pname, params );
+  TRACE( "(%d, %d, %p)\n", coord, pname, params );
   funcs->gl.p_glGetTexGeniv( coord, pname, params );
 }
 
-void WINAPI glGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, void* pixels ) {
+void WINAPI glGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %p)\n", target, level, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %p)\n", target, level, format, type, pixels );
   funcs->gl.p_glGetTexImage( target, level, format, type, pixels );
 }
 
-void WINAPI glGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat* params ) {
+void WINAPI glGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, level, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", target, level, pname, params );
   funcs->gl.p_glGetTexLevelParameterfv( target, level, pname, params );
 }
 
-void WINAPI glGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint* params ) {
+void WINAPI glGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", target, level, pname, params );
+  TRACE( "(%d, %d, %d, %p)\n", target, level, pname, params );
   funcs->gl.p_glGetTexLevelParameteriv( target, level, pname, params );
 }
 
-void WINAPI glGetTexParameterfv( GLenum target, GLenum pname, GLfloat* params ) {
+void WINAPI glGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->gl.p_glGetTexParameterfv( target, pname, params );
 }
 
-void WINAPI glGetTexParameteriv( GLenum target, GLenum pname, GLint* params ) {
+void WINAPI glGetTexParameteriv( GLenum target, GLenum pname, GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->gl.p_glGetTexParameteriv( target, pname, params );
 }
 
-void WINAPI glHint( GLenum target, GLenum mode ) {
+void WINAPI glHint( GLenum target, GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", target, mode );
+  TRACE( "(%d, %d)\n", target, mode );
   funcs->gl.p_glHint( target, mode );
 }
 
-void WINAPI glIndexMask( GLuint mask ) {
+void WINAPI glIndexMask( GLuint mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mask );
+  TRACE( "(%d)\n", mask );
   funcs->gl.p_glIndexMask( mask );
 }
 
-void WINAPI glIndexPointer( GLenum type, GLsizei stride, const void* pointer ) {
+void WINAPI glIndexPointer( GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", type, stride, pointer );
+  TRACE( "(%d, %d, %p)\n", type, stride, pointer );
   funcs->gl.p_glIndexPointer( type, stride, pointer );
 }
 
-void WINAPI glIndexd( GLdouble c ) {
+void WINAPI glIndexd( GLdouble c )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", c );
+  TRACE( "(%f)\n", c );
   funcs->gl.p_glIndexd( c );
 }
 
-void WINAPI glIndexdv( const GLdouble* c ) {
+void WINAPI glIndexdv( const GLdouble *c )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", c );
+  TRACE( "(%p)\n", c );
   funcs->gl.p_glIndexdv( c );
 }
 
-void WINAPI glIndexf( GLfloat c ) {
+void WINAPI glIndexf( GLfloat c )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", c );
+  TRACE( "(%f)\n", c );
   funcs->gl.p_glIndexf( c );
 }
 
-void WINAPI glIndexfv( const GLfloat* c ) {
+void WINAPI glIndexfv( const GLfloat *c )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", c );
+  TRACE( "(%p)\n", c );
   funcs->gl.p_glIndexfv( c );
 }
 
-void WINAPI glIndexi( GLint c ) {
+void WINAPI glIndexi( GLint c )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", c );
+  TRACE( "(%d)\n", c );
   funcs->gl.p_glIndexi( c );
 }
 
-void WINAPI glIndexiv( const GLint* c ) {
+void WINAPI glIndexiv( const GLint *c )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", c );
+  TRACE( "(%p)\n", c );
   funcs->gl.p_glIndexiv( c );
 }
 
-void WINAPI glIndexs( GLshort c ) {
+void WINAPI glIndexs( GLshort c )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", c );
+  TRACE( "(%d)\n", c );
   funcs->gl.p_glIndexs( c );
 }
 
-void WINAPI glIndexsv( const GLshort* c ) {
+void WINAPI glIndexsv( const GLshort *c )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", c );
+  TRACE( "(%p)\n", c );
   funcs->gl.p_glIndexsv( c );
 }
 
-void WINAPI glIndexub( GLubyte c ) {
+void WINAPI glIndexub( GLubyte c )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", c );
+  TRACE( "(%d)\n", c );
   funcs->gl.p_glIndexub( c );
 }
 
-void WINAPI glIndexubv( const GLubyte* c ) {
+void WINAPI glIndexubv( const GLubyte *c )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", c );
+  TRACE( "(%p)\n", c );
   funcs->gl.p_glIndexubv( c );
 }
 
-void WINAPI glInitNames( void ) {
+void WINAPI glInitNames(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->gl.p_glInitNames( );
+  TRACE( "()\n" );
+  funcs->gl.p_glInitNames();
 }
 
-void WINAPI glInterleavedArrays( GLenum format, GLsizei stride, const void* pointer ) {
+void WINAPI glInterleavedArrays( GLenum format, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", format, stride, pointer );
+  TRACE( "(%d, %d, %p)\n", format, stride, pointer );
   funcs->gl.p_glInterleavedArrays( format, stride, pointer );
 }
 
-GLboolean WINAPI glIsEnabled( GLenum cap ) {
+GLboolean WINAPI glIsEnabled( GLenum cap )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", cap );
+  TRACE( "(%d)\n", cap );
   return funcs->gl.p_glIsEnabled( cap );
 }
 
-GLboolean WINAPI glIsList( GLuint list ) {
+GLboolean WINAPI glIsList( GLuint list )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", list );
+  TRACE( "(%d)\n", list );
   return funcs->gl.p_glIsList( list );
 }
 
-GLboolean WINAPI glIsTexture( GLuint texture ) {
+GLboolean WINAPI glIsTexture( GLuint texture )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", texture );
+  TRACE( "(%d)\n", texture );
   return funcs->gl.p_glIsTexture( texture );
 }
 
-void WINAPI glLightModelf( GLenum pname, GLfloat param ) {
+void WINAPI glLightModelf( GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", pname, param );
+  TRACE( "(%d, %f)\n", pname, param );
   funcs->gl.p_glLightModelf( pname, param );
 }
 
-void WINAPI glLightModelfv( GLenum pname, const GLfloat* params ) {
+void WINAPI glLightModelfv( GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->gl.p_glLightModelfv( pname, params );
 }
 
-void WINAPI glLightModeli( GLenum pname, GLint param ) {
+void WINAPI glLightModeli( GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->gl.p_glLightModeli( pname, param );
 }
 
-void WINAPI glLightModeliv( GLenum pname, const GLint* params ) {
+void WINAPI glLightModeliv( GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", pname, params );
+  TRACE( "(%d, %p)\n", pname, params );
   funcs->gl.p_glLightModeliv( pname, params );
 }
 
-void WINAPI glLightf( GLenum light, GLenum pname, GLfloat param ) {
+void WINAPI glLightf( GLenum light, GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", light, pname, param );
+  TRACE( "(%d, %d, %f)\n", light, pname, param );
   funcs->gl.p_glLightf( light, pname, param );
 }
 
-void WINAPI glLightfv( GLenum light, GLenum pname, const GLfloat* params ) {
+void WINAPI glLightfv( GLenum light, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", light, pname, params );
+  TRACE( "(%d, %d, %p)\n", light, pname, params );
   funcs->gl.p_glLightfv( light, pname, params );
 }
 
-void WINAPI glLighti( GLenum light, GLenum pname, GLint param ) {
+void WINAPI glLighti( GLenum light, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", light, pname, param );
+  TRACE( "(%d, %d, %d)\n", light, pname, param );
   funcs->gl.p_glLighti( light, pname, param );
 }
 
-void WINAPI glLightiv( GLenum light, GLenum pname, const GLint* params ) {
+void WINAPI glLightiv( GLenum light, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", light, pname, params );
+  TRACE( "(%d, %d, %p)\n", light, pname, params );
   funcs->gl.p_glLightiv( light, pname, params );
 }
 
-void WINAPI glLineStipple( GLint factor, GLushort pattern ) {
+void WINAPI glLineStipple( GLint factor, GLushort pattern )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", factor, pattern );
+  TRACE( "(%d, %d)\n", factor, pattern );
   funcs->gl.p_glLineStipple( factor, pattern );
 }
 
-void WINAPI glLineWidth( GLfloat width ) {
+void WINAPI glLineWidth( GLfloat width )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", width );
+  TRACE( "(%f)\n", width );
   funcs->gl.p_glLineWidth( width );
 }
 
-void WINAPI glListBase( GLuint base ) {
+void WINAPI glListBase( GLuint base )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", base );
+  TRACE( "(%d)\n", base );
   funcs->gl.p_glListBase( base );
 }
 
-void WINAPI glLoadIdentity( void ) {
+void WINAPI glLoadIdentity(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->gl.p_glLoadIdentity( );
+  TRACE( "()\n" );
+  funcs->gl.p_glLoadIdentity();
 }
 
-void WINAPI glLoadMatrixd( const GLdouble* m ) {
+void WINAPI glLoadMatrixd( const GLdouble *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", m );
+  TRACE( "(%p)\n", m );
   funcs->gl.p_glLoadMatrixd( m );
 }
 
-void WINAPI glLoadMatrixf( const GLfloat* m ) {
+void WINAPI glLoadMatrixf( const GLfloat *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", m );
+  TRACE( "(%p)\n", m );
   funcs->gl.p_glLoadMatrixf( m );
 }
 
-void WINAPI glLoadName( GLuint name ) {
+void WINAPI glLoadName( GLuint name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", name );
+  TRACE( "(%d)\n", name );
   funcs->gl.p_glLoadName( name );
 }
 
-void WINAPI glLogicOp( GLenum opcode ) {
+void WINAPI glLogicOp( GLenum opcode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", opcode );
+  TRACE( "(%d)\n", opcode );
   funcs->gl.p_glLogicOp( opcode );
 }
 
-void WINAPI glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points ) {
+void WINAPI glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %d, %d, %p)\n", target, u1, u2, stride, order, points );
+  TRACE( "(%d, %f, %f, %d, %d, %p)\n", target, u1, u2, stride, order, points );
   funcs->gl.p_glMap1d( target, u1, u2, stride, order, points );
 }
 
-void WINAPI glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points ) {
+void WINAPI glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %d, %d, %p)\n", target, u1, u2, stride, order, points );
+  TRACE( "(%d, %f, %f, %d, %d, %p)\n", target, u1, u2, stride, order, points );
   funcs->gl.p_glMap1f( target, u1, u2, stride, order, points );
 }
 
-void WINAPI glMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points ) {
+void WINAPI glMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
+  TRACE( "(%d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
   funcs->gl.p_glMap2d( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
 }
 
-void WINAPI glMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points ) {
+void WINAPI glMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
+  TRACE( "(%d, %f, %f, %d, %d, %f, %f, %d, %d, %p)\n", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
   funcs->gl.p_glMap2f( target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points );
 }
 
-void WINAPI glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 ) {
+void WINAPI glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", un, u1, u2 );
+  TRACE( "(%d, %f, %f)\n", un, u1, u2 );
   funcs->gl.p_glMapGrid1d( un, u1, u2 );
 }
 
-void WINAPI glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 ) {
+void WINAPI glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f)\n", un, u1, u2 );
+  TRACE( "(%d, %f, %f)\n", un, u1, u2 );
   funcs->gl.p_glMapGrid1f( un, u1, u2 );
 }
 
-void WINAPI glMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 ) {
+void WINAPI glMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %d, %f, %f)\n", un, u1, u2, vn, v1, v2 );
+  TRACE( "(%d, %f, %f, %d, %f, %f)\n", un, u1, u2, vn, v1, v2 );
   funcs->gl.p_glMapGrid2d( un, u1, u2, vn, v1, v2 );
 }
 
-void WINAPI glMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 ) {
+void WINAPI glMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f, %f, %d, %f, %f)\n", un, u1, u2, vn, v1, v2 );
+  TRACE( "(%d, %f, %f, %d, %f, %f)\n", un, u1, u2, vn, v1, v2 );
   funcs->gl.p_glMapGrid2f( un, u1, u2, vn, v1, v2 );
 }
 
-void WINAPI glMaterialf( GLenum face, GLenum pname, GLfloat param ) {
+void WINAPI glMaterialf( GLenum face, GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", face, pname, param );
+  TRACE( "(%d, %d, %f)\n", face, pname, param );
   funcs->gl.p_glMaterialf( face, pname, param );
 }
 
-void WINAPI glMaterialfv( GLenum face, GLenum pname, const GLfloat* params ) {
+void WINAPI glMaterialfv( GLenum face, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", face, pname, params );
+  TRACE( "(%d, %d, %p)\n", face, pname, params );
   funcs->gl.p_glMaterialfv( face, pname, params );
 }
 
-void WINAPI glMateriali( GLenum face, GLenum pname, GLint param ) {
+void WINAPI glMateriali( GLenum face, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", face, pname, param );
+  TRACE( "(%d, %d, %d)\n", face, pname, param );
   funcs->gl.p_glMateriali( face, pname, param );
 }
 
-void WINAPI glMaterialiv( GLenum face, GLenum pname, const GLint* params ) {
+void WINAPI glMaterialiv( GLenum face, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", face, pname, params );
+  TRACE( "(%d, %d, %p)\n", face, pname, params );
   funcs->gl.p_glMaterialiv( face, pname, params );
 }
 
-void WINAPI glMatrixMode( GLenum mode ) {
+void WINAPI glMatrixMode( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   funcs->gl.p_glMatrixMode( mode );
 }
 
-void WINAPI glMultMatrixd( const GLdouble* m ) {
+void WINAPI glMultMatrixd( const GLdouble *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", m );
+  TRACE( "(%p)\n", m );
   funcs->gl.p_glMultMatrixd( m );
 }
 
-void WINAPI glMultMatrixf( const GLfloat* m ) {
+void WINAPI glMultMatrixf( const GLfloat *m )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", m );
+  TRACE( "(%p)\n", m );
   funcs->gl.p_glMultMatrixf( m );
 }
 
-void WINAPI glNewList( GLuint list, GLenum mode ) {
+void WINAPI glNewList( GLuint list, GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", list, mode );
+  TRACE( "(%d, %d)\n", list, mode );
   funcs->gl.p_glNewList( list, mode );
 }
 
-void WINAPI glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz ) {
+void WINAPI glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", nx, ny, nz );
+  TRACE( "(%d, %d, %d)\n", nx, ny, nz );
   funcs->gl.p_glNormal3b( nx, ny, nz );
 }
 
-void WINAPI glNormal3bv( const GLbyte* v ) {
+void WINAPI glNormal3bv( const GLbyte *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glNormal3bv( v );
 }
 
-void WINAPI glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz ) {
+void WINAPI glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", nx, ny, nz );
+  TRACE( "(%f, %f, %f)\n", nx, ny, nz );
   funcs->gl.p_glNormal3d( nx, ny, nz );
 }
 
-void WINAPI glNormal3dv( const GLdouble* v ) {
+void WINAPI glNormal3dv( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glNormal3dv( v );
 }
 
-void WINAPI glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz ) {
+void WINAPI glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", nx, ny, nz );
+  TRACE( "(%f, %f, %f)\n", nx, ny, nz );
   funcs->gl.p_glNormal3f( nx, ny, nz );
 }
 
-void WINAPI glNormal3fv( const GLfloat* v ) {
+void WINAPI glNormal3fv( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glNormal3fv( v );
 }
 
-void WINAPI glNormal3i( GLint nx, GLint ny, GLint nz ) {
+void WINAPI glNormal3i( GLint nx, GLint ny, GLint nz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", nx, ny, nz );
+  TRACE( "(%d, %d, %d)\n", nx, ny, nz );
   funcs->gl.p_glNormal3i( nx, ny, nz );
 }
 
-void WINAPI glNormal3iv( const GLint* v ) {
+void WINAPI glNormal3iv( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glNormal3iv( v );
 }
 
-void WINAPI glNormal3s( GLshort nx, GLshort ny, GLshort nz ) {
+void WINAPI glNormal3s( GLshort nx, GLshort ny, GLshort nz )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", nx, ny, nz );
+  TRACE( "(%d, %d, %d)\n", nx, ny, nz );
   funcs->gl.p_glNormal3s( nx, ny, nz );
 }
 
-void WINAPI glNormal3sv( const GLshort* v ) {
+void WINAPI glNormal3sv( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glNormal3sv( v );
 }
 
-void WINAPI glNormalPointer( GLenum type, GLsizei stride, const void* pointer ) {
+void WINAPI glNormalPointer( GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", type, stride, pointer );
+  TRACE( "(%d, %d, %p)\n", type, stride, pointer );
   funcs->gl.p_glNormalPointer( type, stride, pointer );
 }
 
-void WINAPI glOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar ) {
+void WINAPI glOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f, %f, %f)\n", left, right, bottom, top, zNear, zFar );
+  TRACE( "(%f, %f, %f, %f, %f, %f)\n", left, right, bottom, top, zNear, zFar );
   funcs->gl.p_glOrtho( left, right, bottom, top, zNear, zFar );
 }
 
-void WINAPI glPassThrough( GLfloat token ) {
+void WINAPI glPassThrough( GLfloat token )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", token );
+  TRACE( "(%f)\n", token );
   funcs->gl.p_glPassThrough( token );
 }
 
-void WINAPI glPixelMapfv( GLenum map, GLsizei mapsize, const GLfloat* values ) {
+void WINAPI glPixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", map, mapsize, values );
+  TRACE( "(%d, %d, %p)\n", map, mapsize, values );
   funcs->gl.p_glPixelMapfv( map, mapsize, values );
 }
 
-void WINAPI glPixelMapuiv( GLenum map, GLsizei mapsize, const GLuint* values ) {
+void WINAPI glPixelMapuiv( GLenum map, GLsizei mapsize, const GLuint *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", map, mapsize, values );
+  TRACE( "(%d, %d, %p)\n", map, mapsize, values );
   funcs->gl.p_glPixelMapuiv( map, mapsize, values );
 }
 
-void WINAPI glPixelMapusv( GLenum map, GLsizei mapsize, const GLushort* values ) {
+void WINAPI glPixelMapusv( GLenum map, GLsizei mapsize, const GLushort *values )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", map, mapsize, values );
+  TRACE( "(%d, %d, %p)\n", map, mapsize, values );
   funcs->gl.p_glPixelMapusv( map, mapsize, values );
 }
 
-void WINAPI glPixelStoref( GLenum pname, GLfloat param ) {
+void WINAPI glPixelStoref( GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", pname, param );
+  TRACE( "(%d, %f)\n", pname, param );
   funcs->gl.p_glPixelStoref( pname, param );
 }
 
-void WINAPI glPixelStorei( GLenum pname, GLint param ) {
+void WINAPI glPixelStorei( GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->gl.p_glPixelStorei( pname, param );
 }
 
-void WINAPI glPixelTransferf( GLenum pname, GLfloat param ) {
+void WINAPI glPixelTransferf( GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %f)\n", pname, param );
+  TRACE( "(%d, %f)\n", pname, param );
   funcs->gl.p_glPixelTransferf( pname, param );
 }
 
-void WINAPI glPixelTransferi( GLenum pname, GLint param ) {
+void WINAPI glPixelTransferi( GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", pname, param );
+  TRACE( "(%d, %d)\n", pname, param );
   funcs->gl.p_glPixelTransferi( pname, param );
 }
 
-void WINAPI glPixelZoom( GLfloat xfactor, GLfloat yfactor ) {
+void WINAPI glPixelZoom( GLfloat xfactor, GLfloat yfactor )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", xfactor, yfactor );
+  TRACE( "(%f, %f)\n", xfactor, yfactor );
   funcs->gl.p_glPixelZoom( xfactor, yfactor );
 }
 
-void WINAPI glPointSize( GLfloat size ) {
+void WINAPI glPointSize( GLfloat size )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", size );
+  TRACE( "(%f)\n", size );
   funcs->gl.p_glPointSize( size );
 }
 
-void WINAPI glPolygonMode( GLenum face, GLenum mode ) {
+void WINAPI glPolygonMode( GLenum face, GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", face, mode );
+  TRACE( "(%d, %d)\n", face, mode );
   funcs->gl.p_glPolygonMode( face, mode );
 }
 
-void WINAPI glPolygonOffset( GLfloat factor, GLfloat units ) {
+void WINAPI glPolygonOffset( GLfloat factor, GLfloat units )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", factor, units );
+  TRACE( "(%f, %f)\n", factor, units );
   funcs->gl.p_glPolygonOffset( factor, units );
 }
 
-void WINAPI glPolygonStipple( const GLubyte* mask ) {
+void WINAPI glPolygonStipple( const GLubyte *mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", mask );
+  TRACE( "(%p)\n", mask );
   funcs->gl.p_glPolygonStipple( mask );
 }
 
-void WINAPI glPopAttrib( void ) {
+void WINAPI glPopAttrib(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->gl.p_glPopAttrib( );
+  TRACE( "()\n" );
+  funcs->gl.p_glPopAttrib();
 }
 
-void WINAPI glPopClientAttrib( void ) {
+void WINAPI glPopClientAttrib(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->gl.p_glPopClientAttrib( );
+  TRACE( "()\n" );
+  funcs->gl.p_glPopClientAttrib();
 }
 
-void WINAPI glPopMatrix( void ) {
+void WINAPI glPopMatrix(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->gl.p_glPopMatrix( );
+  TRACE( "()\n" );
+  funcs->gl.p_glPopMatrix();
 }
 
-void WINAPI glPopName( void ) {
+void WINAPI glPopName(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->gl.p_glPopName( );
+  TRACE( "()\n" );
+  funcs->gl.p_glPopName();
 }
 
-void WINAPI glPrioritizeTextures( GLsizei n, const GLuint* textures, const GLfloat* priorities ) {
+void WINAPI glPrioritizeTextures( GLsizei n, const GLuint *textures, const GLfloat *priorities )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p, %p)\n", n, textures, priorities );
+  TRACE( "(%d, %p, %p)\n", n, textures, priorities );
   funcs->gl.p_glPrioritizeTextures( n, textures, priorities );
 }
 
-void WINAPI glPushAttrib( GLbitfield mask ) {
+void WINAPI glPushAttrib( GLbitfield mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mask );
+  TRACE( "(%d)\n", mask );
   funcs->gl.p_glPushAttrib( mask );
 }
 
-void WINAPI glPushClientAttrib( GLbitfield mask ) {
+void WINAPI glPushClientAttrib( GLbitfield mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mask );
+  TRACE( "(%d)\n", mask );
   funcs->gl.p_glPushClientAttrib( mask );
 }
 
-void WINAPI glPushMatrix( void ) {
+void WINAPI glPushMatrix(void)
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("()\n");
-  funcs->gl.p_glPushMatrix( );
+  TRACE( "()\n" );
+  funcs->gl.p_glPushMatrix();
 }
 
-void WINAPI glPushName( GLuint name ) {
+void WINAPI glPushName( GLuint name )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", name );
+  TRACE( "(%d)\n", name );
   funcs->gl.p_glPushName( name );
 }
 
-void WINAPI glRasterPos2d( GLdouble x, GLdouble y ) {
+void WINAPI glRasterPos2d( GLdouble x, GLdouble y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", x, y );
+  TRACE( "(%f, %f)\n", x, y );
   funcs->gl.p_glRasterPos2d( x, y );
 }
 
-void WINAPI glRasterPos2dv( const GLdouble* v ) {
+void WINAPI glRasterPos2dv( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glRasterPos2dv( v );
 }
 
-void WINAPI glRasterPos2f( GLfloat x, GLfloat y ) {
+void WINAPI glRasterPos2f( GLfloat x, GLfloat y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", x, y );
+  TRACE( "(%f, %f)\n", x, y );
   funcs->gl.p_glRasterPos2f( x, y );
 }
 
-void WINAPI glRasterPos2fv( const GLfloat* v ) {
+void WINAPI glRasterPos2fv( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glRasterPos2fv( v );
 }
 
-void WINAPI glRasterPos2i( GLint x, GLint y ) {
+void WINAPI glRasterPos2i( GLint x, GLint y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", x, y );
+  TRACE( "(%d, %d)\n", x, y );
   funcs->gl.p_glRasterPos2i( x, y );
 }
 
-void WINAPI glRasterPos2iv( const GLint* v ) {
+void WINAPI glRasterPos2iv( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glRasterPos2iv( v );
 }
 
-void WINAPI glRasterPos2s( GLshort x, GLshort y ) {
+void WINAPI glRasterPos2s( GLshort x, GLshort y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", x, y );
+  TRACE( "(%d, %d)\n", x, y );
   funcs->gl.p_glRasterPos2s( x, y );
 }
 
-void WINAPI glRasterPos2sv( const GLshort* v ) {
+void WINAPI glRasterPos2sv( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glRasterPos2sv( v );
 }
 
-void WINAPI glRasterPos3d( GLdouble x, GLdouble y, GLdouble z ) {
+void WINAPI glRasterPos3d( GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", x, y, z );
+  TRACE( "(%f, %f, %f)\n", x, y, z );
   funcs->gl.p_glRasterPos3d( x, y, z );
 }
 
-void WINAPI glRasterPos3dv( const GLdouble* v ) {
+void WINAPI glRasterPos3dv( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glRasterPos3dv( v );
 }
 
-void WINAPI glRasterPos3f( GLfloat x, GLfloat y, GLfloat z ) {
+void WINAPI glRasterPos3f( GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", x, y, z );
+  TRACE( "(%f, %f, %f)\n", x, y, z );
   funcs->gl.p_glRasterPos3f( x, y, z );
 }
 
-void WINAPI glRasterPos3fv( const GLfloat* v ) {
+void WINAPI glRasterPos3fv( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glRasterPos3fv( v );
 }
 
-void WINAPI glRasterPos3i( GLint x, GLint y, GLint z ) {
+void WINAPI glRasterPos3i( GLint x, GLint y, GLint z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", x, y, z );
+  TRACE( "(%d, %d, %d)\n", x, y, z );
   funcs->gl.p_glRasterPos3i( x, y, z );
 }
 
-void WINAPI glRasterPos3iv( const GLint* v ) {
+void WINAPI glRasterPos3iv( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glRasterPos3iv( v );
 }
 
-void WINAPI glRasterPos3s( GLshort x, GLshort y, GLshort z ) {
+void WINAPI glRasterPos3s( GLshort x, GLshort y, GLshort z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", x, y, z );
+  TRACE( "(%d, %d, %d)\n", x, y, z );
   funcs->gl.p_glRasterPos3s( x, y, z );
 }
 
-void WINAPI glRasterPos3sv( const GLshort* v ) {
+void WINAPI glRasterPos3sv( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glRasterPos3sv( v );
 }
 
-void WINAPI glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+void WINAPI glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", x, y, z, w );
+  TRACE( "(%f, %f, %f, %f)\n", x, y, z, w );
   funcs->gl.p_glRasterPos4d( x, y, z, w );
 }
 
-void WINAPI glRasterPos4dv( const GLdouble* v ) {
+void WINAPI glRasterPos4dv( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glRasterPos4dv( v );
 }
 
-void WINAPI glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+void WINAPI glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", x, y, z, w );
+  TRACE( "(%f, %f, %f, %f)\n", x, y, z, w );
   funcs->gl.p_glRasterPos4f( x, y, z, w );
 }
 
-void WINAPI glRasterPos4fv( const GLfloat* v ) {
+void WINAPI glRasterPos4fv( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glRasterPos4fv( v );
 }
 
-void WINAPI glRasterPos4i( GLint x, GLint y, GLint z, GLint w ) {
+void WINAPI glRasterPos4i( GLint x, GLint y, GLint z, GLint w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
+  TRACE( "(%d, %d, %d, %d)\n", x, y, z, w );
   funcs->gl.p_glRasterPos4i( x, y, z, w );
 }
 
-void WINAPI glRasterPos4iv( const GLint* v ) {
+void WINAPI glRasterPos4iv( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glRasterPos4iv( v );
 }
 
-void WINAPI glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w ) {
+void WINAPI glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
+  TRACE( "(%d, %d, %d, %d)\n", x, y, z, w );
   funcs->gl.p_glRasterPos4s( x, y, z, w );
 }
 
-void WINAPI glRasterPos4sv( const GLshort* v ) {
+void WINAPI glRasterPos4sv( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glRasterPos4sv( v );
 }
 
-void WINAPI glReadBuffer( GLenum src ) {
+void WINAPI glReadBuffer( GLenum src )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", src );
+  TRACE( "(%d)\n", src );
   funcs->gl.p_glReadBuffer( src );
 }
 
-void WINAPI glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels ) {
+void WINAPI glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", x, y, width, height, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %p)\n", x, y, width, height, format, type, pixels );
   funcs->gl.p_glReadPixels( x, y, width, height, format, type, pixels );
 }
 
-void WINAPI glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 ) {
+void WINAPI glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", x1, y1, x2, y2 );
+  TRACE( "(%f, %f, %f, %f)\n", x1, y1, x2, y2 );
   funcs->gl.p_glRectd( x1, y1, x2, y2 );
 }
 
-void WINAPI glRectdv( const GLdouble* v1, const GLdouble* v2 ) {
+void WINAPI glRectdv( const GLdouble *v1, const GLdouble *v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", v1, v2 );
+  TRACE( "(%p, %p)\n", v1, v2 );
   funcs->gl.p_glRectdv( v1, v2 );
 }
 
-void WINAPI glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 ) {
+void WINAPI glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", x1, y1, x2, y2 );
+  TRACE( "(%f, %f, %f, %f)\n", x1, y1, x2, y2 );
   funcs->gl.p_glRectf( x1, y1, x2, y2 );
 }
 
-void WINAPI glRectfv( const GLfloat* v1, const GLfloat* v2 ) {
+void WINAPI glRectfv( const GLfloat *v1, const GLfloat *v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", v1, v2 );
+  TRACE( "(%p, %p)\n", v1, v2 );
   funcs->gl.p_glRectfv( v1, v2 );
 }
 
-void WINAPI glRecti( GLint x1, GLint y1, GLint x2, GLint y2 ) {
+void WINAPI glRecti( GLint x1, GLint y1, GLint x2, GLint y2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", x1, y1, x2, y2 );
+  TRACE( "(%d, %d, %d, %d)\n", x1, y1, x2, y2 );
   funcs->gl.p_glRecti( x1, y1, x2, y2 );
 }
 
-void WINAPI glRectiv( const GLint* v1, const GLint* v2 ) {
+void WINAPI glRectiv( const GLint *v1, const GLint *v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", v1, v2 );
+  TRACE( "(%p, %p)\n", v1, v2 );
   funcs->gl.p_glRectiv( v1, v2 );
 }
 
-void WINAPI glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 ) {
+void WINAPI glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", x1, y1, x2, y2 );
+  TRACE( "(%d, %d, %d, %d)\n", x1, y1, x2, y2 );
   funcs->gl.p_glRects( x1, y1, x2, y2 );
 }
 
-void WINAPI glRectsv( const GLshort* v1, const GLshort* v2 ) {
+void WINAPI glRectsv( const GLshort *v1, const GLshort *v2 )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p, %p)\n", v1, v2 );
+  TRACE( "(%p, %p)\n", v1, v2 );
   funcs->gl.p_glRectsv( v1, v2 );
 }
 
-GLint WINAPI glRenderMode( GLenum mode ) {
+GLint WINAPI glRenderMode( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   return funcs->gl.p_glRenderMode( mode );
 }
 
-void WINAPI glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z ) {
+void WINAPI glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", angle, x, y, z );
+  TRACE( "(%f, %f, %f, %f)\n", angle, x, y, z );
   funcs->gl.p_glRotated( angle, x, y, z );
 }
 
-void WINAPI glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) {
+void WINAPI glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", angle, x, y, z );
+  TRACE( "(%f, %f, %f, %f)\n", angle, x, y, z );
   funcs->gl.p_glRotatef( angle, x, y, z );
 }
 
-void WINAPI glScaled( GLdouble x, GLdouble y, GLdouble z ) {
+void WINAPI glScaled( GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", x, y, z );
+  TRACE( "(%f, %f, %f)\n", x, y, z );
   funcs->gl.p_glScaled( x, y, z );
 }
 
-void WINAPI glScalef( GLfloat x, GLfloat y, GLfloat z ) {
+void WINAPI glScalef( GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", x, y, z );
+  TRACE( "(%f, %f, %f)\n", x, y, z );
   funcs->gl.p_glScalef( x, y, z );
 }
 
-void WINAPI glScissor( GLint x, GLint y, GLsizei width, GLsizei height ) {
+void WINAPI glScissor( GLint x, GLint y, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", x, y, width, height );
+  TRACE( "(%d, %d, %d, %d)\n", x, y, width, height );
   funcs->gl.p_glScissor( x, y, width, height );
 }
 
-void WINAPI glSelectBuffer( GLsizei size, GLuint* buffer ) {
+void WINAPI glSelectBuffer( GLsizei size, GLuint *buffer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %p)\n", size, buffer );
+  TRACE( "(%d, %p)\n", size, buffer );
   funcs->gl.p_glSelectBuffer( size, buffer );
 }
 
-void WINAPI glShadeModel( GLenum mode ) {
+void WINAPI glShadeModel( GLenum mode )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mode );
+  TRACE( "(%d)\n", mode );
   funcs->gl.p_glShadeModel( mode );
 }
 
-void WINAPI glStencilFunc( GLenum func, GLint ref, GLuint mask ) {
+void WINAPI glStencilFunc( GLenum func, GLint ref, GLuint mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", func, ref, mask );
+  TRACE( "(%d, %d, %d)\n", func, ref, mask );
   funcs->gl.p_glStencilFunc( func, ref, mask );
 }
 
-void WINAPI glStencilMask( GLuint mask ) {
+void WINAPI glStencilMask( GLuint mask )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", mask );
+  TRACE( "(%d)\n", mask );
   funcs->gl.p_glStencilMask( mask );
 }
 
-void WINAPI glStencilOp( GLenum fail, GLenum zfail, GLenum zpass ) {
+void WINAPI glStencilOp( GLenum fail, GLenum zfail, GLenum zpass )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", fail, zfail, zpass );
+  TRACE( "(%d, %d, %d)\n", fail, zfail, zpass );
   funcs->gl.p_glStencilOp( fail, zfail, zpass );
 }
 
-void WINAPI glTexCoord1d( GLdouble s ) {
+void WINAPI glTexCoord1d( GLdouble s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", s );
+  TRACE( "(%f)\n", s );
   funcs->gl.p_glTexCoord1d( s );
 }
 
-void WINAPI glTexCoord1dv( const GLdouble* v ) {
+void WINAPI glTexCoord1dv( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glTexCoord1dv( v );
 }
 
-void WINAPI glTexCoord1f( GLfloat s ) {
+void WINAPI glTexCoord1f( GLfloat s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f)\n", s );
+  TRACE( "(%f)\n", s );
   funcs->gl.p_glTexCoord1f( s );
 }
 
-void WINAPI glTexCoord1fv( const GLfloat* v ) {
+void WINAPI glTexCoord1fv( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glTexCoord1fv( v );
 }
 
-void WINAPI glTexCoord1i( GLint s ) {
+void WINAPI glTexCoord1i( GLint s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", s );
+  TRACE( "(%d)\n", s );
   funcs->gl.p_glTexCoord1i( s );
 }
 
-void WINAPI glTexCoord1iv( const GLint* v ) {
+void WINAPI glTexCoord1iv( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glTexCoord1iv( v );
 }
 
-void WINAPI glTexCoord1s( GLshort s ) {
+void WINAPI glTexCoord1s( GLshort s )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d)\n", s );
+  TRACE( "(%d)\n", s );
   funcs->gl.p_glTexCoord1s( s );
 }
 
-void WINAPI glTexCoord1sv( const GLshort* v ) {
+void WINAPI glTexCoord1sv( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glTexCoord1sv( v );
 }
 
-void WINAPI glTexCoord2d( GLdouble s, GLdouble t ) {
+void WINAPI glTexCoord2d( GLdouble s, GLdouble t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", s, t );
+  TRACE( "(%f, %f)\n", s, t );
   funcs->gl.p_glTexCoord2d( s, t );
 }
 
-void WINAPI glTexCoord2dv( const GLdouble* v ) {
+void WINAPI glTexCoord2dv( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glTexCoord2dv( v );
 }
 
-void WINAPI glTexCoord2f( GLfloat s, GLfloat t ) {
+void WINAPI glTexCoord2f( GLfloat s, GLfloat t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", s, t );
+  TRACE( "(%f, %f)\n", s, t );
   funcs->gl.p_glTexCoord2f( s, t );
 }
 
-void WINAPI glTexCoord2fv( const GLfloat* v ) {
+void WINAPI glTexCoord2fv( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glTexCoord2fv( v );
 }
 
-void WINAPI glTexCoord2i( GLint s, GLint t ) {
+void WINAPI glTexCoord2i( GLint s, GLint t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", s, t );
+  TRACE( "(%d, %d)\n", s, t );
   funcs->gl.p_glTexCoord2i( s, t );
 }
 
-void WINAPI glTexCoord2iv( const GLint* v ) {
+void WINAPI glTexCoord2iv( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glTexCoord2iv( v );
 }
 
-void WINAPI glTexCoord2s( GLshort s, GLshort t ) {
+void WINAPI glTexCoord2s( GLshort s, GLshort t )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", s, t );
+  TRACE( "(%d, %d)\n", s, t );
   funcs->gl.p_glTexCoord2s( s, t );
 }
 
-void WINAPI glTexCoord2sv( const GLshort* v ) {
+void WINAPI glTexCoord2sv( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glTexCoord2sv( v );
 }
 
-void WINAPI glTexCoord3d( GLdouble s, GLdouble t, GLdouble r ) {
+void WINAPI glTexCoord3d( GLdouble s, GLdouble t, GLdouble r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", s, t, r );
+  TRACE( "(%f, %f, %f)\n", s, t, r );
   funcs->gl.p_glTexCoord3d( s, t, r );
 }
 
-void WINAPI glTexCoord3dv( const GLdouble* v ) {
+void WINAPI glTexCoord3dv( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glTexCoord3dv( v );
 }
 
-void WINAPI glTexCoord3f( GLfloat s, GLfloat t, GLfloat r ) {
+void WINAPI glTexCoord3f( GLfloat s, GLfloat t, GLfloat r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", s, t, r );
+  TRACE( "(%f, %f, %f)\n", s, t, r );
   funcs->gl.p_glTexCoord3f( s, t, r );
 }
 
-void WINAPI glTexCoord3fv( const GLfloat* v ) {
+void WINAPI glTexCoord3fv( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glTexCoord3fv( v );
 }
 
-void WINAPI glTexCoord3i( GLint s, GLint t, GLint r ) {
+void WINAPI glTexCoord3i( GLint s, GLint t, GLint r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", s, t, r );
+  TRACE( "(%d, %d, %d)\n", s, t, r );
   funcs->gl.p_glTexCoord3i( s, t, r );
 }
 
-void WINAPI glTexCoord3iv( const GLint* v ) {
+void WINAPI glTexCoord3iv( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glTexCoord3iv( v );
 }
 
-void WINAPI glTexCoord3s( GLshort s, GLshort t, GLshort r ) {
+void WINAPI glTexCoord3s( GLshort s, GLshort t, GLshort r )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", s, t, r );
+  TRACE( "(%d, %d, %d)\n", s, t, r );
   funcs->gl.p_glTexCoord3s( s, t, r );
 }
 
-void WINAPI glTexCoord3sv( const GLshort* v ) {
+void WINAPI glTexCoord3sv( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glTexCoord3sv( v );
 }
 
-void WINAPI glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q ) {
+void WINAPI glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", s, t, r, q );
+  TRACE( "(%f, %f, %f, %f)\n", s, t, r, q );
   funcs->gl.p_glTexCoord4d( s, t, r, q );
 }
 
-void WINAPI glTexCoord4dv( const GLdouble* v ) {
+void WINAPI glTexCoord4dv( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glTexCoord4dv( v );
 }
 
-void WINAPI glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q ) {
+void WINAPI glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", s, t, r, q );
+  TRACE( "(%f, %f, %f, %f)\n", s, t, r, q );
   funcs->gl.p_glTexCoord4f( s, t, r, q );
 }
 
-void WINAPI glTexCoord4fv( const GLfloat* v ) {
+void WINAPI glTexCoord4fv( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glTexCoord4fv( v );
 }
 
-void WINAPI glTexCoord4i( GLint s, GLint t, GLint r, GLint q ) {
+void WINAPI glTexCoord4i( GLint s, GLint t, GLint r, GLint q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", s, t, r, q );
+  TRACE( "(%d, %d, %d, %d)\n", s, t, r, q );
   funcs->gl.p_glTexCoord4i( s, t, r, q );
 }
 
-void WINAPI glTexCoord4iv( const GLint* v ) {
+void WINAPI glTexCoord4iv( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glTexCoord4iv( v );
 }
 
-void WINAPI glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q ) {
+void WINAPI glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", s, t, r, q );
+  TRACE( "(%d, %d, %d, %d)\n", s, t, r, q );
   funcs->gl.p_glTexCoord4s( s, t, r, q );
 }
 
-void WINAPI glTexCoord4sv( const GLshort* v ) {
+void WINAPI glTexCoord4sv( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glTexCoord4sv( v );
 }
 
-void WINAPI glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const void* pointer ) {
+void WINAPI glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer );
+  TRACE( "(%d, %d, %d, %p)\n", size, type, stride, pointer );
   funcs->gl.p_glTexCoordPointer( size, type, stride, pointer );
 }
 
-void WINAPI glTexEnvf( GLenum target, GLenum pname, GLfloat param ) {
+void WINAPI glTexEnvf( GLenum target, GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", target, pname, param );
+  TRACE( "(%d, %d, %f)\n", target, pname, param );
   funcs->gl.p_glTexEnvf( target, pname, param );
 }
 
-void WINAPI glTexEnvfv( GLenum target, GLenum pname, const GLfloat* params ) {
+void WINAPI glTexEnvfv( GLenum target, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->gl.p_glTexEnvfv( target, pname, params );
 }
 
-void WINAPI glTexEnvi( GLenum target, GLenum pname, GLint param ) {
+void WINAPI glTexEnvi( GLenum target, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, pname, param );
+  TRACE( "(%d, %d, %d)\n", target, pname, param );
   funcs->gl.p_glTexEnvi( target, pname, param );
 }
 
-void WINAPI glTexEnviv( GLenum target, GLenum pname, const GLint* params ) {
+void WINAPI glTexEnviv( GLenum target, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->gl.p_glTexEnviv( target, pname, params );
 }
 
-void WINAPI glTexGend( GLenum coord, GLenum pname, GLdouble param ) {
+void WINAPI glTexGend( GLenum coord, GLenum pname, GLdouble param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", coord, pname, param );
+  TRACE( "(%d, %d, %f)\n", coord, pname, param );
   funcs->gl.p_glTexGend( coord, pname, param );
 }
 
-void WINAPI glTexGendv( GLenum coord, GLenum pname, const GLdouble* params ) {
+void WINAPI glTexGendv( GLenum coord, GLenum pname, const GLdouble *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", coord, pname, params );
+  TRACE( "(%d, %d, %p)\n", coord, pname, params );
   funcs->gl.p_glTexGendv( coord, pname, params );
 }
 
-void WINAPI glTexGenf( GLenum coord, GLenum pname, GLfloat param ) {
+void WINAPI glTexGenf( GLenum coord, GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", coord, pname, param );
+  TRACE( "(%d, %d, %f)\n", coord, pname, param );
   funcs->gl.p_glTexGenf( coord, pname, param );
 }
 
-void WINAPI glTexGenfv( GLenum coord, GLenum pname, const GLfloat* params ) {
+void WINAPI glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", coord, pname, params );
+  TRACE( "(%d, %d, %p)\n", coord, pname, params );
   funcs->gl.p_glTexGenfv( coord, pname, params );
 }
 
-void WINAPI glTexGeni( GLenum coord, GLenum pname, GLint param ) {
+void WINAPI glTexGeni( GLenum coord, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", coord, pname, param );
+  TRACE( "(%d, %d, %d)\n", coord, pname, param );
   funcs->gl.p_glTexGeni( coord, pname, param );
 }
 
-void WINAPI glTexGeniv( GLenum coord, GLenum pname, const GLint* params ) {
+void WINAPI glTexGeniv( GLenum coord, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", coord, pname, params );
+  TRACE( "(%d, %d, %p)\n", coord, pname, params );
   funcs->gl.p_glTexGeniv( coord, pname, params );
 }
 
-void WINAPI glTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void* pixels ) {
+void WINAPI glTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, border, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, border, format, type, pixels );
   funcs->gl.p_glTexImage1D( target, level, internalformat, width, border, format, type, pixels );
 }
 
-void WINAPI glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels ) {
+void WINAPI glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, border, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, internalformat, width, height, border, format, type, pixels );
   funcs->gl.p_glTexImage2D( target, level, internalformat, width, height, border, format, type, pixels );
 }
 
-void WINAPI glTexParameterf( GLenum target, GLenum pname, GLfloat param ) {
+void WINAPI glTexParameterf( GLenum target, GLenum pname, GLfloat param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %f)\n", target, pname, param );
+  TRACE( "(%d, %d, %f)\n", target, pname, param );
   funcs->gl.p_glTexParameterf( target, pname, param );
 }
 
-void WINAPI glTexParameterfv( GLenum target, GLenum pname, const GLfloat* params ) {
+void WINAPI glTexParameterfv( GLenum target, GLenum pname, const GLfloat *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->gl.p_glTexParameterfv( target, pname, params );
 }
 
-void WINAPI glTexParameteri( GLenum target, GLenum pname, GLint param ) {
+void WINAPI glTexParameteri( GLenum target, GLenum pname, GLint param )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", target, pname, param );
+  TRACE( "(%d, %d, %d)\n", target, pname, param );
   funcs->gl.p_glTexParameteri( target, pname, param );
 }
 
-void WINAPI glTexParameteriv( GLenum target, GLenum pname, const GLint* params ) {
+void WINAPI glTexParameteriv( GLenum target, GLenum pname, const GLint *params )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %p)\n", target, pname, params );
+  TRACE( "(%d, %d, %p)\n", target, pname, params );
   funcs->gl.p_glTexParameteriv( target, pname, params );
 }
 
-void WINAPI glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels ) {
+void WINAPI glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, width, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, width, format, type, pixels );
   funcs->gl.p_glTexSubImage1D( target, level, xoffset, width, format, type, pixels );
 }
 
-void WINAPI glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels ) {
+void WINAPI glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, width, height, format, type, pixels );
+  TRACE( "(%d, %d, %d, %d, %d, %d, %d, %d, %p)\n", target, level, xoffset, yoffset, width, height, format, type, pixels );
   funcs->gl.p_glTexSubImage2D( target, level, xoffset, yoffset, width, height, format, type, pixels );
 }
 
-void WINAPI glTranslated( GLdouble x, GLdouble y, GLdouble z ) {
+void WINAPI glTranslated( GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", x, y, z );
+  TRACE( "(%f, %f, %f)\n", x, y, z );
   funcs->gl.p_glTranslated( x, y, z );
 }
 
-void WINAPI glTranslatef( GLfloat x, GLfloat y, GLfloat z ) {
+void WINAPI glTranslatef( GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", x, y, z );
+  TRACE( "(%f, %f, %f)\n", x, y, z );
   funcs->gl.p_glTranslatef( x, y, z );
 }
 
-void WINAPI glVertex2d( GLdouble x, GLdouble y ) {
+void WINAPI glVertex2d( GLdouble x, GLdouble y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", x, y );
+  TRACE( "(%f, %f)\n", x, y );
   funcs->gl.p_glVertex2d( x, y );
 }
 
-void WINAPI glVertex2dv( const GLdouble* v ) {
+void WINAPI glVertex2dv( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glVertex2dv( v );
 }
 
-void WINAPI glVertex2f( GLfloat x, GLfloat y ) {
+void WINAPI glVertex2f( GLfloat x, GLfloat y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f)\n", x, y );
+  TRACE( "(%f, %f)\n", x, y );
   funcs->gl.p_glVertex2f( x, y );
 }
 
-void WINAPI glVertex2fv( const GLfloat* v ) {
+void WINAPI glVertex2fv( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glVertex2fv( v );
 }
 
-void WINAPI glVertex2i( GLint x, GLint y ) {
+void WINAPI glVertex2i( GLint x, GLint y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", x, y );
+  TRACE( "(%d, %d)\n", x, y );
   funcs->gl.p_glVertex2i( x, y );
 }
 
-void WINAPI glVertex2iv( const GLint* v ) {
+void WINAPI glVertex2iv( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glVertex2iv( v );
 }
 
-void WINAPI glVertex2s( GLshort x, GLshort y ) {
+void WINAPI glVertex2s( GLshort x, GLshort y )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d)\n", x, y );
+  TRACE( "(%d, %d)\n", x, y );
   funcs->gl.p_glVertex2s( x, y );
 }
 
-void WINAPI glVertex2sv( const GLshort* v ) {
+void WINAPI glVertex2sv( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glVertex2sv( v );
 }
 
-void WINAPI glVertex3d( GLdouble x, GLdouble y, GLdouble z ) {
+void WINAPI glVertex3d( GLdouble x, GLdouble y, GLdouble z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", x, y, z );
+  TRACE( "(%f, %f, %f)\n", x, y, z );
   funcs->gl.p_glVertex3d( x, y, z );
 }
 
-void WINAPI glVertex3dv( const GLdouble* v ) {
+void WINAPI glVertex3dv( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glVertex3dv( v );
 }
 
-void WINAPI glVertex3f( GLfloat x, GLfloat y, GLfloat z ) {
+void WINAPI glVertex3f( GLfloat x, GLfloat y, GLfloat z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f)\n", x, y, z );
+  TRACE( "(%f, %f, %f)\n", x, y, z );
   funcs->gl.p_glVertex3f( x, y, z );
 }
 
-void WINAPI glVertex3fv( const GLfloat* v ) {
+void WINAPI glVertex3fv( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glVertex3fv( v );
 }
 
-void WINAPI glVertex3i( GLint x, GLint y, GLint z ) {
+void WINAPI glVertex3i( GLint x, GLint y, GLint z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", x, y, z );
+  TRACE( "(%d, %d, %d)\n", x, y, z );
   funcs->gl.p_glVertex3i( x, y, z );
 }
 
-void WINAPI glVertex3iv( const GLint* v ) {
+void WINAPI glVertex3iv( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glVertex3iv( v );
 }
 
-void WINAPI glVertex3s( GLshort x, GLshort y, GLshort z ) {
+void WINAPI glVertex3s( GLshort x, GLshort y, GLshort z )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d)\n", x, y, z );
+  TRACE( "(%d, %d, %d)\n", x, y, z );
   funcs->gl.p_glVertex3s( x, y, z );
 }
 
-void WINAPI glVertex3sv( const GLshort* v ) {
+void WINAPI glVertex3sv( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glVertex3sv( v );
 }
 
-void WINAPI glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) {
+void WINAPI glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", x, y, z, w );
+  TRACE( "(%f, %f, %f, %f)\n", x, y, z, w );
   funcs->gl.p_glVertex4d( x, y, z, w );
 }
 
-void WINAPI glVertex4dv( const GLdouble* v ) {
+void WINAPI glVertex4dv( const GLdouble *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glVertex4dv( v );
 }
 
-void WINAPI glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) {
+void WINAPI glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%f, %f, %f, %f)\n", x, y, z, w );
+  TRACE( "(%f, %f, %f, %f)\n", x, y, z, w );
   funcs->gl.p_glVertex4f( x, y, z, w );
 }
 
-void WINAPI glVertex4fv( const GLfloat* v ) {
+void WINAPI glVertex4fv( const GLfloat *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glVertex4fv( v );
 }
 
-void WINAPI glVertex4i( GLint x, GLint y, GLint z, GLint w ) {
+void WINAPI glVertex4i( GLint x, GLint y, GLint z, GLint w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
+  TRACE( "(%d, %d, %d, %d)\n", x, y, z, w );
   funcs->gl.p_glVertex4i( x, y, z, w );
 }
 
-void WINAPI glVertex4iv( const GLint* v ) {
+void WINAPI glVertex4iv( const GLint *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glVertex4iv( v );
 }
 
-void WINAPI glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w ) {
+void WINAPI glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", x, y, z, w );
+  TRACE( "(%d, %d, %d, %d)\n", x, y, z, w );
   funcs->gl.p_glVertex4s( x, y, z, w );
 }
 
-void WINAPI glVertex4sv( const GLshort* v ) {
+void WINAPI glVertex4sv( const GLshort *v )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%p)\n", v );
+  TRACE( "(%p)\n", v );
   funcs->gl.p_glVertex4sv( v );
 }
 
-void WINAPI glVertexPointer( GLint size, GLenum type, GLsizei stride, const void* pointer ) {
+void WINAPI glVertexPointer( GLint size, GLenum type, GLsizei stride, const void *pointer )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %p)\n", size, type, stride, pointer );
+  TRACE( "(%d, %d, %d, %p)\n", size, type, stride, pointer );
   funcs->gl.p_glVertexPointer( size, type, stride, pointer );
 }
 
-void WINAPI glViewport( GLint x, GLint y, GLsizei width, GLsizei height ) {
+void WINAPI glViewport( GLint x, GLint y, GLsizei width, GLsizei height )
+{
   const struct opengl_funcs *funcs = NtCurrentTeb()->glTable;
-  TRACE("(%d, %d, %d, %d)\n", x, y, width, height );
+  TRACE( "(%d, %d, %d, %d)\n", x, y, width, height );
   funcs->gl.p_glViewport( x, y, width, height );
 }
 static BOOL null_wglCopyContext( struct wgl_context * hglrcSrc, struct wgl_context * hglrcDst, UINT mask ) { return 0; }
 static struct wgl_context * null_wglCreateContext( HDC hDc ) { return 0; }
 static BOOL null_wglDeleteContext( struct wgl_context * oldContext ) { return 0; }
-static int null_wglDescribePixelFormat( HDC hdc, int ipfd, UINT cjpfd, PIXELFORMATDESCRIPTOR* ppfd ) { return 0; }
+static int null_wglDescribePixelFormat( HDC hdc, int ipfd, UINT cjpfd, PIXELFORMATDESCRIPTOR *ppfd ) { return 0; }
 static int null_wglGetPixelFormat( HDC hdc ) { return 0; }
 static PROC null_wglGetProcAddress( LPCSTR lpszProc ) { return 0; }
 static BOOL null_wglMakeCurrent( HDC hDc, struct wgl_context * newContext ) { return 0; }
-static BOOL null_wglSetPixelFormat( HDC hdc, int ipfd, const PIXELFORMATDESCRIPTOR* ppfd ) { return 0; }
+static BOOL null_wglSetPixelFormat( HDC hdc, int ipfd, const PIXELFORMATDESCRIPTOR *ppfd ) { return 0; }
 static BOOL null_wglShareLists( struct wgl_context * hrcSrvShare, struct wgl_context * hrcSrvSource ) { return 0; }
 static BOOL null_wglSwapBuffers( HDC hdc ) { return 0; }
 static void null_glAccum( GLenum op, GLfloat value ) { }
 static void null_glAlphaFunc( GLenum func, GLfloat ref ) { }
-static GLboolean null_glAreTexturesResident( GLsizei n, const GLuint* textures, GLboolean* residences ) { return 0; }
+static GLboolean null_glAreTexturesResident( GLsizei n, const GLuint *textures, GLboolean *residences ) { return 0; }
 static void null_glArrayElement( GLint i ) { }
 static void null_glBegin( GLenum mode ) { }
 static void null_glBindTexture( GLenum target, GLuint texture ) { }
-static void null_glBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte* bitmap ) { }
+static void null_glBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap ) { }
 static void null_glBlendFunc( GLenum sfactor, GLenum dfactor ) { }
 static void null_glCallList( GLuint list ) { }
-static void null_glCallLists( GLsizei n, GLenum type, const void* lists ) { }
+static void null_glCallLists( GLsizei n, GLenum type, const void *lists ) { }
 static void null_glClear( GLbitfield mask ) { }
 static void null_glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) { }
 static void null_glClearColor( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) { }
 static void null_glClearDepth( GLdouble depth ) { }
 static void null_glClearIndex( GLfloat c ) { }
 static void null_glClearStencil( GLint s ) { }
-static void null_glClipPlane( GLenum plane, const GLdouble* equation ) { }
+static void null_glClipPlane( GLenum plane, const GLdouble *equation ) { }
 static void null_glColor3b( GLbyte red, GLbyte green, GLbyte blue ) { }
-static void null_glColor3bv( const GLbyte* v ) { }
+static void null_glColor3bv( const GLbyte *v ) { }
 static void null_glColor3d( GLdouble red, GLdouble green, GLdouble blue ) { }
-static void null_glColor3dv( const GLdouble* v ) { }
+static void null_glColor3dv( const GLdouble *v ) { }
 static void null_glColor3f( GLfloat red, GLfloat green, GLfloat blue ) { }
-static void null_glColor3fv( const GLfloat* v ) { }
+static void null_glColor3fv( const GLfloat *v ) { }
 static void null_glColor3i( GLint red, GLint green, GLint blue ) { }
-static void null_glColor3iv( const GLint* v ) { }
+static void null_glColor3iv( const GLint *v ) { }
 static void null_glColor3s( GLshort red, GLshort green, GLshort blue ) { }
-static void null_glColor3sv( const GLshort* v ) { }
+static void null_glColor3sv( const GLshort *v ) { }
 static void null_glColor3ub( GLubyte red, GLubyte green, GLubyte blue ) { }
-static void null_glColor3ubv( const GLubyte* v ) { }
+static void null_glColor3ubv( const GLubyte *v ) { }
 static void null_glColor3ui( GLuint red, GLuint green, GLuint blue ) { }
-static void null_glColor3uiv( const GLuint* v ) { }
+static void null_glColor3uiv( const GLuint *v ) { }
 static void null_glColor3us( GLushort red, GLushort green, GLushort blue ) { }
-static void null_glColor3usv( const GLushort* v ) { }
+static void null_glColor3usv( const GLushort *v ) { }
 static void null_glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha ) { }
-static void null_glColor4bv( const GLbyte* v ) { }
+static void null_glColor4bv( const GLbyte *v ) { }
 static void null_glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha ) { }
-static void null_glColor4dv( const GLdouble* v ) { }
+static void null_glColor4dv( const GLdouble *v ) { }
 static void null_glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) { }
-static void null_glColor4fv( const GLfloat* v ) { }
+static void null_glColor4fv( const GLfloat *v ) { }
 static void null_glColor4i( GLint red, GLint green, GLint blue, GLint alpha ) { }
-static void null_glColor4iv( const GLint* v ) { }
+static void null_glColor4iv( const GLint *v ) { }
 static void null_glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha ) { }
-static void null_glColor4sv( const GLshort* v ) { }
+static void null_glColor4sv( const GLshort *v ) { }
 static void null_glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha ) { }
-static void null_glColor4ubv( const GLubyte* v ) { }
+static void null_glColor4ubv( const GLubyte *v ) { }
 static void null_glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha ) { }
-static void null_glColor4uiv( const GLuint* v ) { }
+static void null_glColor4uiv( const GLuint *v ) { }
 static void null_glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha ) { }
-static void null_glColor4usv( const GLushort* v ) { }
+static void null_glColor4usv( const GLushort *v ) { }
 static void null_glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) { }
 static void null_glColorMaterial( GLenum face, GLenum mode ) { }
-static void null_glColorPointer( GLint size, GLenum type, GLsizei stride, const void* pointer ) { }
+static void null_glColorPointer( GLint size, GLenum type, GLsizei stride, const void *pointer ) { }
 static void null_glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type ) { }
 static void null_glCopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border ) { }
 static void null_glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) { }
@@ -2083,141 +2417,141 @@
 static void null_glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) { }
 static void null_glCullFace( GLenum mode ) { }
 static void null_glDeleteLists( GLuint list, GLsizei range ) { }
-static void null_glDeleteTextures( GLsizei n, const GLuint* textures ) { }
+static void null_glDeleteTextures( GLsizei n, const GLuint *textures ) { }
 static void null_glDepthFunc( GLenum func ) { }
 static void null_glDepthMask( GLboolean flag ) { }
-static void null_glDepthRange( GLdouble nearParam, GLdouble farParam ) { }
+static void null_glDepthRange( GLdouble near, GLdouble far ) { }
 static void null_glDisable( GLenum cap ) { }
 static void null_glDisableClientState( GLenum array ) { }
 static void null_glDrawArrays( GLenum mode, GLint first, GLsizei count ) { }
 static void null_glDrawBuffer( GLenum buf ) { }
-static void null_glDrawElements( GLenum mode, GLsizei count, GLenum type, const void* indices ) { }
-static void null_glDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels ) { }
+static void null_glDrawElements( GLenum mode, GLsizei count, GLenum type, const void *indices ) { }
+static void null_glDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels ) { }
 static void null_glEdgeFlag( GLboolean flag ) { }
-static void null_glEdgeFlagPointer( GLsizei stride, const void* pointer ) { }
-static void null_glEdgeFlagv( const GLboolean* flag ) { }
+static void null_glEdgeFlagPointer( GLsizei stride, const void *pointer ) { }
+static void null_glEdgeFlagv( const GLboolean *flag ) { }
 static void null_glEnable( GLenum cap ) { }
 static void null_glEnableClientState( GLenum array ) { }
-static void null_glEnd( void ) { }
-static void null_glEndList( void ) { }
+static void null_glEnd(void) { }
+static void null_glEndList(void) { }
 static void null_glEvalCoord1d( GLdouble u ) { }
-static void null_glEvalCoord1dv( const GLdouble* u ) { }
+static void null_glEvalCoord1dv( const GLdouble *u ) { }
 static void null_glEvalCoord1f( GLfloat u ) { }
-static void null_glEvalCoord1fv( const GLfloat* u ) { }
+static void null_glEvalCoord1fv( const GLfloat *u ) { }
 static void null_glEvalCoord2d( GLdouble u, GLdouble v ) { }
-static void null_glEvalCoord2dv( const GLdouble* u ) { }
+static void null_glEvalCoord2dv( const GLdouble *u ) { }
 static void null_glEvalCoord2f( GLfloat u, GLfloat v ) { }
-static void null_glEvalCoord2fv( const GLfloat* u ) { }
+static void null_glEvalCoord2fv( const GLfloat *u ) { }
 static void null_glEvalMesh1( GLenum mode, GLint i1, GLint i2 ) { }
 static void null_glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 ) { }
 static void null_glEvalPoint1( GLint i ) { }
 static void null_glEvalPoint2( GLint i, GLint j ) { }
-static void null_glFeedbackBuffer( GLsizei size, GLenum type, GLfloat* buffer ) { }
-static void null_glFinish( void ) { }
-static void null_glFlush( void ) { }
+static void null_glFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer ) { }
+static void null_glFinish(void) { }
+static void null_glFlush(void) { }
 static void null_glFogf( GLenum pname, GLfloat param ) { }
-static void null_glFogfv( GLenum pname, const GLfloat* params ) { }
+static void null_glFogfv( GLenum pname, const GLfloat *params ) { }
 static void null_glFogi( GLenum pname, GLint param ) { }
-static void null_glFogiv( GLenum pname, const GLint* params ) { }
+static void null_glFogiv( GLenum pname, const GLint *params ) { }
 static void null_glFrontFace( GLenum mode ) { }
 static void null_glFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar ) { }
 static GLuint null_glGenLists( GLsizei range ) { return 0; }
-static void null_glGenTextures( GLsizei n, GLuint* textures ) { }
-static void null_glGetBooleanv( GLenum pname, GLboolean* data ) { }
-static void null_glGetClipPlane( GLenum plane, GLdouble* equation ) { }
-static void null_glGetDoublev( GLenum pname, GLdouble* data ) { }
-static GLenum null_glGetError( void ) { return GL_INVALID_OPERATION; }
-static void null_glGetFloatv( GLenum pname, GLfloat* data ) { }
-static void null_glGetIntegerv( GLenum pname, GLint* data ) { }
-static void null_glGetLightfv( GLenum light, GLenum pname, GLfloat* params ) { }
-static void null_glGetLightiv( GLenum light, GLenum pname, GLint* params ) { }
-static void null_glGetMapdv( GLenum target, GLenum query, GLdouble* v ) { }
-static void null_glGetMapfv( GLenum target, GLenum query, GLfloat* v ) { }
-static void null_glGetMapiv( GLenum target, GLenum query, GLint* v ) { }
-static void null_glGetMaterialfv( GLenum face, GLenum pname, GLfloat* params ) { }
-static void null_glGetMaterialiv( GLenum face, GLenum pname, GLint* params ) { }
-static void null_glGetPixelMapfv( GLenum map, GLfloat* values ) { }
-static void null_glGetPixelMapuiv( GLenum map, GLuint* values ) { }
-static void null_glGetPixelMapusv( GLenum map, GLushort* values ) { }
-static void null_glGetPointerv( GLenum pname, void** params ) { }
-static void null_glGetPolygonStipple( GLubyte* mask ) { }
-static const GLubyte* null_glGetString( GLenum name ) { return 0; }
-static void null_glGetTexEnvfv( GLenum target, GLenum pname, GLfloat* params ) { }
-static void null_glGetTexEnviv( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetTexGendv( GLenum coord, GLenum pname, GLdouble* params ) { }
-static void null_glGetTexGenfv( GLenum coord, GLenum pname, GLfloat* params ) { }
-static void null_glGetTexGeniv( GLenum coord, GLenum pname, GLint* params ) { }
-static void null_glGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, void* pixels ) { }
-static void null_glGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat* params ) { }
-static void null_glGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint* params ) { }
-static void null_glGetTexParameterfv( GLenum target, GLenum pname, GLfloat* params ) { }
-static void null_glGetTexParameteriv( GLenum target, GLenum pname, GLint* params ) { }
+static void null_glGenTextures( GLsizei n, GLuint *textures ) { }
+static void null_glGetBooleanv( GLenum pname, GLboolean *data ) { }
+static void null_glGetClipPlane( GLenum plane, GLdouble *equation ) { }
+static void null_glGetDoublev( GLenum pname, GLdouble *data ) { }
+static GLenum null_glGetError(void) { return GL_INVALID_OPERATION; }
+static void null_glGetFloatv( GLenum pname, GLfloat *data ) { }
+static void null_glGetIntegerv( GLenum pname, GLint *data ) { }
+static void null_glGetLightfv( GLenum light, GLenum pname, GLfloat *params ) { }
+static void null_glGetLightiv( GLenum light, GLenum pname, GLint *params ) { }
+static void null_glGetMapdv( GLenum target, GLenum query, GLdouble *v ) { }
+static void null_glGetMapfv( GLenum target, GLenum query, GLfloat *v ) { }
+static void null_glGetMapiv( GLenum target, GLenum query, GLint *v ) { }
+static void null_glGetMaterialfv( GLenum face, GLenum pname, GLfloat *params ) { }
+static void null_glGetMaterialiv( GLenum face, GLenum pname, GLint *params ) { }
+static void null_glGetPixelMapfv( GLenum map, GLfloat *values ) { }
+static void null_glGetPixelMapuiv( GLenum map, GLuint *values ) { }
+static void null_glGetPixelMapusv( GLenum map, GLushort *values ) { }
+static void null_glGetPointerv( GLenum pname, void **params ) { }
+static void null_glGetPolygonStipple( GLubyte *mask ) { }
+static const GLubyte * null_glGetString( GLenum name ) { return 0; }
+static void null_glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params ) { }
+static void null_glGetTexEnviv( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetTexGendv( GLenum coord, GLenum pname, GLdouble *params ) { }
+static void null_glGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params ) { }
+static void null_glGetTexGeniv( GLenum coord, GLenum pname, GLint *params ) { }
+static void null_glGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, void *pixels ) { }
+static void null_glGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat *params ) { }
+static void null_glGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params ) { }
+static void null_glGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params ) { }
+static void null_glGetTexParameteriv( GLenum target, GLenum pname, GLint *params ) { }
 static void null_glHint( GLenum target, GLenum mode ) { }
 static void null_glIndexMask( GLuint mask ) { }
-static void null_glIndexPointer( GLenum type, GLsizei stride, const void* pointer ) { }
+static void null_glIndexPointer( GLenum type, GLsizei stride, const void *pointer ) { }
 static void null_glIndexd( GLdouble c ) { }
-static void null_glIndexdv( const GLdouble* c ) { }
+static void null_glIndexdv( const GLdouble *c ) { }
 static void null_glIndexf( GLfloat c ) { }
-static void null_glIndexfv( const GLfloat* c ) { }
+static void null_glIndexfv( const GLfloat *c ) { }
 static void null_glIndexi( GLint c ) { }
-static void null_glIndexiv( const GLint* c ) { }
+static void null_glIndexiv( const GLint *c ) { }
 static void null_glIndexs( GLshort c ) { }
-static void null_glIndexsv( const GLshort* c ) { }
+static void null_glIndexsv( const GLshort *c ) { }
 static void null_glIndexub( GLubyte c ) { }
-static void null_glIndexubv( const GLubyte* c ) { }
-static void null_glInitNames( void ) { }
-static void null_glInterleavedArrays( GLenum format, GLsizei stride, const void* pointer ) { }
+static void null_glIndexubv( const GLubyte *c ) { }
+static void null_glInitNames(void) { }
+static void null_glInterleavedArrays( GLenum format, GLsizei stride, const void *pointer ) { }
 static GLboolean null_glIsEnabled( GLenum cap ) { return 0; }
 static GLboolean null_glIsList( GLuint list ) { return 0; }
 static GLboolean null_glIsTexture( GLuint texture ) { return 0; }
 static void null_glLightModelf( GLenum pname, GLfloat param ) { }
-static void null_glLightModelfv( GLenum pname, const GLfloat* params ) { }
+static void null_glLightModelfv( GLenum pname, const GLfloat *params ) { }
 static void null_glLightModeli( GLenum pname, GLint param ) { }
-static void null_glLightModeliv( GLenum pname, const GLint* params ) { }
+static void null_glLightModeliv( GLenum pname, const GLint *params ) { }
 static void null_glLightf( GLenum light, GLenum pname, GLfloat param ) { }
-static void null_glLightfv( GLenum light, GLenum pname, const GLfloat* params ) { }
+static void null_glLightfv( GLenum light, GLenum pname, const GLfloat *params ) { }
 static void null_glLighti( GLenum light, GLenum pname, GLint param ) { }
-static void null_glLightiv( GLenum light, GLenum pname, const GLint* params ) { }
+static void null_glLightiv( GLenum light, GLenum pname, const GLint *params ) { }
 static void null_glLineStipple( GLint factor, GLushort pattern ) { }
 static void null_glLineWidth( GLfloat width ) { }
 static void null_glListBase( GLuint base ) { }
-static void null_glLoadIdentity( void ) { }
-static void null_glLoadMatrixd( const GLdouble* m ) { }
-static void null_glLoadMatrixf( const GLfloat* m ) { }
+static void null_glLoadIdentity(void) { }
+static void null_glLoadMatrixd( const GLdouble *m ) { }
+static void null_glLoadMatrixf( const GLfloat *m ) { }
 static void null_glLoadName( GLuint name ) { }
 static void null_glLogicOp( GLenum opcode ) { }
-static void null_glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points ) { }
-static void null_glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points ) { }
-static void null_glMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points ) { }
-static void null_glMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points ) { }
+static void null_glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points ) { }
+static void null_glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points ) { }
+static void null_glMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points ) { }
+static void null_glMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points ) { }
 static void null_glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 ) { }
 static void null_glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 ) { }
 static void null_glMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 ) { }
 static void null_glMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 ) { }
 static void null_glMaterialf( GLenum face, GLenum pname, GLfloat param ) { }
-static void null_glMaterialfv( GLenum face, GLenum pname, const GLfloat* params ) { }
+static void null_glMaterialfv( GLenum face, GLenum pname, const GLfloat *params ) { }
 static void null_glMateriali( GLenum face, GLenum pname, GLint param ) { }
-static void null_glMaterialiv( GLenum face, GLenum pname, const GLint* params ) { }
+static void null_glMaterialiv( GLenum face, GLenum pname, const GLint *params ) { }
 static void null_glMatrixMode( GLenum mode ) { }
-static void null_glMultMatrixd( const GLdouble* m ) { }
-static void null_glMultMatrixf( const GLfloat* m ) { }
+static void null_glMultMatrixd( const GLdouble *m ) { }
+static void null_glMultMatrixf( const GLfloat *m ) { }
 static void null_glNewList( GLuint list, GLenum mode ) { }
 static void null_glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz ) { }
-static void null_glNormal3bv( const GLbyte* v ) { }
+static void null_glNormal3bv( const GLbyte *v ) { }
 static void null_glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz ) { }
-static void null_glNormal3dv( const GLdouble* v ) { }
+static void null_glNormal3dv( const GLdouble *v ) { }
 static void null_glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz ) { }
-static void null_glNormal3fv( const GLfloat* v ) { }
+static void null_glNormal3fv( const GLfloat *v ) { }
 static void null_glNormal3i( GLint nx, GLint ny, GLint nz ) { }
-static void null_glNormal3iv( const GLint* v ) { }
+static void null_glNormal3iv( const GLint *v ) { }
 static void null_glNormal3s( GLshort nx, GLshort ny, GLshort nz ) { }
-static void null_glNormal3sv( const GLshort* v ) { }
-static void null_glNormalPointer( GLenum type, GLsizei stride, const void* pointer ) { }
+static void null_glNormal3sv( const GLshort *v ) { }
+static void null_glNormalPointer( GLenum type, GLsizei stride, const void *pointer ) { }
 static void null_glOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar ) { }
 static void null_glPassThrough( GLfloat token ) { }
-static void null_glPixelMapfv( GLenum map, GLsizei mapsize, const GLfloat* values ) { }
-static void null_glPixelMapuiv( GLenum map, GLsizei mapsize, const GLuint* values ) { }
-static void null_glPixelMapusv( GLenum map, GLsizei mapsize, const GLushort* values ) { }
+static void null_glPixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values ) { }
+static void null_glPixelMapuiv( GLenum map, GLsizei mapsize, const GLuint *values ) { }
+static void null_glPixelMapusv( GLenum map, GLsizei mapsize, const GLushort *values ) { }
 static void null_glPixelStoref( GLenum pname, GLfloat param ) { }
 static void null_glPixelStorei( GLenum pname, GLint param ) { }
 static void null_glPixelTransferf( GLenum pname, GLfloat param ) { }
@@ -2226,139 +2560,139 @@
 static void null_glPointSize( GLfloat size ) { }
 static void null_glPolygonMode( GLenum face, GLenum mode ) { }
 static void null_glPolygonOffset( GLfloat factor, GLfloat units ) { }
-static void null_glPolygonStipple( const GLubyte* mask ) { }
-static void null_glPopAttrib( void ) { }
-static void null_glPopClientAttrib( void ) { }
-static void null_glPopMatrix( void ) { }
-static void null_glPopName( void ) { }
-static void null_glPrioritizeTextures( GLsizei n, const GLuint* textures, const GLfloat* priorities ) { }
+static void null_glPolygonStipple( const GLubyte *mask ) { }
+static void null_glPopAttrib(void) { }
+static void null_glPopClientAttrib(void) { }
+static void null_glPopMatrix(void) { }
+static void null_glPopName(void) { }
+static void null_glPrioritizeTextures( GLsizei n, const GLuint *textures, const GLfloat *priorities ) { }
 static void null_glPushAttrib( GLbitfield mask ) { }
 static void null_glPushClientAttrib( GLbitfield mask ) { }
-static void null_glPushMatrix( void ) { }
+static void null_glPushMatrix(void) { }
 static void null_glPushName( GLuint name ) { }
 static void null_glRasterPos2d( GLdouble x, GLdouble y ) { }
-static void null_glRasterPos2dv( const GLdouble* v ) { }
+static void null_glRasterPos2dv( const GLdouble *v ) { }
 static void null_glRasterPos2f( GLfloat x, GLfloat y ) { }
-static void null_glRasterPos2fv( const GLfloat* v ) { }
+static void null_glRasterPos2fv( const GLfloat *v ) { }
 static void null_glRasterPos2i( GLint x, GLint y ) { }
-static void null_glRasterPos2iv( const GLint* v ) { }
+static void null_glRasterPos2iv( const GLint *v ) { }
 static void null_glRasterPos2s( GLshort x, GLshort y ) { }
-static void null_glRasterPos2sv( const GLshort* v ) { }
+static void null_glRasterPos2sv( const GLshort *v ) { }
 static void null_glRasterPos3d( GLdouble x, GLdouble y, GLdouble z ) { }
-static void null_glRasterPos3dv( const GLdouble* v ) { }
+static void null_glRasterPos3dv( const GLdouble *v ) { }
 static void null_glRasterPos3f( GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glRasterPos3fv( const GLfloat* v ) { }
+static void null_glRasterPos3fv( const GLfloat *v ) { }
 static void null_glRasterPos3i( GLint x, GLint y, GLint z ) { }
-static void null_glRasterPos3iv( const GLint* v ) { }
+static void null_glRasterPos3iv( const GLint *v ) { }
 static void null_glRasterPos3s( GLshort x, GLshort y, GLshort z ) { }
-static void null_glRasterPos3sv( const GLshort* v ) { }
+static void null_glRasterPos3sv( const GLshort *v ) { }
 static void null_glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
-static void null_glRasterPos4dv( const GLdouble* v ) { }
+static void null_glRasterPos4dv( const GLdouble *v ) { }
 static void null_glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { }
-static void null_glRasterPos4fv( const GLfloat* v ) { }
+static void null_glRasterPos4fv( const GLfloat *v ) { }
 static void null_glRasterPos4i( GLint x, GLint y, GLint z, GLint w ) { }
-static void null_glRasterPos4iv( const GLint* v ) { }
+static void null_glRasterPos4iv( const GLint *v ) { }
 static void null_glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w ) { }
-static void null_glRasterPos4sv( const GLshort* v ) { }
+static void null_glRasterPos4sv( const GLshort *v ) { }
 static void null_glReadBuffer( GLenum src ) { }
-static void null_glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels ) { }
+static void null_glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels ) { }
 static void null_glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 ) { }
-static void null_glRectdv( const GLdouble* v1, const GLdouble* v2 ) { }
+static void null_glRectdv( const GLdouble *v1, const GLdouble *v2 ) { }
 static void null_glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 ) { }
-static void null_glRectfv( const GLfloat* v1, const GLfloat* v2 ) { }
+static void null_glRectfv( const GLfloat *v1, const GLfloat *v2 ) { }
 static void null_glRecti( GLint x1, GLint y1, GLint x2, GLint y2 ) { }
-static void null_glRectiv( const GLint* v1, const GLint* v2 ) { }
+static void null_glRectiv( const GLint *v1, const GLint *v2 ) { }
 static void null_glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 ) { }
-static void null_glRectsv( const GLshort* v1, const GLshort* v2 ) { }
+static void null_glRectsv( const GLshort *v1, const GLshort *v2 ) { }
 static GLint null_glRenderMode( GLenum mode ) { return 0; }
 static void null_glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z ) { }
 static void null_glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) { }
 static void null_glScaled( GLdouble x, GLdouble y, GLdouble z ) { }
 static void null_glScalef( GLfloat x, GLfloat y, GLfloat z ) { }
 static void null_glScissor( GLint x, GLint y, GLsizei width, GLsizei height ) { }
-static void null_glSelectBuffer( GLsizei size, GLuint* buffer ) { }
+static void null_glSelectBuffer( GLsizei size, GLuint *buffer ) { }
 static void null_glShadeModel( GLenum mode ) { }
 static void null_glStencilFunc( GLenum func, GLint ref, GLuint mask ) { }
 static void null_glStencilMask( GLuint mask ) { }
 static void null_glStencilOp( GLenum fail, GLenum zfail, GLenum zpass ) { }
 static void null_glTexCoord1d( GLdouble s ) { }
-static void null_glTexCoord1dv( const GLdouble* v ) { }
+static void null_glTexCoord1dv( const GLdouble *v ) { }
 static void null_glTexCoord1f( GLfloat s ) { }
-static void null_glTexCoord1fv( const GLfloat* v ) { }
+static void null_glTexCoord1fv( const GLfloat *v ) { }
 static void null_glTexCoord1i( GLint s ) { }
-static void null_glTexCoord1iv( const GLint* v ) { }
+static void null_glTexCoord1iv( const GLint *v ) { }
 static void null_glTexCoord1s( GLshort s ) { }
-static void null_glTexCoord1sv( const GLshort* v ) { }
+static void null_glTexCoord1sv( const GLshort *v ) { }
 static void null_glTexCoord2d( GLdouble s, GLdouble t ) { }
-static void null_glTexCoord2dv( const GLdouble* v ) { }
+static void null_glTexCoord2dv( const GLdouble *v ) { }
 static void null_glTexCoord2f( GLfloat s, GLfloat t ) { }
-static void null_glTexCoord2fv( const GLfloat* v ) { }
+static void null_glTexCoord2fv( const GLfloat *v ) { }
 static void null_glTexCoord2i( GLint s, GLint t ) { }
-static void null_glTexCoord2iv( const GLint* v ) { }
+static void null_glTexCoord2iv( const GLint *v ) { }
 static void null_glTexCoord2s( GLshort s, GLshort t ) { }
-static void null_glTexCoord2sv( const GLshort* v ) { }
+static void null_glTexCoord2sv( const GLshort *v ) { }
 static void null_glTexCoord3d( GLdouble s, GLdouble t, GLdouble r ) { }
-static void null_glTexCoord3dv( const GLdouble* v ) { }
+static void null_glTexCoord3dv( const GLdouble *v ) { }
 static void null_glTexCoord3f( GLfloat s, GLfloat t, GLfloat r ) { }
-static void null_glTexCoord3fv( const GLfloat* v ) { }
+static void null_glTexCoord3fv( const GLfloat *v ) { }
 static void null_glTexCoord3i( GLint s, GLint t, GLint r ) { }
-static void null_glTexCoord3iv( const GLint* v ) { }
+static void null_glTexCoord3iv( const GLint *v ) { }
 static void null_glTexCoord3s( GLshort s, GLshort t, GLshort r ) { }
-static void null_glTexCoord3sv( const GLshort* v ) { }
+static void null_glTexCoord3sv( const GLshort *v ) { }
 static void null_glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q ) { }
-static void null_glTexCoord4dv( const GLdouble* v ) { }
+static void null_glTexCoord4dv( const GLdouble *v ) { }
 static void null_glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q ) { }
-static void null_glTexCoord4fv( const GLfloat* v ) { }
+static void null_glTexCoord4fv( const GLfloat *v ) { }
 static void null_glTexCoord4i( GLint s, GLint t, GLint r, GLint q ) { }
-static void null_glTexCoord4iv( const GLint* v ) { }
+static void null_glTexCoord4iv( const GLint *v ) { }
 static void null_glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q ) { }
-static void null_glTexCoord4sv( const GLshort* v ) { }
-static void null_glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const void* pointer ) { }
+static void null_glTexCoord4sv( const GLshort *v ) { }
+static void null_glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const void *pointer ) { }
 static void null_glTexEnvf( GLenum target, GLenum pname, GLfloat param ) { }
-static void null_glTexEnvfv( GLenum target, GLenum pname, const GLfloat* params ) { }
+static void null_glTexEnvfv( GLenum target, GLenum pname, const GLfloat *params ) { }
 static void null_glTexEnvi( GLenum target, GLenum pname, GLint param ) { }
-static void null_glTexEnviv( GLenum target, GLenum pname, const GLint* params ) { }
+static void null_glTexEnviv( GLenum target, GLenum pname, const GLint *params ) { }
 static void null_glTexGend( GLenum coord, GLenum pname, GLdouble param ) { }
-static void null_glTexGendv( GLenum coord, GLenum pname, const GLdouble* params ) { }
+static void null_glTexGendv( GLenum coord, GLenum pname, const GLdouble *params ) { }
 static void null_glTexGenf( GLenum coord, GLenum pname, GLfloat param ) { }
-static void null_glTexGenfv( GLenum coord, GLenum pname, const GLfloat* params ) { }
+static void null_glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params ) { }
 static void null_glTexGeni( GLenum coord, GLenum pname, GLint param ) { }
-static void null_glTexGeniv( GLenum coord, GLenum pname, const GLint* params ) { }
-static void null_glTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels ) { }
+static void null_glTexGeniv( GLenum coord, GLenum pname, const GLint *params ) { }
+static void null_glTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels ) { }
 static void null_glTexParameterf( GLenum target, GLenum pname, GLfloat param ) { }
-static void null_glTexParameterfv( GLenum target, GLenum pname, const GLfloat* params ) { }
+static void null_glTexParameterfv( GLenum target, GLenum pname, const GLfloat *params ) { }
 static void null_glTexParameteri( GLenum target, GLenum pname, GLint param ) { }
-static void null_glTexParameteriv( GLenum target, GLenum pname, const GLint* params ) { }
-static void null_glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels ) { }
+static void null_glTexParameteriv( GLenum target, GLenum pname, const GLint *params ) { }
+static void null_glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels ) { }
 static void null_glTranslated( GLdouble x, GLdouble y, GLdouble z ) { }
 static void null_glTranslatef( GLfloat x, GLfloat y, GLfloat z ) { }
 static void null_glVertex2d( GLdouble x, GLdouble y ) { }
-static void null_glVertex2dv( const GLdouble* v ) { }
+static void null_glVertex2dv( const GLdouble *v ) { }
 static void null_glVertex2f( GLfloat x, GLfloat y ) { }
-static void null_glVertex2fv( const GLfloat* v ) { }
+static void null_glVertex2fv( const GLfloat *v ) { }
 static void null_glVertex2i( GLint x, GLint y ) { }
-static void null_glVertex2iv( const GLint* v ) { }
+static void null_glVertex2iv( const GLint *v ) { }
 static void null_glVertex2s( GLshort x, GLshort y ) { }
-static void null_glVertex2sv( const GLshort* v ) { }
+static void null_glVertex2sv( const GLshort *v ) { }
 static void null_glVertex3d( GLdouble x, GLdouble y, GLdouble z ) { }
-static void null_glVertex3dv( const GLdouble* v ) { }
+static void null_glVertex3dv( const GLdouble *v ) { }
 static void null_glVertex3f( GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glVertex3fv( const GLfloat* v ) { }
+static void null_glVertex3fv( const GLfloat *v ) { }
 static void null_glVertex3i( GLint x, GLint y, GLint z ) { }
-static void null_glVertex3iv( const GLint* v ) { }
+static void null_glVertex3iv( const GLint *v ) { }
 static void null_glVertex3s( GLshort x, GLshort y, GLshort z ) { }
-static void null_glVertex3sv( const GLshort* v ) { }
+static void null_glVertex3sv( const GLshort *v ) { }
 static void null_glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
-static void null_glVertex4dv( const GLdouble* v ) { }
+static void null_glVertex4dv( const GLdouble *v ) { }
 static void null_glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { }
-static void null_glVertex4fv( const GLfloat* v ) { }
+static void null_glVertex4fv( const GLfloat *v ) { }
 static void null_glVertex4i( GLint x, GLint y, GLint z, GLint w ) { }
-static void null_glVertex4iv( const GLint* v ) { }
+static void null_glVertex4iv( const GLint *v ) { }
 static void null_glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w ) { }
-static void null_glVertex4sv( const GLshort* v ) { }
-static void null_glVertexPointer( GLint size, GLenum type, GLsizei stride, const void* pointer ) { }
+static void null_glVertex4sv( const GLshort *v ) { }
+static void null_glVertexPointer( GLint size, GLenum type, GLsizei stride, const void *pointer ) { }
 static void null_glViewport( GLint x, GLint y, GLsizei width, GLsizei height ) { }
 static void null_glAccumxOES( GLenum op, GLfixed value ) { }
 static GLboolean null_glAcquireKeyedMutexWin32EXT( GLuint memory, GLuint64 key, GLuint timeout ) { return 0; }
@@ -2367,16 +2701,16 @@
 static void null_glActiveStencilFaceEXT( GLenum face ) { }
 static void null_glActiveTexture( GLenum texture ) { }
 static void null_glActiveTextureARB( GLenum texture ) { }
-static void null_glActiveVaryingNV( GLuint program, const GLchar* name ) { }
+static void null_glActiveVaryingNV( GLuint program, const GLchar *name ) { }
 static void null_glAlphaFragmentOp1ATI( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod ) { }
 static void null_glAlphaFragmentOp2ATI( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod ) { }
 static void null_glAlphaFragmentOp3ATI( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod ) { }
 static void null_glAlphaFuncxOES( GLenum func, GLfixed ref ) { }
 static void null_glAlphaToCoverageDitherControlNV( GLenum mode ) { }
-static void null_glApplyFramebufferAttachmentCMAAINTEL( void ) { }
+static void null_glApplyFramebufferAttachmentCMAAINTEL(void) { }
 static void null_glApplyTextureEXT( GLenum mode ) { }
-static GLboolean null_glAreProgramsResidentNV( GLsizei n, const GLuint* programs, GLboolean* residences ) { return 0; }
-static GLboolean null_glAreTexturesResidentEXT( GLsizei n, const GLuint* textures, GLboolean* residences ) { return 0; }
+static GLboolean null_glAreProgramsResidentNV( GLsizei n, const GLuint *programs, GLboolean *residences ) { return 0; }
+static GLboolean null_glAreTexturesResidentEXT( GLsizei n, const GLuint *textures, GLboolean *residences ) { return 0; }
 static void null_glArrayElementEXT( GLint i ) { }
 static void null_glArrayObjectATI( GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset ) { }
 static void null_glAsyncMarkerSGIX( GLuint marker ) { }
@@ -2385,7 +2719,7 @@
 static void null_glBeginConditionalRender( GLuint id, GLenum mode ) { }
 static void null_glBeginConditionalRenderNV( GLuint id, GLenum mode ) { }
 static void null_glBeginConditionalRenderNVX( GLuint id ) { }
-static void null_glBeginFragmentShaderATI( void ) { }
+static void null_glBeginFragmentShaderATI(void) { }
 static void null_glBeginOcclusionQueryNV( GLuint id ) { }
 static void null_glBeginPerfMonitorAMD( GLuint monitor ) { }
 static void null_glBeginPerfQueryINTEL( GLuint queryHandle ) { }
@@ -2395,10 +2729,10 @@
 static void null_glBeginTransformFeedback( GLenum primitiveMode ) { }
 static void null_glBeginTransformFeedbackEXT( GLenum primitiveMode ) { }
 static void null_glBeginTransformFeedbackNV( GLenum primitiveMode ) { }
-static void null_glBeginVertexShaderEXT( void ) { }
+static void null_glBeginVertexShaderEXT(void) { }
 static void null_glBeginVideoCaptureNV( GLuint video_capture_slot ) { }
-static void null_glBindAttribLocation( GLuint program, GLuint index, const GLchar* name ) { }
-static void null_glBindAttribLocationARB( GLhandleARB programObj, GLuint index, const GLcharARB* name ) { }
+static void null_glBindAttribLocation( GLuint program, GLuint index, const GLchar *name ) { }
+static void null_glBindAttribLocationARB( GLhandleARB programObj, GLuint index, const GLcharARB *name ) { }
 static void null_glBindBuffer( GLenum target, GLuint buffer ) { }
 static void null_glBindBufferARB( GLenum target, GLuint buffer ) { }
 static void null_glBindBufferBase( GLenum target, GLuint index, GLuint buffer ) { }
@@ -2409,17 +2743,17 @@
 static void null_glBindBufferRange( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size ) { }
 static void null_glBindBufferRangeEXT( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size ) { }
 static void null_glBindBufferRangeNV( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size ) { }
-static void null_glBindBuffersBase( GLenum target, GLuint first, GLsizei count, const GLuint* buffers ) { }
-static void null_glBindBuffersRange( GLenum target, GLuint first, GLsizei count, const GLuint* buffers, const GLintptr* offsets, const GLsizeiptr* sizes ) { }
-static void null_glBindFragDataLocation( GLuint program, GLuint color, const GLchar* name ) { }
-static void null_glBindFragDataLocationEXT( GLuint program, GLuint color, const GLchar* name ) { }
-static void null_glBindFragDataLocationIndexed( GLuint program, GLuint colorNumber, GLuint index, const GLchar* name ) { }
+static void null_glBindBuffersBase( GLenum target, GLuint first, GLsizei count, const GLuint *buffers ) { }
+static void null_glBindBuffersRange( GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes ) { }
+static void null_glBindFragDataLocation( GLuint program, GLuint color, const GLchar *name ) { }
+static void null_glBindFragDataLocationEXT( GLuint program, GLuint color, const GLchar *name ) { }
+static void null_glBindFragDataLocationIndexed( GLuint program, GLuint colorNumber, GLuint index, const GLchar *name ) { }
 static void null_glBindFragmentShaderATI( GLuint id ) { }
 static void null_glBindFramebuffer( GLenum target, GLuint framebuffer ) { }
 static void null_glBindFramebufferEXT( GLenum target, GLuint framebuffer ) { }
 static void null_glBindImageTexture( GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format ) { }
 static void null_glBindImageTextureEXT( GLuint index, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLint format ) { }
-static void null_glBindImageTextures( GLuint first, GLsizei count, const GLuint* textures ) { }
+static void null_glBindImageTextures( GLuint first, GLsizei count, const GLuint *textures ) { }
 static GLuint null_glBindLightParameterEXT( GLenum light, GLenum value ) { return 0; }
 static GLuint null_glBindMaterialParameterEXT( GLenum face, GLenum value ) { return 0; }
 static void null_glBindMultiTextureEXT( GLenum texunit, GLenum target, GLuint texture ) { }
@@ -2430,35 +2764,35 @@
 static void null_glBindRenderbuffer( GLenum target, GLuint renderbuffer ) { }
 static void null_glBindRenderbufferEXT( GLenum target, GLuint renderbuffer ) { }
 static void null_glBindSampler( GLuint unit, GLuint sampler ) { }
-static void null_glBindSamplers( GLuint first, GLsizei count, const GLuint* samplers ) { }
+static void null_glBindSamplers( GLuint first, GLsizei count, const GLuint *samplers ) { }
 static GLuint null_glBindTexGenParameterEXT( GLenum unit, GLenum coord, GLenum value ) { return 0; }
 static void null_glBindTextureEXT( GLenum target, GLuint texture ) { }
 static void null_glBindTextureUnit( GLuint unit, GLuint texture ) { }
 static GLuint null_glBindTextureUnitParameterEXT( GLenum unit, GLenum value ) { return 0; }
-static void null_glBindTextures( GLuint first, GLsizei count, const GLuint* textures ) { }
+static void null_glBindTextures( GLuint first, GLsizei count, const GLuint *textures ) { }
 static void null_glBindTransformFeedback( GLenum target, GLuint id ) { }
 static void null_glBindTransformFeedbackNV( GLenum target, GLuint id ) { }
 static void null_glBindVertexArray( GLuint array ) { }
 static void null_glBindVertexArrayAPPLE( GLuint array ) { }
 static void null_glBindVertexBuffer( GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride ) { }
-static void null_glBindVertexBuffers( GLuint first, GLsizei count, const GLuint* buffers, const GLintptr* offsets, const GLsizei* strides ) { }
+static void null_glBindVertexBuffers( GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides ) { }
 static void null_glBindVertexShaderEXT( GLuint id ) { }
 static void null_glBindVideoCaptureStreamBufferNV( GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLintptrARB offset ) { }
 static void null_glBindVideoCaptureStreamTextureNV( GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLenum target, GLuint texture ) { }
 static void null_glBinormal3bEXT( GLbyte bx, GLbyte by, GLbyte bz ) { }
-static void null_glBinormal3bvEXT( const GLbyte* v ) { }
+static void null_glBinormal3bvEXT( const GLbyte *v ) { }
 static void null_glBinormal3dEXT( GLdouble bx, GLdouble by, GLdouble bz ) { }
-static void null_glBinormal3dvEXT( const GLdouble* v ) { }
+static void null_glBinormal3dvEXT( const GLdouble *v ) { }
 static void null_glBinormal3fEXT( GLfloat bx, GLfloat by, GLfloat bz ) { }
-static void null_glBinormal3fvEXT( const GLfloat* v ) { }
+static void null_glBinormal3fvEXT( const GLfloat *v ) { }
 static void null_glBinormal3iEXT( GLint bx, GLint by, GLint bz ) { }
-static void null_glBinormal3ivEXT( const GLint* v ) { }
+static void null_glBinormal3ivEXT( const GLint *v ) { }
 static void null_glBinormal3sEXT( GLshort bx, GLshort by, GLshort bz ) { }
-static void null_glBinormal3svEXT( const GLshort* v ) { }
-static void null_glBinormalPointerEXT( GLenum type, GLsizei stride, const void* pointer ) { }
-static void null_glBitmapxOES( GLsizei width, GLsizei height, GLfixed xorig, GLfixed yorig, GLfixed xmove, GLfixed ymove, const GLubyte* bitmap ) { }
-static void null_glBlendBarrierKHR( void ) { }
-static void null_glBlendBarrierNV( void ) { }
+static void null_glBinormal3svEXT( const GLshort *v ) { }
+static void null_glBinormalPointerEXT( GLenum type, GLsizei stride, const void *pointer ) { }
+static void null_glBitmapxOES( GLsizei width, GLsizei height, GLfixed xorig, GLfixed yorig, GLfixed xmove, GLfixed ymove, const GLubyte *bitmap ) { }
+static void null_glBlendBarrierKHR(void) { }
+static void null_glBlendBarrierNV(void) { }
 static void null_glBlendColor( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) { }
 static void null_glBlendColorEXT( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) { }
 static void null_glBlendColorxOES( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) { }
@@ -2486,16 +2820,16 @@
 static void null_glBlitFramebufferEXT( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter ) { }
 static void null_glBlitNamedFramebuffer( GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter ) { }
 static void null_glBufferAddressRangeNV( GLenum pname, GLuint index, GLuint64EXT address, GLsizeiptr length ) { }
-static void null_glBufferData( GLenum target, GLsizeiptr size, const void* data, GLenum usage ) { }
-static void null_glBufferDataARB( GLenum target, GLsizeiptrARB size, const void* data, GLenum usage ) { }
+static void null_glBufferData( GLenum target, GLsizeiptr size, const void *data, GLenum usage ) { }
+static void null_glBufferDataARB( GLenum target, GLsizeiptrARB size, const void *data, GLenum usage ) { }
 static void null_glBufferPageCommitmentARB( GLenum target, GLintptr offset, GLsizeiptr size, GLboolean commit ) { }
 static void null_glBufferParameteriAPPLE( GLenum target, GLenum pname, GLint param ) { }
-static GLuint null_glBufferRegionEnabled( void ) { return 0; }
-static void null_glBufferStorage( GLenum target, GLsizeiptr size, const void* data, GLbitfield flags ) { }
+static GLuint null_glBufferRegionEnabled(void) { return 0; }
+static void null_glBufferStorage( GLenum target, GLsizeiptr size, const void *data, GLbitfield flags ) { }
 static void null_glBufferStorageExternalEXT( GLenum target, GLintptr offset, GLsizeiptr size, void * clientBuffer, GLbitfield flags ) { }
 static void null_glBufferStorageMemEXT( GLenum target, GLsizeiptr size, GLuint memory, GLuint64 offset ) { }
-static void null_glBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, const void* data ) { }
-static void null_glBufferSubDataARB( GLenum target, GLintptrARB offset, GLsizeiptrARB size, const void* data ) { }
+static void null_glBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, const void *data ) { }
+static void null_glBufferSubDataARB( GLenum target, GLintptrARB offset, GLsizeiptrARB size, const void *data ) { }
 static void null_glCallCommandListNV( GLuint list ) { }
 static GLenum null_glCheckFramebufferStatus( GLenum target ) { return 0; }
 static GLenum null_glCheckFramebufferStatusEXT( GLenum target ) { return 0; }
@@ -2504,12 +2838,12 @@
 static void null_glClampColor( GLenum target, GLenum clamp ) { }
 static void null_glClampColorARB( GLenum target, GLenum clamp ) { }
 static void null_glClearAccumxOES( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) { }
-static void null_glClearBufferData( GLenum target, GLenum internalformat, GLenum format, GLenum type, const void* data ) { }
-static void null_glClearBufferSubData( GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void* data ) { }
+static void null_glClearBufferData( GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data ) { }
+static void null_glClearBufferSubData( GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data ) { }
 static void null_glClearBufferfi( GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil ) { }
-static void null_glClearBufferfv( GLenum buffer, GLint drawbuffer, const GLfloat* value ) { }
-static void null_glClearBufferiv( GLenum buffer, GLint drawbuffer, const GLint* value ) { }
-static void null_glClearBufferuiv( GLenum buffer, GLint drawbuffer, const GLuint* value ) { }
+static void null_glClearBufferfv( GLenum buffer, GLint drawbuffer, const GLfloat *value ) { }
+static void null_glClearBufferiv( GLenum buffer, GLint drawbuffer, const GLint *value ) { }
+static void null_glClearBufferuiv( GLenum buffer, GLint drawbuffer, const GLuint *value ) { }
 static void null_glClearColorIiEXT( GLint red, GLint green, GLint blue, GLint alpha ) { }
 static void null_glClearColorIuiEXT( GLuint red, GLuint green, GLuint blue, GLuint alpha ) { }
 static void null_glClearColorxOES( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) { }
@@ -2517,40 +2851,40 @@
 static void null_glClearDepthf( GLfloat d ) { }
 static void null_glClearDepthfOES( GLclampf depth ) { }
 static void null_glClearDepthxOES( GLfixed depth ) { }
-static void null_glClearNamedBufferData( GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void* data ) { }
-static void null_glClearNamedBufferDataEXT( GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void* data ) { }
-static void null_glClearNamedBufferSubData( GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void* data ) { }
-static void null_glClearNamedBufferSubDataEXT( GLuint buffer, GLenum internalformat, GLsizeiptr offset, GLsizeiptr size, GLenum format, GLenum type, const void* data ) { }
+static void null_glClearNamedBufferData( GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data ) { }
+static void null_glClearNamedBufferDataEXT( GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data ) { }
+static void null_glClearNamedBufferSubData( GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data ) { }
+static void null_glClearNamedBufferSubDataEXT( GLuint buffer, GLenum internalformat, GLsizeiptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data ) { }
 static void null_glClearNamedFramebufferfi( GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil ) { }
-static void null_glClearNamedFramebufferfv( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat* value ) { }
-static void null_glClearNamedFramebufferiv( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint* value ) { }
-static void null_glClearNamedFramebufferuiv( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint* value ) { }
-static void null_glClearTexImage( GLuint texture, GLint level, GLenum format, GLenum type, const void* data ) { }
-static void null_glClearTexSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* data ) { }
+static void null_glClearNamedFramebufferfv( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value ) { }
+static void null_glClearNamedFramebufferiv( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value ) { }
+static void null_glClearNamedFramebufferuiv( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value ) { }
+static void null_glClearTexImage( GLuint texture, GLint level, GLenum format, GLenum type, const void *data ) { }
+static void null_glClearTexSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data ) { }
 static void null_glClientActiveTexture( GLenum texture ) { }
 static void null_glClientActiveTextureARB( GLenum texture ) { }
 static void null_glClientActiveVertexStreamATI( GLenum stream ) { }
 static void null_glClientAttribDefaultEXT( GLbitfield mask ) { }
 static GLenum null_glClientWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout ) { return 0; }
 static void null_glClipControl( GLenum origin, GLenum depth ) { }
-static void null_glClipPlanefOES( GLenum plane, const GLfloat* equation ) { }
-static void null_glClipPlanexOES( GLenum plane, const GLfixed* equation ) { }
+static void null_glClipPlanefOES( GLenum plane, const GLfloat *equation ) { }
+static void null_glClipPlanexOES( GLenum plane, const GLfixed *equation ) { }
 static void null_glColor3fVertex3fSUN( GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glColor3fVertex3fvSUN( const GLfloat* c, const GLfloat* v ) { }
+static void null_glColor3fVertex3fvSUN( const GLfloat *c, const GLfloat *v ) { }
 static void null_glColor3hNV( GLhalfNV red, GLhalfNV green, GLhalfNV blue ) { }
-static void null_glColor3hvNV( const GLhalfNV* v ) { }
+static void null_glColor3hvNV( const GLhalfNV *v ) { }
 static void null_glColor3xOES( GLfixed red, GLfixed green, GLfixed blue ) { }
-static void null_glColor3xvOES( const GLfixed* components ) { }
+static void null_glColor3xvOES( const GLfixed *components ) { }
 static void null_glColor4fNormal3fVertex3fSUN( GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glColor4fNormal3fVertex3fvSUN( const GLfloat* c, const GLfloat* n, const GLfloat* v ) { }
+static void null_glColor4fNormal3fVertex3fvSUN( const GLfloat *c, const GLfloat *n, const GLfloat *v ) { }
 static void null_glColor4hNV( GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha ) { }
-static void null_glColor4hvNV( const GLhalfNV* v ) { }
+static void null_glColor4hvNV( const GLhalfNV *v ) { }
 static void null_glColor4ubVertex2fSUN( GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y ) { }
-static void null_glColor4ubVertex2fvSUN( const GLubyte* c, const GLfloat* v ) { }
+static void null_glColor4ubVertex2fvSUN( const GLubyte *c, const GLfloat *v ) { }
 static void null_glColor4ubVertex3fSUN( GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glColor4ubVertex3fvSUN( const GLubyte* c, const GLfloat* v ) { }
+static void null_glColor4ubVertex3fvSUN( const GLubyte *c, const GLfloat *v ) { }
 static void null_glColor4xOES( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) { }
-static void null_glColor4xvOES( const GLfixed* components ) { }
+static void null_glColor4xvOES( const GLfixed *components ) { }
 static void null_glColorFormatNV( GLint size, GLenum type, GLsizei stride ) { }
 static void null_glColorFragmentOp1ATI( GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod ) { }
 static void null_glColorFragmentOp2ATI( GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod ) { }
@@ -2558,76 +2892,76 @@
 static void null_glColorMaskIndexedEXT( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a ) { }
 static void null_glColorMaski( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a ) { }
 static void null_glColorP3ui( GLenum type, GLuint color ) { }
-static void null_glColorP3uiv( GLenum type, const GLuint* color ) { }
+static void null_glColorP3uiv( GLenum type, const GLuint *color ) { }
 static void null_glColorP4ui( GLenum type, GLuint color ) { }
-static void null_glColorP4uiv( GLenum type, const GLuint* color ) { }
-static void null_glColorPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const void* pointer ) { }
-static void null_glColorPointerListIBM( GLint size, GLenum type, GLint stride, const void** pointer, GLint ptrstride ) { }
-static void null_glColorPointervINTEL( GLint size, GLenum type, const void** pointer ) { }
-static void null_glColorSubTable( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void* data ) { }
-static void null_glColorSubTableEXT( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void* data ) { }
-static void null_glColorTable( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void* table ) { }
-static void null_glColorTableEXT( GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void* table ) { }
-static void null_glColorTableParameterfv( GLenum target, GLenum pname, const GLfloat* params ) { }
-static void null_glColorTableParameterfvSGI( GLenum target, GLenum pname, const GLfloat* params ) { }
-static void null_glColorTableParameteriv( GLenum target, GLenum pname, const GLint* params ) { }
-static void null_glColorTableParameterivSGI( GLenum target, GLenum pname, const GLint* params ) { }
-static void null_glColorTableSGI( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void* table ) { }
+static void null_glColorP4uiv( GLenum type, const GLuint *color ) { }
+static void null_glColorPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer ) { }
+static void null_glColorPointerListIBM( GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride ) { }
+static void null_glColorPointervINTEL( GLint size, GLenum type, const void **pointer ) { }
+static void null_glColorSubTable( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data ) { }
+static void null_glColorSubTableEXT( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data ) { }
+static void null_glColorTable( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table ) { }
+static void null_glColorTableEXT( GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void *table ) { }
+static void null_glColorTableParameterfv( GLenum target, GLenum pname, const GLfloat *params ) { }
+static void null_glColorTableParameterfvSGI( GLenum target, GLenum pname, const GLfloat *params ) { }
+static void null_glColorTableParameteriv( GLenum target, GLenum pname, const GLint *params ) { }
+static void null_glColorTableParameterivSGI( GLenum target, GLenum pname, const GLint *params ) { }
+static void null_glColorTableSGI( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table ) { }
 static void null_glCombinerInputNV( GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage ) { }
 static void null_glCombinerOutputNV( GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum ) { }
 static void null_glCombinerParameterfNV( GLenum pname, GLfloat param ) { }
-static void null_glCombinerParameterfvNV( GLenum pname, const GLfloat* params ) { }
+static void null_glCombinerParameterfvNV( GLenum pname, const GLfloat *params ) { }
 static void null_glCombinerParameteriNV( GLenum pname, GLint param ) { }
-static void null_glCombinerParameterivNV( GLenum pname, const GLint* params ) { }
-static void null_glCombinerStageParameterfvNV( GLenum stage, GLenum pname, const GLfloat* params ) { }
+static void null_glCombinerParameterivNV( GLenum pname, const GLint *params ) { }
+static void null_glCombinerStageParameterfvNV( GLenum stage, GLenum pname, const GLfloat *params ) { }
 static void null_glCommandListSegmentsNV( GLuint list, GLuint segments ) { }
 static void null_glCompileCommandListNV( GLuint list ) { }
 static void null_glCompileShader( GLuint shader ) { }
 static void null_glCompileShaderARB( GLhandleARB shaderObj ) { }
-static void null_glCompileShaderIncludeARB( GLuint shader, GLsizei count, const GLchar*const* path, const GLint* length ) { }
-static void null_glCompressedMultiTexImage1DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* bits ) { }
-static void null_glCompressedMultiTexImage2DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* bits ) { }
-static void null_glCompressedMultiTexImage3DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* bits ) { }
-static void null_glCompressedMultiTexSubImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* bits ) { }
-static void null_glCompressedMultiTexSubImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* bits ) { }
-static void null_glCompressedMultiTexSubImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* bits ) { }
-static void null_glCompressedTexImage1D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* data ) { }
-static void null_glCompressedTexImage1DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* data ) { }
-static void null_glCompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data ) { }
-static void null_glCompressedTexImage2DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data ) { }
-static void null_glCompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data ) { }
-static void null_glCompressedTexImage3DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data ) { }
-static void null_glCompressedTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data ) { }
-static void null_glCompressedTexSubImage1DARB( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data ) { }
-static void null_glCompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data ) { }
-static void null_glCompressedTexSubImage2DARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data ) { }
-static void null_glCompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data ) { }
-static void null_glCompressedTexSubImage3DARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data ) { }
-static void null_glCompressedTextureImage1DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* bits ) { }
-static void null_glCompressedTextureImage2DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* bits ) { }
-static void null_glCompressedTextureImage3DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* bits ) { }
-static void null_glCompressedTextureSubImage1D( GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data ) { }
-static void null_glCompressedTextureSubImage1DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* bits ) { }
-static void null_glCompressedTextureSubImage2D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data ) { }
-static void null_glCompressedTextureSubImage2DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* bits ) { }
-static void null_glCompressedTextureSubImage3D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data ) { }
-static void null_glCompressedTextureSubImage3DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* bits ) { }
+static void null_glCompileShaderIncludeARB( GLuint shader, GLsizei count, const GLchar *const*path, const GLint *length ) { }
+static void null_glCompressedMultiTexImage1DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits ) { }
+static void null_glCompressedMultiTexImage2DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits ) { }
+static void null_glCompressedMultiTexImage3DEXT( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits ) { }
+static void null_glCompressedMultiTexSubImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits ) { }
+static void null_glCompressedMultiTexSubImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits ) { }
+static void null_glCompressedMultiTexSubImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits ) { }
+static void null_glCompressedTexImage1D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data ) { }
+static void null_glCompressedTexImage1DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data ) { }
+static void null_glCompressedTexImage2D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data ) { }
+static void null_glCompressedTexImage2DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data ) { }
+static void null_glCompressedTexImage3D( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data ) { }
+static void null_glCompressedTexImage3DARB( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data ) { }
+static void null_glCompressedTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data ) { }
+static void null_glCompressedTexSubImage1DARB( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data ) { }
+static void null_glCompressedTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data ) { }
+static void null_glCompressedTexSubImage2DARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data ) { }
+static void null_glCompressedTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data ) { }
+static void null_glCompressedTexSubImage3DARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data ) { }
+static void null_glCompressedTextureImage1DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits ) { }
+static void null_glCompressedTextureImage2DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits ) { }
+static void null_glCompressedTextureImage3DEXT( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits ) { }
+static void null_glCompressedTextureSubImage1D( GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data ) { }
+static void null_glCompressedTextureSubImage1DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits ) { }
+static void null_glCompressedTextureSubImage2D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data ) { }
+static void null_glCompressedTextureSubImage2DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits ) { }
+static void null_glCompressedTextureSubImage3D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data ) { }
+static void null_glCompressedTextureSubImage3DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits ) { }
 static void null_glConservativeRasterParameterfNV( GLenum pname, GLfloat value ) { }
 static void null_glConservativeRasterParameteriNV( GLenum pname, GLint param ) { }
-static void null_glConvolutionFilter1D( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void* image ) { }
-static void null_glConvolutionFilter1DEXT( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void* image ) { }
-static void null_glConvolutionFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* image ) { }
-static void null_glConvolutionFilter2DEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* image ) { }
+static void null_glConvolutionFilter1D( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image ) { }
+static void null_glConvolutionFilter1DEXT( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image ) { }
+static void null_glConvolutionFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image ) { }
+static void null_glConvolutionFilter2DEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image ) { }
 static void null_glConvolutionParameterf( GLenum target, GLenum pname, GLfloat params ) { }
 static void null_glConvolutionParameterfEXT( GLenum target, GLenum pname, GLfloat params ) { }
-static void null_glConvolutionParameterfv( GLenum target, GLenum pname, const GLfloat* params ) { }
-static void null_glConvolutionParameterfvEXT( GLenum target, GLenum pname, const GLfloat* params ) { }
+static void null_glConvolutionParameterfv( GLenum target, GLenum pname, const GLfloat *params ) { }
+static void null_glConvolutionParameterfvEXT( GLenum target, GLenum pname, const GLfloat *params ) { }
 static void null_glConvolutionParameteri( GLenum target, GLenum pname, GLint params ) { }
 static void null_glConvolutionParameteriEXT( GLenum target, GLenum pname, GLint params ) { }
-static void null_glConvolutionParameteriv( GLenum target, GLenum pname, const GLint* params ) { }
-static void null_glConvolutionParameterivEXT( GLenum target, GLenum pname, const GLint* params ) { }
+static void null_glConvolutionParameteriv( GLenum target, GLenum pname, const GLint *params ) { }
+static void null_glConvolutionParameterivEXT( GLenum target, GLenum pname, const GLint *params ) { }
 static void null_glConvolutionParameterxOES( GLenum target, GLenum pname, GLfixed param ) { }
-static void null_glConvolutionParameterxvOES( GLenum target, GLenum pname, const GLfixed* params ) { }
+static void null_glConvolutionParameterxvOES( GLenum target, GLenum pname, const GLfixed *params ) { }
 static void null_glCopyBufferSubData( GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size ) { }
 static void null_glCopyColorSubTable( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width ) { }
 static void null_glCopyColorSubTableEXT( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width ) { }
@@ -2660,89 +2994,89 @@
 static void null_glCopyTextureSubImage2DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) { }
 static void null_glCopyTextureSubImage3D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) { }
 static void null_glCopyTextureSubImage3DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height ) { }
-static void null_glCoverFillPathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat* transformValues ) { }
+static void null_glCoverFillPathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues ) { }
 static void null_glCoverFillPathNV( GLuint path, GLenum coverMode ) { }
-static void null_glCoverStrokePathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat* transformValues ) { }
+static void null_glCoverStrokePathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues ) { }
 static void null_glCoverStrokePathNV( GLuint path, GLenum coverMode ) { }
 static void null_glCoverageModulationNV( GLenum components ) { }
-static void null_glCoverageModulationTableNV( GLsizei n, const GLfloat* v ) { }
-static void null_glCreateBuffers( GLsizei n, GLuint* buffers ) { }
-static void null_glCreateCommandListsNV( GLsizei n, GLuint* lists ) { }
-static void null_glCreateFramebuffers( GLsizei n, GLuint* framebuffers ) { }
-static void null_glCreateMemoryObjectsEXT( GLsizei n, GLuint* memoryObjects ) { }
-static void null_glCreatePerfQueryINTEL( GLuint queryId, GLuint* queryHandle ) { }
-static GLuint null_glCreateProgram( void ) { return 0; }
-static GLhandleARB null_glCreateProgramObjectARB( void ) { return 0; }
-static void null_glCreateProgramPipelines( GLsizei n, GLuint* pipelines ) { }
-static void null_glCreateQueries( GLenum target, GLsizei n, GLuint* ids ) { }
-static void null_glCreateRenderbuffers( GLsizei n, GLuint* renderbuffers ) { }
-static void null_glCreateSamplers( GLsizei n, GLuint* samplers ) { }
+static void null_glCoverageModulationTableNV( GLsizei n, const GLfloat *v ) { }
+static void null_glCreateBuffers( GLsizei n, GLuint *buffers ) { }
+static void null_glCreateCommandListsNV( GLsizei n, GLuint *lists ) { }
+static void null_glCreateFramebuffers( GLsizei n, GLuint *framebuffers ) { }
+static void null_glCreateMemoryObjectsEXT( GLsizei n, GLuint *memoryObjects ) { }
+static void null_glCreatePerfQueryINTEL( GLuint queryId, GLuint *queryHandle ) { }
+static GLuint null_glCreateProgram(void) { return 0; }
+static GLhandleARB null_glCreateProgramObjectARB(void) { return 0; }
+static void null_glCreateProgramPipelines( GLsizei n, GLuint *pipelines ) { }
+static void null_glCreateQueries( GLenum target, GLsizei n, GLuint *ids ) { }
+static void null_glCreateRenderbuffers( GLsizei n, GLuint *renderbuffers ) { }
+static void null_glCreateSamplers( GLsizei n, GLuint *samplers ) { }
 static GLuint null_glCreateShader( GLenum type ) { return 0; }
 static GLhandleARB null_glCreateShaderObjectARB( GLenum shaderType ) { return 0; }
-static GLuint null_glCreateShaderProgramEXT( GLenum type, const GLchar* string ) { return 0; }
-static GLuint null_glCreateShaderProgramv( GLenum type, GLsizei count, const GLchar*const* strings ) { return 0; }
-static void null_glCreateStatesNV( GLsizei n, GLuint* states ) { }
-static GLsync null_glCreateSyncFromCLeventARB( void* context, void* event, GLbitfield flags ) { return 0; }
-static void null_glCreateTextures( GLenum target, GLsizei n, GLuint* textures ) { }
-static void null_glCreateTransformFeedbacks( GLsizei n, GLuint* ids ) { }
-static void null_glCreateVertexArrays( GLsizei n, GLuint* arrays ) { }
-static void null_glCullParameterdvEXT( GLenum pname, GLdouble* params ) { }
-static void null_glCullParameterfvEXT( GLenum pname, GLfloat* params ) { }
+static GLuint null_glCreateShaderProgramEXT( GLenum type, const GLchar *string ) { return 0; }
+static GLuint null_glCreateShaderProgramv( GLenum type, GLsizei count, const GLchar *const*strings ) { return 0; }
+static void null_glCreateStatesNV( GLsizei n, GLuint *states ) { }
+static GLsync null_glCreateSyncFromCLeventARB( void *context, void *event, GLbitfield flags ) { return 0; }
+static void null_glCreateTextures( GLenum target, GLsizei n, GLuint *textures ) { }
+static void null_glCreateTransformFeedbacks( GLsizei n, GLuint *ids ) { }
+static void null_glCreateVertexArrays( GLsizei n, GLuint *arrays ) { }
+static void null_glCullParameterdvEXT( GLenum pname, GLdouble *params ) { }
+static void null_glCullParameterfvEXT( GLenum pname, GLfloat *params ) { }
 static void null_glCurrentPaletteMatrixARB( GLint index ) { }
-static void null_glDebugMessageCallback( void * callback, const void* userParam ) { }
-static void null_glDebugMessageCallbackAMD( void * callback, void* userParam ) { }
-static void null_glDebugMessageCallbackARB( void * callback, const void* userParam ) { }
-static void null_glDebugMessageControl( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled ) { }
-static void null_glDebugMessageControlARB( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled ) { }
-static void null_glDebugMessageEnableAMD( GLenum category, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled ) { }
-static void null_glDebugMessageInsert( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* buf ) { }
-static void null_glDebugMessageInsertAMD( GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar* buf ) { }
-static void null_glDebugMessageInsertARB( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* buf ) { }
+static void null_glDebugMessageCallback( void * callback, const void *userParam ) { }
+static void null_glDebugMessageCallbackAMD( void * callback, void *userParam ) { }
+static void null_glDebugMessageCallbackARB( void * callback, const void *userParam ) { }
+static void null_glDebugMessageControl( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled ) { }
+static void null_glDebugMessageControlARB( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled ) { }
+static void null_glDebugMessageEnableAMD( GLenum category, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled ) { }
+static void null_glDebugMessageInsert( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf ) { }
+static void null_glDebugMessageInsertAMD( GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar *buf ) { }
+static void null_glDebugMessageInsertARB( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf ) { }
 static void null_glDeformSGIX( GLbitfield mask ) { }
-static void null_glDeformationMap3dSGIX( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, const GLdouble* points ) { }
-static void null_glDeformationMap3fSGIX( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, const GLfloat* points ) { }
+static void null_glDeformationMap3dSGIX( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, const GLdouble *points ) { }
+static void null_glDeformationMap3fSGIX( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, const GLfloat *points ) { }
 static void null_glDeleteAsyncMarkersSGIX( GLuint marker, GLsizei range ) { }
 static void null_glDeleteBufferRegion( GLenum region ) { }
-static void null_glDeleteBuffers( GLsizei n, const GLuint* buffers ) { }
-static void null_glDeleteBuffersARB( GLsizei n, const GLuint* buffers ) { }
-static void null_glDeleteCommandListsNV( GLsizei n, const GLuint* lists ) { }
-static void null_glDeleteFencesAPPLE( GLsizei n, const GLuint* fences ) { }
-static void null_glDeleteFencesNV( GLsizei n, const GLuint* fences ) { }
+static void null_glDeleteBuffers( GLsizei n, const GLuint *buffers ) { }
+static void null_glDeleteBuffersARB( GLsizei n, const GLuint *buffers ) { }
+static void null_glDeleteCommandListsNV( GLsizei n, const GLuint *lists ) { }
+static void null_glDeleteFencesAPPLE( GLsizei n, const GLuint *fences ) { }
+static void null_glDeleteFencesNV( GLsizei n, const GLuint *fences ) { }
 static void null_glDeleteFragmentShaderATI( GLuint id ) { }
-static void null_glDeleteFramebuffers( GLsizei n, const GLuint* framebuffers ) { }
-static void null_glDeleteFramebuffersEXT( GLsizei n, const GLuint* framebuffers ) { }
-static void null_glDeleteMemoryObjectsEXT( GLsizei n, const GLuint* memoryObjects ) { }
-static void null_glDeleteNamedStringARB( GLint namelen, const GLchar* name ) { }
-static void null_glDeleteNamesAMD( GLenum identifier, GLuint num, const GLuint* names ) { }
+static void null_glDeleteFramebuffers( GLsizei n, const GLuint *framebuffers ) { }
+static void null_glDeleteFramebuffersEXT( GLsizei n, const GLuint *framebuffers ) { }
+static void null_glDeleteMemoryObjectsEXT( GLsizei n, const GLuint *memoryObjects ) { }
+static void null_glDeleteNamedStringARB( GLint namelen, const GLchar *name ) { }
+static void null_glDeleteNamesAMD( GLenum identifier, GLuint num, const GLuint *names ) { }
 static void null_glDeleteObjectARB( GLhandleARB obj ) { }
 static void null_glDeleteObjectBufferATI( GLuint buffer ) { }
-static void null_glDeleteOcclusionQueriesNV( GLsizei n, const GLuint* ids ) { }
+static void null_glDeleteOcclusionQueriesNV( GLsizei n, const GLuint *ids ) { }
 static void null_glDeletePathsNV( GLuint path, GLsizei range ) { }
-static void null_glDeletePerfMonitorsAMD( GLsizei n, GLuint* monitors ) { }
+static void null_glDeletePerfMonitorsAMD( GLsizei n, GLuint *monitors ) { }
 static void null_glDeletePerfQueryINTEL( GLuint queryHandle ) { }
 static void null_glDeleteProgram( GLuint program ) { }
-static void null_glDeleteProgramPipelines( GLsizei n, const GLuint* pipelines ) { }
-static void null_glDeleteProgramsARB( GLsizei n, const GLuint* programs ) { }
-static void null_glDeleteProgramsNV( GLsizei n, const GLuint* programs ) { }
-static void null_glDeleteQueries( GLsizei n, const GLuint* ids ) { }
-static void null_glDeleteQueriesARB( GLsizei n, const GLuint* ids ) { }
-static void null_glDeleteQueryResourceTagNV( GLsizei n, const GLint* tagIds ) { }
-static void null_glDeleteRenderbuffers( GLsizei n, const GLuint* renderbuffers ) { }
-static void null_glDeleteRenderbuffersEXT( GLsizei n, const GLuint* renderbuffers ) { }
-static void null_glDeleteSamplers( GLsizei count, const GLuint* samplers ) { }
-static void null_glDeleteSemaphoresEXT( GLsizei n, const GLuint* semaphores ) { }
+static void null_glDeleteProgramPipelines( GLsizei n, const GLuint *pipelines ) { }
+static void null_glDeleteProgramsARB( GLsizei n, const GLuint *programs ) { }
+static void null_glDeleteProgramsNV( GLsizei n, const GLuint *programs ) { }
+static void null_glDeleteQueries( GLsizei n, const GLuint *ids ) { }
+static void null_glDeleteQueriesARB( GLsizei n, const GLuint *ids ) { }
+static void null_glDeleteQueryResourceTagNV( GLsizei n, const GLint *tagIds ) { }
+static void null_glDeleteRenderbuffers( GLsizei n, const GLuint *renderbuffers ) { }
+static void null_glDeleteRenderbuffersEXT( GLsizei n, const GLuint *renderbuffers ) { }
+static void null_glDeleteSamplers( GLsizei count, const GLuint *samplers ) { }
+static void null_glDeleteSemaphoresEXT( GLsizei n, const GLuint *semaphores ) { }
 static void null_glDeleteShader( GLuint shader ) { }
-static void null_glDeleteStatesNV( GLsizei n, const GLuint* states ) { }
+static void null_glDeleteStatesNV( GLsizei n, const GLuint *states ) { }
 static void null_glDeleteSync( GLsync sync ) { }
-static void null_glDeleteTexturesEXT( GLsizei n, const GLuint* textures ) { }
-static void null_glDeleteTransformFeedbacks( GLsizei n, const GLuint* ids ) { }
-static void null_glDeleteTransformFeedbacksNV( GLsizei n, const GLuint* ids ) { }
-static void null_glDeleteVertexArrays( GLsizei n, const GLuint* arrays ) { }
-static void null_glDeleteVertexArraysAPPLE( GLsizei n, const GLuint* arrays ) { }
+static void null_glDeleteTexturesEXT( GLsizei n, const GLuint *textures ) { }
+static void null_glDeleteTransformFeedbacks( GLsizei n, const GLuint *ids ) { }
+static void null_glDeleteTransformFeedbacksNV( GLsizei n, const GLuint *ids ) { }
+static void null_glDeleteVertexArrays( GLsizei n, const GLuint *arrays ) { }
+static void null_glDeleteVertexArraysAPPLE( GLsizei n, const GLuint *arrays ) { }
 static void null_glDeleteVertexShaderEXT( GLuint id ) { }
 static void null_glDepthBoundsEXT( GLclampd zmin, GLclampd zmax ) { }
 static void null_glDepthBoundsdNV( GLdouble zmin, GLdouble zmax ) { }
-static void null_glDepthRangeArrayv( GLuint first, GLsizei count, const GLdouble* v ) { }
+static void null_glDepthRangeArrayv( GLuint first, GLsizei count, const GLdouble *v ) { }
 static void null_glDepthRangeIndexed( GLuint index, GLdouble n, GLdouble f ) { }
 static void null_glDepthRangedNV( GLdouble zNear, GLdouble zFar ) { }
 static void null_glDepthRangef( GLfloat n, GLfloat f ) { }
@@ -2750,7 +3084,7 @@
 static void null_glDepthRangexOES( GLfixed n, GLfixed f ) { }
 static void null_glDetachObjectARB( GLhandleARB containerObj, GLhandleARB attachedObj ) { }
 static void null_glDetachShader( GLuint program, GLuint shader ) { }
-static void null_glDetailTexFuncSGIS( GLenum target, GLsizei n, const GLfloat* points ) { }
+static void null_glDetailTexFuncSGIS( GLenum target, GLsizei n, const GLfloat *points ) { }
 static void null_glDisableClientStateIndexedEXT( GLenum array, GLuint index ) { }
 static void null_glDisableClientStateiEXT( GLenum array, GLuint index ) { }
 static void null_glDisableIndexedEXT( GLenum target, GLuint index ) { }
@@ -2766,35 +3100,35 @@
 static void null_glDispatchComputeGroupSizeARB( GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z, GLuint group_size_x, GLuint group_size_y, GLuint group_size_z ) { }
 static void null_glDispatchComputeIndirect( GLintptr indirect ) { }
 static void null_glDrawArraysEXT( GLenum mode, GLint first, GLsizei count ) { }
-static void null_glDrawArraysIndirect( GLenum mode, const void* indirect ) { }
+static void null_glDrawArraysIndirect( GLenum mode, const void *indirect ) { }
 static void null_glDrawArraysInstanced( GLenum mode, GLint first, GLsizei count, GLsizei instancecount ) { }
 static void null_glDrawArraysInstancedARB( GLenum mode, GLint first, GLsizei count, GLsizei primcount ) { }
 static void null_glDrawArraysInstancedBaseInstance( GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance ) { }
 static void null_glDrawArraysInstancedEXT( GLenum mode, GLint start, GLsizei count, GLsizei primcount ) { }
 static void null_glDrawBufferRegion( GLenum region, GLint x, GLint y, GLsizei width, GLsizei height, GLint xDest, GLint yDest ) { }
-static void null_glDrawBuffers( GLsizei n, const GLenum* bufs ) { }
-static void null_glDrawBuffersARB( GLsizei n, const GLenum* bufs ) { }
-static void null_glDrawBuffersATI( GLsizei n, const GLenum* bufs ) { }
-static void null_glDrawCommandsAddressNV( GLenum primitiveMode, const GLuint64* indirects, const GLsizei* sizes, GLuint count ) { }
-static void null_glDrawCommandsNV( GLenum primitiveMode, GLuint buffer, const GLintptr* indirects, const GLsizei* sizes, GLuint count ) { }
-static void null_glDrawCommandsStatesAddressNV( const GLuint64* indirects, const GLsizei* sizes, const GLuint* states, const GLuint* fbos, GLuint count ) { }
-static void null_glDrawCommandsStatesNV( GLuint buffer, const GLintptr* indirects, const GLsizei* sizes, const GLuint* states, const GLuint* fbos, GLuint count ) { }
+static void null_glDrawBuffers( GLsizei n, const GLenum *bufs ) { }
+static void null_glDrawBuffersARB( GLsizei n, const GLenum *bufs ) { }
+static void null_glDrawBuffersATI( GLsizei n, const GLenum *bufs ) { }
+static void null_glDrawCommandsAddressNV( GLenum primitiveMode, const GLuint64 *indirects, const GLsizei *sizes, GLuint count ) { }
+static void null_glDrawCommandsNV( GLenum primitiveMode, GLuint buffer, const GLintptr *indirects, const GLsizei *sizes, GLuint count ) { }
+static void null_glDrawCommandsStatesAddressNV( const GLuint64 *indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count ) { }
+static void null_glDrawCommandsStatesNV( GLuint buffer, const GLintptr *indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count ) { }
 static void null_glDrawElementArrayAPPLE( GLenum mode, GLint first, GLsizei count ) { }
 static void null_glDrawElementArrayATI( GLenum mode, GLsizei count ) { }
-static void null_glDrawElementsBaseVertex( GLenum mode, GLsizei count, GLenum type, const void* indices, GLint basevertex ) { }
-static void null_glDrawElementsIndirect( GLenum mode, GLenum type, const void* indirect ) { }
-static void null_glDrawElementsInstanced( GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount ) { }
-static void null_glDrawElementsInstancedARB( GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount ) { }
-static void null_glDrawElementsInstancedBaseInstance( GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLuint baseinstance ) { }
-static void null_glDrawElementsInstancedBaseVertex( GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLint basevertex ) { }
-static void null_glDrawElementsInstancedBaseVertexBaseInstance( GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance ) { }
-static void null_glDrawElementsInstancedEXT( GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount ) { }
+static void null_glDrawElementsBaseVertex( GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex ) { }
+static void null_glDrawElementsIndirect( GLenum mode, GLenum type, const void *indirect ) { }
+static void null_glDrawElementsInstanced( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount ) { }
+static void null_glDrawElementsInstancedARB( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount ) { }
+static void null_glDrawElementsInstancedBaseInstance( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance ) { }
+static void null_glDrawElementsInstancedBaseVertex( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex ) { }
+static void null_glDrawElementsInstancedBaseVertexBaseInstance( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance ) { }
+static void null_glDrawElementsInstancedEXT( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount ) { }
 static void null_glDrawMeshArraysSUN( GLenum mode, GLint first, GLsizei count, GLsizei width ) { }
 static void null_glDrawRangeElementArrayAPPLE( GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count ) { }
 static void null_glDrawRangeElementArrayATI( GLenum mode, GLuint start, GLuint end, GLsizei count ) { }
-static void null_glDrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices ) { }
-static void null_glDrawRangeElementsBaseVertex( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices, GLint basevertex ) { }
-static void null_glDrawRangeElementsEXT( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices ) { }
+static void null_glDrawRangeElements( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices ) { }
+static void null_glDrawRangeElementsBaseVertex( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex ) { }
+static void null_glDrawRangeElementsEXT( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices ) { }
 static void null_glDrawTextureNV( GLuint texture, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1 ) { }
 static void null_glDrawTransformFeedback( GLenum mode, GLuint id ) { }
 static void null_glDrawTransformFeedbackInstanced( GLenum mode, GLuint id, GLsizei instancecount ) { }
@@ -2803,10 +3137,10 @@
 static void null_glDrawTransformFeedbackStreamInstanced( GLenum mode, GLuint id, GLuint stream, GLsizei instancecount ) { }
 static void null_glDrawVkImageNV( GLuint64 vkImage, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1 ) { }
 static void null_glEdgeFlagFormatNV( GLsizei stride ) { }
-static void null_glEdgeFlagPointerEXT( GLsizei stride, GLsizei count, const GLboolean* pointer ) { }
-static void null_glEdgeFlagPointerListIBM( GLint stride, const GLboolean** pointer, GLint ptrstride ) { }
-static void null_glElementPointerAPPLE( GLenum type, const void* pointer ) { }
-static void null_glElementPointerATI( GLenum type, const void* pointer ) { }
+static void null_glEdgeFlagPointerEXT( GLsizei stride, GLsizei count, const GLboolean *pointer ) { }
+static void null_glEdgeFlagPointerListIBM( GLint stride, const GLboolean **pointer, GLint ptrstride ) { }
+static void null_glElementPointerAPPLE( GLenum type, const void *pointer ) { }
+static void null_glElementPointerATI( GLenum type, const void *pointer ) { }
 static void null_glEnableClientStateIndexedEXT( GLenum array, GLuint index ) { }
 static void null_glEnableClientStateiEXT( GLenum array, GLuint index ) { }
 static void null_glEnableIndexedEXT( GLenum target, GLuint index ) { }
@@ -2818,88 +3152,88 @@
 static void null_glEnableVertexAttribArray( GLuint index ) { }
 static void null_glEnableVertexAttribArrayARB( GLuint index ) { }
 static void null_glEnablei( GLenum target, GLuint index ) { }
-static void null_glEndConditionalRender( void ) { }
-static void null_glEndConditionalRenderNV( void ) { }
-static void null_glEndConditionalRenderNVX( void ) { }
-static void null_glEndFragmentShaderATI( void ) { }
-static void null_glEndOcclusionQueryNV( void ) { }
+static void null_glEndConditionalRender(void) { }
+static void null_glEndConditionalRenderNV(void) { }
+static void null_glEndConditionalRenderNVX(void) { }
+static void null_glEndFragmentShaderATI(void) { }
+static void null_glEndOcclusionQueryNV(void) { }
 static void null_glEndPerfMonitorAMD( GLuint monitor ) { }
 static void null_glEndPerfQueryINTEL( GLuint queryHandle ) { }
 static void null_glEndQuery( GLenum target ) { }
 static void null_glEndQueryARB( GLenum target ) { }
 static void null_glEndQueryIndexed( GLenum target, GLuint index ) { }
-static void null_glEndTransformFeedback( void ) { }
-static void null_glEndTransformFeedbackEXT( void ) { }
-static void null_glEndTransformFeedbackNV( void ) { }
-static void null_glEndVertexShaderEXT( void ) { }
+static void null_glEndTransformFeedback(void) { }
+static void null_glEndTransformFeedbackEXT(void) { }
+static void null_glEndTransformFeedbackNV(void) { }
+static void null_glEndVertexShaderEXT(void) { }
 static void null_glEndVideoCaptureNV( GLuint video_capture_slot ) { }
 static void null_glEvalCoord1xOES( GLfixed u ) { }
-static void null_glEvalCoord1xvOES( const GLfixed* coords ) { }
+static void null_glEvalCoord1xvOES( const GLfixed *coords ) { }
 static void null_glEvalCoord2xOES( GLfixed u, GLfixed v ) { }
-static void null_glEvalCoord2xvOES( const GLfixed* coords ) { }
+static void null_glEvalCoord2xvOES( const GLfixed *coords ) { }
 static void null_glEvalMapsNV( GLenum target, GLenum mode ) { }
-static void null_glEvaluateDepthValuesARB( void ) { }
-static void null_glExecuteProgramNV( GLenum target, GLuint id, const GLfloat* params ) { }
+static void null_glEvaluateDepthValuesARB(void) { }
+static void null_glExecuteProgramNV( GLenum target, GLuint id, const GLfloat *params ) { }
 static void null_glExtractComponentEXT( GLuint res, GLuint src, GLuint num ) { }
-static void null_glFeedbackBufferxOES( GLsizei n, GLenum type, const GLfixed* buffer ) { }
+static void null_glFeedbackBufferxOES( GLsizei n, GLenum type, const GLfixed *buffer ) { }
 static GLsync null_glFenceSync( GLenum condition, GLbitfield flags ) { return 0; }
 static void null_glFinalCombinerInputNV( GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage ) { }
-static GLint null_glFinishAsyncSGIX( GLuint* markerp ) { return 0; }
+static GLint null_glFinishAsyncSGIX( GLuint *markerp ) { return 0; }
 static void null_glFinishFenceAPPLE( GLuint fence ) { }
 static void null_glFinishFenceNV( GLuint fence ) { }
 static void null_glFinishObjectAPPLE( GLenum object, GLint name ) { }
-static void null_glFinishTextureSUNX( void ) { }
+static void null_glFinishTextureSUNX(void) { }
 static void null_glFlushMappedBufferRange( GLenum target, GLintptr offset, GLsizeiptr length ) { }
 static void null_glFlushMappedBufferRangeAPPLE( GLenum target, GLintptr offset, GLsizeiptr size ) { }
 static void null_glFlushMappedNamedBufferRange( GLuint buffer, GLintptr offset, GLsizeiptr length ) { }
 static void null_glFlushMappedNamedBufferRangeEXT( GLuint buffer, GLintptr offset, GLsizeiptr length ) { }
 static void null_glFlushPixelDataRangeNV( GLenum target ) { }
-static void null_glFlushRasterSGIX( void ) { }
+static void null_glFlushRasterSGIX(void) { }
 static void null_glFlushStaticDataIBM( GLenum target ) { }
-static void null_glFlushVertexArrayRangeAPPLE( GLsizei length, void* pointer ) { }
-static void null_glFlushVertexArrayRangeNV( void ) { }
+static void null_glFlushVertexArrayRangeAPPLE( GLsizei length, void *pointer ) { }
+static void null_glFlushVertexArrayRangeNV(void) { }
 static void null_glFogCoordFormatNV( GLenum type, GLsizei stride ) { }
-static void null_glFogCoordPointer( GLenum type, GLsizei stride, const void* pointer ) { }
-static void null_glFogCoordPointerEXT( GLenum type, GLsizei stride, const void* pointer ) { }
-static void null_glFogCoordPointerListIBM( GLenum type, GLint stride, const void** pointer, GLint ptrstride ) { }
+static void null_glFogCoordPointer( GLenum type, GLsizei stride, const void *pointer ) { }
+static void null_glFogCoordPointerEXT( GLenum type, GLsizei stride, const void *pointer ) { }
+static void null_glFogCoordPointerListIBM( GLenum type, GLint stride, const void **pointer, GLint ptrstride ) { }
 static void null_glFogCoordd( GLdouble coord ) { }
 static void null_glFogCoorddEXT( GLdouble coord ) { }
-static void null_glFogCoorddv( const GLdouble* coord ) { }
-static void null_glFogCoorddvEXT( const GLdouble* coord ) { }
+static void null_glFogCoorddv( const GLdouble *coord ) { }
+static void null_glFogCoorddvEXT( const GLdouble *coord ) { }
 static void null_glFogCoordf( GLfloat coord ) { }
 static void null_glFogCoordfEXT( GLfloat coord ) { }
-static void null_glFogCoordfv( const GLfloat* coord ) { }
-static void null_glFogCoordfvEXT( const GLfloat* coord ) { }
+static void null_glFogCoordfv( const GLfloat *coord ) { }
+static void null_glFogCoordfvEXT( const GLfloat *coord ) { }
 static void null_glFogCoordhNV( GLhalfNV fog ) { }
-static void null_glFogCoordhvNV( const GLhalfNV* fog ) { }
-static void null_glFogFuncSGIS( GLsizei n, const GLfloat* points ) { }
+static void null_glFogCoordhvNV( const GLhalfNV *fog ) { }
+static void null_glFogFuncSGIS( GLsizei n, const GLfloat *points ) { }
 static void null_glFogxOES( GLenum pname, GLfixed param ) { }
-static void null_glFogxvOES( GLenum pname, const GLfixed* param ) { }
+static void null_glFogxvOES( GLenum pname, const GLfixed *param ) { }
 static void null_glFragmentColorMaterialSGIX( GLenum face, GLenum mode ) { }
 static void null_glFragmentCoverageColorNV( GLuint color ) { }
 static void null_glFragmentLightModelfSGIX( GLenum pname, GLfloat param ) { }
-static void null_glFragmentLightModelfvSGIX( GLenum pname, const GLfloat* params ) { }
+static void null_glFragmentLightModelfvSGIX( GLenum pname, const GLfloat *params ) { }
 static void null_glFragmentLightModeliSGIX( GLenum pname, GLint param ) { }
-static void null_glFragmentLightModelivSGIX( GLenum pname, const GLint* params ) { }
+static void null_glFragmentLightModelivSGIX( GLenum pname, const GLint *params ) { }
 static void null_glFragmentLightfSGIX( GLenum light, GLenum pname, GLfloat param ) { }
-static void null_glFragmentLightfvSGIX( GLenum light, GLenum pname, const GLfloat* params ) { }
+static void null_glFragmentLightfvSGIX( GLenum light, GLenum pname, const GLfloat *params ) { }
 static void null_glFragmentLightiSGIX( GLenum light, GLenum pname, GLint param ) { }
-static void null_glFragmentLightivSGIX( GLenum light, GLenum pname, const GLint* params ) { }
+static void null_glFragmentLightivSGIX( GLenum light, GLenum pname, const GLint *params ) { }
 static void null_glFragmentMaterialfSGIX( GLenum face, GLenum pname, GLfloat param ) { }
-static void null_glFragmentMaterialfvSGIX( GLenum face, GLenum pname, const GLfloat* params ) { }
+static void null_glFragmentMaterialfvSGIX( GLenum face, GLenum pname, const GLfloat *params ) { }
 static void null_glFragmentMaterialiSGIX( GLenum face, GLenum pname, GLint param ) { }
-static void null_glFragmentMaterialivSGIX( GLenum face, GLenum pname, const GLint* params ) { }
-static void null_glFrameTerminatorGREMEDY( void ) { }
+static void null_glFragmentMaterialivSGIX( GLenum face, GLenum pname, const GLint *params ) { }
+static void null_glFrameTerminatorGREMEDY(void) { }
 static void null_glFrameZoomSGIX( GLint factor ) { }
 static void null_glFramebufferDrawBufferEXT( GLuint framebuffer, GLenum mode ) { }
-static void null_glFramebufferDrawBuffersEXT( GLuint framebuffer, GLsizei n, const GLenum* bufs ) { }
+static void null_glFramebufferDrawBuffersEXT( GLuint framebuffer, GLsizei n, const GLenum *bufs ) { }
 static void null_glFramebufferParameteri( GLenum target, GLenum pname, GLint param ) { }
 static void null_glFramebufferReadBufferEXT( GLuint framebuffer, GLenum mode ) { }
 static void null_glFramebufferRenderbuffer( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) { }
 static void null_glFramebufferRenderbufferEXT( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) { }
-static void null_glFramebufferSampleLocationsfvARB( GLenum target, GLuint start, GLsizei count, const GLfloat* v ) { }
-static void null_glFramebufferSampleLocationsfvNV( GLenum target, GLuint start, GLsizei count, const GLfloat* v ) { }
-static void null_glFramebufferSamplePositionsfvAMD( GLenum target, GLuint numsamples, GLuint pixelindex, const GLfloat* values ) { }
+static void null_glFramebufferSampleLocationsfvARB( GLenum target, GLuint start, GLsizei count, const GLfloat *v ) { }
+static void null_glFramebufferSampleLocationsfvNV( GLenum target, GLuint start, GLsizei count, const GLfloat *v ) { }
+static void null_glFramebufferSamplePositionsfvAMD( GLenum target, GLuint numsamples, GLuint pixelindex, const GLfloat *values ) { }
 static void null_glFramebufferTexture( GLenum target, GLenum attachment, GLuint texture, GLint level ) { }
 static void null_glFramebufferTexture1D( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) { }
 static void null_glFramebufferTexture1DEXT( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) { }
@@ -2919,461 +3253,461 @@
 static void null_glFrustumfOES( GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f ) { }
 static void null_glFrustumxOES( GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f ) { }
 static GLuint null_glGenAsyncMarkersSGIX( GLsizei range ) { return 0; }
-static void null_glGenBuffers( GLsizei n, GLuint* buffers ) { }
-static void null_glGenBuffersARB( GLsizei n, GLuint* buffers ) { }
-static void null_glGenFencesAPPLE( GLsizei n, GLuint* fences ) { }
-static void null_glGenFencesNV( GLsizei n, GLuint* fences ) { }
+static void null_glGenBuffers( GLsizei n, GLuint *buffers ) { }
+static void null_glGenBuffersARB( GLsizei n, GLuint *buffers ) { }
+static void null_glGenFencesAPPLE( GLsizei n, GLuint *fences ) { }
+static void null_glGenFencesNV( GLsizei n, GLuint *fences ) { }
 static GLuint null_glGenFragmentShadersATI( GLuint range ) { return 0; }
-static void null_glGenFramebuffers( GLsizei n, GLuint* framebuffers ) { }
-static void null_glGenFramebuffersEXT( GLsizei n, GLuint* framebuffers ) { }
-static void null_glGenNamesAMD( GLenum identifier, GLuint num, GLuint* names ) { }
-static void null_glGenOcclusionQueriesNV( GLsizei n, GLuint* ids ) { }
+static void null_glGenFramebuffers( GLsizei n, GLuint *framebuffers ) { }
+static void null_glGenFramebuffersEXT( GLsizei n, GLuint *framebuffers ) { }
+static void null_glGenNamesAMD( GLenum identifier, GLuint num, GLuint *names ) { }
+static void null_glGenOcclusionQueriesNV( GLsizei n, GLuint *ids ) { }
 static GLuint null_glGenPathsNV( GLsizei range ) { return 0; }
-static void null_glGenPerfMonitorsAMD( GLsizei n, GLuint* monitors ) { }
-static void null_glGenProgramPipelines( GLsizei n, GLuint* pipelines ) { }
-static void null_glGenProgramsARB( GLsizei n, GLuint* programs ) { }
-static void null_glGenProgramsNV( GLsizei n, GLuint* programs ) { }
-static void null_glGenQueries( GLsizei n, GLuint* ids ) { }
-static void null_glGenQueriesARB( GLsizei n, GLuint* ids ) { }
-static void null_glGenQueryResourceTagNV( GLsizei n, GLint* tagIds ) { }
-static void null_glGenRenderbuffers( GLsizei n, GLuint* renderbuffers ) { }
-static void null_glGenRenderbuffersEXT( GLsizei n, GLuint* renderbuffers ) { }
-static void null_glGenSamplers( GLsizei count, GLuint* samplers ) { }
-static void null_glGenSemaphoresEXT( GLsizei n, GLuint* semaphores ) { }
+static void null_glGenPerfMonitorsAMD( GLsizei n, GLuint *monitors ) { }
+static void null_glGenProgramPipelines( GLsizei n, GLuint *pipelines ) { }
+static void null_glGenProgramsARB( GLsizei n, GLuint *programs ) { }
+static void null_glGenProgramsNV( GLsizei n, GLuint *programs ) { }
+static void null_glGenQueries( GLsizei n, GLuint *ids ) { }
+static void null_glGenQueriesARB( GLsizei n, GLuint *ids ) { }
+static void null_glGenQueryResourceTagNV( GLsizei n, GLint *tagIds ) { }
+static void null_glGenRenderbuffers( GLsizei n, GLuint *renderbuffers ) { }
+static void null_glGenRenderbuffersEXT( GLsizei n, GLuint *renderbuffers ) { }
+static void null_glGenSamplers( GLsizei count, GLuint *samplers ) { }
+static void null_glGenSemaphoresEXT( GLsizei n, GLuint *semaphores ) { }
 static GLuint null_glGenSymbolsEXT( GLenum datatype, GLenum storagetype, GLenum range, GLuint components ) { return 0; }
-static void null_glGenTexturesEXT( GLsizei n, GLuint* textures ) { }
-static void null_glGenTransformFeedbacks( GLsizei n, GLuint* ids ) { }
-static void null_glGenTransformFeedbacksNV( GLsizei n, GLuint* ids ) { }
-static void null_glGenVertexArrays( GLsizei n, GLuint* arrays ) { }
-static void null_glGenVertexArraysAPPLE( GLsizei n, GLuint* arrays ) { }
+static void null_glGenTexturesEXT( GLsizei n, GLuint *textures ) { }
+static void null_glGenTransformFeedbacks( GLsizei n, GLuint *ids ) { }
+static void null_glGenTransformFeedbacksNV( GLsizei n, GLuint *ids ) { }
+static void null_glGenVertexArrays( GLsizei n, GLuint *arrays ) { }
+static void null_glGenVertexArraysAPPLE( GLsizei n, GLuint *arrays ) { }
 static GLuint null_glGenVertexShadersEXT( GLuint range ) { return 0; }
 static void null_glGenerateMipmap( GLenum target ) { }
 static void null_glGenerateMipmapEXT( GLenum target ) { }
 static void null_glGenerateMultiTexMipmapEXT( GLenum texunit, GLenum target ) { }
 static void null_glGenerateTextureMipmap( GLuint texture ) { }
 static void null_glGenerateTextureMipmapEXT( GLuint texture, GLenum target ) { }
-static void null_glGetActiveAtomicCounterBufferiv( GLuint program, GLuint bufferIndex, GLenum pname, GLint* params ) { }
-static void null_glGetActiveAttrib( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* type, GLchar* name ) { }
-static void null_glGetActiveAttribARB( GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLcharARB* name ) { }
-static void null_glGetActiveSubroutineName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, GLchar* name ) { }
-static void null_glGetActiveSubroutineUniformName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei* length, GLchar* name ) { }
-static void null_glGetActiveSubroutineUniformiv( GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint* values ) { }
-static void null_glGetActiveUniform( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLint* size, GLenum* type, GLchar* name ) { }
-static void null_glGetActiveUniformARB( GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLcharARB* name ) { }
-static void null_glGetActiveUniformBlockName( GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName ) { }
-static void null_glGetActiveUniformBlockiv( GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params ) { }
-static void null_glGetActiveUniformName( GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformName ) { }
-static void null_glGetActiveUniformsiv( GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params ) { }
-static void null_glGetActiveVaryingNV( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name ) { }
-static void null_glGetArrayObjectfvATI( GLenum array, GLenum pname, GLfloat* params ) { }
-static void null_glGetArrayObjectivATI( GLenum array, GLenum pname, GLint* params ) { }
-static void null_glGetAttachedObjectsARB( GLhandleARB containerObj, GLsizei maxCount, GLsizei* count, GLhandleARB* obj ) { }
-static void null_glGetAttachedShaders( GLuint program, GLsizei maxCount, GLsizei* count, GLuint* shaders ) { }
-static GLint null_glGetAttribLocation( GLuint program, const GLchar* name ) { return 0; }
-static GLint null_glGetAttribLocationARB( GLhandleARB programObj, const GLcharARB* name ) { return 0; }
-static void null_glGetBooleanIndexedvEXT( GLenum target, GLuint index, GLboolean* data ) { }
-static void null_glGetBooleani_v( GLenum target, GLuint index, GLboolean* data ) { }
-static void null_glGetBufferParameteri64v( GLenum target, GLenum pname, GLint64* params ) { }
-static void null_glGetBufferParameteriv( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetBufferParameterivARB( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetBufferParameterui64vNV( GLenum target, GLenum pname, GLuint64EXT* params ) { }
-static void null_glGetBufferPointerv( GLenum target, GLenum pname, void** params ) { }
-static void null_glGetBufferPointervARB( GLenum target, GLenum pname, void** params ) { }
-static void null_glGetBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, void* data ) { }
-static void null_glGetBufferSubDataARB( GLenum target, GLintptrARB offset, GLsizeiptrARB size, void* data ) { }
-static void null_glGetClipPlanefOES( GLenum plane, GLfloat* equation ) { }
-static void null_glGetClipPlanexOES( GLenum plane, GLfixed* equation ) { }
-static void null_glGetColorTable( GLenum target, GLenum format, GLenum type, void* table ) { }
-static void null_glGetColorTableEXT( GLenum target, GLenum format, GLenum type, void* data ) { }
-static void null_glGetColorTableParameterfv( GLenum target, GLenum pname, GLfloat* params ) { }
-static void null_glGetColorTableParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) { }
-static void null_glGetColorTableParameterfvSGI( GLenum target, GLenum pname, GLfloat* params ) { }
-static void null_glGetColorTableParameteriv( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetColorTableParameterivEXT( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetColorTableParameterivSGI( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetColorTableSGI( GLenum target, GLenum format, GLenum type, void* table ) { }
-static void null_glGetCombinerInputParameterfvNV( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat* params ) { }
-static void null_glGetCombinerInputParameterivNV( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint* params ) { }
-static void null_glGetCombinerOutputParameterfvNV( GLenum stage, GLenum portion, GLenum pname, GLfloat* params ) { }
-static void null_glGetCombinerOutputParameterivNV( GLenum stage, GLenum portion, GLenum pname, GLint* params ) { }
-static void null_glGetCombinerStageParameterfvNV( GLenum stage, GLenum pname, GLfloat* params ) { }
+static void null_glGetActiveAtomicCounterBufferiv( GLuint program, GLuint bufferIndex, GLenum pname, GLint *params ) { }
+static void null_glGetActiveAttrib( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name ) { }
+static void null_glGetActiveAttribARB( GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name ) { }
+static void null_glGetActiveSubroutineName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name ) { }
+static void null_glGetActiveSubroutineUniformName( GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name ) { }
+static void null_glGetActiveSubroutineUniformiv( GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values ) { }
+static void null_glGetActiveUniform( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name ) { }
+static void null_glGetActiveUniformARB( GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name ) { }
+static void null_glGetActiveUniformBlockName( GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName ) { }
+static void null_glGetActiveUniformBlockiv( GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params ) { }
+static void null_glGetActiveUniformName( GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName ) { }
+static void null_glGetActiveUniformsiv( GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params ) { }
+static void null_glGetActiveVaryingNV( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name ) { }
+static void null_glGetArrayObjectfvATI( GLenum array, GLenum pname, GLfloat *params ) { }
+static void null_glGetArrayObjectivATI( GLenum array, GLenum pname, GLint *params ) { }
+static void null_glGetAttachedObjectsARB( GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj ) { }
+static void null_glGetAttachedShaders( GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders ) { }
+static GLint null_glGetAttribLocation( GLuint program, const GLchar *name ) { return 0; }
+static GLint null_glGetAttribLocationARB( GLhandleARB programObj, const GLcharARB *name ) { return 0; }
+static void null_glGetBooleanIndexedvEXT( GLenum target, GLuint index, GLboolean *data ) { }
+static void null_glGetBooleani_v( GLenum target, GLuint index, GLboolean *data ) { }
+static void null_glGetBufferParameteri64v( GLenum target, GLenum pname, GLint64 *params ) { }
+static void null_glGetBufferParameteriv( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetBufferParameterivARB( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetBufferParameterui64vNV( GLenum target, GLenum pname, GLuint64EXT *params ) { }
+static void null_glGetBufferPointerv( GLenum target, GLenum pname, void **params ) { }
+static void null_glGetBufferPointervARB( GLenum target, GLenum pname, void **params ) { }
+static void null_glGetBufferSubData( GLenum target, GLintptr offset, GLsizeiptr size, void *data ) { }
+static void null_glGetBufferSubDataARB( GLenum target, GLintptrARB offset, GLsizeiptrARB size, void *data ) { }
+static void null_glGetClipPlanefOES( GLenum plane, GLfloat *equation ) { }
+static void null_glGetClipPlanexOES( GLenum plane, GLfixed *equation ) { }
+static void null_glGetColorTable( GLenum target, GLenum format, GLenum type, void *table ) { }
+static void null_glGetColorTableEXT( GLenum target, GLenum format, GLenum type, void *data ) { }
+static void null_glGetColorTableParameterfv( GLenum target, GLenum pname, GLfloat *params ) { }
+static void null_glGetColorTableParameterfvEXT( GLenum target, GLenum pname, GLfloat *params ) { }
+static void null_glGetColorTableParameterfvSGI( GLenum target, GLenum pname, GLfloat *params ) { }
+static void null_glGetColorTableParameteriv( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetColorTableParameterivEXT( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetColorTableParameterivSGI( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetColorTableSGI( GLenum target, GLenum format, GLenum type, void *table ) { }
+static void null_glGetCombinerInputParameterfvNV( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params ) { }
+static void null_glGetCombinerInputParameterivNV( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params ) { }
+static void null_glGetCombinerOutputParameterfvNV( GLenum stage, GLenum portion, GLenum pname, GLfloat *params ) { }
+static void null_glGetCombinerOutputParameterivNV( GLenum stage, GLenum portion, GLenum pname, GLint *params ) { }
+static void null_glGetCombinerStageParameterfvNV( GLenum stage, GLenum pname, GLfloat *params ) { }
 static GLuint null_glGetCommandHeaderNV( GLenum tokenID, GLuint size ) { return 0; }
-static void null_glGetCompressedMultiTexImageEXT( GLenum texunit, GLenum target, GLint lod, void* img ) { }
-static void null_glGetCompressedTexImage( GLenum target, GLint level, void* img ) { }
-static void null_glGetCompressedTexImageARB( GLenum target, GLint level, void* img ) { }
-static void null_glGetCompressedTextureImage( GLuint texture, GLint level, GLsizei bufSize, void* pixels ) { }
-static void null_glGetCompressedTextureImageEXT( GLuint texture, GLenum target, GLint lod, void* img ) { }
-static void null_glGetCompressedTextureSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void* pixels ) { }
-static void null_glGetConvolutionFilter( GLenum target, GLenum format, GLenum type, void* image ) { }
-static void null_glGetConvolutionFilterEXT( GLenum target, GLenum format, GLenum type, void* image ) { }
-static void null_glGetConvolutionParameterfv( GLenum target, GLenum pname, GLfloat* params ) { }
-static void null_glGetConvolutionParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) { }
-static void null_glGetConvolutionParameteriv( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetConvolutionParameterivEXT( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetConvolutionParameterxvOES( GLenum target, GLenum pname, GLfixed* params ) { }
-static void null_glGetCoverageModulationTableNV( GLsizei bufsize, GLfloat* v ) { }
-static GLuint null_glGetDebugMessageLog( GLuint count, GLsizei bufSize, GLenum* sources, GLenum* types, GLuint* ids, GLenum* severities, GLsizei* lengths, GLchar* messageLog ) { return 0; }
-static GLuint null_glGetDebugMessageLogAMD( GLuint count, GLsizei bufsize, GLenum* categories, GLuint* severities, GLuint* ids, GLsizei* lengths, GLchar* message ) { return 0; }
-static GLuint null_glGetDebugMessageLogARB( GLuint count, GLsizei bufSize, GLenum* sources, GLenum* types, GLuint* ids, GLenum* severities, GLsizei* lengths, GLchar* messageLog ) { return 0; }
-static void null_glGetDetailTexFuncSGIS( GLenum target, GLfloat* points ) { }
-static void null_glGetDoubleIndexedvEXT( GLenum target, GLuint index, GLdouble* data ) { }
-static void null_glGetDoublei_v( GLenum target, GLuint index, GLdouble* data ) { }
-static void null_glGetDoublei_vEXT( GLenum pname, GLuint index, GLdouble* params ) { }
-static void null_glGetFenceivNV( GLuint fence, GLenum pname, GLint* params ) { }
-static void null_glGetFinalCombinerInputParameterfvNV( GLenum variable, GLenum pname, GLfloat* params ) { }
-static void null_glGetFinalCombinerInputParameterivNV( GLenum variable, GLenum pname, GLint* params ) { }
-static void null_glGetFirstPerfQueryIdINTEL( GLuint* queryId ) { }
-static void null_glGetFixedvOES( GLenum pname, GLfixed* params ) { }
-static void null_glGetFloatIndexedvEXT( GLenum target, GLuint index, GLfloat* data ) { }
-static void null_glGetFloati_v( GLenum target, GLuint index, GLfloat* data ) { }
-static void null_glGetFloati_vEXT( GLenum pname, GLuint index, GLfloat* params ) { }
-static void null_glGetFogFuncSGIS( GLfloat* points ) { }
-static GLint null_glGetFragDataIndex( GLuint program, const GLchar* name ) { return 0; }
-static GLint null_glGetFragDataLocation( GLuint program, const GLchar* name ) { return 0; }
-static GLint null_glGetFragDataLocationEXT( GLuint program, const GLchar* name ) { return 0; }
-static void null_glGetFragmentLightfvSGIX( GLenum light, GLenum pname, GLfloat* params ) { }
-static void null_glGetFragmentLightivSGIX( GLenum light, GLenum pname, GLint* params ) { }
-static void null_glGetFragmentMaterialfvSGIX( GLenum face, GLenum pname, GLfloat* params ) { }
-static void null_glGetFragmentMaterialivSGIX( GLenum face, GLenum pname, GLint* params ) { }
-static void null_glGetFramebufferAttachmentParameteriv( GLenum target, GLenum attachment, GLenum pname, GLint* params ) { }
-static void null_glGetFramebufferAttachmentParameterivEXT( GLenum target, GLenum attachment, GLenum pname, GLint* params ) { }
-static void null_glGetFramebufferParameterfvAMD( GLenum target, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, GLfloat* values ) { }
-static void null_glGetFramebufferParameteriv( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetFramebufferParameterivEXT( GLuint framebuffer, GLenum pname, GLint* params ) { }
-static GLenum null_glGetGraphicsResetStatus( void ) { return 0; }
-static GLenum null_glGetGraphicsResetStatusARB( void ) { return 0; }
+static void null_glGetCompressedMultiTexImageEXT( GLenum texunit, GLenum target, GLint lod, void *img ) { }
+static void null_glGetCompressedTexImage( GLenum target, GLint level, void *img ) { }
+static void null_glGetCompressedTexImageARB( GLenum target, GLint level, void *img ) { }
+static void null_glGetCompressedTextureImage( GLuint texture, GLint level, GLsizei bufSize, void *pixels ) { }
+static void null_glGetCompressedTextureImageEXT( GLuint texture, GLenum target, GLint lod, void *img ) { }
+static void null_glGetCompressedTextureSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels ) { }
+static void null_glGetConvolutionFilter( GLenum target, GLenum format, GLenum type, void *image ) { }
+static void null_glGetConvolutionFilterEXT( GLenum target, GLenum format, GLenum type, void *image ) { }
+static void null_glGetConvolutionParameterfv( GLenum target, GLenum pname, GLfloat *params ) { }
+static void null_glGetConvolutionParameterfvEXT( GLenum target, GLenum pname, GLfloat *params ) { }
+static void null_glGetConvolutionParameteriv( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetConvolutionParameterivEXT( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetConvolutionParameterxvOES( GLenum target, GLenum pname, GLfixed *params ) { }
+static void null_glGetCoverageModulationTableNV( GLsizei bufsize, GLfloat *v ) { }
+static GLuint null_glGetDebugMessageLog( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) { return 0; }
+static GLuint null_glGetDebugMessageLogAMD( GLuint count, GLsizei bufsize, GLenum *categories, GLuint *severities, GLuint *ids, GLsizei *lengths, GLchar *message ) { return 0; }
+static GLuint null_glGetDebugMessageLogARB( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog ) { return 0; }
+static void null_glGetDetailTexFuncSGIS( GLenum target, GLfloat *points ) { }
+static void null_glGetDoubleIndexedvEXT( GLenum target, GLuint index, GLdouble *data ) { }
+static void null_glGetDoublei_v( GLenum target, GLuint index, GLdouble *data ) { }
+static void null_glGetDoublei_vEXT( GLenum pname, GLuint index, GLdouble *params ) { }
+static void null_glGetFenceivNV( GLuint fence, GLenum pname, GLint *params ) { }
+static void null_glGetFinalCombinerInputParameterfvNV( GLenum variable, GLenum pname, GLfloat *params ) { }
+static void null_glGetFinalCombinerInputParameterivNV( GLenum variable, GLenum pname, GLint *params ) { }
+static void null_glGetFirstPerfQueryIdINTEL( GLuint *queryId ) { }
+static void null_glGetFixedvOES( GLenum pname, GLfixed *params ) { }
+static void null_glGetFloatIndexedvEXT( GLenum target, GLuint index, GLfloat *data ) { }
+static void null_glGetFloati_v( GLenum target, GLuint index, GLfloat *data ) { }
+static void null_glGetFloati_vEXT( GLenum pname, GLuint index, GLfloat *params ) { }
+static void null_glGetFogFuncSGIS( GLfloat *points ) { }
+static GLint null_glGetFragDataIndex( GLuint program, const GLchar *name ) { return 0; }
+static GLint null_glGetFragDataLocation( GLuint program, const GLchar *name ) { return 0; }
+static GLint null_glGetFragDataLocationEXT( GLuint program, const GLchar *name ) { return 0; }
+static void null_glGetFragmentLightfvSGIX( GLenum light, GLenum pname, GLfloat *params ) { }
+static void null_glGetFragmentLightivSGIX( GLenum light, GLenum pname, GLint *params ) { }
+static void null_glGetFragmentMaterialfvSGIX( GLenum face, GLenum pname, GLfloat *params ) { }
+static void null_glGetFragmentMaterialivSGIX( GLenum face, GLenum pname, GLint *params ) { }
+static void null_glGetFramebufferAttachmentParameteriv( GLenum target, GLenum attachment, GLenum pname, GLint *params ) { }
+static void null_glGetFramebufferAttachmentParameterivEXT( GLenum target, GLenum attachment, GLenum pname, GLint *params ) { }
+static void null_glGetFramebufferParameterfvAMD( GLenum target, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, GLfloat *values ) { }
+static void null_glGetFramebufferParameteriv( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetFramebufferParameterivEXT( GLuint framebuffer, GLenum pname, GLint *params ) { }
+static GLenum null_glGetGraphicsResetStatus(void) { return 0; }
+static GLenum null_glGetGraphicsResetStatusARB(void) { return 0; }
 static GLhandleARB null_glGetHandleARB( GLenum pname ) { return 0; }
-static void null_glGetHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, void* values ) { }
-static void null_glGetHistogramEXT( GLenum target, GLboolean reset, GLenum format, GLenum type, void* values ) { }
-static void null_glGetHistogramParameterfv( GLenum target, GLenum pname, GLfloat* params ) { }
-static void null_glGetHistogramParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) { }
-static void null_glGetHistogramParameteriv( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetHistogramParameterivEXT( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetHistogramParameterxvOES( GLenum target, GLenum pname, GLfixed* params ) { }
+static void null_glGetHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, void *values ) { }
+static void null_glGetHistogramEXT( GLenum target, GLboolean reset, GLenum format, GLenum type, void *values ) { }
+static void null_glGetHistogramParameterfv( GLenum target, GLenum pname, GLfloat *params ) { }
+static void null_glGetHistogramParameterfvEXT( GLenum target, GLenum pname, GLfloat *params ) { }
+static void null_glGetHistogramParameteriv( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetHistogramParameterivEXT( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetHistogramParameterxvOES( GLenum target, GLenum pname, GLfixed *params ) { }
 static GLuint64 null_glGetImageHandleARB( GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format ) { return 0; }
 static GLuint64 null_glGetImageHandleNV( GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format ) { return 0; }
-static void null_glGetImageTransformParameterfvHP( GLenum target, GLenum pname, GLfloat* params ) { }
-static void null_glGetImageTransformParameterivHP( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetInfoLogARB( GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB* infoLog ) { }
-static GLint null_glGetInstrumentsSGIX( void ) { return 0; }
-static void null_glGetInteger64i_v( GLenum target, GLuint index, GLint64* data ) { }
-static void null_glGetInteger64v( GLenum pname, GLint64* data ) { }
-static void null_glGetIntegerIndexedvEXT( GLenum target, GLuint index, GLint* data ) { }
-static void null_glGetIntegeri_v( GLenum target, GLuint index, GLint* data ) { }
-static void null_glGetIntegerui64i_vNV( GLenum value, GLuint index, GLuint64EXT* result ) { }
-static void null_glGetIntegerui64vNV( GLenum value, GLuint64EXT* result ) { }
-static void null_glGetInternalformatSampleivNV( GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, GLsizei bufSize, GLint* params ) { }
-static void null_glGetInternalformati64v( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64* params ) { }
-static void null_glGetInternalformativ( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params ) { }
-static void null_glGetInvariantBooleanvEXT( GLuint id, GLenum value, GLboolean* data ) { }
-static void null_glGetInvariantFloatvEXT( GLuint id, GLenum value, GLfloat* data ) { }
-static void null_glGetInvariantIntegervEXT( GLuint id, GLenum value, GLint* data ) { }
-static void null_glGetLightxOES( GLenum light, GLenum pname, GLfixed* params ) { }
-static void null_glGetListParameterfvSGIX( GLuint list, GLenum pname, GLfloat* params ) { }
-static void null_glGetListParameterivSGIX( GLuint list, GLenum pname, GLint* params ) { }
-static void null_glGetLocalConstantBooleanvEXT( GLuint id, GLenum value, GLboolean* data ) { }
-static void null_glGetLocalConstantFloatvEXT( GLuint id, GLenum value, GLfloat* data ) { }
-static void null_glGetLocalConstantIntegervEXT( GLuint id, GLenum value, GLint* data ) { }
-static void null_glGetMapAttribParameterfvNV( GLenum target, GLuint index, GLenum pname, GLfloat* params ) { }
-static void null_glGetMapAttribParameterivNV( GLenum target, GLuint index, GLenum pname, GLint* params ) { }
-static void null_glGetMapControlPointsNV( GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, void* points ) { }
-static void null_glGetMapParameterfvNV( GLenum target, GLenum pname, GLfloat* params ) { }
-static void null_glGetMapParameterivNV( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetMapxvOES( GLenum target, GLenum query, GLfixed* v ) { }
+static void null_glGetImageTransformParameterfvHP( GLenum target, GLenum pname, GLfloat *params ) { }
+static void null_glGetImageTransformParameterivHP( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetInfoLogARB( GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog ) { }
+static GLint null_glGetInstrumentsSGIX(void) { return 0; }
+static void null_glGetInteger64i_v( GLenum target, GLuint index, GLint64 *data ) { }
+static void null_glGetInteger64v( GLenum pname, GLint64 *data ) { }
+static void null_glGetIntegerIndexedvEXT( GLenum target, GLuint index, GLint *data ) { }
+static void null_glGetIntegeri_v( GLenum target, GLuint index, GLint *data ) { }
+static void null_glGetIntegerui64i_vNV( GLenum value, GLuint index, GLuint64EXT *result ) { }
+static void null_glGetIntegerui64vNV( GLenum value, GLuint64EXT *result ) { }
+static void null_glGetInternalformatSampleivNV( GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, GLsizei bufSize, GLint *params ) { }
+static void null_glGetInternalformati64v( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params ) { }
+static void null_glGetInternalformativ( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params ) { }
+static void null_glGetInvariantBooleanvEXT( GLuint id, GLenum value, GLboolean *data ) { }
+static void null_glGetInvariantFloatvEXT( GLuint id, GLenum value, GLfloat *data ) { }
+static void null_glGetInvariantIntegervEXT( GLuint id, GLenum value, GLint *data ) { }
+static void null_glGetLightxOES( GLenum light, GLenum pname, GLfixed *params ) { }
+static void null_glGetListParameterfvSGIX( GLuint list, GLenum pname, GLfloat *params ) { }
+static void null_glGetListParameterivSGIX( GLuint list, GLenum pname, GLint *params ) { }
+static void null_glGetLocalConstantBooleanvEXT( GLuint id, GLenum value, GLboolean *data ) { }
+static void null_glGetLocalConstantFloatvEXT( GLuint id, GLenum value, GLfloat *data ) { }
+static void null_glGetLocalConstantIntegervEXT( GLuint id, GLenum value, GLint *data ) { }
+static void null_glGetMapAttribParameterfvNV( GLenum target, GLuint index, GLenum pname, GLfloat *params ) { }
+static void null_glGetMapAttribParameterivNV( GLenum target, GLuint index, GLenum pname, GLint *params ) { }
+static void null_glGetMapControlPointsNV( GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, void *points ) { }
+static void null_glGetMapParameterfvNV( GLenum target, GLenum pname, GLfloat *params ) { }
+static void null_glGetMapParameterivNV( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetMapxvOES( GLenum target, GLenum query, GLfixed *v ) { }
 static void null_glGetMaterialxOES( GLenum face, GLenum pname, GLfixed param ) { }
-static void null_glGetMemoryObjectParameterivEXT( GLuint memoryObject, GLenum pname, GLint* params ) { }
-static void null_glGetMinmax( GLenum target, GLboolean reset, GLenum format, GLenum type, void* values ) { }
-static void null_glGetMinmaxEXT( GLenum target, GLboolean reset, GLenum format, GLenum type, void* values ) { }
-static void null_glGetMinmaxParameterfv( GLenum target, GLenum pname, GLfloat* params ) { }
-static void null_glGetMinmaxParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) { }
-static void null_glGetMinmaxParameteriv( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetMinmaxParameterivEXT( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetMultiTexEnvfvEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat* params ) { }
-static void null_glGetMultiTexEnvivEXT( GLenum texunit, GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetMultiTexGendvEXT( GLenum texunit, GLenum coord, GLenum pname, GLdouble* params ) { }
-static void null_glGetMultiTexGenfvEXT( GLenum texunit, GLenum coord, GLenum pname, GLfloat* params ) { }
-static void null_glGetMultiTexGenivEXT( GLenum texunit, GLenum coord, GLenum pname, GLint* params ) { }
-static void null_glGetMultiTexImageEXT( GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void* pixels ) { }
-static void null_glGetMultiTexLevelParameterfvEXT( GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat* params ) { }
-static void null_glGetMultiTexLevelParameterivEXT( GLenum texunit, GLenum target, GLint level, GLenum pname, GLint* params ) { }
-static void null_glGetMultiTexParameterIivEXT( GLenum texunit, GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetMultiTexParameterIuivEXT( GLenum texunit, GLenum target, GLenum pname, GLuint* params ) { }
-static void null_glGetMultiTexParameterfvEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat* params ) { }
-static void null_glGetMultiTexParameterivEXT( GLenum texunit, GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetMultisamplefv( GLenum pname, GLuint index, GLfloat* val ) { }
-static void null_glGetMultisamplefvNV( GLenum pname, GLuint index, GLfloat* val ) { }
-static void null_glGetNamedBufferParameteri64v( GLuint buffer, GLenum pname, GLint64* params ) { }
-static void null_glGetNamedBufferParameteriv( GLuint buffer, GLenum pname, GLint* params ) { }
-static void null_glGetNamedBufferParameterivEXT( GLuint buffer, GLenum pname, GLint* params ) { }
-static void null_glGetNamedBufferParameterui64vNV( GLuint buffer, GLenum pname, GLuint64EXT* params ) { }
-static void null_glGetNamedBufferPointerv( GLuint buffer, GLenum pname, void** params ) { }
-static void null_glGetNamedBufferPointervEXT( GLuint buffer, GLenum pname, void** params ) { }
-static void null_glGetNamedBufferSubData( GLuint buffer, GLintptr offset, GLsizeiptr size, void* data ) { }
-static void null_glGetNamedBufferSubDataEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, void* data ) { }
-static void null_glGetNamedFramebufferAttachmentParameteriv( GLuint framebuffer, GLenum attachment, GLenum pname, GLint* params ) { }
-static void null_glGetNamedFramebufferAttachmentParameterivEXT( GLuint framebuffer, GLenum attachment, GLenum pname, GLint* params ) { }
-static void null_glGetNamedFramebufferParameterfvAMD( GLuint framebuffer, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, GLfloat* values ) { }
-static void null_glGetNamedFramebufferParameteriv( GLuint framebuffer, GLenum pname, GLint* param ) { }
-static void null_glGetNamedFramebufferParameterivEXT( GLuint framebuffer, GLenum pname, GLint* params ) { }
-static void null_glGetNamedProgramLocalParameterIivEXT( GLuint program, GLenum target, GLuint index, GLint* params ) { }
-static void null_glGetNamedProgramLocalParameterIuivEXT( GLuint program, GLenum target, GLuint index, GLuint* params ) { }
-static void null_glGetNamedProgramLocalParameterdvEXT( GLuint program, GLenum target, GLuint index, GLdouble* params ) { }
-static void null_glGetNamedProgramLocalParameterfvEXT( GLuint program, GLenum target, GLuint index, GLfloat* params ) { }
-static void null_glGetNamedProgramStringEXT( GLuint program, GLenum target, GLenum pname, void* string ) { }
-static void null_glGetNamedProgramivEXT( GLuint program, GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetNamedRenderbufferParameteriv( GLuint renderbuffer, GLenum pname, GLint* params ) { }
-static void null_glGetNamedRenderbufferParameterivEXT( GLuint renderbuffer, GLenum pname, GLint* params ) { }
-static void null_glGetNamedStringARB( GLint namelen, const GLchar* name, GLsizei bufSize, GLint* stringlen, GLchar* string ) { }
-static void null_glGetNamedStringivARB( GLint namelen, const GLchar* name, GLenum pname, GLint* params ) { }
-static void null_glGetNextPerfQueryIdINTEL( GLuint queryId, GLuint* nextQueryId ) { }
-static void null_glGetObjectBufferfvATI( GLuint buffer, GLenum pname, GLfloat* params ) { }
-static void null_glGetObjectBufferivATI( GLuint buffer, GLenum pname, GLint* params ) { }
-static void null_glGetObjectLabel( GLenum identifier, GLuint name, GLsizei bufSize, GLsizei* length, GLchar* label ) { }
-static void null_glGetObjectLabelEXT( GLenum type, GLuint object, GLsizei bufSize, GLsizei* length, GLchar* label ) { }
-static void null_glGetObjectParameterfvARB( GLhandleARB obj, GLenum pname, GLfloat* params ) { }
-static void null_glGetObjectParameterivAPPLE( GLenum objectType, GLuint name, GLenum pname, GLint* params ) { }
-static void null_glGetObjectParameterivARB( GLhandleARB obj, GLenum pname, GLint* params ) { }
-static void null_glGetObjectPtrLabel( const void* ptr, GLsizei bufSize, GLsizei* length, GLchar* label ) { }
-static void null_glGetOcclusionQueryivNV( GLuint id, GLenum pname, GLint* params ) { }
-static void null_glGetOcclusionQueryuivNV( GLuint id, GLenum pname, GLuint* params ) { }
-static void null_glGetPathColorGenfvNV( GLenum color, GLenum pname, GLfloat* value ) { }
-static void null_glGetPathColorGenivNV( GLenum color, GLenum pname, GLint* value ) { }
-static void null_glGetPathCommandsNV( GLuint path, GLubyte* commands ) { }
-static void null_glGetPathCoordsNV( GLuint path, GLfloat* coords ) { }
-static void null_glGetPathDashArrayNV( GLuint path, GLfloat* dashArray ) { }
+static void null_glGetMemoryObjectParameterivEXT( GLuint memoryObject, GLenum pname, GLint *params ) { }
+static void null_glGetMinmax( GLenum target, GLboolean reset, GLenum format, GLenum type, void *values ) { }
+static void null_glGetMinmaxEXT( GLenum target, GLboolean reset, GLenum format, GLenum type, void *values ) { }
+static void null_glGetMinmaxParameterfv( GLenum target, GLenum pname, GLfloat *params ) { }
+static void null_glGetMinmaxParameterfvEXT( GLenum target, GLenum pname, GLfloat *params ) { }
+static void null_glGetMinmaxParameteriv( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetMinmaxParameterivEXT( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetMultiTexEnvfvEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat *params ) { }
+static void null_glGetMultiTexEnvivEXT( GLenum texunit, GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetMultiTexGendvEXT( GLenum texunit, GLenum coord, GLenum pname, GLdouble *params ) { }
+static void null_glGetMultiTexGenfvEXT( GLenum texunit, GLenum coord, GLenum pname, GLfloat *params ) { }
+static void null_glGetMultiTexGenivEXT( GLenum texunit, GLenum coord, GLenum pname, GLint *params ) { }
+static void null_glGetMultiTexImageEXT( GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void *pixels ) { }
+static void null_glGetMultiTexLevelParameterfvEXT( GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat *params ) { }
+static void null_glGetMultiTexLevelParameterivEXT( GLenum texunit, GLenum target, GLint level, GLenum pname, GLint *params ) { }
+static void null_glGetMultiTexParameterIivEXT( GLenum texunit, GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetMultiTexParameterIuivEXT( GLenum texunit, GLenum target, GLenum pname, GLuint *params ) { }
+static void null_glGetMultiTexParameterfvEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat *params ) { }
+static void null_glGetMultiTexParameterivEXT( GLenum texunit, GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetMultisamplefv( GLenum pname, GLuint index, GLfloat *val ) { }
+static void null_glGetMultisamplefvNV( GLenum pname, GLuint index, GLfloat *val ) { }
+static void null_glGetNamedBufferParameteri64v( GLuint buffer, GLenum pname, GLint64 *params ) { }
+static void null_glGetNamedBufferParameteriv( GLuint buffer, GLenum pname, GLint *params ) { }
+static void null_glGetNamedBufferParameterivEXT( GLuint buffer, GLenum pname, GLint *params ) { }
+static void null_glGetNamedBufferParameterui64vNV( GLuint buffer, GLenum pname, GLuint64EXT *params ) { }
+static void null_glGetNamedBufferPointerv( GLuint buffer, GLenum pname, void **params ) { }
+static void null_glGetNamedBufferPointervEXT( GLuint buffer, GLenum pname, void **params ) { }
+static void null_glGetNamedBufferSubData( GLuint buffer, GLintptr offset, GLsizeiptr size, void *data ) { }
+static void null_glGetNamedBufferSubDataEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, void *data ) { }
+static void null_glGetNamedFramebufferAttachmentParameteriv( GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params ) { }
+static void null_glGetNamedFramebufferAttachmentParameterivEXT( GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params ) { }
+static void null_glGetNamedFramebufferParameterfvAMD( GLuint framebuffer, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, GLfloat *values ) { }
+static void null_glGetNamedFramebufferParameteriv( GLuint framebuffer, GLenum pname, GLint *param ) { }
+static void null_glGetNamedFramebufferParameterivEXT( GLuint framebuffer, GLenum pname, GLint *params ) { }
+static void null_glGetNamedProgramLocalParameterIivEXT( GLuint program, GLenum target, GLuint index, GLint *params ) { }
+static void null_glGetNamedProgramLocalParameterIuivEXT( GLuint program, GLenum target, GLuint index, GLuint *params ) { }
+static void null_glGetNamedProgramLocalParameterdvEXT( GLuint program, GLenum target, GLuint index, GLdouble *params ) { }
+static void null_glGetNamedProgramLocalParameterfvEXT( GLuint program, GLenum target, GLuint index, GLfloat *params ) { }
+static void null_glGetNamedProgramStringEXT( GLuint program, GLenum target, GLenum pname, void *string ) { }
+static void null_glGetNamedProgramivEXT( GLuint program, GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetNamedRenderbufferParameteriv( GLuint renderbuffer, GLenum pname, GLint *params ) { }
+static void null_glGetNamedRenderbufferParameterivEXT( GLuint renderbuffer, GLenum pname, GLint *params ) { }
+static void null_glGetNamedStringARB( GLint namelen, const GLchar *name, GLsizei bufSize, GLint *stringlen, GLchar *string ) { }
+static void null_glGetNamedStringivARB( GLint namelen, const GLchar *name, GLenum pname, GLint *params ) { }
+static void null_glGetNextPerfQueryIdINTEL( GLuint queryId, GLuint *nextQueryId ) { }
+static void null_glGetObjectBufferfvATI( GLuint buffer, GLenum pname, GLfloat *params ) { }
+static void null_glGetObjectBufferivATI( GLuint buffer, GLenum pname, GLint *params ) { }
+static void null_glGetObjectLabel( GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label ) { }
+static void null_glGetObjectLabelEXT( GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label ) { }
+static void null_glGetObjectParameterfvARB( GLhandleARB obj, GLenum pname, GLfloat *params ) { }
+static void null_glGetObjectParameterivAPPLE( GLenum objectType, GLuint name, GLenum pname, GLint *params ) { }
+static void null_glGetObjectParameterivARB( GLhandleARB obj, GLenum pname, GLint *params ) { }
+static void null_glGetObjectPtrLabel( const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label ) { }
+static void null_glGetOcclusionQueryivNV( GLuint id, GLenum pname, GLint *params ) { }
+static void null_glGetOcclusionQueryuivNV( GLuint id, GLenum pname, GLuint *params ) { }
+static void null_glGetPathColorGenfvNV( GLenum color, GLenum pname, GLfloat *value ) { }
+static void null_glGetPathColorGenivNV( GLenum color, GLenum pname, GLint *value ) { }
+static void null_glGetPathCommandsNV( GLuint path, GLubyte *commands ) { }
+static void null_glGetPathCoordsNV( GLuint path, GLfloat *coords ) { }
+static void null_glGetPathDashArrayNV( GLuint path, GLfloat *dashArray ) { }
 static GLfloat null_glGetPathLengthNV( GLuint path, GLsizei startSegment, GLsizei numSegments ) { return 0; }
-static void null_glGetPathMetricRangeNV( GLbitfield metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat* metrics ) { }
-static void null_glGetPathMetricsNV( GLbitfield metricQueryMask, GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLsizei stride, GLfloat* metrics ) { }
-static void null_glGetPathParameterfvNV( GLuint path, GLenum pname, GLfloat* value ) { }
-static void null_glGetPathParameterivNV( GLuint path, GLenum pname, GLint* value ) { }
-static void null_glGetPathSpacingNV( GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, GLfloat* returnedSpacing ) { }
-static void null_glGetPathTexGenfvNV( GLenum texCoordSet, GLenum pname, GLfloat* value ) { }
-static void null_glGetPathTexGenivNV( GLenum texCoordSet, GLenum pname, GLint* value ) { }
-static void null_glGetPerfCounterInfoINTEL( GLuint queryId, GLuint counterId, GLuint counterNameLength, GLchar* counterName, GLuint counterDescLength, GLchar* counterDesc, GLuint* counterOffset, GLuint* counterDataSize, GLuint* counterTypeEnum, GLuint* counterDataTypeEnum, GLuint64* rawCounterMaxValue ) { }
-static void null_glGetPerfMonitorCounterDataAMD( GLuint monitor, GLenum pname, GLsizei dataSize, GLuint* data, GLint* bytesWritten ) { }
-static void null_glGetPerfMonitorCounterInfoAMD( GLuint group, GLuint counter, GLenum pname, void* data ) { }
-static void null_glGetPerfMonitorCounterStringAMD( GLuint group, GLuint counter, GLsizei bufSize, GLsizei* length, GLchar* counterString ) { }
-static void null_glGetPerfMonitorCountersAMD( GLuint group, GLint* numCounters, GLint* maxActiveCounters, GLsizei counterSize, GLuint* counters ) { }
-static void null_glGetPerfMonitorGroupStringAMD( GLuint group, GLsizei bufSize, GLsizei* length, GLchar* groupString ) { }
-static void null_glGetPerfMonitorGroupsAMD( GLint* numGroups, GLsizei groupsSize, GLuint* groups ) { }
-static void null_glGetPerfQueryDataINTEL( GLuint queryHandle, GLuint flags, GLsizei dataSize, GLvoid* data, GLuint* bytesWritten ) { }
-static void null_glGetPerfQueryIdByNameINTEL( GLchar* queryName, GLuint* queryId ) { }
-static void null_glGetPerfQueryInfoINTEL( GLuint queryId, GLuint queryNameLength, GLchar* queryName, GLuint* dataSize, GLuint* noCounters, GLuint* noInstances, GLuint* capsMask ) { }
-static void null_glGetPixelMapxv( GLenum map, GLint size, GLfixed* values ) { }
-static void null_glGetPixelTexGenParameterfvSGIS( GLenum pname, GLfloat* params ) { }
-static void null_glGetPixelTexGenParameterivSGIS( GLenum pname, GLint* params ) { }
-static void null_glGetPixelTransformParameterfvEXT( GLenum target, GLenum pname, GLfloat* params ) { }
-static void null_glGetPixelTransformParameterivEXT( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetPointerIndexedvEXT( GLenum target, GLuint index, void** data ) { }
-static void null_glGetPointeri_vEXT( GLenum pname, GLuint index, void** params ) { }
-static void null_glGetPointervEXT( GLenum pname, void** params ) { }
-static void null_glGetProgramBinary( GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, void* binary ) { }
-static void null_glGetProgramEnvParameterIivNV( GLenum target, GLuint index, GLint* params ) { }
-static void null_glGetProgramEnvParameterIuivNV( GLenum target, GLuint index, GLuint* params ) { }
-static void null_glGetProgramEnvParameterdvARB( GLenum target, GLuint index, GLdouble* params ) { }
-static void null_glGetProgramEnvParameterfvARB( GLenum target, GLuint index, GLfloat* params ) { }
-static void null_glGetProgramInfoLog( GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog ) { }
-static void null_glGetProgramInterfaceiv( GLuint program, GLenum programInterface, GLenum pname, GLint* params ) { }
-static void null_glGetProgramLocalParameterIivNV( GLenum target, GLuint index, GLint* params ) { }
-static void null_glGetProgramLocalParameterIuivNV( GLenum target, GLuint index, GLuint* params ) { }
-static void null_glGetProgramLocalParameterdvARB( GLenum target, GLuint index, GLdouble* params ) { }
-static void null_glGetProgramLocalParameterfvARB( GLenum target, GLuint index, GLfloat* params ) { }
-static void null_glGetProgramNamedParameterdvNV( GLuint id, GLsizei len, const GLubyte* name, GLdouble* params ) { }
-static void null_glGetProgramNamedParameterfvNV( GLuint id, GLsizei len, const GLubyte* name, GLfloat* params ) { }
-static void null_glGetProgramParameterdvNV( GLenum target, GLuint index, GLenum pname, GLdouble* params ) { }
-static void null_glGetProgramParameterfvNV( GLenum target, GLuint index, GLenum pname, GLfloat* params ) { }
-static void null_glGetProgramPipelineInfoLog( GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog ) { }
-static void null_glGetProgramPipelineiv( GLuint pipeline, GLenum pname, GLint* params ) { }
-static GLuint null_glGetProgramResourceIndex( GLuint program, GLenum programInterface, const GLchar* name ) { return 0; }
-static GLint null_glGetProgramResourceLocation( GLuint program, GLenum programInterface, const GLchar* name ) { return 0; }
-static GLint null_glGetProgramResourceLocationIndex( GLuint program, GLenum programInterface, const GLchar* name ) { return 0; }
-static void null_glGetProgramResourceName( GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name ) { }
-static void null_glGetProgramResourcefvNV( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum* props, GLsizei bufSize, GLsizei* length, GLfloat* params ) { }
-static void null_glGetProgramResourceiv( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum* props, GLsizei bufSize, GLsizei* length, GLint* params ) { }
-static void null_glGetProgramStageiv( GLuint program, GLenum shadertype, GLenum pname, GLint* values ) { }
-static void null_glGetProgramStringARB( GLenum target, GLenum pname, void* string ) { }
-static void null_glGetProgramStringNV( GLuint id, GLenum pname, GLubyte* program ) { }
-static void null_glGetProgramSubroutineParameteruivNV( GLenum target, GLuint index, GLuint* param ) { }
-static void null_glGetProgramiv( GLuint program, GLenum pname, GLint* params ) { }
-static void null_glGetProgramivARB( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetProgramivNV( GLuint id, GLenum pname, GLint* params ) { }
+static void null_glGetPathMetricRangeNV( GLbitfield metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat *metrics ) { }
+static void null_glGetPathMetricsNV( GLbitfield metricQueryMask, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLsizei stride, GLfloat *metrics ) { }
+static void null_glGetPathParameterfvNV( GLuint path, GLenum pname, GLfloat *value ) { }
+static void null_glGetPathParameterivNV( GLuint path, GLenum pname, GLint *value ) { }
+static void null_glGetPathSpacingNV( GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, GLfloat *returnedSpacing ) { }
+static void null_glGetPathTexGenfvNV( GLenum texCoordSet, GLenum pname, GLfloat *value ) { }
+static void null_glGetPathTexGenivNV( GLenum texCoordSet, GLenum pname, GLint *value ) { }
+static void null_glGetPerfCounterInfoINTEL( GLuint queryId, GLuint counterId, GLuint counterNameLength, GLchar *counterName, GLuint counterDescLength, GLchar *counterDesc, GLuint *counterOffset, GLuint *counterDataSize, GLuint *counterTypeEnum, GLuint *counterDataTypeEnum, GLuint64 *rawCounterMaxValue ) { }
+static void null_glGetPerfMonitorCounterDataAMD( GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten ) { }
+static void null_glGetPerfMonitorCounterInfoAMD( GLuint group, GLuint counter, GLenum pname, void *data ) { }
+static void null_glGetPerfMonitorCounterStringAMD( GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString ) { }
+static void null_glGetPerfMonitorCountersAMD( GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters ) { }
+static void null_glGetPerfMonitorGroupStringAMD( GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString ) { }
+static void null_glGetPerfMonitorGroupsAMD( GLint *numGroups, GLsizei groupsSize, GLuint *groups ) { }
+static void null_glGetPerfQueryDataINTEL( GLuint queryHandle, GLuint flags, GLsizei dataSize, GLvoid *data, GLuint *bytesWritten ) { }
+static void null_glGetPerfQueryIdByNameINTEL( GLchar *queryName, GLuint *queryId ) { }
+static void null_glGetPerfQueryInfoINTEL( GLuint queryId, GLuint queryNameLength, GLchar *queryName, GLuint *dataSize, GLuint *noCounters, GLuint *noInstances, GLuint *capsMask ) { }
+static void null_glGetPixelMapxv( GLenum map, GLint size, GLfixed *values ) { }
+static void null_glGetPixelTexGenParameterfvSGIS( GLenum pname, GLfloat *params ) { }
+static void null_glGetPixelTexGenParameterivSGIS( GLenum pname, GLint *params ) { }
+static void null_glGetPixelTransformParameterfvEXT( GLenum target, GLenum pname, GLfloat *params ) { }
+static void null_glGetPixelTransformParameterivEXT( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetPointerIndexedvEXT( GLenum target, GLuint index, void **data ) { }
+static void null_glGetPointeri_vEXT( GLenum pname, GLuint index, void **params ) { }
+static void null_glGetPointervEXT( GLenum pname, void **params ) { }
+static void null_glGetProgramBinary( GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary ) { }
+static void null_glGetProgramEnvParameterIivNV( GLenum target, GLuint index, GLint *params ) { }
+static void null_glGetProgramEnvParameterIuivNV( GLenum target, GLuint index, GLuint *params ) { }
+static void null_glGetProgramEnvParameterdvARB( GLenum target, GLuint index, GLdouble *params ) { }
+static void null_glGetProgramEnvParameterfvARB( GLenum target, GLuint index, GLfloat *params ) { }
+static void null_glGetProgramInfoLog( GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog ) { }
+static void null_glGetProgramInterfaceiv( GLuint program, GLenum programInterface, GLenum pname, GLint *params ) { }
+static void null_glGetProgramLocalParameterIivNV( GLenum target, GLuint index, GLint *params ) { }
+static void null_glGetProgramLocalParameterIuivNV( GLenum target, GLuint index, GLuint *params ) { }
+static void null_glGetProgramLocalParameterdvARB( GLenum target, GLuint index, GLdouble *params ) { }
+static void null_glGetProgramLocalParameterfvARB( GLenum target, GLuint index, GLfloat *params ) { }
+static void null_glGetProgramNamedParameterdvNV( GLuint id, GLsizei len, const GLubyte *name, GLdouble *params ) { }
+static void null_glGetProgramNamedParameterfvNV( GLuint id, GLsizei len, const GLubyte *name, GLfloat *params ) { }
+static void null_glGetProgramParameterdvNV( GLenum target, GLuint index, GLenum pname, GLdouble *params ) { }
+static void null_glGetProgramParameterfvNV( GLenum target, GLuint index, GLenum pname, GLfloat *params ) { }
+static void null_glGetProgramPipelineInfoLog( GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog ) { }
+static void null_glGetProgramPipelineiv( GLuint pipeline, GLenum pname, GLint *params ) { }
+static GLuint null_glGetProgramResourceIndex( GLuint program, GLenum programInterface, const GLchar *name ) { return 0; }
+static GLint null_glGetProgramResourceLocation( GLuint program, GLenum programInterface, const GLchar *name ) { return 0; }
+static GLint null_glGetProgramResourceLocationIndex( GLuint program, GLenum programInterface, const GLchar *name ) { return 0; }
+static void null_glGetProgramResourceName( GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name ) { }
+static void null_glGetProgramResourcefvNV( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLfloat *params ) { }
+static void null_glGetProgramResourceiv( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params ) { }
+static void null_glGetProgramStageiv( GLuint program, GLenum shadertype, GLenum pname, GLint *values ) { }
+static void null_glGetProgramStringARB( GLenum target, GLenum pname, void *string ) { }
+static void null_glGetProgramStringNV( GLuint id, GLenum pname, GLubyte *program ) { }
+static void null_glGetProgramSubroutineParameteruivNV( GLenum target, GLuint index, GLuint *param ) { }
+static void null_glGetProgramiv( GLuint program, GLenum pname, GLint *params ) { }
+static void null_glGetProgramivARB( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetProgramivNV( GLuint id, GLenum pname, GLint *params ) { }
 static void null_glGetQueryBufferObjecti64v( GLuint id, GLuint buffer, GLenum pname, GLintptr offset ) { }
 static void null_glGetQueryBufferObjectiv( GLuint id, GLuint buffer, GLenum pname, GLintptr offset ) { }
 static void null_glGetQueryBufferObjectui64v( GLuint id, GLuint buffer, GLenum pname, GLintptr offset ) { }
 static void null_glGetQueryBufferObjectuiv( GLuint id, GLuint buffer, GLenum pname, GLintptr offset ) { }
-static void null_glGetQueryIndexediv( GLenum target, GLuint index, GLenum pname, GLint* params ) { }
-static void null_glGetQueryObjecti64v( GLuint id, GLenum pname, GLint64* params ) { }
-static void null_glGetQueryObjecti64vEXT( GLuint id, GLenum pname, GLint64* params ) { }
-static void null_glGetQueryObjectiv( GLuint id, GLenum pname, GLint* params ) { }
-static void null_glGetQueryObjectivARB( GLuint id, GLenum pname, GLint* params ) { }
-static void null_glGetQueryObjectui64v( GLuint id, GLenum pname, GLuint64* params ) { }
-static void null_glGetQueryObjectui64vEXT( GLuint id, GLenum pname, GLuint64* params ) { }
-static void null_glGetQueryObjectuiv( GLuint id, GLenum pname, GLuint* params ) { }
-static void null_glGetQueryObjectuivARB( GLuint id, GLenum pname, GLuint* params ) { }
-static void null_glGetQueryiv( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetQueryivARB( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetRenderbufferParameteriv( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetRenderbufferParameterivEXT( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetSamplerParameterIiv( GLuint sampler, GLenum pname, GLint* params ) { }
-static void null_glGetSamplerParameterIuiv( GLuint sampler, GLenum pname, GLuint* params ) { }
-static void null_glGetSamplerParameterfv( GLuint sampler, GLenum pname, GLfloat* params ) { }
-static void null_glGetSamplerParameteriv( GLuint sampler, GLenum pname, GLint* params ) { }
-static void null_glGetSemaphoreParameterui64vEXT( GLuint semaphore, GLenum pname, GLuint64* params ) { }
-static void null_glGetSeparableFilter( GLenum target, GLenum format, GLenum type, void* row, void* column, void* span ) { }
-static void null_glGetSeparableFilterEXT( GLenum target, GLenum format, GLenum type, void* row, void* column, void* span ) { }
-static void null_glGetShaderInfoLog( GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog ) { }
-static void null_glGetShaderPrecisionFormat( GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision ) { }
-static void null_glGetShaderSource( GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source ) { }
-static void null_glGetShaderSourceARB( GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB* source ) { }
-static void null_glGetShaderiv( GLuint shader, GLenum pname, GLint* params ) { }
-static void null_glGetSharpenTexFuncSGIS( GLenum target, GLfloat* points ) { }
+static void null_glGetQueryIndexediv( GLenum target, GLuint index, GLenum pname, GLint *params ) { }
+static void null_glGetQueryObjecti64v( GLuint id, GLenum pname, GLint64 *params ) { }
+static void null_glGetQueryObjecti64vEXT( GLuint id, GLenum pname, GLint64 *params ) { }
+static void null_glGetQueryObjectiv( GLuint id, GLenum pname, GLint *params ) { }
+static void null_glGetQueryObjectivARB( GLuint id, GLenum pname, GLint *params ) { }
+static void null_glGetQueryObjectui64v( GLuint id, GLenum pname, GLuint64 *params ) { }
+static void null_glGetQueryObjectui64vEXT( GLuint id, GLenum pname, GLuint64 *params ) { }
+static void null_glGetQueryObjectuiv( GLuint id, GLenum pname, GLuint *params ) { }
+static void null_glGetQueryObjectuivARB( GLuint id, GLenum pname, GLuint *params ) { }
+static void null_glGetQueryiv( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetQueryivARB( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetRenderbufferParameteriv( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetRenderbufferParameterivEXT( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetSamplerParameterIiv( GLuint sampler, GLenum pname, GLint *params ) { }
+static void null_glGetSamplerParameterIuiv( GLuint sampler, GLenum pname, GLuint *params ) { }
+static void null_glGetSamplerParameterfv( GLuint sampler, GLenum pname, GLfloat *params ) { }
+static void null_glGetSamplerParameteriv( GLuint sampler, GLenum pname, GLint *params ) { }
+static void null_glGetSemaphoreParameterui64vEXT( GLuint semaphore, GLenum pname, GLuint64 *params ) { }
+static void null_glGetSeparableFilter( GLenum target, GLenum format, GLenum type, void *row, void *column, void *span ) { }
+static void null_glGetSeparableFilterEXT( GLenum target, GLenum format, GLenum type, void *row, void *column, void *span ) { }
+static void null_glGetShaderInfoLog( GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog ) { }
+static void null_glGetShaderPrecisionFormat( GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision ) { }
+static void null_glGetShaderSource( GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source ) { }
+static void null_glGetShaderSourceARB( GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *source ) { }
+static void null_glGetShaderiv( GLuint shader, GLenum pname, GLint *params ) { }
+static void null_glGetSharpenTexFuncSGIS( GLenum target, GLfloat *points ) { }
 static GLushort null_glGetStageIndexNV( GLenum shadertype ) { return 0; }
-static const GLubyte* null_glGetStringi( GLenum name, GLuint index ) { return 0; }
-static GLuint null_glGetSubroutineIndex( GLuint program, GLenum shadertype, const GLchar* name ) { return 0; }
-static GLint null_glGetSubroutineUniformLocation( GLuint program, GLenum shadertype, const GLchar* name ) { return 0; }
-static void null_glGetSynciv( GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values ) { }
-static void null_glGetTexBumpParameterfvATI( GLenum pname, GLfloat* param ) { }
-static void null_glGetTexBumpParameterivATI( GLenum pname, GLint* param ) { }
-static void null_glGetTexEnvxvOES( GLenum target, GLenum pname, GLfixed* params ) { }
-static void null_glGetTexFilterFuncSGIS( GLenum target, GLenum filter, GLfloat* weights ) { }
-static void null_glGetTexGenxvOES( GLenum coord, GLenum pname, GLfixed* params ) { }
-static void null_glGetTexLevelParameterxvOES( GLenum target, GLint level, GLenum pname, GLfixed* params ) { }
-static void null_glGetTexParameterIiv( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetTexParameterIivEXT( GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetTexParameterIuiv( GLenum target, GLenum pname, GLuint* params ) { }
-static void null_glGetTexParameterIuivEXT( GLenum target, GLenum pname, GLuint* params ) { }
-static void null_glGetTexParameterPointervAPPLE( GLenum target, GLenum pname, void** params ) { }
-static void null_glGetTexParameterxvOES( GLenum target, GLenum pname, GLfixed* params ) { }
+static const GLubyte * null_glGetStringi( GLenum name, GLuint index ) { return 0; }
+static GLuint null_glGetSubroutineIndex( GLuint program, GLenum shadertype, const GLchar *name ) { return 0; }
+static GLint null_glGetSubroutineUniformLocation( GLuint program, GLenum shadertype, const GLchar *name ) { return 0; }
+static void null_glGetSynciv( GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values ) { }
+static void null_glGetTexBumpParameterfvATI( GLenum pname, GLfloat *param ) { }
+static void null_glGetTexBumpParameterivATI( GLenum pname, GLint *param ) { }
+static void null_glGetTexEnvxvOES( GLenum target, GLenum pname, GLfixed *params ) { }
+static void null_glGetTexFilterFuncSGIS( GLenum target, GLenum filter, GLfloat *weights ) { }
+static void null_glGetTexGenxvOES( GLenum coord, GLenum pname, GLfixed *params ) { }
+static void null_glGetTexLevelParameterxvOES( GLenum target, GLint level, GLenum pname, GLfixed *params ) { }
+static void null_glGetTexParameterIiv( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetTexParameterIivEXT( GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetTexParameterIuiv( GLenum target, GLenum pname, GLuint *params ) { }
+static void null_glGetTexParameterIuivEXT( GLenum target, GLenum pname, GLuint *params ) { }
+static void null_glGetTexParameterPointervAPPLE( GLenum target, GLenum pname, void **params ) { }
+static void null_glGetTexParameterxvOES( GLenum target, GLenum pname, GLfixed *params ) { }
 static GLuint64 null_glGetTextureHandleARB( GLuint texture ) { return 0; }
 static GLuint64 null_glGetTextureHandleNV( GLuint texture ) { return 0; }
-static void null_glGetTextureImage( GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* pixels ) { }
-static void null_glGetTextureImageEXT( GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void* pixels ) { }
-static void null_glGetTextureLevelParameterfv( GLuint texture, GLint level, GLenum pname, GLfloat* params ) { }
-static void null_glGetTextureLevelParameterfvEXT( GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat* params ) { }
-static void null_glGetTextureLevelParameteriv( GLuint texture, GLint level, GLenum pname, GLint* params ) { }
-static void null_glGetTextureLevelParameterivEXT( GLuint texture, GLenum target, GLint level, GLenum pname, GLint* params ) { }
-static void null_glGetTextureParameterIiv( GLuint texture, GLenum pname, GLint* params ) { }
-static void null_glGetTextureParameterIivEXT( GLuint texture, GLenum target, GLenum pname, GLint* params ) { }
-static void null_glGetTextureParameterIuiv( GLuint texture, GLenum pname, GLuint* params ) { }
-static void null_glGetTextureParameterIuivEXT( GLuint texture, GLenum target, GLenum pname, GLuint* params ) { }
-static void null_glGetTextureParameterfv( GLuint texture, GLenum pname, GLfloat* params ) { }
-static void null_glGetTextureParameterfvEXT( GLuint texture, GLenum target, GLenum pname, GLfloat* params ) { }
-static void null_glGetTextureParameteriv( GLuint texture, GLenum pname, GLint* params ) { }
-static void null_glGetTextureParameterivEXT( GLuint texture, GLenum target, GLenum pname, GLint* params ) { }
+static void null_glGetTextureImage( GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels ) { }
+static void null_glGetTextureImageEXT( GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void *pixels ) { }
+static void null_glGetTextureLevelParameterfv( GLuint texture, GLint level, GLenum pname, GLfloat *params ) { }
+static void null_glGetTextureLevelParameterfvEXT( GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat *params ) { }
+static void null_glGetTextureLevelParameteriv( GLuint texture, GLint level, GLenum pname, GLint *params ) { }
+static void null_glGetTextureLevelParameterivEXT( GLuint texture, GLenum target, GLint level, GLenum pname, GLint *params ) { }
+static void null_glGetTextureParameterIiv( GLuint texture, GLenum pname, GLint *params ) { }
+static void null_glGetTextureParameterIivEXT( GLuint texture, GLenum target, GLenum pname, GLint *params ) { }
+static void null_glGetTextureParameterIuiv( GLuint texture, GLenum pname, GLuint *params ) { }
+static void null_glGetTextureParameterIuivEXT( GLuint texture, GLenum target, GLenum pname, GLuint *params ) { }
+static void null_glGetTextureParameterfv( GLuint texture, GLenum pname, GLfloat *params ) { }
+static void null_glGetTextureParameterfvEXT( GLuint texture, GLenum target, GLenum pname, GLfloat *params ) { }
+static void null_glGetTextureParameteriv( GLuint texture, GLenum pname, GLint *params ) { }
+static void null_glGetTextureParameterivEXT( GLuint texture, GLenum target, GLenum pname, GLint *params ) { }
 static GLuint64 null_glGetTextureSamplerHandleARB( GLuint texture, GLuint sampler ) { return 0; }
 static GLuint64 null_glGetTextureSamplerHandleNV( GLuint texture, GLuint sampler ) { return 0; }
-static void null_glGetTextureSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void* pixels ) { }
-static void null_glGetTrackMatrixivNV( GLenum target, GLuint address, GLenum pname, GLint* params ) { }
-static void null_glGetTransformFeedbackVarying( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name ) { }
-static void null_glGetTransformFeedbackVaryingEXT( GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name ) { }
-static void null_glGetTransformFeedbackVaryingNV( GLuint program, GLuint index, GLint* location ) { }
-static void null_glGetTransformFeedbacki64_v( GLuint xfb, GLenum pname, GLuint index, GLint64* param ) { }
-static void null_glGetTransformFeedbacki_v( GLuint xfb, GLenum pname, GLuint index, GLint* param ) { }
-static void null_glGetTransformFeedbackiv( GLuint xfb, GLenum pname, GLint* param ) { }
-static GLuint null_glGetUniformBlockIndex( GLuint program, const GLchar* uniformBlockName ) { return 0; }
+static void null_glGetTextureSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels ) { }
+static void null_glGetTrackMatrixivNV( GLenum target, GLuint address, GLenum pname, GLint *params ) { }
+static void null_glGetTransformFeedbackVarying( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name ) { }
+static void null_glGetTransformFeedbackVaryingEXT( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name ) { }
+static void null_glGetTransformFeedbackVaryingNV( GLuint program, GLuint index, GLint *location ) { }
+static void null_glGetTransformFeedbacki64_v( GLuint xfb, GLenum pname, GLuint index, GLint64 *param ) { }
+static void null_glGetTransformFeedbacki_v( GLuint xfb, GLenum pname, GLuint index, GLint *param ) { }
+static void null_glGetTransformFeedbackiv( GLuint xfb, GLenum pname, GLint *param ) { }
+static GLuint null_glGetUniformBlockIndex( GLuint program, const GLchar *uniformBlockName ) { return 0; }
 static GLint null_glGetUniformBufferSizeEXT( GLuint program, GLint location ) { return 0; }
-static void null_glGetUniformIndices( GLuint program, GLsizei uniformCount, const GLchar*const* uniformNames, GLuint* uniformIndices ) { }
-static GLint null_glGetUniformLocation( GLuint program, const GLchar* name ) { return 0; }
-static GLint null_glGetUniformLocationARB( GLhandleARB programObj, const GLcharARB* name ) { return 0; }
+static void null_glGetUniformIndices( GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices ) { }
+static GLint null_glGetUniformLocation( GLuint program, const GLchar *name ) { return 0; }
+static GLint null_glGetUniformLocationARB( GLhandleARB programObj, const GLcharARB *name ) { return 0; }
 static GLintptr null_glGetUniformOffsetEXT( GLuint program, GLint location ) { return 0; }
-static void null_glGetUniformSubroutineuiv( GLenum shadertype, GLint location, GLuint* params ) { }
-static void null_glGetUniformdv( GLuint program, GLint location, GLdouble* params ) { }
-static void null_glGetUniformfv( GLuint program, GLint location, GLfloat* params ) { }
-static void null_glGetUniformfvARB( GLhandleARB programObj, GLint location, GLfloat* params ) { }
-static void null_glGetUniformi64vARB( GLuint program, GLint location, GLint64* params ) { }
-static void null_glGetUniformi64vNV( GLuint program, GLint location, GLint64EXT* params ) { }
-static void null_glGetUniformiv( GLuint program, GLint location, GLint* params ) { }
-static void null_glGetUniformivARB( GLhandleARB programObj, GLint location, GLint* params ) { }
-static void null_glGetUniformui64vARB( GLuint program, GLint location, GLuint64* params ) { }
-static void null_glGetUniformui64vNV( GLuint program, GLint location, GLuint64EXT* params ) { }
-static void null_glGetUniformuiv( GLuint program, GLint location, GLuint* params ) { }
-static void null_glGetUniformuivEXT( GLuint program, GLint location, GLuint* params ) { }
-static void null_glGetUnsignedBytei_vEXT( GLenum target, GLuint index, GLubyte* data ) { }
-static void null_glGetUnsignedBytevEXT( GLenum pname, GLubyte* data ) { }
-static void null_glGetVariantArrayObjectfvATI( GLuint id, GLenum pname, GLfloat* params ) { }
-static void null_glGetVariantArrayObjectivATI( GLuint id, GLenum pname, GLint* params ) { }
-static void null_glGetVariantBooleanvEXT( GLuint id, GLenum value, GLboolean* data ) { }
-static void null_glGetVariantFloatvEXT( GLuint id, GLenum value, GLfloat* data ) { }
-static void null_glGetVariantIntegervEXT( GLuint id, GLenum value, GLint* data ) { }
-static void null_glGetVariantPointervEXT( GLuint id, GLenum value, void** data ) { }
-static GLint null_glGetVaryingLocationNV( GLuint program, const GLchar* name ) { return 0; }
-static void null_glGetVertexArrayIndexed64iv( GLuint vaobj, GLuint index, GLenum pname, GLint64* param ) { }
-static void null_glGetVertexArrayIndexediv( GLuint vaobj, GLuint index, GLenum pname, GLint* param ) { }
-static void null_glGetVertexArrayIntegeri_vEXT( GLuint vaobj, GLuint index, GLenum pname, GLint* param ) { }
-static void null_glGetVertexArrayIntegervEXT( GLuint vaobj, GLenum pname, GLint* param ) { }
-static void null_glGetVertexArrayPointeri_vEXT( GLuint vaobj, GLuint index, GLenum pname, void** param ) { }
-static void null_glGetVertexArrayPointervEXT( GLuint vaobj, GLenum pname, void** param ) { }
-static void null_glGetVertexArrayiv( GLuint vaobj, GLenum pname, GLint* param ) { }
-static void null_glGetVertexAttribArrayObjectfvATI( GLuint index, GLenum pname, GLfloat* params ) { }
-static void null_glGetVertexAttribArrayObjectivATI( GLuint index, GLenum pname, GLint* params ) { }
-static void null_glGetVertexAttribIiv( GLuint index, GLenum pname, GLint* params ) { }
-static void null_glGetVertexAttribIivEXT( GLuint index, GLenum pname, GLint* params ) { }
-static void null_glGetVertexAttribIuiv( GLuint index, GLenum pname, GLuint* params ) { }
-static void null_glGetVertexAttribIuivEXT( GLuint index, GLenum pname, GLuint* params ) { }
-static void null_glGetVertexAttribLdv( GLuint index, GLenum pname, GLdouble* params ) { }
-static void null_glGetVertexAttribLdvEXT( GLuint index, GLenum pname, GLdouble* params ) { }
-static void null_glGetVertexAttribLi64vNV( GLuint index, GLenum pname, GLint64EXT* params ) { }
-static void null_glGetVertexAttribLui64vARB( GLuint index, GLenum pname, GLuint64EXT* params ) { }
-static void null_glGetVertexAttribLui64vNV( GLuint index, GLenum pname, GLuint64EXT* params ) { }
-static void null_glGetVertexAttribPointerv( GLuint index, GLenum pname, void** pointer ) { }
-static void null_glGetVertexAttribPointervARB( GLuint index, GLenum pname, void** pointer ) { }
-static void null_glGetVertexAttribPointervNV( GLuint index, GLenum pname, void** pointer ) { }
-static void null_glGetVertexAttribdv( GLuint index, GLenum pname, GLdouble* params ) { }
-static void null_glGetVertexAttribdvARB( GLuint index, GLenum pname, GLdouble* params ) { }
-static void null_glGetVertexAttribdvNV( GLuint index, GLenum pname, GLdouble* params ) { }
-static void null_glGetVertexAttribfv( GLuint index, GLenum pname, GLfloat* params ) { }
-static void null_glGetVertexAttribfvARB( GLuint index, GLenum pname, GLfloat* params ) { }
-static void null_glGetVertexAttribfvNV( GLuint index, GLenum pname, GLfloat* params ) { }
-static void null_glGetVertexAttribiv( GLuint index, GLenum pname, GLint* params ) { }
-static void null_glGetVertexAttribivARB( GLuint index, GLenum pname, GLint* params ) { }
-static void null_glGetVertexAttribivNV( GLuint index, GLenum pname, GLint* params ) { }
-static void null_glGetVideoCaptureStreamdvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble* params ) { }
-static void null_glGetVideoCaptureStreamfvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat* params ) { }
-static void null_glGetVideoCaptureStreamivNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLint* params ) { }
-static void null_glGetVideoCaptureivNV( GLuint video_capture_slot, GLenum pname, GLint* params ) { }
-static void null_glGetVideoi64vNV( GLuint video_slot, GLenum pname, GLint64EXT* params ) { }
-static void null_glGetVideoivNV( GLuint video_slot, GLenum pname, GLint* params ) { }
-static void null_glGetVideoui64vNV( GLuint video_slot, GLenum pname, GLuint64EXT* params ) { }
-static void null_glGetVideouivNV( GLuint video_slot, GLenum pname, GLuint* params ) { }
-static void * null_glGetVkProcAddrNV( const GLchar* name ) { return 0; }
-static void null_glGetnColorTable( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void* table ) { }
-static void null_glGetnColorTableARB( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void* table ) { }
-static void null_glGetnCompressedTexImage( GLenum target, GLint lod, GLsizei bufSize, void* pixels ) { }
-static void null_glGetnCompressedTexImageARB( GLenum target, GLint lod, GLsizei bufSize, void* img ) { }
-static void null_glGetnConvolutionFilter( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void* image ) { }
-static void null_glGetnConvolutionFilterARB( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void* image ) { }
-static void null_glGetnHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void* values ) { }
-static void null_glGetnHistogramARB( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void* values ) { }
-static void null_glGetnMapdv( GLenum target, GLenum query, GLsizei bufSize, GLdouble* v ) { }
-static void null_glGetnMapdvARB( GLenum target, GLenum query, GLsizei bufSize, GLdouble* v ) { }
-static void null_glGetnMapfv( GLenum target, GLenum query, GLsizei bufSize, GLfloat* v ) { }
-static void null_glGetnMapfvARB( GLenum target, GLenum query, GLsizei bufSize, GLfloat* v ) { }
-static void null_glGetnMapiv( GLenum target, GLenum query, GLsizei bufSize, GLint* v ) { }
-static void null_glGetnMapivARB( GLenum target, GLenum query, GLsizei bufSize, GLint* v ) { }
-static void null_glGetnMinmax( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void* values ) { }
-static void null_glGetnMinmaxARB( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void* values ) { }
-static void null_glGetnPixelMapfv( GLenum map, GLsizei bufSize, GLfloat* values ) { }
-static void null_glGetnPixelMapfvARB( GLenum map, GLsizei bufSize, GLfloat* values ) { }
-static void null_glGetnPixelMapuiv( GLenum map, GLsizei bufSize, GLuint* values ) { }
-static void null_glGetnPixelMapuivARB( GLenum map, GLsizei bufSize, GLuint* values ) { }
-static void null_glGetnPixelMapusv( GLenum map, GLsizei bufSize, GLushort* values ) { }
-static void null_glGetnPixelMapusvARB( GLenum map, GLsizei bufSize, GLushort* values ) { }
-static void null_glGetnPolygonStipple( GLsizei bufSize, GLubyte* pattern ) { }
-static void null_glGetnPolygonStippleARB( GLsizei bufSize, GLubyte* pattern ) { }
-static void null_glGetnSeparableFilter( GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void* row, GLsizei columnBufSize, void* column, void* span ) { }
-static void null_glGetnSeparableFilterARB( GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void* row, GLsizei columnBufSize, void* column, void* span ) { }
-static void null_glGetnTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* pixels ) { }
-static void null_glGetnTexImageARB( GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void* img ) { }
-static void null_glGetnUniformdv( GLuint program, GLint location, GLsizei bufSize, GLdouble* params ) { }
-static void null_glGetnUniformdvARB( GLuint program, GLint location, GLsizei bufSize, GLdouble* params ) { }
-static void null_glGetnUniformfv( GLuint program, GLint location, GLsizei bufSize, GLfloat* params ) { }
-static void null_glGetnUniformfvARB( GLuint program, GLint location, GLsizei bufSize, GLfloat* params ) { }
-static void null_glGetnUniformi64vARB( GLuint program, GLint location, GLsizei bufSize, GLint64* params ) { }
-static void null_glGetnUniformiv( GLuint program, GLint location, GLsizei bufSize, GLint* params ) { }
-static void null_glGetnUniformivARB( GLuint program, GLint location, GLsizei bufSize, GLint* params ) { }
-static void null_glGetnUniformui64vARB( GLuint program, GLint location, GLsizei bufSize, GLuint64* params ) { }
-static void null_glGetnUniformuiv( GLuint program, GLint location, GLsizei bufSize, GLuint* params ) { }
-static void null_glGetnUniformuivARB( GLuint program, GLint location, GLsizei bufSize, GLuint* params ) { }
+static void null_glGetUniformSubroutineuiv( GLenum shadertype, GLint location, GLuint *params ) { }
+static void null_glGetUniformdv( GLuint program, GLint location, GLdouble *params ) { }
+static void null_glGetUniformfv( GLuint program, GLint location, GLfloat *params ) { }
+static void null_glGetUniformfvARB( GLhandleARB programObj, GLint location, GLfloat *params ) { }
+static void null_glGetUniformi64vARB( GLuint program, GLint location, GLint64 *params ) { }
+static void null_glGetUniformi64vNV( GLuint program, GLint location, GLint64EXT *params ) { }
+static void null_glGetUniformiv( GLuint program, GLint location, GLint *params ) { }
+static void null_glGetUniformivARB( GLhandleARB programObj, GLint location, GLint *params ) { }
+static void null_glGetUniformui64vARB( GLuint program, GLint location, GLuint64 *params ) { }
+static void null_glGetUniformui64vNV( GLuint program, GLint location, GLuint64EXT *params ) { }
+static void null_glGetUniformuiv( GLuint program, GLint location, GLuint *params ) { }
+static void null_glGetUniformuivEXT( GLuint program, GLint location, GLuint *params ) { }
+static void null_glGetUnsignedBytei_vEXT( GLenum target, GLuint index, GLubyte *data ) { }
+static void null_glGetUnsignedBytevEXT( GLenum pname, GLubyte *data ) { }
+static void null_glGetVariantArrayObjectfvATI( GLuint id, GLenum pname, GLfloat *params ) { }
+static void null_glGetVariantArrayObjectivATI( GLuint id, GLenum pname, GLint *params ) { }
+static void null_glGetVariantBooleanvEXT( GLuint id, GLenum value, GLboolean *data ) { }
+static void null_glGetVariantFloatvEXT( GLuint id, GLenum value, GLfloat *data ) { }
+static void null_glGetVariantIntegervEXT( GLuint id, GLenum value, GLint *data ) { }
+static void null_glGetVariantPointervEXT( GLuint id, GLenum value, void **data ) { }
+static GLint null_glGetVaryingLocationNV( GLuint program, const GLchar *name ) { return 0; }
+static void null_glGetVertexArrayIndexed64iv( GLuint vaobj, GLuint index, GLenum pname, GLint64 *param ) { }
+static void null_glGetVertexArrayIndexediv( GLuint vaobj, GLuint index, GLenum pname, GLint *param ) { }
+static void null_glGetVertexArrayIntegeri_vEXT( GLuint vaobj, GLuint index, GLenum pname, GLint *param ) { }
+static void null_glGetVertexArrayIntegervEXT( GLuint vaobj, GLenum pname, GLint *param ) { }
+static void null_glGetVertexArrayPointeri_vEXT( GLuint vaobj, GLuint index, GLenum pname, void **param ) { }
+static void null_glGetVertexArrayPointervEXT( GLuint vaobj, GLenum pname, void **param ) { }
+static void null_glGetVertexArrayiv( GLuint vaobj, GLenum pname, GLint *param ) { }
+static void null_glGetVertexAttribArrayObjectfvATI( GLuint index, GLenum pname, GLfloat *params ) { }
+static void null_glGetVertexAttribArrayObjectivATI( GLuint index, GLenum pname, GLint *params ) { }
+static void null_glGetVertexAttribIiv( GLuint index, GLenum pname, GLint *params ) { }
+static void null_glGetVertexAttribIivEXT( GLuint index, GLenum pname, GLint *params ) { }
+static void null_glGetVertexAttribIuiv( GLuint index, GLenum pname, GLuint *params ) { }
+static void null_glGetVertexAttribIuivEXT( GLuint index, GLenum pname, GLuint *params ) { }
+static void null_glGetVertexAttribLdv( GLuint index, GLenum pname, GLdouble *params ) { }
+static void null_glGetVertexAttribLdvEXT( GLuint index, GLenum pname, GLdouble *params ) { }
+static void null_glGetVertexAttribLi64vNV( GLuint index, GLenum pname, GLint64EXT *params ) { }
+static void null_glGetVertexAttribLui64vARB( GLuint index, GLenum pname, GLuint64EXT *params ) { }
+static void null_glGetVertexAttribLui64vNV( GLuint index, GLenum pname, GLuint64EXT *params ) { }
+static void null_glGetVertexAttribPointerv( GLuint index, GLenum pname, void **pointer ) { }
+static void null_glGetVertexAttribPointervARB( GLuint index, GLenum pname, void **pointer ) { }
+static void null_glGetVertexAttribPointervNV( GLuint index, GLenum pname, void **pointer ) { }
+static void null_glGetVertexAttribdv( GLuint index, GLenum pname, GLdouble *params ) { }
+static void null_glGetVertexAttribdvARB( GLuint index, GLenum pname, GLdouble *params ) { }
+static void null_glGetVertexAttribdvNV( GLuint index, GLenum pname, GLdouble *params ) { }
+static void null_glGetVertexAttribfv( GLuint index, GLenum pname, GLfloat *params ) { }
+static void null_glGetVertexAttribfvARB( GLuint index, GLenum pname, GLfloat *params ) { }
+static void null_glGetVertexAttribfvNV( GLuint index, GLenum pname, GLfloat *params ) { }
+static void null_glGetVertexAttribiv( GLuint index, GLenum pname, GLint *params ) { }
+static void null_glGetVertexAttribivARB( GLuint index, GLenum pname, GLint *params ) { }
+static void null_glGetVertexAttribivNV( GLuint index, GLenum pname, GLint *params ) { }
+static void null_glGetVideoCaptureStreamdvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble *params ) { }
+static void null_glGetVideoCaptureStreamfvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat *params ) { }
+static void null_glGetVideoCaptureStreamivNV( GLuint video_capture_slot, GLuint stream, GLenum pname, GLint *params ) { }
+static void null_glGetVideoCaptureivNV( GLuint video_capture_slot, GLenum pname, GLint *params ) { }
+static void null_glGetVideoi64vNV( GLuint video_slot, GLenum pname, GLint64EXT *params ) { }
+static void null_glGetVideoivNV( GLuint video_slot, GLenum pname, GLint *params ) { }
+static void null_glGetVideoui64vNV( GLuint video_slot, GLenum pname, GLuint64EXT *params ) { }
+static void null_glGetVideouivNV( GLuint video_slot, GLenum pname, GLuint *params ) { }
+static void * null_glGetVkProcAddrNV( const GLchar *name ) { return 0; }
+static void null_glGetnColorTable( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table ) { }
+static void null_glGetnColorTableARB( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table ) { }
+static void null_glGetnCompressedTexImage( GLenum target, GLint lod, GLsizei bufSize, void *pixels ) { }
+static void null_glGetnCompressedTexImageARB( GLenum target, GLint lod, GLsizei bufSize, void *img ) { }
+static void null_glGetnConvolutionFilter( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image ) { }
+static void null_glGetnConvolutionFilterARB( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image ) { }
+static void null_glGetnHistogram( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values ) { }
+static void null_glGetnHistogramARB( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values ) { }
+static void null_glGetnMapdv( GLenum target, GLenum query, GLsizei bufSize, GLdouble *v ) { }
+static void null_glGetnMapdvARB( GLenum target, GLenum query, GLsizei bufSize, GLdouble *v ) { }
+static void null_glGetnMapfv( GLenum target, GLenum query, GLsizei bufSize, GLfloat *v ) { }
+static void null_glGetnMapfvARB( GLenum target, GLenum query, GLsizei bufSize, GLfloat *v ) { }
+static void null_glGetnMapiv( GLenum target, GLenum query, GLsizei bufSize, GLint *v ) { }
+static void null_glGetnMapivARB( GLenum target, GLenum query, GLsizei bufSize, GLint *v ) { }
+static void null_glGetnMinmax( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values ) { }
+static void null_glGetnMinmaxARB( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values ) { }
+static void null_glGetnPixelMapfv( GLenum map, GLsizei bufSize, GLfloat *values ) { }
+static void null_glGetnPixelMapfvARB( GLenum map, GLsizei bufSize, GLfloat *values ) { }
+static void null_glGetnPixelMapuiv( GLenum map, GLsizei bufSize, GLuint *values ) { }
+static void null_glGetnPixelMapuivARB( GLenum map, GLsizei bufSize, GLuint *values ) { }
+static void null_glGetnPixelMapusv( GLenum map, GLsizei bufSize, GLushort *values ) { }
+static void null_glGetnPixelMapusvARB( GLenum map, GLsizei bufSize, GLushort *values ) { }
+static void null_glGetnPolygonStipple( GLsizei bufSize, GLubyte *pattern ) { }
+static void null_glGetnPolygonStippleARB( GLsizei bufSize, GLubyte *pattern ) { }
+static void null_glGetnSeparableFilter( GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void *row, GLsizei columnBufSize, void *column, void *span ) { }
+static void null_glGetnSeparableFilterARB( GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void *row, GLsizei columnBufSize, void *column, void *span ) { }
+static void null_glGetnTexImage( GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels ) { }
+static void null_glGetnTexImageARB( GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *img ) { }
+static void null_glGetnUniformdv( GLuint program, GLint location, GLsizei bufSize, GLdouble *params ) { }
+static void null_glGetnUniformdvARB( GLuint program, GLint location, GLsizei bufSize, GLdouble *params ) { }
+static void null_glGetnUniformfv( GLuint program, GLint location, GLsizei bufSize, GLfloat *params ) { }
+static void null_glGetnUniformfvARB( GLuint program, GLint location, GLsizei bufSize, GLfloat *params ) { }
+static void null_glGetnUniformi64vARB( GLuint program, GLint location, GLsizei bufSize, GLint64 *params ) { }
+static void null_glGetnUniformiv( GLuint program, GLint location, GLsizei bufSize, GLint *params ) { }
+static void null_glGetnUniformivARB( GLuint program, GLint location, GLsizei bufSize, GLint *params ) { }
+static void null_glGetnUniformui64vARB( GLuint program, GLint location, GLsizei bufSize, GLuint64 *params ) { }
+static void null_glGetnUniformuiv( GLuint program, GLint location, GLsizei bufSize, GLuint *params ) { }
+static void null_glGetnUniformuivARB( GLuint program, GLint location, GLsizei bufSize, GLuint *params ) { }
 static void null_glGlobalAlphaFactorbSUN( GLbyte factor ) { }
 static void null_glGlobalAlphaFactordSUN( GLdouble factor ) { }
 static void null_glGlobalAlphaFactorfSUN( GLfloat factor ) { }
@@ -3385,35 +3719,35 @@
 static void null_glHintPGI( GLenum target, GLint mode ) { }
 static void null_glHistogram( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink ) { }
 static void null_glHistogramEXT( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink ) { }
-static void null_glIglooInterfaceSGIX( GLenum pname, const void* params ) { }
+static void null_glIglooInterfaceSGIX( GLenum pname, const void *params ) { }
 static void null_glImageTransformParameterfHP( GLenum target, GLenum pname, GLfloat param ) { }
-static void null_glImageTransformParameterfvHP( GLenum target, GLenum pname, const GLfloat* params ) { }
+static void null_glImageTransformParameterfvHP( GLenum target, GLenum pname, const GLfloat *params ) { }
 static void null_glImageTransformParameteriHP( GLenum target, GLenum pname, GLint param ) { }
-static void null_glImageTransformParameterivHP( GLenum target, GLenum pname, const GLint* params ) { }
+static void null_glImageTransformParameterivHP( GLenum target, GLenum pname, const GLint *params ) { }
 static void null_glImportMemoryFdEXT( GLuint memory, GLuint64 size, GLenum handleType, GLint fd ) { }
-static void null_glImportMemoryWin32HandleEXT( GLuint memory, GLuint64 size, GLenum handleType, void* handle ) { }
-static void null_glImportMemoryWin32NameEXT( GLuint memory, GLuint64 size, GLenum handleType, const void* name ) { }
+static void null_glImportMemoryWin32HandleEXT( GLuint memory, GLuint64 size, GLenum handleType, void *handle ) { }
+static void null_glImportMemoryWin32NameEXT( GLuint memory, GLuint64 size, GLenum handleType, const void *name ) { }
 static void null_glImportSemaphoreFdEXT( GLuint semaphore, GLenum handleType, GLint fd ) { }
-static void null_glImportSemaphoreWin32HandleEXT( GLuint semaphore, GLenum handleType, void* handle ) { }
-static void null_glImportSemaphoreWin32NameEXT( GLuint semaphore, GLenum handleType, const void* name ) { }
+static void null_glImportSemaphoreWin32HandleEXT( GLuint semaphore, GLenum handleType, void *handle ) { }
+static void null_glImportSemaphoreWin32NameEXT( GLuint semaphore, GLenum handleType, const void *name ) { }
 static GLsync null_glImportSyncEXT( GLenum external_sync_type, GLintptr external_sync, GLbitfield flags ) { return 0; }
 static void null_glIndexFormatNV( GLenum type, GLsizei stride ) { }
 static void null_glIndexFuncEXT( GLenum func, GLclampf ref ) { }
 static void null_glIndexMaterialEXT( GLenum face, GLenum mode ) { }
-static void null_glIndexPointerEXT( GLenum type, GLsizei stride, GLsizei count, const void* pointer ) { }
-static void null_glIndexPointerListIBM( GLenum type, GLint stride, const void** pointer, GLint ptrstride ) { }
+static void null_glIndexPointerEXT( GLenum type, GLsizei stride, GLsizei count, const void *pointer ) { }
+static void null_glIndexPointerListIBM( GLenum type, GLint stride, const void **pointer, GLint ptrstride ) { }
 static void null_glIndexxOES( GLfixed component ) { }
-static void null_glIndexxvOES( const GLfixed* component ) { }
+static void null_glIndexxvOES( const GLfixed *component ) { }
 static void null_glInsertComponentEXT( GLuint res, GLuint src, GLuint num ) { }
-static void null_glInsertEventMarkerEXT( GLsizei length, const GLchar* marker ) { }
-static void null_glInstrumentsBufferSGIX( GLsizei size, GLint* buffer ) { }
+static void null_glInsertEventMarkerEXT( GLsizei length, const GLchar *marker ) { }
+static void null_glInstrumentsBufferSGIX( GLsizei size, GLint *buffer ) { }
 static void null_glInterpolatePathsNV( GLuint resultPath, GLuint pathA, GLuint pathB, GLfloat weight ) { }
 static void null_glInvalidateBufferData( GLuint buffer ) { }
 static void null_glInvalidateBufferSubData( GLuint buffer, GLintptr offset, GLsizeiptr length ) { }
-static void null_glInvalidateFramebuffer( GLenum target, GLsizei numAttachments, const GLenum* attachments ) { }
-static void null_glInvalidateNamedFramebufferData( GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments ) { }
-static void null_glInvalidateNamedFramebufferSubData( GLuint framebuffer, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height ) { }
-static void null_glInvalidateSubFramebuffer( GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height ) { }
+static void null_glInvalidateFramebuffer( GLenum target, GLsizei numAttachments, const GLenum *attachments ) { }
+static void null_glInvalidateNamedFramebufferData( GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments ) { }
+static void null_glInvalidateNamedFramebufferSubData( GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height ) { }
+static void null_glInvalidateSubFramebuffer( GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height ) { }
 static void null_glInvalidateTexImage( GLuint texture, GLint level ) { }
 static void null_glInvalidateTexSubImage( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth ) { }
 static GLboolean null_glIsAsyncMarkerSGIX( GLuint marker ) { return 0; }
@@ -3432,7 +3766,7 @@
 static GLboolean null_glIsMemoryObjectEXT( GLuint memoryObject ) { return 0; }
 static GLboolean null_glIsNameAMD( GLenum identifier, GLuint name ) { return 0; }
 static GLboolean null_glIsNamedBufferResidentNV( GLuint buffer ) { return 0; }
-static GLboolean null_glIsNamedStringARB( GLint namelen, const GLchar* name ) { return 0; }
+static GLboolean null_glIsNamedStringARB( GLint namelen, const GLchar *name ) { return 0; }
 static GLboolean null_glIsObjectBufferATI( GLuint buffer ) { return 0; }
 static GLboolean null_glIsOcclusionQueryNV( GLuint id ) { return 0; }
 static GLboolean null_glIsPathNV( GLuint path ) { return 0; }
@@ -3461,33 +3795,33 @@
 static GLboolean null_glIsVertexArrayAPPLE( GLuint array ) { return 0; }
 static GLboolean null_glIsVertexAttribEnabledAPPLE( GLuint index, GLenum pname ) { return 0; }
 static void null_glLGPUCopyImageSubDataNVX( GLuint sourceGpu, GLbitfield destinationGpuMask, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srxY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth ) { }
-static void null_glLGPUInterlockNVX( void ) { }
-static void null_glLGPUNamedBufferSubDataNVX( GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, const void* data ) { }
-static void null_glLabelObjectEXT( GLenum type, GLuint object, GLsizei length, const GLchar* label ) { }
+static void null_glLGPUInterlockNVX(void) { }
+static void null_glLGPUNamedBufferSubDataNVX( GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data ) { }
+static void null_glLabelObjectEXT( GLenum type, GLuint object, GLsizei length, const GLchar *label ) { }
 static void null_glLightEnviSGIX( GLenum pname, GLint param ) { }
 static void null_glLightModelxOES( GLenum pname, GLfixed param ) { }
-static void null_glLightModelxvOES( GLenum pname, const GLfixed* param ) { }
+static void null_glLightModelxvOES( GLenum pname, const GLfixed *param ) { }
 static void null_glLightxOES( GLenum light, GLenum pname, GLfixed param ) { }
-static void null_glLightxvOES( GLenum light, GLenum pname, const GLfixed* params ) { }
+static void null_glLightxvOES( GLenum light, GLenum pname, const GLfixed *params ) { }
 static void null_glLineWidthxOES( GLfixed width ) { }
 static void null_glLinkProgram( GLuint program ) { }
 static void null_glLinkProgramARB( GLhandleARB programObj ) { }
-static void null_glListDrawCommandsStatesClientNV( GLuint list, GLuint segment, const void** indirects, const GLsizei* sizes, const GLuint* states, const GLuint* fbos, GLuint count ) { }
+static void null_glListDrawCommandsStatesClientNV( GLuint list, GLuint segment, const void **indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count ) { }
 static void null_glListParameterfSGIX( GLuint list, GLenum pname, GLfloat param ) { }
-static void null_glListParameterfvSGIX( GLuint list, GLenum pname, const GLfloat* params ) { }
+static void null_glListParameterfvSGIX( GLuint list, GLenum pname, const GLfloat *params ) { }
 static void null_glListParameteriSGIX( GLuint list, GLenum pname, GLint param ) { }
-static void null_glListParameterivSGIX( GLuint list, GLenum pname, const GLint* params ) { }
+static void null_glListParameterivSGIX( GLuint list, GLenum pname, const GLint *params ) { }
 static void null_glLoadIdentityDeformationMapSGIX( GLbitfield mask ) { }
-static void null_glLoadMatrixxOES( const GLfixed* m ) { }
-static void null_glLoadProgramNV( GLenum target, GLuint id, GLsizei len, const GLubyte* program ) { }
-static void null_glLoadTransposeMatrixd( const GLdouble* m ) { }
-static void null_glLoadTransposeMatrixdARB( const GLdouble* m ) { }
-static void null_glLoadTransposeMatrixf( const GLfloat* m ) { }
-static void null_glLoadTransposeMatrixfARB( const GLfloat* m ) { }
-static void null_glLoadTransposeMatrixxOES( const GLfixed* m ) { }
+static void null_glLoadMatrixxOES( const GLfixed *m ) { }
+static void null_glLoadProgramNV( GLenum target, GLuint id, GLsizei len, const GLubyte *program ) { }
+static void null_glLoadTransposeMatrixd( const GLdouble *m ) { }
+static void null_glLoadTransposeMatrixdARB( const GLdouble *m ) { }
+static void null_glLoadTransposeMatrixf( const GLfloat *m ) { }
+static void null_glLoadTransposeMatrixfARB( const GLfloat *m ) { }
+static void null_glLoadTransposeMatrixxOES( const GLfixed *m ) { }
 static void null_glLockArraysEXT( GLint first, GLsizei count ) { }
 static void null_glMTexCoord2fSGIS( GLenum target, GLfloat s, GLfloat t ) { }
-static void null_glMTexCoord2fvSGIS( GLenum target, GLfloat* v ) { }
+static void null_glMTexCoord2fvSGIS( GLenum target, GLfloat * v ) { }
 static void null_glMakeBufferNonResidentNV( GLenum target ) { }
 static void null_glMakeBufferResidentNV( GLenum target, GLenum access ) { }
 static void null_glMakeImageHandleNonResidentARB( GLuint64 handle ) { }
@@ -3502,46 +3836,46 @@
 static void null_glMakeTextureHandleResidentNV( GLuint64 handle ) { }
 static void null_glMap1xOES( GLenum target, GLfixed u1, GLfixed u2, GLint stride, GLint order, GLfixed points ) { }
 static void null_glMap2xOES( GLenum target, GLfixed u1, GLfixed u2, GLint ustride, GLint uorder, GLfixed v1, GLfixed v2, GLint vstride, GLint vorder, GLfixed points ) { }
-static void* null_glMapBuffer( GLenum target, GLenum access ) { return 0; }
-static void* null_glMapBufferARB( GLenum target, GLenum access ) { return 0; }
-static void* null_glMapBufferRange( GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access ) { return 0; }
-static void null_glMapControlPointsNV( GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const void* points ) { }
+static void * null_glMapBuffer( GLenum target, GLenum access ) { return 0; }
+static void * null_glMapBufferARB( GLenum target, GLenum access ) { return 0; }
+static void * null_glMapBufferRange( GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access ) { return 0; }
+static void null_glMapControlPointsNV( GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const void *points ) { }
 static void null_glMapGrid1xOES( GLint n, GLfixed u1, GLfixed u2 ) { }
 static void null_glMapGrid2xOES( GLint n, GLfixed u1, GLfixed u2, GLfixed v1, GLfixed v2 ) { }
-static void* null_glMapNamedBuffer( GLuint buffer, GLenum access ) { return 0; }
-static void* null_glMapNamedBufferEXT( GLuint buffer, GLenum access ) { return 0; }
-static void* null_glMapNamedBufferRange( GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access ) { return 0; }
-static void* null_glMapNamedBufferRangeEXT( GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access ) { return 0; }
-static void* null_glMapObjectBufferATI( GLuint buffer ) { return 0; }
-static void null_glMapParameterfvNV( GLenum target, GLenum pname, const GLfloat* params ) { }
-static void null_glMapParameterivNV( GLenum target, GLenum pname, const GLint* params ) { }
-static void* null_glMapTexture2DINTEL( GLuint texture, GLint level, GLbitfield access, GLint* stride, GLenum* layout ) { return 0; }
-static void null_glMapVertexAttrib1dAPPLE( GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble* points ) { }
-static void null_glMapVertexAttrib1fAPPLE( GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat* points ) { }
-static void null_glMapVertexAttrib2dAPPLE( GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble* points ) { }
-static void null_glMapVertexAttrib2fAPPLE( GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat* points ) { }
+static void * null_glMapNamedBuffer( GLuint buffer, GLenum access ) { return 0; }
+static void * null_glMapNamedBufferEXT( GLuint buffer, GLenum access ) { return 0; }
+static void * null_glMapNamedBufferRange( GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access ) { return 0; }
+static void * null_glMapNamedBufferRangeEXT( GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access ) { return 0; }
+static void * null_glMapObjectBufferATI( GLuint buffer ) { return 0; }
+static void null_glMapParameterfvNV( GLenum target, GLenum pname, const GLfloat *params ) { }
+static void null_glMapParameterivNV( GLenum target, GLenum pname, const GLint *params ) { }
+static void * null_glMapTexture2DINTEL( GLuint texture, GLint level, GLbitfield access, GLint *stride, GLenum *layout ) { return 0; }
+static void null_glMapVertexAttrib1dAPPLE( GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points ) { }
+static void null_glMapVertexAttrib1fAPPLE( GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points ) { }
+static void null_glMapVertexAttrib2dAPPLE( GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points ) { }
+static void null_glMapVertexAttrib2fAPPLE( GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points ) { }
 static void null_glMaterialxOES( GLenum face, GLenum pname, GLfixed param ) { }
-static void null_glMaterialxvOES( GLenum face, GLenum pname, const GLfixed* param ) { }
+static void null_glMaterialxvOES( GLenum face, GLenum pname, const GLfixed *param ) { }
 static void null_glMatrixFrustumEXT( GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar ) { }
-static void null_glMatrixIndexPointerARB( GLint size, GLenum type, GLsizei stride, const void* pointer ) { }
-static void null_glMatrixIndexubvARB( GLint size, const GLubyte* indices ) { }
-static void null_glMatrixIndexuivARB( GLint size, const GLuint* indices ) { }
-static void null_glMatrixIndexusvARB( GLint size, const GLushort* indices ) { }
-static void null_glMatrixLoad3x2fNV( GLenum matrixMode, const GLfloat* m ) { }
-static void null_glMatrixLoad3x3fNV( GLenum matrixMode, const GLfloat* m ) { }
+static void null_glMatrixIndexPointerARB( GLint size, GLenum type, GLsizei stride, const void *pointer ) { }
+static void null_glMatrixIndexubvARB( GLint size, const GLubyte *indices ) { }
+static void null_glMatrixIndexuivARB( GLint size, const GLuint *indices ) { }
+static void null_glMatrixIndexusvARB( GLint size, const GLushort *indices ) { }
+static void null_glMatrixLoad3x2fNV( GLenum matrixMode, const GLfloat *m ) { }
+static void null_glMatrixLoad3x3fNV( GLenum matrixMode, const GLfloat *m ) { }
 static void null_glMatrixLoadIdentityEXT( GLenum mode ) { }
-static void null_glMatrixLoadTranspose3x3fNV( GLenum matrixMode, const GLfloat* m ) { }
-static void null_glMatrixLoadTransposedEXT( GLenum mode, const GLdouble* m ) { }
-static void null_glMatrixLoadTransposefEXT( GLenum mode, const GLfloat* m ) { }
-static void null_glMatrixLoaddEXT( GLenum mode, const GLdouble* m ) { }
-static void null_glMatrixLoadfEXT( GLenum mode, const GLfloat* m ) { }
-static void null_glMatrixMult3x2fNV( GLenum matrixMode, const GLfloat* m ) { }
-static void null_glMatrixMult3x3fNV( GLenum matrixMode, const GLfloat* m ) { }
-static void null_glMatrixMultTranspose3x3fNV( GLenum matrixMode, const GLfloat* m ) { }
-static void null_glMatrixMultTransposedEXT( GLenum mode, const GLdouble* m ) { }
-static void null_glMatrixMultTransposefEXT( GLenum mode, const GLfloat* m ) { }
-static void null_glMatrixMultdEXT( GLenum mode, const GLdouble* m ) { }
-static void null_glMatrixMultfEXT( GLenum mode, const GLfloat* m ) { }
+static void null_glMatrixLoadTranspose3x3fNV( GLenum matrixMode, const GLfloat *m ) { }
+static void null_glMatrixLoadTransposedEXT( GLenum mode, const GLdouble *m ) { }
+static void null_glMatrixLoadTransposefEXT( GLenum mode, const GLfloat *m ) { }
+static void null_glMatrixLoaddEXT( GLenum mode, const GLdouble *m ) { }
+static void null_glMatrixLoadfEXT( GLenum mode, const GLfloat *m ) { }
+static void null_glMatrixMult3x2fNV( GLenum matrixMode, const GLfloat *m ) { }
+static void null_glMatrixMult3x3fNV( GLenum matrixMode, const GLfloat *m ) { }
+static void null_glMatrixMultTranspose3x3fNV( GLenum matrixMode, const GLfloat *m ) { }
+static void null_glMatrixMultTransposedEXT( GLenum mode, const GLdouble *m ) { }
+static void null_glMatrixMultTransposefEXT( GLenum mode, const GLfloat *m ) { }
+static void null_glMatrixMultdEXT( GLenum mode, const GLdouble *m ) { }
+static void null_glMatrixMultfEXT( GLenum mode, const GLfloat *m ) { }
 static void null_glMatrixOrthoEXT( GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar ) { }
 static void null_glMatrixPopEXT( GLenum mode ) { }
 static void null_glMatrixPushEXT( GLenum mode ) { }
@@ -3556,224 +3890,224 @@
 static void null_glMemoryBarrier( GLbitfield barriers ) { }
 static void null_glMemoryBarrierByRegion( GLbitfield barriers ) { }
 static void null_glMemoryBarrierEXT( GLbitfield barriers ) { }
-static void null_glMemoryObjectParameterivEXT( GLuint memoryObject, GLenum pname, const GLint* params ) { }
+static void null_glMemoryObjectParameterivEXT( GLuint memoryObject, GLenum pname, const GLint *params ) { }
 static void null_glMinSampleShading( GLfloat value ) { }
 static void null_glMinSampleShadingARB( GLfloat value ) { }
 static void null_glMinmax( GLenum target, GLenum internalformat, GLboolean sink ) { }
 static void null_glMinmaxEXT( GLenum target, GLenum internalformat, GLboolean sink ) { }
-static void null_glMultMatrixxOES( const GLfixed* m ) { }
-static void null_glMultTransposeMatrixd( const GLdouble* m ) { }
-static void null_glMultTransposeMatrixdARB( const GLdouble* m ) { }
-static void null_glMultTransposeMatrixf( const GLfloat* m ) { }
-static void null_glMultTransposeMatrixfARB( const GLfloat* m ) { }
-static void null_glMultTransposeMatrixxOES( const GLfixed* m ) { }
-static void null_glMultiDrawArrays( GLenum mode, const GLint* first, const GLsizei* count, GLsizei drawcount ) { }
-static void null_glMultiDrawArraysEXT( GLenum mode, const GLint* first, const GLsizei* count, GLsizei primcount ) { }
-static void null_glMultiDrawArraysIndirect( GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride ) { }
-static void null_glMultiDrawArraysIndirectAMD( GLenum mode, const void* indirect, GLsizei primcount, GLsizei stride ) { }
-static void null_glMultiDrawArraysIndirectBindlessCountNV( GLenum mode, const void* indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount ) { }
-static void null_glMultiDrawArraysIndirectBindlessNV( GLenum mode, const void* indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount ) { }
-static void null_glMultiDrawArraysIndirectCount( GLenum mode, const void* indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride ) { }
-static void null_glMultiDrawArraysIndirectCountARB( GLenum mode, const void* indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride ) { }
-static void null_glMultiDrawElementArrayAPPLE( GLenum mode, const GLint* first, const GLsizei* count, GLsizei primcount ) { }
-static void null_glMultiDrawElements( GLenum mode, const GLsizei* count, GLenum type, const void*const* indices, GLsizei drawcount ) { }
-static void null_glMultiDrawElementsBaseVertex( GLenum mode, const GLsizei* count, GLenum type, const void*const* indices, GLsizei drawcount, const GLint* basevertex ) { }
-static void null_glMultiDrawElementsEXT( GLenum mode, const GLsizei* count, GLenum type, const void*const* indices, GLsizei primcount ) { }
-static void null_glMultiDrawElementsIndirect( GLenum mode, GLenum type, const void* indirect, GLsizei drawcount, GLsizei stride ) { }
-static void null_glMultiDrawElementsIndirectAMD( GLenum mode, GLenum type, const void* indirect, GLsizei primcount, GLsizei stride ) { }
-static void null_glMultiDrawElementsIndirectBindlessCountNV( GLenum mode, GLenum type, const void* indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount ) { }
-static void null_glMultiDrawElementsIndirectBindlessNV( GLenum mode, GLenum type, const void* indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount ) { }
-static void null_glMultiDrawElementsIndirectCount( GLenum mode, GLenum type, const void* indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride ) { }
-static void null_glMultiDrawElementsIndirectCountARB( GLenum mode, GLenum type, const void* indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride ) { }
-static void null_glMultiDrawRangeElementArrayAPPLE( GLenum mode, GLuint start, GLuint end, const GLint* first, const GLsizei* count, GLsizei primcount ) { }
-static void null_glMultiModeDrawArraysIBM( const GLenum* mode, const GLint* first, const GLsizei* count, GLsizei primcount, GLint modestride ) { }
-static void null_glMultiModeDrawElementsIBM( const GLenum* mode, const GLsizei* count, GLenum type, const void*const* indices, GLsizei primcount, GLint modestride ) { }
+static void null_glMultMatrixxOES( const GLfixed *m ) { }
+static void null_glMultTransposeMatrixd( const GLdouble *m ) { }
+static void null_glMultTransposeMatrixdARB( const GLdouble *m ) { }
+static void null_glMultTransposeMatrixf( const GLfloat *m ) { }
+static void null_glMultTransposeMatrixfARB( const GLfloat *m ) { }
+static void null_glMultTransposeMatrixxOES( const GLfixed *m ) { }
+static void null_glMultiDrawArrays( GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount ) { }
+static void null_glMultiDrawArraysEXT( GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount ) { }
+static void null_glMultiDrawArraysIndirect( GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride ) { }
+static void null_glMultiDrawArraysIndirectAMD( GLenum mode, const void *indirect, GLsizei primcount, GLsizei stride ) { }
+static void null_glMultiDrawArraysIndirectBindlessCountNV( GLenum mode, const void *indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount ) { }
+static void null_glMultiDrawArraysIndirectBindlessNV( GLenum mode, const void *indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount ) { }
+static void null_glMultiDrawArraysIndirectCount( GLenum mode, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride ) { }
+static void null_glMultiDrawArraysIndirectCountARB( GLenum mode, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride ) { }
+static void null_glMultiDrawElementArrayAPPLE( GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount ) { }
+static void null_glMultiDrawElements( GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount ) { }
+static void null_glMultiDrawElementsBaseVertex( GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex ) { }
+static void null_glMultiDrawElementsEXT( GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei primcount ) { }
+static void null_glMultiDrawElementsIndirect( GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride ) { }
+static void null_glMultiDrawElementsIndirectAMD( GLenum mode, GLenum type, const void *indirect, GLsizei primcount, GLsizei stride ) { }
+static void null_glMultiDrawElementsIndirectBindlessCountNV( GLenum mode, GLenum type, const void *indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount ) { }
+static void null_glMultiDrawElementsIndirectBindlessNV( GLenum mode, GLenum type, const void *indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount ) { }
+static void null_glMultiDrawElementsIndirectCount( GLenum mode, GLenum type, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride ) { }
+static void null_glMultiDrawElementsIndirectCountARB( GLenum mode, GLenum type, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride ) { }
+static void null_glMultiDrawRangeElementArrayAPPLE( GLenum mode, GLuint start, GLuint end, const GLint *first, const GLsizei *count, GLsizei primcount ) { }
+static void null_glMultiModeDrawArraysIBM( const GLenum *mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride ) { }
+static void null_glMultiModeDrawElementsIBM( const GLenum *mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei primcount, GLint modestride ) { }
 static void null_glMultiTexBufferEXT( GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer ) { }
 static void null_glMultiTexCoord1bOES( GLenum texture, GLbyte s ) { }
-static void null_glMultiTexCoord1bvOES( GLenum texture, const GLbyte* coords ) { }
+static void null_glMultiTexCoord1bvOES( GLenum texture, const GLbyte *coords ) { }
 static void null_glMultiTexCoord1d( GLenum target, GLdouble s ) { }
 static void null_glMultiTexCoord1dARB( GLenum target, GLdouble s ) { }
 static void null_glMultiTexCoord1dSGIS( GLenum target, GLdouble s ) { }
-static void null_glMultiTexCoord1dv( GLenum target, const GLdouble* v ) { }
-static void null_glMultiTexCoord1dvARB( GLenum target, const GLdouble* v ) { }
-static void null_glMultiTexCoord1dvSGIS( GLenum target, GLdouble* v ) { }
+static void null_glMultiTexCoord1dv( GLenum target, const GLdouble *v ) { }
+static void null_glMultiTexCoord1dvARB( GLenum target, const GLdouble *v ) { }
+static void null_glMultiTexCoord1dvSGIS( GLenum target, GLdouble * v ) { }
 static void null_glMultiTexCoord1f( GLenum target, GLfloat s ) { }
 static void null_glMultiTexCoord1fARB( GLenum target, GLfloat s ) { }
 static void null_glMultiTexCoord1fSGIS( GLenum target, GLfloat s ) { }
-static void null_glMultiTexCoord1fv( GLenum target, const GLfloat* v ) { }
-static void null_glMultiTexCoord1fvARB( GLenum target, const GLfloat* v ) { }
-static void null_glMultiTexCoord1fvSGIS( GLenum target, const GLfloat* v ) { }
+static void null_glMultiTexCoord1fv( GLenum target, const GLfloat *v ) { }
+static void null_glMultiTexCoord1fvARB( GLenum target, const GLfloat *v ) { }
+static void null_glMultiTexCoord1fvSGIS( GLenum target, const GLfloat * v ) { }
 static void null_glMultiTexCoord1hNV( GLenum target, GLhalfNV s ) { }
-static void null_glMultiTexCoord1hvNV( GLenum target, const GLhalfNV* v ) { }
+static void null_glMultiTexCoord1hvNV( GLenum target, const GLhalfNV *v ) { }
 static void null_glMultiTexCoord1i( GLenum target, GLint s ) { }
 static void null_glMultiTexCoord1iARB( GLenum target, GLint s ) { }
 static void null_glMultiTexCoord1iSGIS( GLenum target, GLint s ) { }
-static void null_glMultiTexCoord1iv( GLenum target, const GLint* v ) { }
-static void null_glMultiTexCoord1ivARB( GLenum target, const GLint* v ) { }
-static void null_glMultiTexCoord1ivSGIS( GLenum target, GLint* v ) { }
+static void null_glMultiTexCoord1iv( GLenum target, const GLint *v ) { }
+static void null_glMultiTexCoord1ivARB( GLenum target, const GLint *v ) { }
+static void null_glMultiTexCoord1ivSGIS( GLenum target, GLint * v ) { }
 static void null_glMultiTexCoord1s( GLenum target, GLshort s ) { }
 static void null_glMultiTexCoord1sARB( GLenum target, GLshort s ) { }
 static void null_glMultiTexCoord1sSGIS( GLenum target, GLshort s ) { }
-static void null_glMultiTexCoord1sv( GLenum target, const GLshort* v ) { }
-static void null_glMultiTexCoord1svARB( GLenum target, const GLshort* v ) { }
-static void null_glMultiTexCoord1svSGIS( GLenum target, GLshort* v ) { }
+static void null_glMultiTexCoord1sv( GLenum target, const GLshort *v ) { }
+static void null_glMultiTexCoord1svARB( GLenum target, const GLshort *v ) { }
+static void null_glMultiTexCoord1svSGIS( GLenum target, GLshort * v ) { }
 static void null_glMultiTexCoord1xOES( GLenum texture, GLfixed s ) { }
-static void null_glMultiTexCoord1xvOES( GLenum texture, const GLfixed* coords ) { }
+static void null_glMultiTexCoord1xvOES( GLenum texture, const GLfixed *coords ) { }
 static void null_glMultiTexCoord2bOES( GLenum texture, GLbyte s, GLbyte t ) { }
-static void null_glMultiTexCoord2bvOES( GLenum texture, const GLbyte* coords ) { }
+static void null_glMultiTexCoord2bvOES( GLenum texture, const GLbyte *coords ) { }
 static void null_glMultiTexCoord2d( GLenum target, GLdouble s, GLdouble t ) { }
 static void null_glMultiTexCoord2dARB( GLenum target, GLdouble s, GLdouble t ) { }
 static void null_glMultiTexCoord2dSGIS( GLenum target, GLdouble s, GLdouble t ) { }
-static void null_glMultiTexCoord2dv( GLenum target, const GLdouble* v ) { }
-static void null_glMultiTexCoord2dvARB( GLenum target, const GLdouble* v ) { }
-static void null_glMultiTexCoord2dvSGIS( GLenum target, GLdouble* v ) { }
+static void null_glMultiTexCoord2dv( GLenum target, const GLdouble *v ) { }
+static void null_glMultiTexCoord2dvARB( GLenum target, const GLdouble *v ) { }
+static void null_glMultiTexCoord2dvSGIS( GLenum target, GLdouble * v ) { }
 static void null_glMultiTexCoord2f( GLenum target, GLfloat s, GLfloat t ) { }
 static void null_glMultiTexCoord2fARB( GLenum target, GLfloat s, GLfloat t ) { }
 static void null_glMultiTexCoord2fSGIS( GLenum target, GLfloat s, GLfloat t ) { }
-static void null_glMultiTexCoord2fv( GLenum target, const GLfloat* v ) { }
-static void null_glMultiTexCoord2fvARB( GLenum target, const GLfloat* v ) { }
-static void null_glMultiTexCoord2fvSGIS( GLenum target, GLfloat* v ) { }
+static void null_glMultiTexCoord2fv( GLenum target, const GLfloat *v ) { }
+static void null_glMultiTexCoord2fvARB( GLenum target, const GLfloat *v ) { }
+static void null_glMultiTexCoord2fvSGIS( GLenum target, GLfloat * v ) { }
 static void null_glMultiTexCoord2hNV( GLenum target, GLhalfNV s, GLhalfNV t ) { }
-static void null_glMultiTexCoord2hvNV( GLenum target, const GLhalfNV* v ) { }
+static void null_glMultiTexCoord2hvNV( GLenum target, const GLhalfNV *v ) { }
 static void null_glMultiTexCoord2i( GLenum target, GLint s, GLint t ) { }
 static void null_glMultiTexCoord2iARB( GLenum target, GLint s, GLint t ) { }
 static void null_glMultiTexCoord2iSGIS( GLenum target, GLint s, GLint t ) { }
-static void null_glMultiTexCoord2iv( GLenum target, const GLint* v ) { }
-static void null_glMultiTexCoord2ivARB( GLenum target, const GLint* v ) { }
-static void null_glMultiTexCoord2ivSGIS( GLenum target, GLint* v ) { }
+static void null_glMultiTexCoord2iv( GLenum target, const GLint *v ) { }
+static void null_glMultiTexCoord2ivARB( GLenum target, const GLint *v ) { }
+static void null_glMultiTexCoord2ivSGIS( GLenum target, GLint * v ) { }
 static void null_glMultiTexCoord2s( GLenum target, GLshort s, GLshort t ) { }
 static void null_glMultiTexCoord2sARB( GLenum target, GLshort s, GLshort t ) { }
 static void null_glMultiTexCoord2sSGIS( GLenum target, GLshort s, GLshort t ) { }
-static void null_glMultiTexCoord2sv( GLenum target, const GLshort* v ) { }
-static void null_glMultiTexCoord2svARB( GLenum target, const GLshort* v ) { }
-static void null_glMultiTexCoord2svSGIS( GLenum target, GLshort* v ) { }
+static void null_glMultiTexCoord2sv( GLenum target, const GLshort *v ) { }
+static void null_glMultiTexCoord2svARB( GLenum target, const GLshort *v ) { }
+static void null_glMultiTexCoord2svSGIS( GLenum target, GLshort * v ) { }
 static void null_glMultiTexCoord2xOES( GLenum texture, GLfixed s, GLfixed t ) { }
-static void null_glMultiTexCoord2xvOES( GLenum texture, const GLfixed* coords ) { }
+static void null_glMultiTexCoord2xvOES( GLenum texture, const GLfixed *coords ) { }
 static void null_glMultiTexCoord3bOES( GLenum texture, GLbyte s, GLbyte t, GLbyte r ) { }
-static void null_glMultiTexCoord3bvOES( GLenum texture, const GLbyte* coords ) { }
+static void null_glMultiTexCoord3bvOES( GLenum texture, const GLbyte *coords ) { }
 static void null_glMultiTexCoord3d( GLenum target, GLdouble s, GLdouble t, GLdouble r ) { }
 static void null_glMultiTexCoord3dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r ) { }
 static void null_glMultiTexCoord3dSGIS( GLenum target, GLdouble s, GLdouble t, GLdouble r ) { }
-static void null_glMultiTexCoord3dv( GLenum target, const GLdouble* v ) { }
-static void null_glMultiTexCoord3dvARB( GLenum target, const GLdouble* v ) { }
-static void null_glMultiTexCoord3dvSGIS( GLenum target, GLdouble* v ) { }
+static void null_glMultiTexCoord3dv( GLenum target, const GLdouble *v ) { }
+static void null_glMultiTexCoord3dvARB( GLenum target, const GLdouble *v ) { }
+static void null_glMultiTexCoord3dvSGIS( GLenum target, GLdouble * v ) { }
 static void null_glMultiTexCoord3f( GLenum target, GLfloat s, GLfloat t, GLfloat r ) { }
 static void null_glMultiTexCoord3fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r ) { }
 static void null_glMultiTexCoord3fSGIS( GLenum target, GLfloat s, GLfloat t, GLfloat r ) { }
-static void null_glMultiTexCoord3fv( GLenum target, const GLfloat* v ) { }
-static void null_glMultiTexCoord3fvARB( GLenum target, const GLfloat* v ) { }
-static void null_glMultiTexCoord3fvSGIS( GLenum target, GLfloat* v ) { }
+static void null_glMultiTexCoord3fv( GLenum target, const GLfloat *v ) { }
+static void null_glMultiTexCoord3fvARB( GLenum target, const GLfloat *v ) { }
+static void null_glMultiTexCoord3fvSGIS( GLenum target, GLfloat * v ) { }
 static void null_glMultiTexCoord3hNV( GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r ) { }
-static void null_glMultiTexCoord3hvNV( GLenum target, const GLhalfNV* v ) { }
+static void null_glMultiTexCoord3hvNV( GLenum target, const GLhalfNV *v ) { }
 static void null_glMultiTexCoord3i( GLenum target, GLint s, GLint t, GLint r ) { }
 static void null_glMultiTexCoord3iARB( GLenum target, GLint s, GLint t, GLint r ) { }
 static void null_glMultiTexCoord3iSGIS( GLenum target, GLint s, GLint t, GLint r ) { }
-static void null_glMultiTexCoord3iv( GLenum target, const GLint* v ) { }
-static void null_glMultiTexCoord3ivARB( GLenum target, const GLint* v ) { }
-static void null_glMultiTexCoord3ivSGIS( GLenum target, GLint* v ) { }
+static void null_glMultiTexCoord3iv( GLenum target, const GLint *v ) { }
+static void null_glMultiTexCoord3ivARB( GLenum target, const GLint *v ) { }
+static void null_glMultiTexCoord3ivSGIS( GLenum target, GLint * v ) { }
 static void null_glMultiTexCoord3s( GLenum target, GLshort s, GLshort t, GLshort r ) { }
 static void null_glMultiTexCoord3sARB( GLenum target, GLshort s, GLshort t, GLshort r ) { }
 static void null_glMultiTexCoord3sSGIS( GLenum target, GLshort s, GLshort t, GLshort r ) { }
-static void null_glMultiTexCoord3sv( GLenum target, const GLshort* v ) { }
-static void null_glMultiTexCoord3svARB( GLenum target, const GLshort* v ) { }
-static void null_glMultiTexCoord3svSGIS( GLenum target, GLshort* v ) { }
+static void null_glMultiTexCoord3sv( GLenum target, const GLshort *v ) { }
+static void null_glMultiTexCoord3svARB( GLenum target, const GLshort *v ) { }
+static void null_glMultiTexCoord3svSGIS( GLenum target, GLshort * v ) { }
 static void null_glMultiTexCoord3xOES( GLenum texture, GLfixed s, GLfixed t, GLfixed r ) { }
-static void null_glMultiTexCoord3xvOES( GLenum texture, const GLfixed* coords ) { }
+static void null_glMultiTexCoord3xvOES( GLenum texture, const GLfixed *coords ) { }
 static void null_glMultiTexCoord4bOES( GLenum texture, GLbyte s, GLbyte t, GLbyte r, GLbyte q ) { }
-static void null_glMultiTexCoord4bvOES( GLenum texture, const GLbyte* coords ) { }
+static void null_glMultiTexCoord4bvOES( GLenum texture, const GLbyte *coords ) { }
 static void null_glMultiTexCoord4d( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q ) { }
 static void null_glMultiTexCoord4dARB( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q ) { }
 static void null_glMultiTexCoord4dSGIS( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q ) { }
-static void null_glMultiTexCoord4dv( GLenum target, const GLdouble* v ) { }
-static void null_glMultiTexCoord4dvARB( GLenum target, const GLdouble* v ) { }
-static void null_glMultiTexCoord4dvSGIS( GLenum target, GLdouble* v ) { }
+static void null_glMultiTexCoord4dv( GLenum target, const GLdouble *v ) { }
+static void null_glMultiTexCoord4dvARB( GLenum target, const GLdouble *v ) { }
+static void null_glMultiTexCoord4dvSGIS( GLenum target, GLdouble * v ) { }
 static void null_glMultiTexCoord4f( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q ) { }
 static void null_glMultiTexCoord4fARB( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q ) { }
 static void null_glMultiTexCoord4fSGIS( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q ) { }
-static void null_glMultiTexCoord4fv( GLenum target, const GLfloat* v ) { }
-static void null_glMultiTexCoord4fvARB( GLenum target, const GLfloat* v ) { }
-static void null_glMultiTexCoord4fvSGIS( GLenum target, GLfloat* v ) { }
+static void null_glMultiTexCoord4fv( GLenum target, const GLfloat *v ) { }
+static void null_glMultiTexCoord4fvARB( GLenum target, const GLfloat *v ) { }
+static void null_glMultiTexCoord4fvSGIS( GLenum target, GLfloat * v ) { }
 static void null_glMultiTexCoord4hNV( GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q ) { }
-static void null_glMultiTexCoord4hvNV( GLenum target, const GLhalfNV* v ) { }
+static void null_glMultiTexCoord4hvNV( GLenum target, const GLhalfNV *v ) { }
 static void null_glMultiTexCoord4i( GLenum target, GLint s, GLint t, GLint r, GLint q ) { }
 static void null_glMultiTexCoord4iARB( GLenum target, GLint s, GLint t, GLint r, GLint q ) { }
 static void null_glMultiTexCoord4iSGIS( GLenum target, GLint s, GLint t, GLint r, GLint q ) { }
-static void null_glMultiTexCoord4iv( GLenum target, const GLint* v ) { }
-static void null_glMultiTexCoord4ivARB( GLenum target, const GLint* v ) { }
-static void null_glMultiTexCoord4ivSGIS( GLenum target, GLint* v ) { }
+static void null_glMultiTexCoord4iv( GLenum target, const GLint *v ) { }
+static void null_glMultiTexCoord4ivARB( GLenum target, const GLint *v ) { }
+static void null_glMultiTexCoord4ivSGIS( GLenum target, GLint * v ) { }
 static void null_glMultiTexCoord4s( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q ) { }
 static void null_glMultiTexCoord4sARB( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q ) { }
 static void null_glMultiTexCoord4sSGIS( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q ) { }
-static void null_glMultiTexCoord4sv( GLenum target, const GLshort* v ) { }
-static void null_glMultiTexCoord4svARB( GLenum target, const GLshort* v ) { }
-static void null_glMultiTexCoord4svSGIS( GLenum target, GLshort* v ) { }
+static void null_glMultiTexCoord4sv( GLenum target, const GLshort *v ) { }
+static void null_glMultiTexCoord4svARB( GLenum target, const GLshort *v ) { }
+static void null_glMultiTexCoord4svSGIS( GLenum target, GLshort * v ) { }
 static void null_glMultiTexCoord4xOES( GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q ) { }
-static void null_glMultiTexCoord4xvOES( GLenum texture, const GLfixed* coords ) { }
+static void null_glMultiTexCoord4xvOES( GLenum texture, const GLfixed *coords ) { }
 static void null_glMultiTexCoordP1ui( GLenum texture, GLenum type, GLuint coords ) { }
-static void null_glMultiTexCoordP1uiv( GLenum texture, GLenum type, const GLuint* coords ) { }
+static void null_glMultiTexCoordP1uiv( GLenum texture, GLenum type, const GLuint *coords ) { }
 static void null_glMultiTexCoordP2ui( GLenum texture, GLenum type, GLuint coords ) { }
-static void null_glMultiTexCoordP2uiv( GLenum texture, GLenum type, const GLuint* coords ) { }
+static void null_glMultiTexCoordP2uiv( GLenum texture, GLenum type, const GLuint *coords ) { }
 static void null_glMultiTexCoordP3ui( GLenum texture, GLenum type, GLuint coords ) { }
-static void null_glMultiTexCoordP3uiv( GLenum texture, GLenum type, const GLuint* coords ) { }
+static void null_glMultiTexCoordP3uiv( GLenum texture, GLenum type, const GLuint *coords ) { }
 static void null_glMultiTexCoordP4ui( GLenum texture, GLenum type, GLuint coords ) { }
-static void null_glMultiTexCoordP4uiv( GLenum texture, GLenum type, const GLuint* coords ) { }
-static void null_glMultiTexCoordPointerEXT( GLenum texunit, GLint size, GLenum type, GLsizei stride, const void* pointer ) { }
-static void null_glMultiTexCoordPointerSGIS( GLenum target, GLint size, GLenum type, GLsizei stride, GLvoid* pointer ) { }
+static void null_glMultiTexCoordP4uiv( GLenum texture, GLenum type, const GLuint *coords ) { }
+static void null_glMultiTexCoordPointerEXT( GLenum texunit, GLint size, GLenum type, GLsizei stride, const void *pointer ) { }
+static void null_glMultiTexCoordPointerSGIS( GLenum target, GLint size, GLenum type, GLsizei stride, GLvoid * pointer ) { }
 static void null_glMultiTexEnvfEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat param ) { }
-static void null_glMultiTexEnvfvEXT( GLenum texunit, GLenum target, GLenum pname, const GLfloat* params ) { }
+static void null_glMultiTexEnvfvEXT( GLenum texunit, GLenum target, GLenum pname, const GLfloat *params ) { }
 static void null_glMultiTexEnviEXT( GLenum texunit, GLenum target, GLenum pname, GLint param ) { }
-static void null_glMultiTexEnvivEXT( GLenum texunit, GLenum target, GLenum pname, const GLint* params ) { }
+static void null_glMultiTexEnvivEXT( GLenum texunit, GLenum target, GLenum pname, const GLint *params ) { }
 static void null_glMultiTexGendEXT( GLenum texunit, GLenum coord, GLenum pname, GLdouble param ) { }
-static void null_glMultiTexGendvEXT( GLenum texunit, GLenum coord, GLenum pname, const GLdouble* params ) { }
+static void null_glMultiTexGendvEXT( GLenum texunit, GLenum coord, GLenum pname, const GLdouble *params ) { }
 static void null_glMultiTexGenfEXT( GLenum texunit, GLenum coord, GLenum pname, GLfloat param ) { }
-static void null_glMultiTexGenfvEXT( GLenum texunit, GLenum coord, GLenum pname, const GLfloat* params ) { }
+static void null_glMultiTexGenfvEXT( GLenum texunit, GLenum coord, GLenum pname, const GLfloat *params ) { }
 static void null_glMultiTexGeniEXT( GLenum texunit, GLenum coord, GLenum pname, GLint param ) { }
-static void null_glMultiTexGenivEXT( GLenum texunit, GLenum coord, GLenum pname, const GLint* params ) { }
-static void null_glMultiTexImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glMultiTexImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glMultiTexImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glMultiTexParameterIivEXT( GLenum texunit, GLenum target, GLenum pname, const GLint* params ) { }
-static void null_glMultiTexParameterIuivEXT( GLenum texunit, GLenum target, GLenum pname, const GLuint* params ) { }
+static void null_glMultiTexGenivEXT( GLenum texunit, GLenum coord, GLenum pname, const GLint *params ) { }
+static void null_glMultiTexImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glMultiTexImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glMultiTexImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glMultiTexParameterIivEXT( GLenum texunit, GLenum target, GLenum pname, const GLint *params ) { }
+static void null_glMultiTexParameterIuivEXT( GLenum texunit, GLenum target, GLenum pname, const GLuint *params ) { }
 static void null_glMultiTexParameterfEXT( GLenum texunit, GLenum target, GLenum pname, GLfloat param ) { }
-static void null_glMultiTexParameterfvEXT( GLenum texunit, GLenum target, GLenum pname, const GLfloat* params ) { }
+static void null_glMultiTexParameterfvEXT( GLenum texunit, GLenum target, GLenum pname, const GLfloat *params ) { }
 static void null_glMultiTexParameteriEXT( GLenum texunit, GLenum target, GLenum pname, GLint param ) { }
-static void null_glMultiTexParameterivEXT( GLenum texunit, GLenum target, GLenum pname, const GLint* params ) { }
+static void null_glMultiTexParameterivEXT( GLenum texunit, GLenum target, GLenum pname, const GLint *params ) { }
 static void null_glMultiTexRenderbufferEXT( GLenum texunit, GLenum target, GLuint renderbuffer ) { }
-static void null_glMultiTexSubImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glMultiTexSubImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glMultiTexSubImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glMulticastBarrierNV( void ) { }
+static void null_glMultiTexSubImage1DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glMultiTexSubImage2DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glMultiTexSubImage3DEXT( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glMulticastBarrierNV(void) { }
 static void null_glMulticastBlitFramebufferNV( GLuint srcGpu, GLuint dstGpu, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter ) { }
-static void null_glMulticastBufferSubDataNV( GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, const GLvoid* data ) { }
+static void null_glMulticastBufferSubDataNV( GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, const GLvoid *data ) { }
 static void null_glMulticastCopyBufferSubDataNV( GLuint readGpu, GLbitfield writeGpuMask, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size ) { }
 static void null_glMulticastCopyImageSubDataNV( GLuint srcGpu, GLbitfield dstGpuMask, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth ) { }
-static void null_glMulticastFramebufferSampleLocationsfvNV( GLuint gpu, GLuint framebuffer, GLuint start, GLsizei count, const GLfloat* v ) { }
-static void null_glMulticastGetQueryObjecti64vNV( GLuint gpu, GLuint id, GLenum pname, GLint64* params ) { }
-static void null_glMulticastGetQueryObjectivNV( GLuint gpu, GLuint id, GLenum pname, GLint* params ) { }
-static void null_glMulticastGetQueryObjectui64vNV( GLuint gpu, GLuint id, GLenum pname, GLuint64* params ) { }
-static void null_glMulticastGetQueryObjectuivNV( GLuint gpu, GLuint id, GLenum pname, GLuint* params ) { }
+static void null_glMulticastFramebufferSampleLocationsfvNV( GLuint gpu, GLuint framebuffer, GLuint start, GLsizei count, const GLfloat *v ) { }
+static void null_glMulticastGetQueryObjecti64vNV( GLuint gpu, GLuint id, GLenum pname, GLint64 *params ) { }
+static void null_glMulticastGetQueryObjectivNV( GLuint gpu, GLuint id, GLenum pname, GLint *params ) { }
+static void null_glMulticastGetQueryObjectui64vNV( GLuint gpu, GLuint id, GLenum pname, GLuint64 *params ) { }
+static void null_glMulticastGetQueryObjectuivNV( GLuint gpu, GLuint id, GLenum pname, GLuint *params ) { }
 static void null_glMulticastWaitSyncNV( GLuint signalGpu, GLbitfield waitGpuMask ) { }
-static void null_glNamedBufferData( GLuint buffer, GLsizeiptr size, const void* data, GLenum usage ) { }
-static void null_glNamedBufferDataEXT( GLuint buffer, GLsizeiptr size, const void* data, GLenum usage ) { }
+static void null_glNamedBufferData( GLuint buffer, GLsizeiptr size, const void *data, GLenum usage ) { }
+static void null_glNamedBufferDataEXT( GLuint buffer, GLsizeiptr size, const void *data, GLenum usage ) { }
 static void null_glNamedBufferPageCommitmentARB( GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit ) { }
 static void null_glNamedBufferPageCommitmentEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit ) { }
-static void null_glNamedBufferStorage( GLuint buffer, GLsizeiptr size, const void* data, GLbitfield flags ) { }
-static void null_glNamedBufferStorageEXT( GLuint buffer, GLsizeiptr size, const void* data, GLbitfield flags ) { }
+static void null_glNamedBufferStorage( GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags ) { }
+static void null_glNamedBufferStorageEXT( GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags ) { }
 static void null_glNamedBufferStorageExternalEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, void * clientBuffer, GLbitfield flags ) { }
 static void null_glNamedBufferStorageMemEXT( GLuint buffer, GLsizeiptr size, GLuint memory, GLuint64 offset ) { }
-static void null_glNamedBufferSubData( GLuint buffer, GLintptr offset, GLsizeiptr size, const void* data ) { }
-static void null_glNamedBufferSubDataEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, const void* data ) { }
+static void null_glNamedBufferSubData( GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data ) { }
+static void null_glNamedBufferSubDataEXT( GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data ) { }
 static void null_glNamedCopyBufferSubDataEXT( GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size ) { }
 static void null_glNamedFramebufferDrawBuffer( GLuint framebuffer, GLenum buf ) { }
-static void null_glNamedFramebufferDrawBuffers( GLuint framebuffer, GLsizei n, const GLenum* bufs ) { }
+static void null_glNamedFramebufferDrawBuffers( GLuint framebuffer, GLsizei n, const GLenum *bufs ) { }
 static void null_glNamedFramebufferParameteri( GLuint framebuffer, GLenum pname, GLint param ) { }
 static void null_glNamedFramebufferParameteriEXT( GLuint framebuffer, GLenum pname, GLint param ) { }
 static void null_glNamedFramebufferReadBuffer( GLuint framebuffer, GLenum src ) { }
 static void null_glNamedFramebufferRenderbuffer( GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) { }
 static void null_glNamedFramebufferRenderbufferEXT( GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer ) { }
-static void null_glNamedFramebufferSampleLocationsfvARB( GLuint framebuffer, GLuint start, GLsizei count, const GLfloat* v ) { }
-static void null_glNamedFramebufferSampleLocationsfvNV( GLuint framebuffer, GLuint start, GLsizei count, const GLfloat* v ) { }
-static void null_glNamedFramebufferSamplePositionsfvAMD( GLuint framebuffer, GLuint numsamples, GLuint pixelindex, const GLfloat* values ) { }
+static void null_glNamedFramebufferSampleLocationsfvARB( GLuint framebuffer, GLuint start, GLsizei count, const GLfloat *v ) { }
+static void null_glNamedFramebufferSampleLocationsfvNV( GLuint framebuffer, GLuint start, GLsizei count, const GLfloat *v ) { }
+static void null_glNamedFramebufferSamplePositionsfvAMD( GLuint framebuffer, GLuint numsamples, GLuint pixelindex, const GLfloat *values ) { }
 static void null_glNamedFramebufferTexture( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level ) { }
 static void null_glNamedFramebufferTexture1DEXT( GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) { }
 static void null_glNamedFramebufferTexture2DEXT( GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level ) { }
@@ -3783,49 +4117,49 @@
 static void null_glNamedFramebufferTextureLayer( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer ) { }
 static void null_glNamedFramebufferTextureLayerEXT( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer ) { }
 static void null_glNamedProgramLocalParameter4dEXT( GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
-static void null_glNamedProgramLocalParameter4dvEXT( GLuint program, GLenum target, GLuint index, const GLdouble* params ) { }
+static void null_glNamedProgramLocalParameter4dvEXT( GLuint program, GLenum target, GLuint index, const GLdouble *params ) { }
 static void null_glNamedProgramLocalParameter4fEXT( GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { }
-static void null_glNamedProgramLocalParameter4fvEXT( GLuint program, GLenum target, GLuint index, const GLfloat* params ) { }
+static void null_glNamedProgramLocalParameter4fvEXT( GLuint program, GLenum target, GLuint index, const GLfloat *params ) { }
 static void null_glNamedProgramLocalParameterI4iEXT( GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w ) { }
-static void null_glNamedProgramLocalParameterI4ivEXT( GLuint program, GLenum target, GLuint index, const GLint* params ) { }
+static void null_glNamedProgramLocalParameterI4ivEXT( GLuint program, GLenum target, GLuint index, const GLint *params ) { }
 static void null_glNamedProgramLocalParameterI4uiEXT( GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) { }
-static void null_glNamedProgramLocalParameterI4uivEXT( GLuint program, GLenum target, GLuint index, const GLuint* params ) { }
-static void null_glNamedProgramLocalParameters4fvEXT( GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat* params ) { }
-static void null_glNamedProgramLocalParametersI4ivEXT( GLuint program, GLenum target, GLuint index, GLsizei count, const GLint* params ) { }
-static void null_glNamedProgramLocalParametersI4uivEXT( GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint* params ) { }
-static void null_glNamedProgramStringEXT( GLuint program, GLenum target, GLenum format, GLsizei len, const void* string ) { }
+static void null_glNamedProgramLocalParameterI4uivEXT( GLuint program, GLenum target, GLuint index, const GLuint *params ) { }
+static void null_glNamedProgramLocalParameters4fvEXT( GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat *params ) { }
+static void null_glNamedProgramLocalParametersI4ivEXT( GLuint program, GLenum target, GLuint index, GLsizei count, const GLint *params ) { }
+static void null_glNamedProgramLocalParametersI4uivEXT( GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint *params ) { }
+static void null_glNamedProgramStringEXT( GLuint program, GLenum target, GLenum format, GLsizei len, const void *string ) { }
 static void null_glNamedRenderbufferStorage( GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height ) { }
 static void null_glNamedRenderbufferStorageEXT( GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height ) { }
 static void null_glNamedRenderbufferStorageMultisample( GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height ) { }
 static void null_glNamedRenderbufferStorageMultisampleCoverageEXT( GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height ) { }
 static void null_glNamedRenderbufferStorageMultisampleEXT( GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height ) { }
-static void null_glNamedStringARB( GLenum type, GLint namelen, const GLchar* name, GLint stringlen, const GLchar* string ) { }
+static void null_glNamedStringARB( GLenum type, GLint namelen, const GLchar *name, GLint stringlen, const GLchar *string ) { }
 static GLuint null_glNewBufferRegion( GLenum type ) { return 0; }
-static GLuint null_glNewObjectBufferATI( GLsizei size, const void* pointer, GLenum usage ) { return 0; }
+static GLuint null_glNewObjectBufferATI( GLsizei size, const void *pointer, GLenum usage ) { return 0; }
 static void null_glNormal3fVertex3fSUN( GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glNormal3fVertex3fvSUN( const GLfloat* n, const GLfloat* v ) { }
+static void null_glNormal3fVertex3fvSUN( const GLfloat *n, const GLfloat *v ) { }
 static void null_glNormal3hNV( GLhalfNV nx, GLhalfNV ny, GLhalfNV nz ) { }
-static void null_glNormal3hvNV( const GLhalfNV* v ) { }
+static void null_glNormal3hvNV( const GLhalfNV *v ) { }
 static void null_glNormal3xOES( GLfixed nx, GLfixed ny, GLfixed nz ) { }
-static void null_glNormal3xvOES( const GLfixed* coords ) { }
+static void null_glNormal3xvOES( const GLfixed *coords ) { }
 static void null_glNormalFormatNV( GLenum type, GLsizei stride ) { }
 static void null_glNormalP3ui( GLenum type, GLuint coords ) { }
-static void null_glNormalP3uiv( GLenum type, const GLuint* coords ) { }
-static void null_glNormalPointerEXT( GLenum type, GLsizei stride, GLsizei count, const void* pointer ) { }
-static void null_glNormalPointerListIBM( GLenum type, GLint stride, const void** pointer, GLint ptrstride ) { }
-static void null_glNormalPointervINTEL( GLenum type, const void** pointer ) { }
+static void null_glNormalP3uiv( GLenum type, const GLuint *coords ) { }
+static void null_glNormalPointerEXT( GLenum type, GLsizei stride, GLsizei count, const void *pointer ) { }
+static void null_glNormalPointerListIBM( GLenum type, GLint stride, const void **pointer, GLint ptrstride ) { }
+static void null_glNormalPointervINTEL( GLenum type, const void **pointer ) { }
 static void null_glNormalStream3bATI( GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz ) { }
-static void null_glNormalStream3bvATI( GLenum stream, const GLbyte* coords ) { }
+static void null_glNormalStream3bvATI( GLenum stream, const GLbyte *coords ) { }
 static void null_glNormalStream3dATI( GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz ) { }
-static void null_glNormalStream3dvATI( GLenum stream, const GLdouble* coords ) { }
+static void null_glNormalStream3dvATI( GLenum stream, const GLdouble *coords ) { }
 static void null_glNormalStream3fATI( GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz ) { }
-static void null_glNormalStream3fvATI( GLenum stream, const GLfloat* coords ) { }
+static void null_glNormalStream3fvATI( GLenum stream, const GLfloat *coords ) { }
 static void null_glNormalStream3iATI( GLenum stream, GLint nx, GLint ny, GLint nz ) { }
-static void null_glNormalStream3ivATI( GLenum stream, const GLint* coords ) { }
+static void null_glNormalStream3ivATI( GLenum stream, const GLint *coords ) { }
 static void null_glNormalStream3sATI( GLenum stream, GLshort nx, GLshort ny, GLshort nz ) { }
-static void null_glNormalStream3svATI( GLenum stream, const GLshort* coords ) { }
-static void null_glObjectLabel( GLenum identifier, GLuint name, GLsizei length, const GLchar* label ) { }
-static void null_glObjectPtrLabel( const void* ptr, GLsizei length, const GLchar* label ) { }
+static void null_glNormalStream3svATI( GLenum stream, const GLshort *coords ) { }
+static void null_glObjectLabel( GLenum identifier, GLuint name, GLsizei length, const GLchar *label ) { }
+static void null_glObjectPtrLabel( const void *ptr, GLsizei length, const GLchar *label ) { }
 static GLenum null_glObjectPurgeableAPPLE( GLenum objectType, GLuint name, GLenum option ) { return 0; }
 static GLenum null_glObjectUnpurgeableAPPLE( GLenum objectType, GLuint name, GLenum option ) { return 0; }
 static void null_glOrthofOES( GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f ) { }
@@ -3834,321 +4168,321 @@
 static void null_glPNTrianglesiATI( GLenum pname, GLint param ) { }
 static void null_glPassTexCoordATI( GLuint dst, GLuint coord, GLenum swizzle ) { }
 static void null_glPassThroughxOES( GLfixed token ) { }
-static void null_glPatchParameterfv( GLenum pname, const GLfloat* values ) { }
+static void null_glPatchParameterfv( GLenum pname, const GLfloat *values ) { }
 static void null_glPatchParameteri( GLenum pname, GLint value ) { }
-static void null_glPathColorGenNV( GLenum color, GLenum genMode, GLenum colorFormat, const GLfloat* coeffs ) { }
-static void null_glPathCommandsNV( GLuint path, GLsizei numCommands, const GLubyte* commands, GLsizei numCoords, GLenum coordType, const void* coords ) { }
-static void null_glPathCoordsNV( GLuint path, GLsizei numCoords, GLenum coordType, const void* coords ) { }
+static void null_glPathColorGenNV( GLenum color, GLenum genMode, GLenum colorFormat, const GLfloat *coeffs ) { }
+static void null_glPathCommandsNV( GLuint path, GLsizei numCommands, const GLubyte *commands, GLsizei numCoords, GLenum coordType, const void *coords ) { }
+static void null_glPathCoordsNV( GLuint path, GLsizei numCoords, GLenum coordType, const void *coords ) { }
 static void null_glPathCoverDepthFuncNV( GLenum func ) { }
-static void null_glPathDashArrayNV( GLuint path, GLsizei dashCount, const GLfloat* dashArray ) { }
+static void null_glPathDashArrayNV( GLuint path, GLsizei dashCount, const GLfloat *dashArray ) { }
 static void null_glPathFogGenNV( GLenum genMode ) { }
-static GLenum null_glPathGlyphIndexArrayNV( GLuint firstPathName, GLenum fontTarget, const void* fontName, GLbitfield fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale ) { return 0; }
-static GLenum null_glPathGlyphIndexRangeNV( GLenum fontTarget, const void* fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint baseAndCount[2] ) { return 0; }
-static void null_glPathGlyphRangeNV( GLuint firstPathName, GLenum fontTarget, const void* fontName, GLbitfield fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale ) { }
-static void null_glPathGlyphsNV( GLuint firstPathName, GLenum fontTarget, const void* fontName, GLbitfield fontStyle, GLsizei numGlyphs, GLenum type, const void* charcodes, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale ) { }
-static GLenum null_glPathMemoryGlyphIndexArrayNV( GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, const void* fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale ) { return 0; }
+static GLenum null_glPathGlyphIndexArrayNV( GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale ) { return 0; }
+static GLenum null_glPathGlyphIndexRangeNV( GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint baseAndCount[2] ) { return 0; }
+static void null_glPathGlyphRangeNV( GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale ) { }
+static void null_glPathGlyphsNV( GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLsizei numGlyphs, GLenum type, const void *charcodes, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale ) { }
+static GLenum null_glPathMemoryGlyphIndexArrayNV( GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, const void *fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale ) { return 0; }
 static void null_glPathParameterfNV( GLuint path, GLenum pname, GLfloat value ) { }
-static void null_glPathParameterfvNV( GLuint path, GLenum pname, const GLfloat* value ) { }
+static void null_glPathParameterfvNV( GLuint path, GLenum pname, const GLfloat *value ) { }
 static void null_glPathParameteriNV( GLuint path, GLenum pname, GLint value ) { }
-static void null_glPathParameterivNV( GLuint path, GLenum pname, const GLint* value ) { }
+static void null_glPathParameterivNV( GLuint path, GLenum pname, const GLint *value ) { }
 static void null_glPathStencilDepthOffsetNV( GLfloat factor, GLfloat units ) { }
 static void null_glPathStencilFuncNV( GLenum func, GLint ref, GLuint mask ) { }
-static void null_glPathStringNV( GLuint path, GLenum format, GLsizei length, const void* pathString ) { }
-static void null_glPathSubCommandsNV( GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, const GLubyte* commands, GLsizei numCoords, GLenum coordType, const void* coords ) { }
-static void null_glPathSubCoordsNV( GLuint path, GLsizei coordStart, GLsizei numCoords, GLenum coordType, const void* coords ) { }
-static void null_glPathTexGenNV( GLenum texCoordSet, GLenum genMode, GLint components, const GLfloat* coeffs ) { }
-static void null_glPauseTransformFeedback( void ) { }
-static void null_glPauseTransformFeedbackNV( void ) { }
-static void null_glPixelDataRangeNV( GLenum target, GLsizei length, const void* pointer ) { }
-static void null_glPixelMapx( GLenum map, GLint size, const GLfixed* values ) { }
+static void null_glPathStringNV( GLuint path, GLenum format, GLsizei length, const void *pathString ) { }
+static void null_glPathSubCommandsNV( GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, const GLubyte *commands, GLsizei numCoords, GLenum coordType, const void *coords ) { }
+static void null_glPathSubCoordsNV( GLuint path, GLsizei coordStart, GLsizei numCoords, GLenum coordType, const void *coords ) { }
+static void null_glPathTexGenNV( GLenum texCoordSet, GLenum genMode, GLint components, const GLfloat *coeffs ) { }
+static void null_glPauseTransformFeedback(void) { }
+static void null_glPauseTransformFeedbackNV(void) { }
+static void null_glPixelDataRangeNV( GLenum target, GLsizei length, const void *pointer ) { }
+static void null_glPixelMapx( GLenum map, GLint size, const GLfixed *values ) { }
 static void null_glPixelStorex( GLenum pname, GLfixed param ) { }
 static void null_glPixelTexGenParameterfSGIS( GLenum pname, GLfloat param ) { }
-static void null_glPixelTexGenParameterfvSGIS( GLenum pname, const GLfloat* params ) { }
+static void null_glPixelTexGenParameterfvSGIS( GLenum pname, const GLfloat *params ) { }
 static void null_glPixelTexGenParameteriSGIS( GLenum pname, GLint param ) { }
-static void null_glPixelTexGenParameterivSGIS( GLenum pname, const GLint* params ) { }
+static void null_glPixelTexGenParameterivSGIS( GLenum pname, const GLint *params ) { }
 static void null_glPixelTexGenSGIX( GLenum mode ) { }
 static void null_glPixelTransferxOES( GLenum pname, GLfixed param ) { }
 static void null_glPixelTransformParameterfEXT( GLenum target, GLenum pname, GLfloat param ) { }
-static void null_glPixelTransformParameterfvEXT( GLenum target, GLenum pname, const GLfloat* params ) { }
+static void null_glPixelTransformParameterfvEXT( GLenum target, GLenum pname, const GLfloat *params ) { }
 static void null_glPixelTransformParameteriEXT( GLenum target, GLenum pname, GLint param ) { }
-static void null_glPixelTransformParameterivEXT( GLenum target, GLenum pname, const GLint* params ) { }
+static void null_glPixelTransformParameterivEXT( GLenum target, GLenum pname, const GLint *params ) { }
 static void null_glPixelZoomxOES( GLfixed xfactor, GLfixed yfactor ) { }
-static GLboolean null_glPointAlongPathNV( GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat* x, GLfloat* y, GLfloat* tangentX, GLfloat* tangentY ) { return 0; }
+static GLboolean null_glPointAlongPathNV( GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat *x, GLfloat *y, GLfloat *tangentX, GLfloat *tangentY ) { return 0; }
 static void null_glPointParameterf( GLenum pname, GLfloat param ) { }
 static void null_glPointParameterfARB( GLenum pname, GLfloat param ) { }
 static void null_glPointParameterfEXT( GLenum pname, GLfloat param ) { }
 static void null_glPointParameterfSGIS( GLenum pname, GLfloat param ) { }
-static void null_glPointParameterfv( GLenum pname, const GLfloat* params ) { }
-static void null_glPointParameterfvARB( GLenum pname, const GLfloat* params ) { }
-static void null_glPointParameterfvEXT( GLenum pname, const GLfloat* params ) { }
-static void null_glPointParameterfvSGIS( GLenum pname, const GLfloat* params ) { }
+static void null_glPointParameterfv( GLenum pname, const GLfloat *params ) { }
+static void null_glPointParameterfvARB( GLenum pname, const GLfloat *params ) { }
+static void null_glPointParameterfvEXT( GLenum pname, const GLfloat *params ) { }
+static void null_glPointParameterfvSGIS( GLenum pname, const GLfloat *params ) { }
 static void null_glPointParameteri( GLenum pname, GLint param ) { }
 static void null_glPointParameteriNV( GLenum pname, GLint param ) { }
-static void null_glPointParameteriv( GLenum pname, const GLint* params ) { }
-static void null_glPointParameterivNV( GLenum pname, const GLint* params ) { }
-static void null_glPointParameterxvOES( GLenum pname, const GLfixed* params ) { }
+static void null_glPointParameteriv( GLenum pname, const GLint *params ) { }
+static void null_glPointParameterivNV( GLenum pname, const GLint *params ) { }
+static void null_glPointParameterxvOES( GLenum pname, const GLfixed *params ) { }
 static void null_glPointSizexOES( GLfixed size ) { }
-static GLint null_glPollAsyncSGIX( GLuint* markerp ) { return 0; }
-static GLint null_glPollInstrumentsSGIX( GLint* marker_p ) { return 0; }
+static GLint null_glPollAsyncSGIX( GLuint *markerp ) { return 0; }
+static GLint null_glPollInstrumentsSGIX( GLint *marker_p ) { return 0; }
 static void null_glPolygonOffsetClamp( GLfloat factor, GLfloat units, GLfloat clamp ) { }
 static void null_glPolygonOffsetClampEXT( GLfloat factor, GLfloat units, GLfloat clamp ) { }
 static void null_glPolygonOffsetEXT( GLfloat factor, GLfloat bias ) { }
 static void null_glPolygonOffsetxOES( GLfixed factor, GLfixed units ) { }
-static void null_glPopDebugGroup( void ) { }
-static void null_glPopGroupMarkerEXT( void ) { }
+static void null_glPopDebugGroup(void) { }
+static void null_glPopGroupMarkerEXT(void) { }
 static void null_glPresentFrameDualFillNV( GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLenum target1, GLuint fill1, GLenum target2, GLuint fill2, GLenum target3, GLuint fill3 ) { }
 static void null_glPresentFrameKeyedNV( GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1 ) { }
 static void null_glPrimitiveBoundingBoxARB( GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW ) { }
 static void null_glPrimitiveRestartIndex( GLuint index ) { }
 static void null_glPrimitiveRestartIndexNV( GLuint index ) { }
-static void null_glPrimitiveRestartNV( void ) { }
-static void null_glPrioritizeTexturesEXT( GLsizei n, const GLuint* textures, const GLclampf* priorities ) { }
-static void null_glPrioritizeTexturesxOES( GLsizei n, const GLuint* textures, const GLfixed* priorities ) { }
-static void null_glProgramBinary( GLuint program, GLenum binaryFormat, const void* binary, GLsizei length ) { }
-static void null_glProgramBufferParametersIivNV( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLint* params ) { }
-static void null_glProgramBufferParametersIuivNV( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLuint* params ) { }
-static void null_glProgramBufferParametersfvNV( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLfloat* params ) { }
+static void null_glPrimitiveRestartNV(void) { }
+static void null_glPrioritizeTexturesEXT( GLsizei n, const GLuint *textures, const GLclampf *priorities ) { }
+static void null_glPrioritizeTexturesxOES( GLsizei n, const GLuint *textures, const GLfixed *priorities ) { }
+static void null_glProgramBinary( GLuint program, GLenum binaryFormat, const void *binary, GLsizei length ) { }
+static void null_glProgramBufferParametersIivNV( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLint *params ) { }
+static void null_glProgramBufferParametersIuivNV( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLuint *params ) { }
+static void null_glProgramBufferParametersfvNV( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLfloat *params ) { }
 static void null_glProgramEnvParameter4dARB( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
-static void null_glProgramEnvParameter4dvARB( GLenum target, GLuint index, const GLdouble* params ) { }
+static void null_glProgramEnvParameter4dvARB( GLenum target, GLuint index, const GLdouble *params ) { }
 static void null_glProgramEnvParameter4fARB( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { }
-static void null_glProgramEnvParameter4fvARB( GLenum target, GLuint index, const GLfloat* params ) { }
+static void null_glProgramEnvParameter4fvARB( GLenum target, GLuint index, const GLfloat *params ) { }
 static void null_glProgramEnvParameterI4iNV( GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w ) { }
-static void null_glProgramEnvParameterI4ivNV( GLenum target, GLuint index, const GLint* params ) { }
+static void null_glProgramEnvParameterI4ivNV( GLenum target, GLuint index, const GLint *params ) { }
 static void null_glProgramEnvParameterI4uiNV( GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) { }
-static void null_glProgramEnvParameterI4uivNV( GLenum target, GLuint index, const GLuint* params ) { }
-static void null_glProgramEnvParameters4fvEXT( GLenum target, GLuint index, GLsizei count, const GLfloat* params ) { }
-static void null_glProgramEnvParametersI4ivNV( GLenum target, GLuint index, GLsizei count, const GLint* params ) { }
-static void null_glProgramEnvParametersI4uivNV( GLenum target, GLuint index, GLsizei count, const GLuint* params ) { }
+static void null_glProgramEnvParameterI4uivNV( GLenum target, GLuint index, const GLuint *params ) { }
+static void null_glProgramEnvParameters4fvEXT( GLenum target, GLuint index, GLsizei count, const GLfloat *params ) { }
+static void null_glProgramEnvParametersI4ivNV( GLenum target, GLuint index, GLsizei count, const GLint *params ) { }
+static void null_glProgramEnvParametersI4uivNV( GLenum target, GLuint index, GLsizei count, const GLuint *params ) { }
 static void null_glProgramLocalParameter4dARB( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
-static void null_glProgramLocalParameter4dvARB( GLenum target, GLuint index, const GLdouble* params ) { }
+static void null_glProgramLocalParameter4dvARB( GLenum target, GLuint index, const GLdouble *params ) { }
 static void null_glProgramLocalParameter4fARB( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { }
-static void null_glProgramLocalParameter4fvARB( GLenum target, GLuint index, const GLfloat* params ) { }
+static void null_glProgramLocalParameter4fvARB( GLenum target, GLuint index, const GLfloat *params ) { }
 static void null_glProgramLocalParameterI4iNV( GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w ) { }
-static void null_glProgramLocalParameterI4ivNV( GLenum target, GLuint index, const GLint* params ) { }
+static void null_glProgramLocalParameterI4ivNV( GLenum target, GLuint index, const GLint *params ) { }
 static void null_glProgramLocalParameterI4uiNV( GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) { }
-static void null_glProgramLocalParameterI4uivNV( GLenum target, GLuint index, const GLuint* params ) { }
-static void null_glProgramLocalParameters4fvEXT( GLenum target, GLuint index, GLsizei count, const GLfloat* params ) { }
-static void null_glProgramLocalParametersI4ivNV( GLenum target, GLuint index, GLsizei count, const GLint* params ) { }
-static void null_glProgramLocalParametersI4uivNV( GLenum target, GLuint index, GLsizei count, const GLuint* params ) { }
-static void null_glProgramNamedParameter4dNV( GLuint id, GLsizei len, const GLubyte* name, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
-static void null_glProgramNamedParameter4dvNV( GLuint id, GLsizei len, const GLubyte* name, const GLdouble* v ) { }
-static void null_glProgramNamedParameter4fNV( GLuint id, GLsizei len, const GLubyte* name, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { }
-static void null_glProgramNamedParameter4fvNV( GLuint id, GLsizei len, const GLubyte* name, const GLfloat* v ) { }
+static void null_glProgramLocalParameterI4uivNV( GLenum target, GLuint index, const GLuint *params ) { }
+static void null_glProgramLocalParameters4fvEXT( GLenum target, GLuint index, GLsizei count, const GLfloat *params ) { }
+static void null_glProgramLocalParametersI4ivNV( GLenum target, GLuint index, GLsizei count, const GLint *params ) { }
+static void null_glProgramLocalParametersI4uivNV( GLenum target, GLuint index, GLsizei count, const GLuint *params ) { }
+static void null_glProgramNamedParameter4dNV( GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
+static void null_glProgramNamedParameter4dvNV( GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v ) { }
+static void null_glProgramNamedParameter4fNV( GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { }
+static void null_glProgramNamedParameter4fvNV( GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v ) { }
 static void null_glProgramParameter4dNV( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
-static void null_glProgramParameter4dvNV( GLenum target, GLuint index, const GLdouble* v ) { }
+static void null_glProgramParameter4dvNV( GLenum target, GLuint index, const GLdouble *v ) { }
 static void null_glProgramParameter4fNV( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { }
-static void null_glProgramParameter4fvNV( GLenum target, GLuint index, const GLfloat* v ) { }
+static void null_glProgramParameter4fvNV( GLenum target, GLuint index, const GLfloat *v ) { }
 static void null_glProgramParameteri( GLuint program, GLenum pname, GLint value ) { }
 static void null_glProgramParameteriARB( GLuint program, GLenum pname, GLint value ) { }
 static void null_glProgramParameteriEXT( GLuint program, GLenum pname, GLint value ) { }
-static void null_glProgramParameters4dvNV( GLenum target, GLuint index, GLsizei count, const GLdouble* v ) { }
-static void null_glProgramParameters4fvNV( GLenum target, GLuint index, GLsizei count, const GLfloat* v ) { }
-static void null_glProgramPathFragmentInputGenNV( GLuint program, GLint location, GLenum genMode, GLint components, const GLfloat* coeffs ) { }
-static void null_glProgramStringARB( GLenum target, GLenum format, GLsizei len, const void* string ) { }
-static void null_glProgramSubroutineParametersuivNV( GLenum target, GLsizei count, const GLuint* params ) { }
+static void null_glProgramParameters4dvNV( GLenum target, GLuint index, GLsizei count, const GLdouble *v ) { }
+static void null_glProgramParameters4fvNV( GLenum target, GLuint index, GLsizei count, const GLfloat *v ) { }
+static void null_glProgramPathFragmentInputGenNV( GLuint program, GLint location, GLenum genMode, GLint components, const GLfloat *coeffs ) { }
+static void null_glProgramStringARB( GLenum target, GLenum format, GLsizei len, const void *string ) { }
+static void null_glProgramSubroutineParametersuivNV( GLenum target, GLsizei count, const GLuint *params ) { }
 static void null_glProgramUniform1d( GLuint program, GLint location, GLdouble v0 ) { }
 static void null_glProgramUniform1dEXT( GLuint program, GLint location, GLdouble x ) { }
-static void null_glProgramUniform1dv( GLuint program, GLint location, GLsizei count, const GLdouble* value ) { }
-static void null_glProgramUniform1dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble* value ) { }
+static void null_glProgramUniform1dv( GLuint program, GLint location, GLsizei count, const GLdouble *value ) { }
+static void null_glProgramUniform1dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble *value ) { }
 static void null_glProgramUniform1f( GLuint program, GLint location, GLfloat v0 ) { }
 static void null_glProgramUniform1fEXT( GLuint program, GLint location, GLfloat v0 ) { }
-static void null_glProgramUniform1fv( GLuint program, GLint location, GLsizei count, const GLfloat* value ) { }
-static void null_glProgramUniform1fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat* value ) { }
+static void null_glProgramUniform1fv( GLuint program, GLint location, GLsizei count, const GLfloat *value ) { }
+static void null_glProgramUniform1fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat *value ) { }
 static void null_glProgramUniform1i( GLuint program, GLint location, GLint v0 ) { }
 static void null_glProgramUniform1i64ARB( GLuint program, GLint location, GLint64 x ) { }
 static void null_glProgramUniform1i64NV( GLuint program, GLint location, GLint64EXT x ) { }
-static void null_glProgramUniform1i64vARB( GLuint program, GLint location, GLsizei count, const GLint64* value ) { }
-static void null_glProgramUniform1i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT* value ) { }
+static void null_glProgramUniform1i64vARB( GLuint program, GLint location, GLsizei count, const GLint64 *value ) { }
+static void null_glProgramUniform1i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT *value ) { }
 static void null_glProgramUniform1iEXT( GLuint program, GLint location, GLint v0 ) { }
-static void null_glProgramUniform1iv( GLuint program, GLint location, GLsizei count, const GLint* value ) { }
-static void null_glProgramUniform1ivEXT( GLuint program, GLint location, GLsizei count, const GLint* value ) { }
+static void null_glProgramUniform1iv( GLuint program, GLint location, GLsizei count, const GLint *value ) { }
+static void null_glProgramUniform1ivEXT( GLuint program, GLint location, GLsizei count, const GLint *value ) { }
 static void null_glProgramUniform1ui( GLuint program, GLint location, GLuint v0 ) { }
 static void null_glProgramUniform1ui64ARB( GLuint program, GLint location, GLuint64 x ) { }
 static void null_glProgramUniform1ui64NV( GLuint program, GLint location, GLuint64EXT x ) { }
-static void null_glProgramUniform1ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64* value ) { }
-static void null_glProgramUniform1ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT* value ) { }
+static void null_glProgramUniform1ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64 *value ) { }
+static void null_glProgramUniform1ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value ) { }
 static void null_glProgramUniform1uiEXT( GLuint program, GLint location, GLuint v0 ) { }
-static void null_glProgramUniform1uiv( GLuint program, GLint location, GLsizei count, const GLuint* value ) { }
-static void null_glProgramUniform1uivEXT( GLuint program, GLint location, GLsizei count, const GLuint* value ) { }
+static void null_glProgramUniform1uiv( GLuint program, GLint location, GLsizei count, const GLuint *value ) { }
+static void null_glProgramUniform1uivEXT( GLuint program, GLint location, GLsizei count, const GLuint *value ) { }
 static void null_glProgramUniform2d( GLuint program, GLint location, GLdouble v0, GLdouble v1 ) { }
 static void null_glProgramUniform2dEXT( GLuint program, GLint location, GLdouble x, GLdouble y ) { }
-static void null_glProgramUniform2dv( GLuint program, GLint location, GLsizei count, const GLdouble* value ) { }
-static void null_glProgramUniform2dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble* value ) { }
+static void null_glProgramUniform2dv( GLuint program, GLint location, GLsizei count, const GLdouble *value ) { }
+static void null_glProgramUniform2dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble *value ) { }
 static void null_glProgramUniform2f( GLuint program, GLint location, GLfloat v0, GLfloat v1 ) { }
 static void null_glProgramUniform2fEXT( GLuint program, GLint location, GLfloat v0, GLfloat v1 ) { }
-static void null_glProgramUniform2fv( GLuint program, GLint location, GLsizei count, const GLfloat* value ) { }
-static void null_glProgramUniform2fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat* value ) { }
+static void null_glProgramUniform2fv( GLuint program, GLint location, GLsizei count, const GLfloat *value ) { }
+static void null_glProgramUniform2fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat *value ) { }
 static void null_glProgramUniform2i( GLuint program, GLint location, GLint v0, GLint v1 ) { }
 static void null_glProgramUniform2i64ARB( GLuint program, GLint location, GLint64 x, GLint64 y ) { }
 static void null_glProgramUniform2i64NV( GLuint program, GLint location, GLint64EXT x, GLint64EXT y ) { }
-static void null_glProgramUniform2i64vARB( GLuint program, GLint location, GLsizei count, const GLint64* value ) { }
-static void null_glProgramUniform2i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT* value ) { }
+static void null_glProgramUniform2i64vARB( GLuint program, GLint location, GLsizei count, const GLint64 *value ) { }
+static void null_glProgramUniform2i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT *value ) { }
 static void null_glProgramUniform2iEXT( GLuint program, GLint location, GLint v0, GLint v1 ) { }
-static void null_glProgramUniform2iv( GLuint program, GLint location, GLsizei count, const GLint* value ) { }
-static void null_glProgramUniform2ivEXT( GLuint program, GLint location, GLsizei count, const GLint* value ) { }
+static void null_glProgramUniform2iv( GLuint program, GLint location, GLsizei count, const GLint *value ) { }
+static void null_glProgramUniform2ivEXT( GLuint program, GLint location, GLsizei count, const GLint *value ) { }
 static void null_glProgramUniform2ui( GLuint program, GLint location, GLuint v0, GLuint v1 ) { }
 static void null_glProgramUniform2ui64ARB( GLuint program, GLint location, GLuint64 x, GLuint64 y ) { }
 static void null_glProgramUniform2ui64NV( GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y ) { }
-static void null_glProgramUniform2ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64* value ) { }
-static void null_glProgramUniform2ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT* value ) { }
+static void null_glProgramUniform2ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64 *value ) { }
+static void null_glProgramUniform2ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value ) { }
 static void null_glProgramUniform2uiEXT( GLuint program, GLint location, GLuint v0, GLuint v1 ) { }
-static void null_glProgramUniform2uiv( GLuint program, GLint location, GLsizei count, const GLuint* value ) { }
-static void null_glProgramUniform2uivEXT( GLuint program, GLint location, GLsizei count, const GLuint* value ) { }
+static void null_glProgramUniform2uiv( GLuint program, GLint location, GLsizei count, const GLuint *value ) { }
+static void null_glProgramUniform2uivEXT( GLuint program, GLint location, GLsizei count, const GLuint *value ) { }
 static void null_glProgramUniform3d( GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2 ) { }
 static void null_glProgramUniform3dEXT( GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z ) { }
-static void null_glProgramUniform3dv( GLuint program, GLint location, GLsizei count, const GLdouble* value ) { }
-static void null_glProgramUniform3dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble* value ) { }
+static void null_glProgramUniform3dv( GLuint program, GLint location, GLsizei count, const GLdouble *value ) { }
+static void null_glProgramUniform3dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble *value ) { }
 static void null_glProgramUniform3f( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 ) { }
 static void null_glProgramUniform3fEXT( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 ) { }
-static void null_glProgramUniform3fv( GLuint program, GLint location, GLsizei count, const GLfloat* value ) { }
-static void null_glProgramUniform3fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat* value ) { }
+static void null_glProgramUniform3fv( GLuint program, GLint location, GLsizei count, const GLfloat *value ) { }
+static void null_glProgramUniform3fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat *value ) { }
 static void null_glProgramUniform3i( GLuint program, GLint location, GLint v0, GLint v1, GLint v2 ) { }
 static void null_glProgramUniform3i64ARB( GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z ) { }
 static void null_glProgramUniform3i64NV( GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z ) { }
-static void null_glProgramUniform3i64vARB( GLuint program, GLint location, GLsizei count, const GLint64* value ) { }
-static void null_glProgramUniform3i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT* value ) { }
+static void null_glProgramUniform3i64vARB( GLuint program, GLint location, GLsizei count, const GLint64 *value ) { }
+static void null_glProgramUniform3i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT *value ) { }
 static void null_glProgramUniform3iEXT( GLuint program, GLint location, GLint v0, GLint v1, GLint v2 ) { }
-static void null_glProgramUniform3iv( GLuint program, GLint location, GLsizei count, const GLint* value ) { }
-static void null_glProgramUniform3ivEXT( GLuint program, GLint location, GLsizei count, const GLint* value ) { }
+static void null_glProgramUniform3iv( GLuint program, GLint location, GLsizei count, const GLint *value ) { }
+static void null_glProgramUniform3ivEXT( GLuint program, GLint location, GLsizei count, const GLint *value ) { }
 static void null_glProgramUniform3ui( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 ) { }
 static void null_glProgramUniform3ui64ARB( GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z ) { }
 static void null_glProgramUniform3ui64NV( GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z ) { }
-static void null_glProgramUniform3ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64* value ) { }
-static void null_glProgramUniform3ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT* value ) { }
+static void null_glProgramUniform3ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64 *value ) { }
+static void null_glProgramUniform3ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value ) { }
 static void null_glProgramUniform3uiEXT( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 ) { }
-static void null_glProgramUniform3uiv( GLuint program, GLint location, GLsizei count, const GLuint* value ) { }
-static void null_glProgramUniform3uivEXT( GLuint program, GLint location, GLsizei count, const GLuint* value ) { }
+static void null_glProgramUniform3uiv( GLuint program, GLint location, GLsizei count, const GLuint *value ) { }
+static void null_glProgramUniform3uivEXT( GLuint program, GLint location, GLsizei count, const GLuint *value ) { }
 static void null_glProgramUniform4d( GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3 ) { }
 static void null_glProgramUniform4dEXT( GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
-static void null_glProgramUniform4dv( GLuint program, GLint location, GLsizei count, const GLdouble* value ) { }
-static void null_glProgramUniform4dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble* value ) { }
+static void null_glProgramUniform4dv( GLuint program, GLint location, GLsizei count, const GLdouble *value ) { }
+static void null_glProgramUniform4dvEXT( GLuint program, GLint location, GLsizei count, const GLdouble *value ) { }
 static void null_glProgramUniform4f( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) { }
 static void null_glProgramUniform4fEXT( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) { }
-static void null_glProgramUniform4fv( GLuint program, GLint location, GLsizei count, const GLfloat* value ) { }
-static void null_glProgramUniform4fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat* value ) { }
+static void null_glProgramUniform4fv( GLuint program, GLint location, GLsizei count, const GLfloat *value ) { }
+static void null_glProgramUniform4fvEXT( GLuint program, GLint location, GLsizei count, const GLfloat *value ) { }
 static void null_glProgramUniform4i( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 ) { }
 static void null_glProgramUniform4i64ARB( GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w ) { }
 static void null_glProgramUniform4i64NV( GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w ) { }
-static void null_glProgramUniform4i64vARB( GLuint program, GLint location, GLsizei count, const GLint64* value ) { }
-static void null_glProgramUniform4i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT* value ) { }
+static void null_glProgramUniform4i64vARB( GLuint program, GLint location, GLsizei count, const GLint64 *value ) { }
+static void null_glProgramUniform4i64vNV( GLuint program, GLint location, GLsizei count, const GLint64EXT *value ) { }
 static void null_glProgramUniform4iEXT( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 ) { }
-static void null_glProgramUniform4iv( GLuint program, GLint location, GLsizei count, const GLint* value ) { }
-static void null_glProgramUniform4ivEXT( GLuint program, GLint location, GLsizei count, const GLint* value ) { }
+static void null_glProgramUniform4iv( GLuint program, GLint location, GLsizei count, const GLint *value ) { }
+static void null_glProgramUniform4ivEXT( GLuint program, GLint location, GLsizei count, const GLint *value ) { }
 static void null_glProgramUniform4ui( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) { }
 static void null_glProgramUniform4ui64ARB( GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w ) { }
 static void null_glProgramUniform4ui64NV( GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w ) { }
-static void null_glProgramUniform4ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64* value ) { }
-static void null_glProgramUniform4ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT* value ) { }
+static void null_glProgramUniform4ui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64 *value ) { }
+static void null_glProgramUniform4ui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value ) { }
 static void null_glProgramUniform4uiEXT( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) { }
-static void null_glProgramUniform4uiv( GLuint program, GLint location, GLsizei count, const GLuint* value ) { }
-static void null_glProgramUniform4uivEXT( GLuint program, GLint location, GLsizei count, const GLuint* value ) { }
+static void null_glProgramUniform4uiv( GLuint program, GLint location, GLsizei count, const GLuint *value ) { }
+static void null_glProgramUniform4uivEXT( GLuint program, GLint location, GLsizei count, const GLuint *value ) { }
 static void null_glProgramUniformHandleui64ARB( GLuint program, GLint location, GLuint64 value ) { }
 static void null_glProgramUniformHandleui64NV( GLuint program, GLint location, GLuint64 value ) { }
-static void null_glProgramUniformHandleui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64* values ) { }
-static void null_glProgramUniformHandleui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64* values ) { }
-static void null_glProgramUniformMatrix2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glProgramUniformMatrix2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glProgramUniformMatrix2x3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix2x3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix2x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glProgramUniformMatrix2x3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glProgramUniformMatrix2x4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix2x4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix2x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glProgramUniformMatrix2x4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glProgramUniformMatrix3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glProgramUniformMatrix3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glProgramUniformMatrix3x2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix3x2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix3x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glProgramUniformMatrix3x2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glProgramUniformMatrix3x4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix3x4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix3x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glProgramUniformMatrix3x4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glProgramUniformMatrix4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glProgramUniformMatrix4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glProgramUniformMatrix4x2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix4x2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix4x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glProgramUniformMatrix4x2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glProgramUniformMatrix4x3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix4x3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glProgramUniformMatrix4x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glProgramUniformMatrix4x3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
+static void null_glProgramUniformHandleui64vARB( GLuint program, GLint location, GLsizei count, const GLuint64 *values ) { }
+static void null_glProgramUniformHandleui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64 *values ) { }
+static void null_glProgramUniformMatrix2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glProgramUniformMatrix2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glProgramUniformMatrix2x3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix2x3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix2x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glProgramUniformMatrix2x3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glProgramUniformMatrix2x4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix2x4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix2x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glProgramUniformMatrix2x4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glProgramUniformMatrix3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glProgramUniformMatrix3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glProgramUniformMatrix3x2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix3x2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix3x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glProgramUniformMatrix3x2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glProgramUniformMatrix3x4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix3x4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix3x4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glProgramUniformMatrix3x4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glProgramUniformMatrix4dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix4dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix4fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glProgramUniformMatrix4fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glProgramUniformMatrix4x2dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix4x2dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix4x2fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glProgramUniformMatrix4x2fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glProgramUniformMatrix4x3dv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix4x3dvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glProgramUniformMatrix4x3fv( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glProgramUniformMatrix4x3fvEXT( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
 static void null_glProgramUniformui64NV( GLuint program, GLint location, GLuint64EXT value ) { }
-static void null_glProgramUniformui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT* value ) { }
+static void null_glProgramUniformui64vNV( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value ) { }
 static void null_glProgramVertexLimitNV( GLenum target, GLint limit ) { }
 static void null_glProvokingVertex( GLenum mode ) { }
 static void null_glProvokingVertexEXT( GLenum mode ) { }
 static void null_glPushClientAttribDefaultEXT( GLbitfield mask ) { }
-static void null_glPushDebugGroup( GLenum source, GLuint id, GLsizei length, const GLchar* message ) { }
-static void null_glPushGroupMarkerEXT( GLsizei length, const GLchar* marker ) { }
+static void null_glPushDebugGroup( GLenum source, GLuint id, GLsizei length, const GLchar *message ) { }
+static void null_glPushGroupMarkerEXT( GLsizei length, const GLchar *marker ) { }
 static void null_glQueryCounter( GLuint id, GLenum target ) { }
-static GLbitfield null_glQueryMatrixxOES( GLfixed* mantissa, GLint* exponent ) { return 0; }
+static GLbitfield null_glQueryMatrixxOES( GLfixed *mantissa, GLint *exponent ) { return 0; }
 static void null_glQueryObjectParameteruiAMD( GLenum target, GLuint id, GLenum pname, GLuint param ) { }
-static GLint null_glQueryResourceNV( GLenum queryType, GLint tagId, GLuint bufSize, GLint* buffer ) { return 0; }
-static void null_glQueryResourceTagNV( GLint tagId, const GLchar* tagString ) { }
+static GLint null_glQueryResourceNV( GLenum queryType, GLint tagId, GLuint bufSize, GLint *buffer ) { return 0; }
+static void null_glQueryResourceTagNV( GLint tagId, const GLchar *tagString ) { }
 static void null_glRasterPos2xOES( GLfixed x, GLfixed y ) { }
-static void null_glRasterPos2xvOES( const GLfixed* coords ) { }
+static void null_glRasterPos2xvOES( const GLfixed *coords ) { }
 static void null_glRasterPos3xOES( GLfixed x, GLfixed y, GLfixed z ) { }
-static void null_glRasterPos3xvOES( const GLfixed* coords ) { }
+static void null_glRasterPos3xvOES( const GLfixed *coords ) { }
 static void null_glRasterPos4xOES( GLfixed x, GLfixed y, GLfixed z, GLfixed w ) { }
-static void null_glRasterPos4xvOES( const GLfixed* coords ) { }
+static void null_glRasterPos4xvOES( const GLfixed *coords ) { }
 static void null_glRasterSamplesEXT( GLuint samples, GLboolean fixedsamplelocations ) { }
 static void null_glReadBufferRegion( GLenum region, GLint x, GLint y, GLsizei width, GLsizei height ) { }
 static void null_glReadInstrumentsSGIX( GLint marker ) { }
-static void null_glReadnPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void* data ) { }
-static void null_glReadnPixelsARB( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void* data ) { }
+static void null_glReadnPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data ) { }
+static void null_glReadnPixelsARB( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data ) { }
 static void null_glRectxOES( GLfixed x1, GLfixed y1, GLfixed x2, GLfixed y2 ) { }
-static void null_glRectxvOES( const GLfixed* v1, const GLfixed* v2 ) { }
-static void null_glReferencePlaneSGIX( const GLdouble* equation ) { }
+static void null_glRectxvOES( const GLfixed *v1, const GLfixed *v2 ) { }
+static void null_glReferencePlaneSGIX( const GLdouble *equation ) { }
 static GLboolean null_glReleaseKeyedMutexWin32EXT( GLuint memory, GLuint64 key ) { return 0; }
-static void null_glReleaseShaderCompiler( void ) { }
+static void null_glReleaseShaderCompiler(void) { }
 static void null_glRenderGpuMaskNV( GLbitfield mask ) { }
 static void null_glRenderbufferStorage( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) { }
 static void null_glRenderbufferStorageEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height ) { }
 static void null_glRenderbufferStorageMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height ) { }
 static void null_glRenderbufferStorageMultisampleCoverageNV( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height ) { }
 static void null_glRenderbufferStorageMultisampleEXT( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height ) { }
-static void null_glReplacementCodePointerSUN( GLenum type, GLsizei stride, const void** pointer ) { }
+static void null_glReplacementCodePointerSUN( GLenum type, GLsizei stride, const void **pointer ) { }
 static void null_glReplacementCodeubSUN( GLubyte code ) { }
-static void null_glReplacementCodeubvSUN( const GLubyte* code ) { }
+static void null_glReplacementCodeubvSUN( const GLubyte *code ) { }
 static void null_glReplacementCodeuiColor3fVertex3fSUN( GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glReplacementCodeuiColor3fVertex3fvSUN( const GLuint* rc, const GLfloat* c, const GLfloat* v ) { }
+static void null_glReplacementCodeuiColor3fVertex3fvSUN( const GLuint *rc, const GLfloat *c, const GLfloat *v ) { }
 static void null_glReplacementCodeuiColor4fNormal3fVertex3fSUN( GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glReplacementCodeuiColor4fNormal3fVertex3fvSUN( const GLuint* rc, const GLfloat* c, const GLfloat* n, const GLfloat* v ) { }
+static void null_glReplacementCodeuiColor4fNormal3fVertex3fvSUN( const GLuint *rc, const GLfloat *c, const GLfloat *n, const GLfloat *v ) { }
 static void null_glReplacementCodeuiColor4ubVertex3fSUN( GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glReplacementCodeuiColor4ubVertex3fvSUN( const GLuint* rc, const GLubyte* c, const GLfloat* v ) { }
+static void null_glReplacementCodeuiColor4ubVertex3fvSUN( const GLuint *rc, const GLubyte *c, const GLfloat *v ) { }
 static void null_glReplacementCodeuiNormal3fVertex3fSUN( GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glReplacementCodeuiNormal3fVertex3fvSUN( const GLuint* rc, const GLfloat* n, const GLfloat* v ) { }
+static void null_glReplacementCodeuiNormal3fVertex3fvSUN( const GLuint *rc, const GLfloat *n, const GLfloat *v ) { }
 static void null_glReplacementCodeuiSUN( GLuint code ) { }
 static void null_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN( GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN( const GLuint* rc, const GLfloat* tc, const GLfloat* c, const GLfloat* n, const GLfloat* v ) { }
+static void null_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN( const GLuint *rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v ) { }
 static void null_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN( GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN( const GLuint* rc, const GLfloat* tc, const GLfloat* n, const GLfloat* v ) { }
+static void null_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN( const GLuint *rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v ) { }
 static void null_glReplacementCodeuiTexCoord2fVertex3fSUN( GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glReplacementCodeuiTexCoord2fVertex3fvSUN( const GLuint* rc, const GLfloat* tc, const GLfloat* v ) { }
+static void null_glReplacementCodeuiTexCoord2fVertex3fvSUN( const GLuint *rc, const GLfloat *tc, const GLfloat *v ) { }
 static void null_glReplacementCodeuiVertex3fSUN( GLuint rc, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glReplacementCodeuiVertex3fvSUN( const GLuint* rc, const GLfloat* v ) { }
-static void null_glReplacementCodeuivSUN( const GLuint* code ) { }
+static void null_glReplacementCodeuiVertex3fvSUN( const GLuint *rc, const GLfloat *v ) { }
+static void null_glReplacementCodeuivSUN( const GLuint *code ) { }
 static void null_glReplacementCodeusSUN( GLushort code ) { }
-static void null_glReplacementCodeusvSUN( const GLushort* code ) { }
-static void null_glRequestResidentProgramsNV( GLsizei n, const GLuint* programs ) { }
+static void null_glReplacementCodeusvSUN( const GLushort *code ) { }
+static void null_glRequestResidentProgramsNV( GLsizei n, const GLuint *programs ) { }
 static void null_glResetHistogram( GLenum target ) { }
 static void null_glResetHistogramEXT( GLenum target ) { }
 static void null_glResetMinmax( GLenum target ) { }
 static void null_glResetMinmaxEXT( GLenum target ) { }
-static void null_glResizeBuffersMESA( void ) { }
-static void null_glResolveDepthValuesNV( void ) { }
-static void null_glResumeTransformFeedback( void ) { }
-static void null_glResumeTransformFeedbackNV( void ) { }
+static void null_glResizeBuffersMESA(void) { }
+static void null_glResolveDepthValuesNV(void) { }
+static void null_glResumeTransformFeedback(void) { }
+static void null_glResumeTransformFeedbackNV(void) { }
 static void null_glRotatexOES( GLfixed angle, GLfixed x, GLfixed y, GLfixed z ) { }
 static void null_glSampleCoverage( GLfloat value, GLboolean invert ) { }
 static void null_glSampleCoverageARB( GLfloat value, GLboolean invert ) { }
@@ -4159,89 +4493,89 @@
 static void null_glSampleMaski( GLuint maskNumber, GLbitfield mask ) { }
 static void null_glSamplePatternEXT( GLenum pattern ) { }
 static void null_glSamplePatternSGIS( GLenum pattern ) { }
-static void null_glSamplerParameterIiv( GLuint sampler, GLenum pname, const GLint* param ) { }
-static void null_glSamplerParameterIuiv( GLuint sampler, GLenum pname, const GLuint* param ) { }
+static void null_glSamplerParameterIiv( GLuint sampler, GLenum pname, const GLint *param ) { }
+static void null_glSamplerParameterIuiv( GLuint sampler, GLenum pname, const GLuint *param ) { }
 static void null_glSamplerParameterf( GLuint sampler, GLenum pname, GLfloat param ) { }
-static void null_glSamplerParameterfv( GLuint sampler, GLenum pname, const GLfloat* param ) { }
+static void null_glSamplerParameterfv( GLuint sampler, GLenum pname, const GLfloat *param ) { }
 static void null_glSamplerParameteri( GLuint sampler, GLenum pname, GLint param ) { }
-static void null_glSamplerParameteriv( GLuint sampler, GLenum pname, const GLint* param ) { }
+static void null_glSamplerParameteriv( GLuint sampler, GLenum pname, const GLint *param ) { }
 static void null_glScalexOES( GLfixed x, GLfixed y, GLfixed z ) { }
-static void null_glScissorArrayv( GLuint first, GLsizei count, const GLint* v ) { }
+static void null_glScissorArrayv( GLuint first, GLsizei count, const GLint *v ) { }
 static void null_glScissorIndexed( GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height ) { }
-static void null_glScissorIndexedv( GLuint index, const GLint* v ) { }
+static void null_glScissorIndexedv( GLuint index, const GLint *v ) { }
 static void null_glSecondaryColor3b( GLbyte red, GLbyte green, GLbyte blue ) { }
 static void null_glSecondaryColor3bEXT( GLbyte red, GLbyte green, GLbyte blue ) { }
-static void null_glSecondaryColor3bv( const GLbyte* v ) { }
-static void null_glSecondaryColor3bvEXT( const GLbyte* v ) { }
+static void null_glSecondaryColor3bv( const GLbyte *v ) { }
+static void null_glSecondaryColor3bvEXT( const GLbyte *v ) { }
 static void null_glSecondaryColor3d( GLdouble red, GLdouble green, GLdouble blue ) { }
 static void null_glSecondaryColor3dEXT( GLdouble red, GLdouble green, GLdouble blue ) { }
-static void null_glSecondaryColor3dv( const GLdouble* v ) { }
-static void null_glSecondaryColor3dvEXT( const GLdouble* v ) { }
+static void null_glSecondaryColor3dv( const GLdouble *v ) { }
+static void null_glSecondaryColor3dvEXT( const GLdouble *v ) { }
 static void null_glSecondaryColor3f( GLfloat red, GLfloat green, GLfloat blue ) { }
 static void null_glSecondaryColor3fEXT( GLfloat red, GLfloat green, GLfloat blue ) { }
-static void null_glSecondaryColor3fv( const GLfloat* v ) { }
-static void null_glSecondaryColor3fvEXT( const GLfloat* v ) { }
+static void null_glSecondaryColor3fv( const GLfloat *v ) { }
+static void null_glSecondaryColor3fvEXT( const GLfloat *v ) { }
 static void null_glSecondaryColor3hNV( GLhalfNV red, GLhalfNV green, GLhalfNV blue ) { }
-static void null_glSecondaryColor3hvNV( const GLhalfNV* v ) { }
+static void null_glSecondaryColor3hvNV( const GLhalfNV *v ) { }
 static void null_glSecondaryColor3i( GLint red, GLint green, GLint blue ) { }
 static void null_glSecondaryColor3iEXT( GLint red, GLint green, GLint blue ) { }
-static void null_glSecondaryColor3iv( const GLint* v ) { }
-static void null_glSecondaryColor3ivEXT( const GLint* v ) { }
+static void null_glSecondaryColor3iv( const GLint *v ) { }
+static void null_glSecondaryColor3ivEXT( const GLint *v ) { }
 static void null_glSecondaryColor3s( GLshort red, GLshort green, GLshort blue ) { }
 static void null_glSecondaryColor3sEXT( GLshort red, GLshort green, GLshort blue ) { }
-static void null_glSecondaryColor3sv( const GLshort* v ) { }
-static void null_glSecondaryColor3svEXT( const GLshort* v ) { }
+static void null_glSecondaryColor3sv( const GLshort *v ) { }
+static void null_glSecondaryColor3svEXT( const GLshort *v ) { }
 static void null_glSecondaryColor3ub( GLubyte red, GLubyte green, GLubyte blue ) { }
 static void null_glSecondaryColor3ubEXT( GLubyte red, GLubyte green, GLubyte blue ) { }
-static void null_glSecondaryColor3ubv( const GLubyte* v ) { }
-static void null_glSecondaryColor3ubvEXT( const GLubyte* v ) { }
+static void null_glSecondaryColor3ubv( const GLubyte *v ) { }
+static void null_glSecondaryColor3ubvEXT( const GLubyte *v ) { }
 static void null_glSecondaryColor3ui( GLuint red, GLuint green, GLuint blue ) { }
 static void null_glSecondaryColor3uiEXT( GLuint red, GLuint green, GLuint blue ) { }
-static void null_glSecondaryColor3uiv( const GLuint* v ) { }
-static void null_glSecondaryColor3uivEXT( const GLuint* v ) { }
+static void null_glSecondaryColor3uiv( const GLuint *v ) { }
+static void null_glSecondaryColor3uivEXT( const GLuint *v ) { }
 static void null_glSecondaryColor3us( GLushort red, GLushort green, GLushort blue ) { }
 static void null_glSecondaryColor3usEXT( GLushort red, GLushort green, GLushort blue ) { }
-static void null_glSecondaryColor3usv( const GLushort* v ) { }
-static void null_glSecondaryColor3usvEXT( const GLushort* v ) { }
+static void null_glSecondaryColor3usv( const GLushort *v ) { }
+static void null_glSecondaryColor3usvEXT( const GLushort *v ) { }
 static void null_glSecondaryColorFormatNV( GLint size, GLenum type, GLsizei stride ) { }
 static void null_glSecondaryColorP3ui( GLenum type, GLuint color ) { }
-static void null_glSecondaryColorP3uiv( GLenum type, const GLuint* color ) { }
-static void null_glSecondaryColorPointer( GLint size, GLenum type, GLsizei stride, const void* pointer ) { }
-static void null_glSecondaryColorPointerEXT( GLint size, GLenum type, GLsizei stride, const void* pointer ) { }
-static void null_glSecondaryColorPointerListIBM( GLint size, GLenum type, GLint stride, const void** pointer, GLint ptrstride ) { }
-static void null_glSelectPerfMonitorCountersAMD( GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint* counterList ) { }
+static void null_glSecondaryColorP3uiv( GLenum type, const GLuint *color ) { }
+static void null_glSecondaryColorPointer( GLint size, GLenum type, GLsizei stride, const void *pointer ) { }
+static void null_glSecondaryColorPointerEXT( GLint size, GLenum type, GLsizei stride, const void *pointer ) { }
+static void null_glSecondaryColorPointerListIBM( GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride ) { }
+static void null_glSelectPerfMonitorCountersAMD( GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint *counterList ) { }
 static void null_glSelectTextureCoordSetSGIS( GLenum target ) { }
 static void null_glSelectTextureSGIS( GLenum target ) { }
-static void null_glSemaphoreParameterui64vEXT( GLuint semaphore, GLenum pname, const GLuint64* params ) { }
-static void null_glSeparableFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* row, const void* column ) { }
-static void null_glSeparableFilter2DEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* row, const void* column ) { }
+static void null_glSemaphoreParameterui64vEXT( GLuint semaphore, GLenum pname, const GLuint64 *params ) { }
+static void null_glSeparableFilter2D( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column ) { }
+static void null_glSeparableFilter2DEXT( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column ) { }
 static void null_glSetFenceAPPLE( GLuint fence ) { }
 static void null_glSetFenceNV( GLuint fence, GLenum condition ) { }
-static void null_glSetFragmentShaderConstantATI( GLuint dst, const GLfloat* value ) { }
-static void null_glSetInvariantEXT( GLuint id, GLenum type, const void* addr ) { }
-static void null_glSetLocalConstantEXT( GLuint id, GLenum type, const void* addr ) { }
-static void null_glSetMultisamplefvAMD( GLenum pname, GLuint index, const GLfloat* val ) { }
-static void null_glShaderBinary( GLsizei count, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length ) { }
+static void null_glSetFragmentShaderConstantATI( GLuint dst, const GLfloat *value ) { }
+static void null_glSetInvariantEXT( GLuint id, GLenum type, const void *addr ) { }
+static void null_glSetLocalConstantEXT( GLuint id, GLenum type, const void *addr ) { }
+static void null_glSetMultisamplefvAMD( GLenum pname, GLuint index, const GLfloat *val ) { }
+static void null_glShaderBinary( GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length ) { }
 static void null_glShaderOp1EXT( GLenum op, GLuint res, GLuint arg1 ) { }
 static void null_glShaderOp2EXT( GLenum op, GLuint res, GLuint arg1, GLuint arg2 ) { }
 static void null_glShaderOp3EXT( GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3 ) { }
-static void null_glShaderSource( GLuint shader, GLsizei count, const GLchar*const* string, const GLint* length ) { }
-static void null_glShaderSourceARB( GLhandleARB shaderObj, GLsizei count, const GLcharARB** string, const GLint* length ) { }
+static void null_glShaderSource( GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length ) { }
+static void null_glShaderSourceARB( GLhandleARB shaderObj, GLsizei count, const GLcharARB **string, const GLint *length ) { }
 static void null_glShaderStorageBlockBinding( GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding ) { }
-static void null_glSharpenTexFuncSGIS( GLenum target, GLsizei n, const GLfloat* points ) { }
-static void null_glSignalSemaphoreEXT( GLuint semaphore, GLuint numBufferBarriers, const GLuint* buffers, GLuint numTextureBarriers, const GLuint* textures, const GLenum* dstLayouts ) { }
+static void null_glSharpenTexFuncSGIS( GLenum target, GLsizei n, const GLfloat *points ) { }
+static void null_glSignalSemaphoreEXT( GLuint semaphore, GLuint numBufferBarriers, const GLuint *buffers, GLuint numTextureBarriers, const GLuint *textures, const GLenum *dstLayouts ) { }
 static void null_glSignalVkFenceNV( GLuint64 vkFence ) { }
 static void null_glSignalVkSemaphoreNV( GLuint64 vkSemaphore ) { }
-static void null_glSpecializeShader( GLuint shader, const GLchar* pEntryPoint, GLuint numSpecializationConstants, const GLuint* pConstantIndex, const GLuint* pConstantValue ) { }
-static void null_glSpecializeShaderARB( GLuint shader, const GLchar* pEntryPoint, GLuint numSpecializationConstants, const GLuint* pConstantIndex, const GLuint* pConstantValue ) { }
+static void null_glSpecializeShader( GLuint shader, const GLchar *pEntryPoint, GLuint numSpecializationConstants, const GLuint *pConstantIndex, const GLuint *pConstantValue ) { }
+static void null_glSpecializeShaderARB( GLuint shader, const GLchar *pEntryPoint, GLuint numSpecializationConstants, const GLuint *pConstantIndex, const GLuint *pConstantValue ) { }
 static void null_glSpriteParameterfSGIX( GLenum pname, GLfloat param ) { }
-static void null_glSpriteParameterfvSGIX( GLenum pname, const GLfloat* params ) { }
+static void null_glSpriteParameterfvSGIX( GLenum pname, const GLfloat *params ) { }
 static void null_glSpriteParameteriSGIX( GLenum pname, GLint param ) { }
-static void null_glSpriteParameterivSGIX( GLenum pname, const GLint* params ) { }
-static void null_glStartInstrumentsSGIX( void ) { }
+static void null_glSpriteParameterivSGIX( GLenum pname, const GLint *params ) { }
+static void null_glStartInstrumentsSGIX(void) { }
 static void null_glStateCaptureNV( GLuint state, GLenum mode ) { }
 static void null_glStencilClearTagEXT( GLsizei stencilTagBits, GLuint stencilClearTag ) { }
-static void null_glStencilFillPathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, const GLfloat* transformValues ) { }
+static void null_glStencilFillPathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, const GLfloat *transformValues ) { }
 static void null_glStencilFillPathNV( GLuint path, GLenum fillMode, GLuint mask ) { }
 static void null_glStencilFuncSeparate( GLenum face, GLenum func, GLint ref, GLuint mask ) { }
 static void null_glStencilFuncSeparateATI( GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask ) { }
@@ -4249,29 +4583,29 @@
 static void null_glStencilOpSeparate( GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass ) { }
 static void null_glStencilOpSeparateATI( GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass ) { }
 static void null_glStencilOpValueAMD( GLenum face, GLuint value ) { }
-static void null_glStencilStrokePathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, const GLfloat* transformValues ) { }
+static void null_glStencilStrokePathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, const GLfloat *transformValues ) { }
 static void null_glStencilStrokePathNV( GLuint path, GLint reference, GLuint mask ) { }
-static void null_glStencilThenCoverFillPathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat* transformValues ) { }
+static void null_glStencilThenCoverFillPathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat *transformValues ) { }
 static void null_glStencilThenCoverFillPathNV( GLuint path, GLenum fillMode, GLuint mask, GLenum coverMode ) { }
-static void null_glStencilThenCoverStrokePathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLint reference, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat* transformValues ) { }
+static void null_glStencilThenCoverStrokePathInstancedNV( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLint reference, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat *transformValues ) { }
 static void null_glStencilThenCoverStrokePathNV( GLuint path, GLint reference, GLuint mask, GLenum coverMode ) { }
 static void null_glStopInstrumentsSGIX( GLint marker ) { }
-static void null_glStringMarkerGREMEDY( GLsizei len, const void* string ) { }
+static void null_glStringMarkerGREMEDY( GLsizei len, const void *string ) { }
 static void null_glSubpixelPrecisionBiasNV( GLuint xbits, GLuint ybits ) { }
 static void null_glSwizzleEXT( GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW ) { }
 static void null_glSyncTextureINTEL( GLuint texture ) { }
-static void null_glTagSampleBufferSGIX( void ) { }
+static void null_glTagSampleBufferSGIX(void) { }
 static void null_glTangent3bEXT( GLbyte tx, GLbyte ty, GLbyte tz ) { }
-static void null_glTangent3bvEXT( const GLbyte* v ) { }
+static void null_glTangent3bvEXT( const GLbyte *v ) { }
 static void null_glTangent3dEXT( GLdouble tx, GLdouble ty, GLdouble tz ) { }
-static void null_glTangent3dvEXT( const GLdouble* v ) { }
+static void null_glTangent3dvEXT( const GLdouble *v ) { }
 static void null_glTangent3fEXT( GLfloat tx, GLfloat ty, GLfloat tz ) { }
-static void null_glTangent3fvEXT( const GLfloat* v ) { }
+static void null_glTangent3fvEXT( const GLfloat *v ) { }
 static void null_glTangent3iEXT( GLint tx, GLint ty, GLint tz ) { }
-static void null_glTangent3ivEXT( const GLint* v ) { }
+static void null_glTangent3ivEXT( const GLint *v ) { }
 static void null_glTangent3sEXT( GLshort tx, GLshort ty, GLshort tz ) { }
-static void null_glTangent3svEXT( const GLshort* v ) { }
-static void null_glTangentPointerEXT( GLenum type, GLsizei stride, const void* pointer ) { }
+static void null_glTangent3svEXT( const GLshort *v ) { }
+static void null_glTangentPointerEXT( GLenum type, GLsizei stride, const void *pointer ) { }
 static void null_glTbufferMask3DFX( GLuint mask ) { }
 static void null_glTessellationFactorAMD( GLfloat factor ) { }
 static void null_glTessellationModeAMD( GLenum mode ) { }
@@ -4282,77 +4616,77 @@
 static void null_glTexBufferARB( GLenum target, GLenum internalformat, GLuint buffer ) { }
 static void null_glTexBufferEXT( GLenum target, GLenum internalformat, GLuint buffer ) { }
 static void null_glTexBufferRange( GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size ) { }
-static void null_glTexBumpParameterfvATI( GLenum pname, const GLfloat* param ) { }
-static void null_glTexBumpParameterivATI( GLenum pname, const GLint* param ) { }
+static void null_glTexBumpParameterfvATI( GLenum pname, const GLfloat *param ) { }
+static void null_glTexBumpParameterivATI( GLenum pname, const GLint *param ) { }
 static void null_glTexCoord1bOES( GLbyte s ) { }
-static void null_glTexCoord1bvOES( const GLbyte* coords ) { }
+static void null_glTexCoord1bvOES( const GLbyte *coords ) { }
 static void null_glTexCoord1hNV( GLhalfNV s ) { }
-static void null_glTexCoord1hvNV( const GLhalfNV* v ) { }
+static void null_glTexCoord1hvNV( const GLhalfNV *v ) { }
 static void null_glTexCoord1xOES( GLfixed s ) { }
-static void null_glTexCoord1xvOES( const GLfixed* coords ) { }
+static void null_glTexCoord1xvOES( const GLfixed *coords ) { }
 static void null_glTexCoord2bOES( GLbyte s, GLbyte t ) { }
-static void null_glTexCoord2bvOES( const GLbyte* coords ) { }
+static void null_glTexCoord2bvOES( const GLbyte *coords ) { }
 static void null_glTexCoord2fColor3fVertex3fSUN( GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glTexCoord2fColor3fVertex3fvSUN( const GLfloat* tc, const GLfloat* c, const GLfloat* v ) { }
+static void null_glTexCoord2fColor3fVertex3fvSUN( const GLfloat *tc, const GLfloat *c, const GLfloat *v ) { }
 static void null_glTexCoord2fColor4fNormal3fVertex3fSUN( GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glTexCoord2fColor4fNormal3fVertex3fvSUN( const GLfloat* tc, const GLfloat* c, const GLfloat* n, const GLfloat* v ) { }
+static void null_glTexCoord2fColor4fNormal3fVertex3fvSUN( const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v ) { }
 static void null_glTexCoord2fColor4ubVertex3fSUN( GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glTexCoord2fColor4ubVertex3fvSUN( const GLfloat* tc, const GLubyte* c, const GLfloat* v ) { }
+static void null_glTexCoord2fColor4ubVertex3fvSUN( const GLfloat *tc, const GLubyte *c, const GLfloat *v ) { }
 static void null_glTexCoord2fNormal3fVertex3fSUN( GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glTexCoord2fNormal3fVertex3fvSUN( const GLfloat* tc, const GLfloat* n, const GLfloat* v ) { }
+static void null_glTexCoord2fNormal3fVertex3fvSUN( const GLfloat *tc, const GLfloat *n, const GLfloat *v ) { }
 static void null_glTexCoord2fVertex3fSUN( GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glTexCoord2fVertex3fvSUN( const GLfloat* tc, const GLfloat* v ) { }
+static void null_glTexCoord2fVertex3fvSUN( const GLfloat *tc, const GLfloat *v ) { }
 static void null_glTexCoord2hNV( GLhalfNV s, GLhalfNV t ) { }
-static void null_glTexCoord2hvNV( const GLhalfNV* v ) { }
+static void null_glTexCoord2hvNV( const GLhalfNV *v ) { }
 static void null_glTexCoord2xOES( GLfixed s, GLfixed t ) { }
-static void null_glTexCoord2xvOES( const GLfixed* coords ) { }
+static void null_glTexCoord2xvOES( const GLfixed *coords ) { }
 static void null_glTexCoord3bOES( GLbyte s, GLbyte t, GLbyte r ) { }
-static void null_glTexCoord3bvOES( const GLbyte* coords ) { }
+static void null_glTexCoord3bvOES( const GLbyte *coords ) { }
 static void null_glTexCoord3hNV( GLhalfNV s, GLhalfNV t, GLhalfNV r ) { }
-static void null_glTexCoord3hvNV( const GLhalfNV* v ) { }
+static void null_glTexCoord3hvNV( const GLhalfNV *v ) { }
 static void null_glTexCoord3xOES( GLfixed s, GLfixed t, GLfixed r ) { }
-static void null_glTexCoord3xvOES( const GLfixed* coords ) { }
+static void null_glTexCoord3xvOES( const GLfixed *coords ) { }
 static void null_glTexCoord4bOES( GLbyte s, GLbyte t, GLbyte r, GLbyte q ) { }
-static void null_glTexCoord4bvOES( const GLbyte* coords ) { }
+static void null_glTexCoord4bvOES( const GLbyte *coords ) { }
 static void null_glTexCoord4fColor4fNormal3fVertex4fSUN( GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { }
-static void null_glTexCoord4fColor4fNormal3fVertex4fvSUN( const GLfloat* tc, const GLfloat* c, const GLfloat* n, const GLfloat* v ) { }
+static void null_glTexCoord4fColor4fNormal3fVertex4fvSUN( const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v ) { }
 static void null_glTexCoord4fVertex4fSUN( GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { }
-static void null_glTexCoord4fVertex4fvSUN( const GLfloat* tc, const GLfloat* v ) { }
+static void null_glTexCoord4fVertex4fvSUN( const GLfloat *tc, const GLfloat *v ) { }
 static void null_glTexCoord4hNV( GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q ) { }
-static void null_glTexCoord4hvNV( const GLhalfNV* v ) { }
+static void null_glTexCoord4hvNV( const GLhalfNV *v ) { }
 static void null_glTexCoord4xOES( GLfixed s, GLfixed t, GLfixed r, GLfixed q ) { }
-static void null_glTexCoord4xvOES( const GLfixed* coords ) { }
+static void null_glTexCoord4xvOES( const GLfixed *coords ) { }
 static void null_glTexCoordFormatNV( GLint size, GLenum type, GLsizei stride ) { }
 static void null_glTexCoordP1ui( GLenum type, GLuint coords ) { }
-static void null_glTexCoordP1uiv( GLenum type, const GLuint* coords ) { }
+static void null_glTexCoordP1uiv( GLenum type, const GLuint *coords ) { }
 static void null_glTexCoordP2ui( GLenum type, GLuint coords ) { }
-static void null_glTexCoordP2uiv( GLenum type, const GLuint* coords ) { }
+static void null_glTexCoordP2uiv( GLenum type, const GLuint *coords ) { }
 static void null_glTexCoordP3ui( GLenum type, GLuint coords ) { }
-static void null_glTexCoordP3uiv( GLenum type, const GLuint* coords ) { }
+static void null_glTexCoordP3uiv( GLenum type, const GLuint *coords ) { }
 static void null_glTexCoordP4ui( GLenum type, GLuint coords ) { }
-static void null_glTexCoordP4uiv( GLenum type, const GLuint* coords ) { }
-static void null_glTexCoordPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const void* pointer ) { }
-static void null_glTexCoordPointerListIBM( GLint size, GLenum type, GLint stride, const void** pointer, GLint ptrstride ) { }
-static void null_glTexCoordPointervINTEL( GLint size, GLenum type, const void** pointer ) { }
+static void null_glTexCoordP4uiv( GLenum type, const GLuint *coords ) { }
+static void null_glTexCoordPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer ) { }
+static void null_glTexCoordPointerListIBM( GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride ) { }
+static void null_glTexCoordPointervINTEL( GLint size, GLenum type, const void **pointer ) { }
 static void null_glTexEnvxOES( GLenum target, GLenum pname, GLfixed param ) { }
-static void null_glTexEnvxvOES( GLenum target, GLenum pname, const GLfixed* params ) { }
-static void null_glTexFilterFuncSGIS( GLenum target, GLenum filter, GLsizei n, const GLfloat* weights ) { }
+static void null_glTexEnvxvOES( GLenum target, GLenum pname, const GLfixed *params ) { }
+static void null_glTexFilterFuncSGIS( GLenum target, GLenum filter, GLsizei n, const GLfloat *weights ) { }
 static void null_glTexGenxOES( GLenum coord, GLenum pname, GLfixed param ) { }
-static void null_glTexGenxvOES( GLenum coord, GLenum pname, const GLfixed* params ) { }
+static void null_glTexGenxvOES( GLenum coord, GLenum pname, const GLfixed *params ) { }
 static void null_glTexImage2DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations ) { }
 static void null_glTexImage2DMultisampleCoverageNV( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations ) { }
-static void null_glTexImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glTexImage3DEXT( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels ) { }
+static void null_glTexImage3D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glTexImage3DEXT( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels ) { }
 static void null_glTexImage3DMultisample( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations ) { }
 static void null_glTexImage3DMultisampleCoverageNV( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations ) { }
-static void null_glTexImage4DSGIS( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const void* pixels ) { }
+static void null_glTexImage4DSGIS( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const void *pixels ) { }
 static void null_glTexPageCommitmentARB( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit ) { }
-static void null_glTexParameterIiv( GLenum target, GLenum pname, const GLint* params ) { }
-static void null_glTexParameterIivEXT( GLenum target, GLenum pname, const GLint* params ) { }
-static void null_glTexParameterIuiv( GLenum target, GLenum pname, const GLuint* params ) { }
-static void null_glTexParameterIuivEXT( GLenum target, GLenum pname, const GLuint* params ) { }
+static void null_glTexParameterIiv( GLenum target, GLenum pname, const GLint *params ) { }
+static void null_glTexParameterIivEXT( GLenum target, GLenum pname, const GLint *params ) { }
+static void null_glTexParameterIuiv( GLenum target, GLenum pname, const GLuint *params ) { }
+static void null_glTexParameterIuivEXT( GLenum target, GLenum pname, const GLuint *params ) { }
 static void null_glTexParameterxOES( GLenum target, GLenum pname, GLfixed param ) { }
-static void null_glTexParameterxvOES( GLenum target, GLenum pname, const GLfixed* params ) { }
+static void null_glTexParameterxvOES( GLenum target, GLenum pname, const GLfixed *params ) { }
 static void null_glTexRenderbufferNV( GLenum target, GLuint renderbuffer ) { }
 static void null_glTexStorage1D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width ) { }
 static void null_glTexStorage2D( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height ) { }
@@ -4365,42 +4699,42 @@
 static void null_glTexStorageMem3DEXT( GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset ) { }
 static void null_glTexStorageMem3DMultisampleEXT( GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset ) { }
 static void null_glTexStorageSparseAMD( GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags ) { }
-static void null_glTexSubImage1DEXT( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glTexSubImage2DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glTexSubImage4DSGIS( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glTextureBarrier( void ) { }
-static void null_glTextureBarrierNV( void ) { }
+static void null_glTexSubImage1DEXT( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glTexSubImage2DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glTexSubImage3D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glTexSubImage3DEXT( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glTexSubImage4DSGIS( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glTextureBarrier(void) { }
+static void null_glTextureBarrierNV(void) { }
 static void null_glTextureBuffer( GLuint texture, GLenum internalformat, GLuint buffer ) { }
 static void null_glTextureBufferEXT( GLuint texture, GLenum target, GLenum internalformat, GLuint buffer ) { }
 static void null_glTextureBufferRange( GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size ) { }
 static void null_glTextureBufferRangeEXT( GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size ) { }
 static void null_glTextureColorMaskSGIS( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) { }
-static void null_glTextureImage1DEXT( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glTextureImage2DEXT( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels ) { }
+static void null_glTextureImage1DEXT( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glTextureImage2DEXT( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels ) { }
 static void null_glTextureImage2DMultisampleCoverageNV( GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations ) { }
 static void null_glTextureImage2DMultisampleNV( GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations ) { }
-static void null_glTextureImage3DEXT( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels ) { }
+static void null_glTextureImage3DEXT( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels ) { }
 static void null_glTextureImage3DMultisampleCoverageNV( GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations ) { }
 static void null_glTextureImage3DMultisampleNV( GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations ) { }
 static void null_glTextureLightEXT( GLenum pname ) { }
 static void null_glTextureMaterialEXT( GLenum face, GLenum mode ) { }
 static void null_glTextureNormalEXT( GLenum mode ) { }
 static void null_glTexturePageCommitmentEXT( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit ) { }
-static void null_glTextureParameterIiv( GLuint texture, GLenum pname, const GLint* params ) { }
-static void null_glTextureParameterIivEXT( GLuint texture, GLenum target, GLenum pname, const GLint* params ) { }
-static void null_glTextureParameterIuiv( GLuint texture, GLenum pname, const GLuint* params ) { }
-static void null_glTextureParameterIuivEXT( GLuint texture, GLenum target, GLenum pname, const GLuint* params ) { }
+static void null_glTextureParameterIiv( GLuint texture, GLenum pname, const GLint *params ) { }
+static void null_glTextureParameterIivEXT( GLuint texture, GLenum target, GLenum pname, const GLint *params ) { }
+static void null_glTextureParameterIuiv( GLuint texture, GLenum pname, const GLuint *params ) { }
+static void null_glTextureParameterIuivEXT( GLuint texture, GLenum target, GLenum pname, const GLuint *params ) { }
 static void null_glTextureParameterf( GLuint texture, GLenum pname, GLfloat param ) { }
 static void null_glTextureParameterfEXT( GLuint texture, GLenum target, GLenum pname, GLfloat param ) { }
-static void null_glTextureParameterfv( GLuint texture, GLenum pname, const GLfloat* param ) { }
-static void null_glTextureParameterfvEXT( GLuint texture, GLenum target, GLenum pname, const GLfloat* params ) { }
+static void null_glTextureParameterfv( GLuint texture, GLenum pname, const GLfloat *param ) { }
+static void null_glTextureParameterfvEXT( GLuint texture, GLenum target, GLenum pname, const GLfloat *params ) { }
 static void null_glTextureParameteri( GLuint texture, GLenum pname, GLint param ) { }
 static void null_glTextureParameteriEXT( GLuint texture, GLenum target, GLenum pname, GLint param ) { }
-static void null_glTextureParameteriv( GLuint texture, GLenum pname, const GLint* param ) { }
-static void null_glTextureParameterivEXT( GLuint texture, GLenum target, GLenum pname, const GLint* params ) { }
-static void null_glTextureRangeAPPLE( GLenum target, GLsizei length, const void* pointer ) { }
+static void null_glTextureParameteriv( GLuint texture, GLenum pname, const GLint *param ) { }
+static void null_glTextureParameterivEXT( GLuint texture, GLenum target, GLenum pname, const GLint *params ) { }
+static void null_glTextureRangeAPPLE( GLenum target, GLsizei length, const void *pointer ) { }
 static void null_glTextureRenderbufferEXT( GLuint texture, GLenum target, GLuint renderbuffer ) { }
 static void null_glTextureStorage1D( GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width ) { }
 static void null_glTextureStorage1DEXT( GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width ) { }
@@ -4418,194 +4752,194 @@
 static void null_glTextureStorageMem3DEXT( GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset ) { }
 static void null_glTextureStorageMem3DMultisampleEXT( GLuint texture, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset ) { }
 static void null_glTextureStorageSparseAMD( GLuint texture, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags ) { }
-static void null_glTextureSubImage1D( GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glTextureSubImage1DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glTextureSubImage2D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glTextureSubImage2DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glTextureSubImage3D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels ) { }
-static void null_glTextureSubImage3DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels ) { }
+static void null_glTextureSubImage1D( GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glTextureSubImage1DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glTextureSubImage2D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glTextureSubImage2DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glTextureSubImage3D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels ) { }
+static void null_glTextureSubImage3DEXT( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels ) { }
 static void null_glTextureView( GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers ) { }
 static void null_glTrackMatrixNV( GLenum target, GLuint address, GLenum matrix, GLenum transform ) { }
-static void null_glTransformFeedbackAttribsNV( GLsizei count, const GLint* attribs, GLenum bufferMode ) { }
+static void null_glTransformFeedbackAttribsNV( GLsizei count, const GLint *attribs, GLenum bufferMode ) { }
 static void null_glTransformFeedbackBufferBase( GLuint xfb, GLuint index, GLuint buffer ) { }
 static void null_glTransformFeedbackBufferRange( GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size ) { }
-static void null_glTransformFeedbackStreamAttribsNV( GLsizei count, const GLint* attribs, GLsizei nbuffers, const GLint* bufstreams, GLenum bufferMode ) { }
-static void null_glTransformFeedbackVaryings( GLuint program, GLsizei count, const GLchar*const* varyings, GLenum bufferMode ) { }
-static void null_glTransformFeedbackVaryingsEXT( GLuint program, GLsizei count, const GLchar*const* varyings, GLenum bufferMode ) { }
-static void null_glTransformFeedbackVaryingsNV( GLuint program, GLsizei count, const GLint* locations, GLenum bufferMode ) { }
-static void null_glTransformPathNV( GLuint resultPath, GLuint srcPath, GLenum transformType, const GLfloat* transformValues ) { }
+static void null_glTransformFeedbackStreamAttribsNV( GLsizei count, const GLint *attribs, GLsizei nbuffers, const GLint *bufstreams, GLenum bufferMode ) { }
+static void null_glTransformFeedbackVaryings( GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode ) { }
+static void null_glTransformFeedbackVaryingsEXT( GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode ) { }
+static void null_glTransformFeedbackVaryingsNV( GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode ) { }
+static void null_glTransformPathNV( GLuint resultPath, GLuint srcPath, GLenum transformType, const GLfloat *transformValues ) { }
 static void null_glTranslatexOES( GLfixed x, GLfixed y, GLfixed z ) { }
 static void null_glUniform1d( GLint location, GLdouble x ) { }
-static void null_glUniform1dv( GLint location, GLsizei count, const GLdouble* value ) { }
+static void null_glUniform1dv( GLint location, GLsizei count, const GLdouble *value ) { }
 static void null_glUniform1f( GLint location, GLfloat v0 ) { }
 static void null_glUniform1fARB( GLint location, GLfloat v0 ) { }
-static void null_glUniform1fv( GLint location, GLsizei count, const GLfloat* value ) { }
-static void null_glUniform1fvARB( GLint location, GLsizei count, const GLfloat* value ) { }
+static void null_glUniform1fv( GLint location, GLsizei count, const GLfloat *value ) { }
+static void null_glUniform1fvARB( GLint location, GLsizei count, const GLfloat *value ) { }
 static void null_glUniform1i( GLint location, GLint v0 ) { }
 static void null_glUniform1i64ARB( GLint location, GLint64 x ) { }
 static void null_glUniform1i64NV( GLint location, GLint64EXT x ) { }
-static void null_glUniform1i64vARB( GLint location, GLsizei count, const GLint64* value ) { }
-static void null_glUniform1i64vNV( GLint location, GLsizei count, const GLint64EXT* value ) { }
+static void null_glUniform1i64vARB( GLint location, GLsizei count, const GLint64 *value ) { }
+static void null_glUniform1i64vNV( GLint location, GLsizei count, const GLint64EXT *value ) { }
 static void null_glUniform1iARB( GLint location, GLint v0 ) { }
-static void null_glUniform1iv( GLint location, GLsizei count, const GLint* value ) { }
-static void null_glUniform1ivARB( GLint location, GLsizei count, const GLint* value ) { }
+static void null_glUniform1iv( GLint location, GLsizei count, const GLint *value ) { }
+static void null_glUniform1ivARB( GLint location, GLsizei count, const GLint *value ) { }
 static void null_glUniform1ui( GLint location, GLuint v0 ) { }
 static void null_glUniform1ui64ARB( GLint location, GLuint64 x ) { }
 static void null_glUniform1ui64NV( GLint location, GLuint64EXT x ) { }
-static void null_glUniform1ui64vARB( GLint location, GLsizei count, const GLuint64* value ) { }
-static void null_glUniform1ui64vNV( GLint location, GLsizei count, const GLuint64EXT* value ) { }
+static void null_glUniform1ui64vARB( GLint location, GLsizei count, const GLuint64 *value ) { }
+static void null_glUniform1ui64vNV( GLint location, GLsizei count, const GLuint64EXT *value ) { }
 static void null_glUniform1uiEXT( GLint location, GLuint v0 ) { }
-static void null_glUniform1uiv( GLint location, GLsizei count, const GLuint* value ) { }
-static void null_glUniform1uivEXT( GLint location, GLsizei count, const GLuint* value ) { }
+static void null_glUniform1uiv( GLint location, GLsizei count, const GLuint *value ) { }
+static void null_glUniform1uivEXT( GLint location, GLsizei count, const GLuint *value ) { }
 static void null_glUniform2d( GLint location, GLdouble x, GLdouble y ) { }
-static void null_glUniform2dv( GLint location, GLsizei count, const GLdouble* value ) { }
+static void null_glUniform2dv( GLint location, GLsizei count, const GLdouble *value ) { }
 static void null_glUniform2f( GLint location, GLfloat v0, GLfloat v1 ) { }
 static void null_glUniform2fARB( GLint location, GLfloat v0, GLfloat v1 ) { }
-static void null_glUniform2fv( GLint location, GLsizei count, const GLfloat* value ) { }
-static void null_glUniform2fvARB( GLint location, GLsizei count, const GLfloat* value ) { }
+static void null_glUniform2fv( GLint location, GLsizei count, const GLfloat *value ) { }
+static void null_glUniform2fvARB( GLint location, GLsizei count, const GLfloat *value ) { }
 static void null_glUniform2i( GLint location, GLint v0, GLint v1 ) { }
 static void null_glUniform2i64ARB( GLint location, GLint64 x, GLint64 y ) { }
 static void null_glUniform2i64NV( GLint location, GLint64EXT x, GLint64EXT y ) { }
-static void null_glUniform2i64vARB( GLint location, GLsizei count, const GLint64* value ) { }
-static void null_glUniform2i64vNV( GLint location, GLsizei count, const GLint64EXT* value ) { }
+static void null_glUniform2i64vARB( GLint location, GLsizei count, const GLint64 *value ) { }
+static void null_glUniform2i64vNV( GLint location, GLsizei count, const GLint64EXT *value ) { }
 static void null_glUniform2iARB( GLint location, GLint v0, GLint v1 ) { }
-static void null_glUniform2iv( GLint location, GLsizei count, const GLint* value ) { }
-static void null_glUniform2ivARB( GLint location, GLsizei count, const GLint* value ) { }
+static void null_glUniform2iv( GLint location, GLsizei count, const GLint *value ) { }
+static void null_glUniform2ivARB( GLint location, GLsizei count, const GLint *value ) { }
 static void null_glUniform2ui( GLint location, GLuint v0, GLuint v1 ) { }
 static void null_glUniform2ui64ARB( GLint location, GLuint64 x, GLuint64 y ) { }
 static void null_glUniform2ui64NV( GLint location, GLuint64EXT x, GLuint64EXT y ) { }
-static void null_glUniform2ui64vARB( GLint location, GLsizei count, const GLuint64* value ) { }
-static void null_glUniform2ui64vNV( GLint location, GLsizei count, const GLuint64EXT* value ) { }
+static void null_glUniform2ui64vARB( GLint location, GLsizei count, const GLuint64 *value ) { }
+static void null_glUniform2ui64vNV( GLint location, GLsizei count, const GLuint64EXT *value ) { }
 static void null_glUniform2uiEXT( GLint location, GLuint v0, GLuint v1 ) { }
-static void null_glUniform2uiv( GLint location, GLsizei count, const GLuint* value ) { }
-static void null_glUniform2uivEXT( GLint location, GLsizei count, const GLuint* value ) { }
+static void null_glUniform2uiv( GLint location, GLsizei count, const GLuint *value ) { }
+static void null_glUniform2uivEXT( GLint location, GLsizei count, const GLuint *value ) { }
 static void null_glUniform3d( GLint location, GLdouble x, GLdouble y, GLdouble z ) { }
-static void null_glUniform3dv( GLint location, GLsizei count, const GLdouble* value ) { }
+static void null_glUniform3dv( GLint location, GLsizei count, const GLdouble *value ) { }
 static void null_glUniform3f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2 ) { }
 static void null_glUniform3fARB( GLint location, GLfloat v0, GLfloat v1, GLfloat v2 ) { }
-static void null_glUniform3fv( GLint location, GLsizei count, const GLfloat* value ) { }
-static void null_glUniform3fvARB( GLint location, GLsizei count, const GLfloat* value ) { }
+static void null_glUniform3fv( GLint location, GLsizei count, const GLfloat *value ) { }
+static void null_glUniform3fvARB( GLint location, GLsizei count, const GLfloat *value ) { }
 static void null_glUniform3i( GLint location, GLint v0, GLint v1, GLint v2 ) { }
 static void null_glUniform3i64ARB( GLint location, GLint64 x, GLint64 y, GLint64 z ) { }
 static void null_glUniform3i64NV( GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z ) { }
-static void null_glUniform3i64vARB( GLint location, GLsizei count, const GLint64* value ) { }
-static void null_glUniform3i64vNV( GLint location, GLsizei count, const GLint64EXT* value ) { }
+static void null_glUniform3i64vARB( GLint location, GLsizei count, const GLint64 *value ) { }
+static void null_glUniform3i64vNV( GLint location, GLsizei count, const GLint64EXT *value ) { }
 static void null_glUniform3iARB( GLint location, GLint v0, GLint v1, GLint v2 ) { }
-static void null_glUniform3iv( GLint location, GLsizei count, const GLint* value ) { }
-static void null_glUniform3ivARB( GLint location, GLsizei count, const GLint* value ) { }
+static void null_glUniform3iv( GLint location, GLsizei count, const GLint *value ) { }
+static void null_glUniform3ivARB( GLint location, GLsizei count, const GLint *value ) { }
 static void null_glUniform3ui( GLint location, GLuint v0, GLuint v1, GLuint v2 ) { }
 static void null_glUniform3ui64ARB( GLint location, GLuint64 x, GLuint64 y, GLuint64 z ) { }
 static void null_glUniform3ui64NV( GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z ) { }
-static void null_glUniform3ui64vARB( GLint location, GLsizei count, const GLuint64* value ) { }
-static void null_glUniform3ui64vNV( GLint location, GLsizei count, const GLuint64EXT* value ) { }
+static void null_glUniform3ui64vARB( GLint location, GLsizei count, const GLuint64 *value ) { }
+static void null_glUniform3ui64vNV( GLint location, GLsizei count, const GLuint64EXT *value ) { }
 static void null_glUniform3uiEXT( GLint location, GLuint v0, GLuint v1, GLuint v2 ) { }
-static void null_glUniform3uiv( GLint location, GLsizei count, const GLuint* value ) { }
-static void null_glUniform3uivEXT( GLint location, GLsizei count, const GLuint* value ) { }
+static void null_glUniform3uiv( GLint location, GLsizei count, const GLuint *value ) { }
+static void null_glUniform3uivEXT( GLint location, GLsizei count, const GLuint *value ) { }
 static void null_glUniform4d( GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
-static void null_glUniform4dv( GLint location, GLsizei count, const GLdouble* value ) { }
+static void null_glUniform4dv( GLint location, GLsizei count, const GLdouble *value ) { }
 static void null_glUniform4f( GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) { }
 static void null_glUniform4fARB( GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 ) { }
-static void null_glUniform4fv( GLint location, GLsizei count, const GLfloat* value ) { }
-static void null_glUniform4fvARB( GLint location, GLsizei count, const GLfloat* value ) { }
+static void null_glUniform4fv( GLint location, GLsizei count, const GLfloat *value ) { }
+static void null_glUniform4fvARB( GLint location, GLsizei count, const GLfloat *value ) { }
 static void null_glUniform4i( GLint location, GLint v0, GLint v1, GLint v2, GLint v3 ) { }
 static void null_glUniform4i64ARB( GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w ) { }
 static void null_glUniform4i64NV( GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w ) { }
-static void null_glUniform4i64vARB( GLint location, GLsizei count, const GLint64* value ) { }
-static void null_glUniform4i64vNV( GLint location, GLsizei count, const GLint64EXT* value ) { }
+static void null_glUniform4i64vARB( GLint location, GLsizei count, const GLint64 *value ) { }
+static void null_glUniform4i64vNV( GLint location, GLsizei count, const GLint64EXT *value ) { }
 static void null_glUniform4iARB( GLint location, GLint v0, GLint v1, GLint v2, GLint v3 ) { }
-static void null_glUniform4iv( GLint location, GLsizei count, const GLint* value ) { }
-static void null_glUniform4ivARB( GLint location, GLsizei count, const GLint* value ) { }
+static void null_glUniform4iv( GLint location, GLsizei count, const GLint *value ) { }
+static void null_glUniform4ivARB( GLint location, GLsizei count, const GLint *value ) { }
 static void null_glUniform4ui( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) { }
 static void null_glUniform4ui64ARB( GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w ) { }
 static void null_glUniform4ui64NV( GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w ) { }
-static void null_glUniform4ui64vARB( GLint location, GLsizei count, const GLuint64* value ) { }
-static void null_glUniform4ui64vNV( GLint location, GLsizei count, const GLuint64EXT* value ) { }
+static void null_glUniform4ui64vARB( GLint location, GLsizei count, const GLuint64 *value ) { }
+static void null_glUniform4ui64vNV( GLint location, GLsizei count, const GLuint64EXT *value ) { }
 static void null_glUniform4uiEXT( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 ) { }
-static void null_glUniform4uiv( GLint location, GLsizei count, const GLuint* value ) { }
-static void null_glUniform4uivEXT( GLint location, GLsizei count, const GLuint* value ) { }
+static void null_glUniform4uiv( GLint location, GLsizei count, const GLuint *value ) { }
+static void null_glUniform4uivEXT( GLint location, GLsizei count, const GLuint *value ) { }
 static void null_glUniformBlockBinding( GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding ) { }
 static void null_glUniformBufferEXT( GLuint program, GLint location, GLuint buffer ) { }
 static void null_glUniformHandleui64ARB( GLint location, GLuint64 value ) { }
 static void null_glUniformHandleui64NV( GLint location, GLuint64 value ) { }
-static void null_glUniformHandleui64vARB( GLint location, GLsizei count, const GLuint64* value ) { }
-static void null_glUniformHandleui64vNV( GLint location, GLsizei count, const GLuint64* value ) { }
-static void null_glUniformMatrix2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glUniformMatrix2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glUniformMatrix2fvARB( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glUniformMatrix2x3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glUniformMatrix2x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glUniformMatrix2x4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glUniformMatrix2x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glUniformMatrix3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glUniformMatrix3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glUniformMatrix3fvARB( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glUniformMatrix3x2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glUniformMatrix3x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glUniformMatrix3x4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glUniformMatrix3x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glUniformMatrix4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glUniformMatrix4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glUniformMatrix4fvARB( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glUniformMatrix4x2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glUniformMatrix4x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glUniformMatrix4x3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble* value ) { }
-static void null_glUniformMatrix4x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat* value ) { }
-static void null_glUniformSubroutinesuiv( GLenum shadertype, GLsizei count, const GLuint* indices ) { }
+static void null_glUniformHandleui64vARB( GLint location, GLsizei count, const GLuint64 *value ) { }
+static void null_glUniformHandleui64vNV( GLint location, GLsizei count, const GLuint64 *value ) { }
+static void null_glUniformMatrix2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glUniformMatrix2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glUniformMatrix2fvARB( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glUniformMatrix2x3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glUniformMatrix2x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glUniformMatrix2x4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glUniformMatrix2x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glUniformMatrix3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glUniformMatrix3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glUniformMatrix3fvARB( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glUniformMatrix3x2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glUniformMatrix3x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glUniformMatrix3x4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glUniformMatrix3x4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glUniformMatrix4dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glUniformMatrix4fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glUniformMatrix4fvARB( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glUniformMatrix4x2dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glUniformMatrix4x2fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glUniformMatrix4x3dv( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value ) { }
+static void null_glUniformMatrix4x3fv( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value ) { }
+static void null_glUniformSubroutinesuiv( GLenum shadertype, GLsizei count, const GLuint *indices ) { }
 static void null_glUniformui64NV( GLint location, GLuint64EXT value ) { }
-static void null_glUniformui64vNV( GLint location, GLsizei count, const GLuint64EXT* value ) { }
-static void null_glUnlockArraysEXT( void ) { }
+static void null_glUniformui64vNV( GLint location, GLsizei count, const GLuint64EXT *value ) { }
+static void null_glUnlockArraysEXT(void) { }
 static GLboolean null_glUnmapBuffer( GLenum target ) { return 0; }
 static GLboolean null_glUnmapBufferARB( GLenum target ) { return 0; }
 static GLboolean null_glUnmapNamedBuffer( GLuint buffer ) { return 0; }
 static GLboolean null_glUnmapNamedBufferEXT( GLuint buffer ) { return 0; }
 static void null_glUnmapObjectBufferATI( GLuint buffer ) { }
 static void null_glUnmapTexture2DINTEL( GLuint texture, GLint level ) { }
-static void null_glUpdateObjectBufferATI( GLuint buffer, GLuint offset, GLsizei size, const void* pointer, GLenum preserve ) { }
+static void null_glUpdateObjectBufferATI( GLuint buffer, GLuint offset, GLsizei size, const void *pointer, GLenum preserve ) { }
 static void null_glUseProgram( GLuint program ) { }
 static void null_glUseProgramObjectARB( GLhandleARB programObj ) { }
 static void null_glUseProgramStages( GLuint pipeline, GLbitfield stages, GLuint program ) { }
 static void null_glUseShaderProgramEXT( GLenum type, GLuint program ) { }
-static void null_glVDPAUFiniNV( void ) { }
-static void null_glVDPAUGetSurfaceivNV( GLvdpauSurfaceNV surface, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values ) { }
-static void null_glVDPAUInitNV( const void* vdpDevice, const void* getProcAddress ) { }
+static void null_glVDPAUFiniNV(void) { }
+static void null_glVDPAUGetSurfaceivNV( GLvdpauSurfaceNV surface, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values ) { }
+static void null_glVDPAUInitNV( const void *vdpDevice, const void *getProcAddress ) { }
 static GLboolean null_glVDPAUIsSurfaceNV( GLvdpauSurfaceNV surface ) { return 0; }
-static void null_glVDPAUMapSurfacesNV( GLsizei numSurfaces, const GLvdpauSurfaceNV* surfaces ) { }
-static GLvdpauSurfaceNV null_glVDPAURegisterOutputSurfaceNV( const void* vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint* textureNames ) { return 0; }
-static GLvdpauSurfaceNV null_glVDPAURegisterVideoSurfaceNV( const void* vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint* textureNames ) { return 0; }
+static void null_glVDPAUMapSurfacesNV( GLsizei numSurfaces, const GLvdpauSurfaceNV *surfaces ) { }
+static GLvdpauSurfaceNV null_glVDPAURegisterOutputSurfaceNV( const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames ) { return 0; }
+static GLvdpauSurfaceNV null_glVDPAURegisterVideoSurfaceNV( const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames ) { return 0; }
 static void null_glVDPAUSurfaceAccessNV( GLvdpauSurfaceNV surface, GLenum access ) { }
-static void null_glVDPAUUnmapSurfacesNV( GLsizei numSurface, const GLvdpauSurfaceNV* surfaces ) { }
+static void null_glVDPAUUnmapSurfacesNV( GLsizei numSurface, const GLvdpauSurfaceNV *surfaces ) { }
 static void null_glVDPAUUnregisterSurfaceNV( GLvdpauSurfaceNV surface ) { }
 static void null_glValidateProgram( GLuint program ) { }
 static void null_glValidateProgramARB( GLhandleARB programObj ) { }
 static void null_glValidateProgramPipeline( GLuint pipeline ) { }
 static void null_glVariantArrayObjectATI( GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset ) { }
-static void null_glVariantPointerEXT( GLuint id, GLenum type, GLuint stride, const void* addr ) { }
-static void null_glVariantbvEXT( GLuint id, const GLbyte* addr ) { }
-static void null_glVariantdvEXT( GLuint id, const GLdouble* addr ) { }
-static void null_glVariantfvEXT( GLuint id, const GLfloat* addr ) { }
-static void null_glVariantivEXT( GLuint id, const GLint* addr ) { }
-static void null_glVariantsvEXT( GLuint id, const GLshort* addr ) { }
-static void null_glVariantubvEXT( GLuint id, const GLubyte* addr ) { }
-static void null_glVariantuivEXT( GLuint id, const GLuint* addr ) { }
-static void null_glVariantusvEXT( GLuint id, const GLushort* addr ) { }
+static void null_glVariantPointerEXT( GLuint id, GLenum type, GLuint stride, const void *addr ) { }
+static void null_glVariantbvEXT( GLuint id, const GLbyte *addr ) { }
+static void null_glVariantdvEXT( GLuint id, const GLdouble *addr ) { }
+static void null_glVariantfvEXT( GLuint id, const GLfloat *addr ) { }
+static void null_glVariantivEXT( GLuint id, const GLint *addr ) { }
+static void null_glVariantsvEXT( GLuint id, const GLshort *addr ) { }
+static void null_glVariantubvEXT( GLuint id, const GLubyte *addr ) { }
+static void null_glVariantuivEXT( GLuint id, const GLuint *addr ) { }
+static void null_glVariantusvEXT( GLuint id, const GLushort *addr ) { }
 static void null_glVertex2bOES( GLbyte x, GLbyte y ) { }
-static void null_glVertex2bvOES( const GLbyte* coords ) { }
+static void null_glVertex2bvOES( const GLbyte *coords ) { }
 static void null_glVertex2hNV( GLhalfNV x, GLhalfNV y ) { }
-static void null_glVertex2hvNV( const GLhalfNV* v ) { }
+static void null_glVertex2hvNV( const GLhalfNV *v ) { }
 static void null_glVertex2xOES( GLfixed x ) { }
-static void null_glVertex2xvOES( const GLfixed* coords ) { }
+static void null_glVertex2xvOES( const GLfixed *coords ) { }
 static void null_glVertex3bOES( GLbyte x, GLbyte y, GLbyte z ) { }
-static void null_glVertex3bvOES( const GLbyte* coords ) { }
+static void null_glVertex3bvOES( const GLbyte *coords ) { }
 static void null_glVertex3hNV( GLhalfNV x, GLhalfNV y, GLhalfNV z ) { }
-static void null_glVertex3hvNV( const GLhalfNV* v ) { }
+static void null_glVertex3hvNV( const GLhalfNV *v ) { }
 static void null_glVertex3xOES( GLfixed x, GLfixed y ) { }
-static void null_glVertex3xvOES( const GLfixed* coords ) { }
+static void null_glVertex3xvOES( const GLfixed *coords ) { }
 static void null_glVertex4bOES( GLbyte x, GLbyte y, GLbyte z, GLbyte w ) { }
-static void null_glVertex4bvOES( const GLbyte* coords ) { }
+static void null_glVertex4bvOES( const GLbyte *coords ) { }
 static void null_glVertex4hNV( GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w ) { }
-static void null_glVertex4hvNV( const GLhalfNV* v ) { }
+static void null_glVertex4hvNV( const GLhalfNV *v ) { }
 static void null_glVertex4xOES( GLfixed x, GLfixed y, GLfixed z ) { }
-static void null_glVertex4xvOES( const GLfixed* coords ) { }
+static void null_glVertex4xvOES( const GLfixed *coords ) { }
 static void null_glVertexArrayAttribBinding( GLuint vaobj, GLuint attribindex, GLuint bindingindex ) { }
 static void null_glVertexArrayAttribFormat( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset ) { }
 static void null_glVertexArrayAttribIFormat( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset ) { }
@@ -4620,8 +4954,8 @@
 static void null_glVertexArrayMultiTexCoordOffsetEXT( GLuint vaobj, GLuint buffer, GLenum texunit, GLint size, GLenum type, GLsizei stride, GLintptr offset ) { }
 static void null_glVertexArrayNormalOffsetEXT( GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset ) { }
 static void null_glVertexArrayParameteriAPPLE( GLenum pname, GLint param ) { }
-static void null_glVertexArrayRangeAPPLE( GLsizei length, void* pointer ) { }
-static void null_glVertexArrayRangeNV( GLsizei length, const void* pointer ) { }
+static void null_glVertexArrayRangeAPPLE( GLsizei length, void *pointer ) { }
+static void null_glVertexArrayRangeNV( GLsizei length, const void *pointer ) { }
 static void null_glVertexArraySecondaryColorOffsetEXT( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset ) { }
 static void null_glVertexArrayTexCoordOffsetEXT( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset ) { }
 static void null_glVertexArrayVertexAttribBindingEXT( GLuint vaobj, GLuint attribindex, GLuint bindingindex ) { }
@@ -4634,114 +4968,114 @@
 static void null_glVertexArrayVertexAttribOffsetEXT( GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset ) { }
 static void null_glVertexArrayVertexBindingDivisorEXT( GLuint vaobj, GLuint bindingindex, GLuint divisor ) { }
 static void null_glVertexArrayVertexBuffer( GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride ) { }
-static void null_glVertexArrayVertexBuffers( GLuint vaobj, GLuint first, GLsizei count, const GLuint* buffers, const GLintptr* offsets, const GLsizei* strides ) { }
+static void null_glVertexArrayVertexBuffers( GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides ) { }
 static void null_glVertexArrayVertexOffsetEXT( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset ) { }
 static void null_glVertexAttrib1d( GLuint index, GLdouble x ) { }
 static void null_glVertexAttrib1dARB( GLuint index, GLdouble x ) { }
 static void null_glVertexAttrib1dNV( GLuint index, GLdouble x ) { }
-static void null_glVertexAttrib1dv( GLuint index, const GLdouble* v ) { }
-static void null_glVertexAttrib1dvARB( GLuint index, const GLdouble* v ) { }
-static void null_glVertexAttrib1dvNV( GLuint index, const GLdouble* v ) { }
+static void null_glVertexAttrib1dv( GLuint index, const GLdouble *v ) { }
+static void null_glVertexAttrib1dvARB( GLuint index, const GLdouble *v ) { }
+static void null_glVertexAttrib1dvNV( GLuint index, const GLdouble *v ) { }
 static void null_glVertexAttrib1f( GLuint index, GLfloat x ) { }
 static void null_glVertexAttrib1fARB( GLuint index, GLfloat x ) { }
 static void null_glVertexAttrib1fNV( GLuint index, GLfloat x ) { }
-static void null_glVertexAttrib1fv( GLuint index, const GLfloat* v ) { }
-static void null_glVertexAttrib1fvARB( GLuint index, const GLfloat* v ) { }
-static void null_glVertexAttrib1fvNV( GLuint index, const GLfloat* v ) { }
+static void null_glVertexAttrib1fv( GLuint index, const GLfloat *v ) { }
+static void null_glVertexAttrib1fvARB( GLuint index, const GLfloat *v ) { }
+static void null_glVertexAttrib1fvNV( GLuint index, const GLfloat *v ) { }
 static void null_glVertexAttrib1hNV( GLuint index, GLhalfNV x ) { }
-static void null_glVertexAttrib1hvNV( GLuint index, const GLhalfNV* v ) { }
+static void null_glVertexAttrib1hvNV( GLuint index, const GLhalfNV *v ) { }
 static void null_glVertexAttrib1s( GLuint index, GLshort x ) { }
 static void null_glVertexAttrib1sARB( GLuint index, GLshort x ) { }
 static void null_glVertexAttrib1sNV( GLuint index, GLshort x ) { }
-static void null_glVertexAttrib1sv( GLuint index, const GLshort* v ) { }
-static void null_glVertexAttrib1svARB( GLuint index, const GLshort* v ) { }
-static void null_glVertexAttrib1svNV( GLuint index, const GLshort* v ) { }
+static void null_glVertexAttrib1sv( GLuint index, const GLshort *v ) { }
+static void null_glVertexAttrib1svARB( GLuint index, const GLshort *v ) { }
+static void null_glVertexAttrib1svNV( GLuint index, const GLshort *v ) { }
 static void null_glVertexAttrib2d( GLuint index, GLdouble x, GLdouble y ) { }
 static void null_glVertexAttrib2dARB( GLuint index, GLdouble x, GLdouble y ) { }
 static void null_glVertexAttrib2dNV( GLuint index, GLdouble x, GLdouble y ) { }
-static void null_glVertexAttrib2dv( GLuint index, const GLdouble* v ) { }
-static void null_glVertexAttrib2dvARB( GLuint index, const GLdouble* v ) { }
-static void null_glVertexAttrib2dvNV( GLuint index, const GLdouble* v ) { }
+static void null_glVertexAttrib2dv( GLuint index, const GLdouble *v ) { }
+static void null_glVertexAttrib2dvARB( GLuint index, const GLdouble *v ) { }
+static void null_glVertexAttrib2dvNV( GLuint index, const GLdouble *v ) { }
 static void null_glVertexAttrib2f( GLuint index, GLfloat x, GLfloat y ) { }
 static void null_glVertexAttrib2fARB( GLuint index, GLfloat x, GLfloat y ) { }
 static void null_glVertexAttrib2fNV( GLuint index, GLfloat x, GLfloat y ) { }
-static void null_glVertexAttrib2fv( GLuint index, const GLfloat* v ) { }
-static void null_glVertexAttrib2fvARB( GLuint index, const GLfloat* v ) { }
-static void null_glVertexAttrib2fvNV( GLuint index, const GLfloat* v ) { }
+static void null_glVertexAttrib2fv( GLuint index, const GLfloat *v ) { }
+static void null_glVertexAttrib2fvARB( GLuint index, const GLfloat *v ) { }
+static void null_glVertexAttrib2fvNV( GLuint index, const GLfloat *v ) { }
 static void null_glVertexAttrib2hNV( GLuint index, GLhalfNV x, GLhalfNV y ) { }
-static void null_glVertexAttrib2hvNV( GLuint index, const GLhalfNV* v ) { }
+static void null_glVertexAttrib2hvNV( GLuint index, const GLhalfNV *v ) { }
 static void null_glVertexAttrib2s( GLuint index, GLshort x, GLshort y ) { }
 static void null_glVertexAttrib2sARB( GLuint index, GLshort x, GLshort y ) { }
 static void null_glVertexAttrib2sNV( GLuint index, GLshort x, GLshort y ) { }
-static void null_glVertexAttrib2sv( GLuint index, const GLshort* v ) { }
-static void null_glVertexAttrib2svARB( GLuint index, const GLshort* v ) { }
-static void null_glVertexAttrib2svNV( GLuint index, const GLshort* v ) { }
+static void null_glVertexAttrib2sv( GLuint index, const GLshort *v ) { }
+static void null_glVertexAttrib2svARB( GLuint index, const GLshort *v ) { }
+static void null_glVertexAttrib2svNV( GLuint index, const GLshort *v ) { }
 static void null_glVertexAttrib3d( GLuint index, GLdouble x, GLdouble y, GLdouble z ) { }
 static void null_glVertexAttrib3dARB( GLuint index, GLdouble x, GLdouble y, GLdouble z ) { }
 static void null_glVertexAttrib3dNV( GLuint index, GLdouble x, GLdouble y, GLdouble z ) { }
-static void null_glVertexAttrib3dv( GLuint index, const GLdouble* v ) { }
-static void null_glVertexAttrib3dvARB( GLuint index, const GLdouble* v ) { }
-static void null_glVertexAttrib3dvNV( GLuint index, const GLdouble* v ) { }
+static void null_glVertexAttrib3dv( GLuint index, const GLdouble *v ) { }
+static void null_glVertexAttrib3dvARB( GLuint index, const GLdouble *v ) { }
+static void null_glVertexAttrib3dvNV( GLuint index, const GLdouble *v ) { }
 static void null_glVertexAttrib3f( GLuint index, GLfloat x, GLfloat y, GLfloat z ) { }
 static void null_glVertexAttrib3fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z ) { }
 static void null_glVertexAttrib3fNV( GLuint index, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glVertexAttrib3fv( GLuint index, const GLfloat* v ) { }
-static void null_glVertexAttrib3fvARB( GLuint index, const GLfloat* v ) { }
-static void null_glVertexAttrib3fvNV( GLuint index, const GLfloat* v ) { }
+static void null_glVertexAttrib3fv( GLuint index, const GLfloat *v ) { }
+static void null_glVertexAttrib3fvARB( GLuint index, const GLfloat *v ) { }
+static void null_glVertexAttrib3fvNV( GLuint index, const GLfloat *v ) { }
 static void null_glVertexAttrib3hNV( GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z ) { }
-static void null_glVertexAttrib3hvNV( GLuint index, const GLhalfNV* v ) { }
+static void null_glVertexAttrib3hvNV( GLuint index, const GLhalfNV *v ) { }
 static void null_glVertexAttrib3s( GLuint index, GLshort x, GLshort y, GLshort z ) { }
 static void null_glVertexAttrib3sARB( GLuint index, GLshort x, GLshort y, GLshort z ) { }
 static void null_glVertexAttrib3sNV( GLuint index, GLshort x, GLshort y, GLshort z ) { }
-static void null_glVertexAttrib3sv( GLuint index, const GLshort* v ) { }
-static void null_glVertexAttrib3svARB( GLuint index, const GLshort* v ) { }
-static void null_glVertexAttrib3svNV( GLuint index, const GLshort* v ) { }
-static void null_glVertexAttrib4Nbv( GLuint index, const GLbyte* v ) { }
-static void null_glVertexAttrib4NbvARB( GLuint index, const GLbyte* v ) { }
-static void null_glVertexAttrib4Niv( GLuint index, const GLint* v ) { }
-static void null_glVertexAttrib4NivARB( GLuint index, const GLint* v ) { }
-static void null_glVertexAttrib4Nsv( GLuint index, const GLshort* v ) { }
-static void null_glVertexAttrib4NsvARB( GLuint index, const GLshort* v ) { }
+static void null_glVertexAttrib3sv( GLuint index, const GLshort *v ) { }
+static void null_glVertexAttrib3svARB( GLuint index, const GLshort *v ) { }
+static void null_glVertexAttrib3svNV( GLuint index, const GLshort *v ) { }
+static void null_glVertexAttrib4Nbv( GLuint index, const GLbyte *v ) { }
+static void null_glVertexAttrib4NbvARB( GLuint index, const GLbyte *v ) { }
+static void null_glVertexAttrib4Niv( GLuint index, const GLint *v ) { }
+static void null_glVertexAttrib4NivARB( GLuint index, const GLint *v ) { }
+static void null_glVertexAttrib4Nsv( GLuint index, const GLshort *v ) { }
+static void null_glVertexAttrib4NsvARB( GLuint index, const GLshort *v ) { }
 static void null_glVertexAttrib4Nub( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w ) { }
 static void null_glVertexAttrib4NubARB( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w ) { }
-static void null_glVertexAttrib4Nubv( GLuint index, const GLubyte* v ) { }
-static void null_glVertexAttrib4NubvARB( GLuint index, const GLubyte* v ) { }
-static void null_glVertexAttrib4Nuiv( GLuint index, const GLuint* v ) { }
-static void null_glVertexAttrib4NuivARB( GLuint index, const GLuint* v ) { }
-static void null_glVertexAttrib4Nusv( GLuint index, const GLushort* v ) { }
-static void null_glVertexAttrib4NusvARB( GLuint index, const GLushort* v ) { }
-static void null_glVertexAttrib4bv( GLuint index, const GLbyte* v ) { }
-static void null_glVertexAttrib4bvARB( GLuint index, const GLbyte* v ) { }
+static void null_glVertexAttrib4Nubv( GLuint index, const GLubyte *v ) { }
+static void null_glVertexAttrib4NubvARB( GLuint index, const GLubyte *v ) { }
+static void null_glVertexAttrib4Nuiv( GLuint index, const GLuint *v ) { }
+static void null_glVertexAttrib4NuivARB( GLuint index, const GLuint *v ) { }
+static void null_glVertexAttrib4Nusv( GLuint index, const GLushort *v ) { }
+static void null_glVertexAttrib4NusvARB( GLuint index, const GLushort *v ) { }
+static void null_glVertexAttrib4bv( GLuint index, const GLbyte *v ) { }
+static void null_glVertexAttrib4bvARB( GLuint index, const GLbyte *v ) { }
 static void null_glVertexAttrib4d( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
 static void null_glVertexAttrib4dARB( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
 static void null_glVertexAttrib4dNV( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
-static void null_glVertexAttrib4dv( GLuint index, const GLdouble* v ) { }
-static void null_glVertexAttrib4dvARB( GLuint index, const GLdouble* v ) { }
-static void null_glVertexAttrib4dvNV( GLuint index, const GLdouble* v ) { }
+static void null_glVertexAttrib4dv( GLuint index, const GLdouble *v ) { }
+static void null_glVertexAttrib4dvARB( GLuint index, const GLdouble *v ) { }
+static void null_glVertexAttrib4dvNV( GLuint index, const GLdouble *v ) { }
 static void null_glVertexAttrib4f( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { }
 static void null_glVertexAttrib4fARB( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { }
 static void null_glVertexAttrib4fNV( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { }
-static void null_glVertexAttrib4fv( GLuint index, const GLfloat* v ) { }
-static void null_glVertexAttrib4fvARB( GLuint index, const GLfloat* v ) { }
-static void null_glVertexAttrib4fvNV( GLuint index, const GLfloat* v ) { }
+static void null_glVertexAttrib4fv( GLuint index, const GLfloat *v ) { }
+static void null_glVertexAttrib4fvARB( GLuint index, const GLfloat *v ) { }
+static void null_glVertexAttrib4fvNV( GLuint index, const GLfloat *v ) { }
 static void null_glVertexAttrib4hNV( GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w ) { }
-static void null_glVertexAttrib4hvNV( GLuint index, const GLhalfNV* v ) { }
-static void null_glVertexAttrib4iv( GLuint index, const GLint* v ) { }
-static void null_glVertexAttrib4ivARB( GLuint index, const GLint* v ) { }
+static void null_glVertexAttrib4hvNV( GLuint index, const GLhalfNV *v ) { }
+static void null_glVertexAttrib4iv( GLuint index, const GLint *v ) { }
+static void null_glVertexAttrib4ivARB( GLuint index, const GLint *v ) { }
 static void null_glVertexAttrib4s( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w ) { }
 static void null_glVertexAttrib4sARB( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w ) { }
 static void null_glVertexAttrib4sNV( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w ) { }
-static void null_glVertexAttrib4sv( GLuint index, const GLshort* v ) { }
-static void null_glVertexAttrib4svARB( GLuint index, const GLshort* v ) { }
-static void null_glVertexAttrib4svNV( GLuint index, const GLshort* v ) { }
+static void null_glVertexAttrib4sv( GLuint index, const GLshort *v ) { }
+static void null_glVertexAttrib4svARB( GLuint index, const GLshort *v ) { }
+static void null_glVertexAttrib4svNV( GLuint index, const GLshort *v ) { }
 static void null_glVertexAttrib4ubNV( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w ) { }
-static void null_glVertexAttrib4ubv( GLuint index, const GLubyte* v ) { }
-static void null_glVertexAttrib4ubvARB( GLuint index, const GLubyte* v ) { }
-static void null_glVertexAttrib4ubvNV( GLuint index, const GLubyte* v ) { }
-static void null_glVertexAttrib4uiv( GLuint index, const GLuint* v ) { }
-static void null_glVertexAttrib4uivARB( GLuint index, const GLuint* v ) { }
-static void null_glVertexAttrib4usv( GLuint index, const GLushort* v ) { }
-static void null_glVertexAttrib4usvARB( GLuint index, const GLushort* v ) { }
+static void null_glVertexAttrib4ubv( GLuint index, const GLubyte *v ) { }
+static void null_glVertexAttrib4ubvARB( GLuint index, const GLubyte *v ) { }
+static void null_glVertexAttrib4ubvNV( GLuint index, const GLubyte *v ) { }
+static void null_glVertexAttrib4uiv( GLuint index, const GLuint *v ) { }
+static void null_glVertexAttrib4uivARB( GLuint index, const GLuint *v ) { }
+static void null_glVertexAttrib4usv( GLuint index, const GLushort *v ) { }
+static void null_glVertexAttrib4usvARB( GLuint index, const GLushort *v ) { }
 static void null_glVertexAttribArrayObjectATI( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset ) { }
 static void null_glVertexAttribBinding( GLuint attribindex, GLuint bindingindex ) { }
 static void null_glVertexAttribDivisor( GLuint index, GLuint divisor ) { }
@@ -4750,269 +5084,269 @@
 static void null_glVertexAttribFormatNV( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride ) { }
 static void null_glVertexAttribI1i( GLuint index, GLint x ) { }
 static void null_glVertexAttribI1iEXT( GLuint index, GLint x ) { }
-static void null_glVertexAttribI1iv( GLuint index, const GLint* v ) { }
-static void null_glVertexAttribI1ivEXT( GLuint index, const GLint* v ) { }
+static void null_glVertexAttribI1iv( GLuint index, const GLint *v ) { }
+static void null_glVertexAttribI1ivEXT( GLuint index, const GLint *v ) { }
 static void null_glVertexAttribI1ui( GLuint index, GLuint x ) { }
 static void null_glVertexAttribI1uiEXT( GLuint index, GLuint x ) { }
-static void null_glVertexAttribI1uiv( GLuint index, const GLuint* v ) { }
-static void null_glVertexAttribI1uivEXT( GLuint index, const GLuint* v ) { }
+static void null_glVertexAttribI1uiv( GLuint index, const GLuint *v ) { }
+static void null_glVertexAttribI1uivEXT( GLuint index, const GLuint *v ) { }
 static void null_glVertexAttribI2i( GLuint index, GLint x, GLint y ) { }
 static void null_glVertexAttribI2iEXT( GLuint index, GLint x, GLint y ) { }
-static void null_glVertexAttribI2iv( GLuint index, const GLint* v ) { }
-static void null_glVertexAttribI2ivEXT( GLuint index, const GLint* v ) { }
+static void null_glVertexAttribI2iv( GLuint index, const GLint *v ) { }
+static void null_glVertexAttribI2ivEXT( GLuint index, const GLint *v ) { }
 static void null_glVertexAttribI2ui( GLuint index, GLuint x, GLuint y ) { }
 static void null_glVertexAttribI2uiEXT( GLuint index, GLuint x, GLuint y ) { }
-static void null_glVertexAttribI2uiv( GLuint index, const GLuint* v ) { }
-static void null_glVertexAttribI2uivEXT( GLuint index, const GLuint* v ) { }
+static void null_glVertexAttribI2uiv( GLuint index, const GLuint *v ) { }
+static void null_glVertexAttribI2uivEXT( GLuint index, const GLuint *v ) { }
 static void null_glVertexAttribI3i( GLuint index, GLint x, GLint y, GLint z ) { }
 static void null_glVertexAttribI3iEXT( GLuint index, GLint x, GLint y, GLint z ) { }
-static void null_glVertexAttribI3iv( GLuint index, const GLint* v ) { }
-static void null_glVertexAttribI3ivEXT( GLuint index, const GLint* v ) { }
+static void null_glVertexAttribI3iv( GLuint index, const GLint *v ) { }
+static void null_glVertexAttribI3ivEXT( GLuint index, const GLint *v ) { }
 static void null_glVertexAttribI3ui( GLuint index, GLuint x, GLuint y, GLuint z ) { }
 static void null_glVertexAttribI3uiEXT( GLuint index, GLuint x, GLuint y, GLuint z ) { }
-static void null_glVertexAttribI3uiv( GLuint index, const GLuint* v ) { }
-static void null_glVertexAttribI3uivEXT( GLuint index, const GLuint* v ) { }
-static void null_glVertexAttribI4bv( GLuint index, const GLbyte* v ) { }
-static void null_glVertexAttribI4bvEXT( GLuint index, const GLbyte* v ) { }
+static void null_glVertexAttribI3uiv( GLuint index, const GLuint *v ) { }
+static void null_glVertexAttribI3uivEXT( GLuint index, const GLuint *v ) { }
+static void null_glVertexAttribI4bv( GLuint index, const GLbyte *v ) { }
+static void null_glVertexAttribI4bvEXT( GLuint index, const GLbyte *v ) { }
 static void null_glVertexAttribI4i( GLuint index, GLint x, GLint y, GLint z, GLint w ) { }
 static void null_glVertexAttribI4iEXT( GLuint index, GLint x, GLint y, GLint z, GLint w ) { }
-static void null_glVertexAttribI4iv( GLuint index, const GLint* v ) { }
-static void null_glVertexAttribI4ivEXT( GLuint index, const GLint* v ) { }
-static void null_glVertexAttribI4sv( GLuint index, const GLshort* v ) { }
-static void null_glVertexAttribI4svEXT( GLuint index, const GLshort* v ) { }
-static void null_glVertexAttribI4ubv( GLuint index, const GLubyte* v ) { }
-static void null_glVertexAttribI4ubvEXT( GLuint index, const GLubyte* v ) { }
+static void null_glVertexAttribI4iv( GLuint index, const GLint *v ) { }
+static void null_glVertexAttribI4ivEXT( GLuint index, const GLint *v ) { }
+static void null_glVertexAttribI4sv( GLuint index, const GLshort *v ) { }
+static void null_glVertexAttribI4svEXT( GLuint index, const GLshort *v ) { }
+static void null_glVertexAttribI4ubv( GLuint index, const GLubyte *v ) { }
+static void null_glVertexAttribI4ubvEXT( GLuint index, const GLubyte *v ) { }
 static void null_glVertexAttribI4ui( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) { }
 static void null_glVertexAttribI4uiEXT( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w ) { }
-static void null_glVertexAttribI4uiv( GLuint index, const GLuint* v ) { }
-static void null_glVertexAttribI4uivEXT( GLuint index, const GLuint* v ) { }
-static void null_glVertexAttribI4usv( GLuint index, const GLushort* v ) { }
-static void null_glVertexAttribI4usvEXT( GLuint index, const GLushort* v ) { }
+static void null_glVertexAttribI4uiv( GLuint index, const GLuint *v ) { }
+static void null_glVertexAttribI4uivEXT( GLuint index, const GLuint *v ) { }
+static void null_glVertexAttribI4usv( GLuint index, const GLushort *v ) { }
+static void null_glVertexAttribI4usvEXT( GLuint index, const GLushort *v ) { }
 static void null_glVertexAttribIFormat( GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset ) { }
 static void null_glVertexAttribIFormatNV( GLuint index, GLint size, GLenum type, GLsizei stride ) { }
-static void null_glVertexAttribIPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer ) { }
-static void null_glVertexAttribIPointerEXT( GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer ) { }
+static void null_glVertexAttribIPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer ) { }
+static void null_glVertexAttribIPointerEXT( GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer ) { }
 static void null_glVertexAttribL1d( GLuint index, GLdouble x ) { }
 static void null_glVertexAttribL1dEXT( GLuint index, GLdouble x ) { }
-static void null_glVertexAttribL1dv( GLuint index, const GLdouble* v ) { }
-static void null_glVertexAttribL1dvEXT( GLuint index, const GLdouble* v ) { }
+static void null_glVertexAttribL1dv( GLuint index, const GLdouble *v ) { }
+static void null_glVertexAttribL1dvEXT( GLuint index, const GLdouble *v ) { }
 static void null_glVertexAttribL1i64NV( GLuint index, GLint64EXT x ) { }
-static void null_glVertexAttribL1i64vNV( GLuint index, const GLint64EXT* v ) { }
+static void null_glVertexAttribL1i64vNV( GLuint index, const GLint64EXT *v ) { }
 static void null_glVertexAttribL1ui64ARB( GLuint index, GLuint64EXT x ) { }
 static void null_glVertexAttribL1ui64NV( GLuint index, GLuint64EXT x ) { }
-static void null_glVertexAttribL1ui64vARB( GLuint index, const GLuint64EXT* v ) { }
-static void null_glVertexAttribL1ui64vNV( GLuint index, const GLuint64EXT* v ) { }
+static void null_glVertexAttribL1ui64vARB( GLuint index, const GLuint64EXT *v ) { }
+static void null_glVertexAttribL1ui64vNV( GLuint index, const GLuint64EXT *v ) { }
 static void null_glVertexAttribL2d( GLuint index, GLdouble x, GLdouble y ) { }
 static void null_glVertexAttribL2dEXT( GLuint index, GLdouble x, GLdouble y ) { }
-static void null_glVertexAttribL2dv( GLuint index, const GLdouble* v ) { }
-static void null_glVertexAttribL2dvEXT( GLuint index, const GLdouble* v ) { }
+static void null_glVertexAttribL2dv( GLuint index, const GLdouble *v ) { }
+static void null_glVertexAttribL2dvEXT( GLuint index, const GLdouble *v ) { }
 static void null_glVertexAttribL2i64NV( GLuint index, GLint64EXT x, GLint64EXT y ) { }
-static void null_glVertexAttribL2i64vNV( GLuint index, const GLint64EXT* v ) { }
+static void null_glVertexAttribL2i64vNV( GLuint index, const GLint64EXT *v ) { }
 static void null_glVertexAttribL2ui64NV( GLuint index, GLuint64EXT x, GLuint64EXT y ) { }
-static void null_glVertexAttribL2ui64vNV( GLuint index, const GLuint64EXT* v ) { }
+static void null_glVertexAttribL2ui64vNV( GLuint index, const GLuint64EXT *v ) { }
 static void null_glVertexAttribL3d( GLuint index, GLdouble x, GLdouble y, GLdouble z ) { }
 static void null_glVertexAttribL3dEXT( GLuint index, GLdouble x, GLdouble y, GLdouble z ) { }
-static void null_glVertexAttribL3dv( GLuint index, const GLdouble* v ) { }
-static void null_glVertexAttribL3dvEXT( GLuint index, const GLdouble* v ) { }
+static void null_glVertexAttribL3dv( GLuint index, const GLdouble *v ) { }
+static void null_glVertexAttribL3dvEXT( GLuint index, const GLdouble *v ) { }
 static void null_glVertexAttribL3i64NV( GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z ) { }
-static void null_glVertexAttribL3i64vNV( GLuint index, const GLint64EXT* v ) { }
+static void null_glVertexAttribL3i64vNV( GLuint index, const GLint64EXT *v ) { }
 static void null_glVertexAttribL3ui64NV( GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z ) { }
-static void null_glVertexAttribL3ui64vNV( GLuint index, const GLuint64EXT* v ) { }
+static void null_glVertexAttribL3ui64vNV( GLuint index, const GLuint64EXT *v ) { }
 static void null_glVertexAttribL4d( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
 static void null_glVertexAttribL4dEXT( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
-static void null_glVertexAttribL4dv( GLuint index, const GLdouble* v ) { }
-static void null_glVertexAttribL4dvEXT( GLuint index, const GLdouble* v ) { }
+static void null_glVertexAttribL4dv( GLuint index, const GLdouble *v ) { }
+static void null_glVertexAttribL4dvEXT( GLuint index, const GLdouble *v ) { }
 static void null_glVertexAttribL4i64NV( GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w ) { }
-static void null_glVertexAttribL4i64vNV( GLuint index, const GLint64EXT* v ) { }
+static void null_glVertexAttribL4i64vNV( GLuint index, const GLint64EXT *v ) { }
 static void null_glVertexAttribL4ui64NV( GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w ) { }
-static void null_glVertexAttribL4ui64vNV( GLuint index, const GLuint64EXT* v ) { }
+static void null_glVertexAttribL4ui64vNV( GLuint index, const GLuint64EXT *v ) { }
 static void null_glVertexAttribLFormat( GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset ) { }
 static void null_glVertexAttribLFormatNV( GLuint index, GLint size, GLenum type, GLsizei stride ) { }
-static void null_glVertexAttribLPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer ) { }
-static void null_glVertexAttribLPointerEXT( GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer ) { }
+static void null_glVertexAttribLPointer( GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer ) { }
+static void null_glVertexAttribLPointerEXT( GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer ) { }
 static void null_glVertexAttribP1ui( GLuint index, GLenum type, GLboolean normalized, GLuint value ) { }
-static void null_glVertexAttribP1uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint* value ) { }
+static void null_glVertexAttribP1uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint *value ) { }
 static void null_glVertexAttribP2ui( GLuint index, GLenum type, GLboolean normalized, GLuint value ) { }
-static void null_glVertexAttribP2uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint* value ) { }
+static void null_glVertexAttribP2uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint *value ) { }
 static void null_glVertexAttribP3ui( GLuint index, GLenum type, GLboolean normalized, GLuint value ) { }
-static void null_glVertexAttribP3uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint* value ) { }
+static void null_glVertexAttribP3uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint *value ) { }
 static void null_glVertexAttribP4ui( GLuint index, GLenum type, GLboolean normalized, GLuint value ) { }
-static void null_glVertexAttribP4uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint* value ) { }
+static void null_glVertexAttribP4uiv( GLuint index, GLenum type, GLboolean normalized, const GLuint *value ) { }
 static void null_glVertexAttribParameteriAMD( GLuint index, GLenum pname, GLint param ) { }
-static void null_glVertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer ) { }
-static void null_glVertexAttribPointerARB( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer ) { }
-static void null_glVertexAttribPointerNV( GLuint index, GLint fsize, GLenum type, GLsizei stride, const void* pointer ) { }
-static void null_glVertexAttribs1dvNV( GLuint index, GLsizei count, const GLdouble* v ) { }
-static void null_glVertexAttribs1fvNV( GLuint index, GLsizei count, const GLfloat* v ) { }
-static void null_glVertexAttribs1hvNV( GLuint index, GLsizei n, const GLhalfNV* v ) { }
-static void null_glVertexAttribs1svNV( GLuint index, GLsizei count, const GLshort* v ) { }
-static void null_glVertexAttribs2dvNV( GLuint index, GLsizei count, const GLdouble* v ) { }
-static void null_glVertexAttribs2fvNV( GLuint index, GLsizei count, const GLfloat* v ) { }
-static void null_glVertexAttribs2hvNV( GLuint index, GLsizei n, const GLhalfNV* v ) { }
-static void null_glVertexAttribs2svNV( GLuint index, GLsizei count, const GLshort* v ) { }
-static void null_glVertexAttribs3dvNV( GLuint index, GLsizei count, const GLdouble* v ) { }
-static void null_glVertexAttribs3fvNV( GLuint index, GLsizei count, const GLfloat* v ) { }
-static void null_glVertexAttribs3hvNV( GLuint index, GLsizei n, const GLhalfNV* v ) { }
-static void null_glVertexAttribs3svNV( GLuint index, GLsizei count, const GLshort* v ) { }
-static void null_glVertexAttribs4dvNV( GLuint index, GLsizei count, const GLdouble* v ) { }
-static void null_glVertexAttribs4fvNV( GLuint index, GLsizei count, const GLfloat* v ) { }
-static void null_glVertexAttribs4hvNV( GLuint index, GLsizei n, const GLhalfNV* v ) { }
-static void null_glVertexAttribs4svNV( GLuint index, GLsizei count, const GLshort* v ) { }
-static void null_glVertexAttribs4ubvNV( GLuint index, GLsizei count, const GLubyte* v ) { }
+static void null_glVertexAttribPointer( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer ) { }
+static void null_glVertexAttribPointerARB( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer ) { }
+static void null_glVertexAttribPointerNV( GLuint index, GLint fsize, GLenum type, GLsizei stride, const void *pointer ) { }
+static void null_glVertexAttribs1dvNV( GLuint index, GLsizei count, const GLdouble *v ) { }
+static void null_glVertexAttribs1fvNV( GLuint index, GLsizei count, const GLfloat *v ) { }
+static void null_glVertexAttribs1hvNV( GLuint index, GLsizei n, const GLhalfNV *v ) { }
+static void null_glVertexAttribs1svNV( GLuint index, GLsizei count, const GLshort *v ) { }
+static void null_glVertexAttribs2dvNV( GLuint index, GLsizei count, const GLdouble *v ) { }
+static void null_glVertexAttribs2fvNV( GLuint index, GLsizei count, const GLfloat *v ) { }
+static void null_glVertexAttribs2hvNV( GLuint index, GLsizei n, const GLhalfNV *v ) { }
+static void null_glVertexAttribs2svNV( GLuint index, GLsizei count, const GLshort *v ) { }
+static void null_glVertexAttribs3dvNV( GLuint index, GLsizei count, const GLdouble *v ) { }
+static void null_glVertexAttribs3fvNV( GLuint index, GLsizei count, const GLfloat *v ) { }
+static void null_glVertexAttribs3hvNV( GLuint index, GLsizei n, const GLhalfNV *v ) { }
+static void null_glVertexAttribs3svNV( GLuint index, GLsizei count, const GLshort *v ) { }
+static void null_glVertexAttribs4dvNV( GLuint index, GLsizei count, const GLdouble *v ) { }
+static void null_glVertexAttribs4fvNV( GLuint index, GLsizei count, const GLfloat *v ) { }
+static void null_glVertexAttribs4hvNV( GLuint index, GLsizei n, const GLhalfNV *v ) { }
+static void null_glVertexAttribs4svNV( GLuint index, GLsizei count, const GLshort *v ) { }
+static void null_glVertexAttribs4ubvNV( GLuint index, GLsizei count, const GLubyte *v ) { }
 static void null_glVertexBindingDivisor( GLuint bindingindex, GLuint divisor ) { }
 static void null_glVertexBlendARB( GLint count ) { }
 static void null_glVertexBlendEnvfATI( GLenum pname, GLfloat param ) { }
 static void null_glVertexBlendEnviATI( GLenum pname, GLint param ) { }
 static void null_glVertexFormatNV( GLint size, GLenum type, GLsizei stride ) { }
 static void null_glVertexP2ui( GLenum type, GLuint value ) { }
-static void null_glVertexP2uiv( GLenum type, const GLuint* value ) { }
+static void null_glVertexP2uiv( GLenum type, const GLuint *value ) { }
 static void null_glVertexP3ui( GLenum type, GLuint value ) { }
-static void null_glVertexP3uiv( GLenum type, const GLuint* value ) { }
+static void null_glVertexP3uiv( GLenum type, const GLuint *value ) { }
 static void null_glVertexP4ui( GLenum type, GLuint value ) { }
-static void null_glVertexP4uiv( GLenum type, const GLuint* value ) { }
-static void null_glVertexPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const void* pointer ) { }
-static void null_glVertexPointerListIBM( GLint size, GLenum type, GLint stride, const void** pointer, GLint ptrstride ) { }
-static void null_glVertexPointervINTEL( GLint size, GLenum type, const void** pointer ) { }
+static void null_glVertexP4uiv( GLenum type, const GLuint *value ) { }
+static void null_glVertexPointerEXT( GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer ) { }
+static void null_glVertexPointerListIBM( GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride ) { }
+static void null_glVertexPointervINTEL( GLint size, GLenum type, const void **pointer ) { }
 static void null_glVertexStream1dATI( GLenum stream, GLdouble x ) { }
-static void null_glVertexStream1dvATI( GLenum stream, const GLdouble* coords ) { }
+static void null_glVertexStream1dvATI( GLenum stream, const GLdouble *coords ) { }
 static void null_glVertexStream1fATI( GLenum stream, GLfloat x ) { }
-static void null_glVertexStream1fvATI( GLenum stream, const GLfloat* coords ) { }
+static void null_glVertexStream1fvATI( GLenum stream, const GLfloat *coords ) { }
 static void null_glVertexStream1iATI( GLenum stream, GLint x ) { }
-static void null_glVertexStream1ivATI( GLenum stream, const GLint* coords ) { }
+static void null_glVertexStream1ivATI( GLenum stream, const GLint *coords ) { }
 static void null_glVertexStream1sATI( GLenum stream, GLshort x ) { }
-static void null_glVertexStream1svATI( GLenum stream, const GLshort* coords ) { }
+static void null_glVertexStream1svATI( GLenum stream, const GLshort *coords ) { }
 static void null_glVertexStream2dATI( GLenum stream, GLdouble x, GLdouble y ) { }
-static void null_glVertexStream2dvATI( GLenum stream, const GLdouble* coords ) { }
+static void null_glVertexStream2dvATI( GLenum stream, const GLdouble *coords ) { }
 static void null_glVertexStream2fATI( GLenum stream, GLfloat x, GLfloat y ) { }
-static void null_glVertexStream2fvATI( GLenum stream, const GLfloat* coords ) { }
+static void null_glVertexStream2fvATI( GLenum stream, const GLfloat *coords ) { }
 static void null_glVertexStream2iATI( GLenum stream, GLint x, GLint y ) { }
-static void null_glVertexStream2ivATI( GLenum stream, const GLint* coords ) { }
+static void null_glVertexStream2ivATI( GLenum stream, const GLint *coords ) { }
 static void null_glVertexStream2sATI( GLenum stream, GLshort x, GLshort y ) { }
-static void null_glVertexStream2svATI( GLenum stream, const GLshort* coords ) { }
+static void null_glVertexStream2svATI( GLenum stream, const GLshort *coords ) { }
 static void null_glVertexStream3dATI( GLenum stream, GLdouble x, GLdouble y, GLdouble z ) { }
-static void null_glVertexStream3dvATI( GLenum stream, const GLdouble* coords ) { }
+static void null_glVertexStream3dvATI( GLenum stream, const GLdouble *coords ) { }
 static void null_glVertexStream3fATI( GLenum stream, GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glVertexStream3fvATI( GLenum stream, const GLfloat* coords ) { }
+static void null_glVertexStream3fvATI( GLenum stream, const GLfloat *coords ) { }
 static void null_glVertexStream3iATI( GLenum stream, GLint x, GLint y, GLint z ) { }
-static void null_glVertexStream3ivATI( GLenum stream, const GLint* coords ) { }
+static void null_glVertexStream3ivATI( GLenum stream, const GLint *coords ) { }
 static void null_glVertexStream3sATI( GLenum stream, GLshort x, GLshort y, GLshort z ) { }
-static void null_glVertexStream3svATI( GLenum stream, const GLshort* coords ) { }
+static void null_glVertexStream3svATI( GLenum stream, const GLshort *coords ) { }
 static void null_glVertexStream4dATI( GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
-static void null_glVertexStream4dvATI( GLenum stream, const GLdouble* coords ) { }
+static void null_glVertexStream4dvATI( GLenum stream, const GLdouble *coords ) { }
 static void null_glVertexStream4fATI( GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { }
-static void null_glVertexStream4fvATI( GLenum stream, const GLfloat* coords ) { }
+static void null_glVertexStream4fvATI( GLenum stream, const GLfloat *coords ) { }
 static void null_glVertexStream4iATI( GLenum stream, GLint x, GLint y, GLint z, GLint w ) { }
-static void null_glVertexStream4ivATI( GLenum stream, const GLint* coords ) { }
+static void null_glVertexStream4ivATI( GLenum stream, const GLint *coords ) { }
 static void null_glVertexStream4sATI( GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w ) { }
-static void null_glVertexStream4svATI( GLenum stream, const GLshort* coords ) { }
-static void null_glVertexWeightPointerEXT( GLint size, GLenum type, GLsizei stride, const void* pointer ) { }
+static void null_glVertexStream4svATI( GLenum stream, const GLshort *coords ) { }
+static void null_glVertexWeightPointerEXT( GLint size, GLenum type, GLsizei stride, const void *pointer ) { }
 static void null_glVertexWeightfEXT( GLfloat weight ) { }
-static void null_glVertexWeightfvEXT( const GLfloat* weight ) { }
+static void null_glVertexWeightfvEXT( const GLfloat *weight ) { }
 static void null_glVertexWeighthNV( GLhalfNV weight ) { }
-static void null_glVertexWeighthvNV( const GLhalfNV* weight ) { }
-static GLenum null_glVideoCaptureNV( GLuint video_capture_slot, GLuint* sequence_num, GLuint64EXT* capture_time ) { return 0; }
-static void null_glVideoCaptureStreamParameterdvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLdouble* params ) { }
-static void null_glVideoCaptureStreamParameterfvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLfloat* params ) { }
-static void null_glVideoCaptureStreamParameterivNV( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLint* params ) { }
-static void null_glViewportArrayv( GLuint first, GLsizei count, const GLfloat* v ) { }
+static void null_glVertexWeighthvNV( const GLhalfNV *weight ) { }
+static GLenum null_glVideoCaptureNV( GLuint video_capture_slot, GLuint *sequence_num, GLuint64EXT *capture_time ) { return 0; }
+static void null_glVideoCaptureStreamParameterdvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLdouble *params ) { }
+static void null_glVideoCaptureStreamParameterfvNV( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLfloat *params ) { }
+static void null_glVideoCaptureStreamParameterivNV( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLint *params ) { }
+static void null_glViewportArrayv( GLuint first, GLsizei count, const GLfloat *v ) { }
 static void null_glViewportIndexedf( GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h ) { }
-static void null_glViewportIndexedfv( GLuint index, const GLfloat* v ) { }
+static void null_glViewportIndexedfv( GLuint index, const GLfloat *v ) { }
 static void null_glViewportPositionWScaleNV( GLuint index, GLfloat xcoeff, GLfloat ycoeff ) { }
 static void null_glViewportSwizzleNV( GLuint index, GLenum swizzlex, GLenum swizzley, GLenum swizzlez, GLenum swizzlew ) { }
-static void null_glWaitSemaphoreEXT( GLuint semaphore, GLuint numBufferBarriers, const GLuint* buffers, GLuint numTextureBarriers, const GLuint* textures, const GLenum* srcLayouts ) { }
+static void null_glWaitSemaphoreEXT( GLuint semaphore, GLuint numBufferBarriers, const GLuint *buffers, GLuint numTextureBarriers, const GLuint *textures, const GLenum *srcLayouts ) { }
 static void null_glWaitSync( GLsync sync, GLbitfield flags, GLuint64 timeout ) { }
 static void null_glWaitVkSemaphoreNV( GLuint64 vkSemaphore ) { }
-static void null_glWeightPathsNV( GLuint resultPath, GLsizei numPaths, const GLuint* paths, const GLfloat* weights ) { }
-static void null_glWeightPointerARB( GLint size, GLenum type, GLsizei stride, const void* pointer ) { }
-static void null_glWeightbvARB( GLint size, const GLbyte* weights ) { }
-static void null_glWeightdvARB( GLint size, const GLdouble* weights ) { }
-static void null_glWeightfvARB( GLint size, const GLfloat* weights ) { }
-static void null_glWeightivARB( GLint size, const GLint* weights ) { }
-static void null_glWeightsvARB( GLint size, const GLshort* weights ) { }
-static void null_glWeightubvARB( GLint size, const GLubyte* weights ) { }
-static void null_glWeightuivARB( GLint size, const GLuint* weights ) { }
-static void null_glWeightusvARB( GLint size, const GLushort* weights ) { }
+static void null_glWeightPathsNV( GLuint resultPath, GLsizei numPaths, const GLuint *paths, const GLfloat *weights ) { }
+static void null_glWeightPointerARB( GLint size, GLenum type, GLsizei stride, const void *pointer ) { }
+static void null_glWeightbvARB( GLint size, const GLbyte *weights ) { }
+static void null_glWeightdvARB( GLint size, const GLdouble *weights ) { }
+static void null_glWeightfvARB( GLint size, const GLfloat *weights ) { }
+static void null_glWeightivARB( GLint size, const GLint *weights ) { }
+static void null_glWeightsvARB( GLint size, const GLshort *weights ) { }
+static void null_glWeightubvARB( GLint size, const GLubyte *weights ) { }
+static void null_glWeightuivARB( GLint size, const GLuint *weights ) { }
+static void null_glWeightusvARB( GLint size, const GLushort *weights ) { }
 static void null_glWindowPos2d( GLdouble x, GLdouble y ) { }
 static void null_glWindowPos2dARB( GLdouble x, GLdouble y ) { }
 static void null_glWindowPos2dMESA( GLdouble x, GLdouble y ) { }
-static void null_glWindowPos2dv( const GLdouble* v ) { }
-static void null_glWindowPos2dvARB( const GLdouble* v ) { }
-static void null_glWindowPos2dvMESA( const GLdouble* v ) { }
+static void null_glWindowPos2dv( const GLdouble *v ) { }
+static void null_glWindowPos2dvARB( const GLdouble *v ) { }
+static void null_glWindowPos2dvMESA( const GLdouble *v ) { }
 static void null_glWindowPos2f( GLfloat x, GLfloat y ) { }
 static void null_glWindowPos2fARB( GLfloat x, GLfloat y ) { }
 static void null_glWindowPos2fMESA( GLfloat x, GLfloat y ) { }
-static void null_glWindowPos2fv( const GLfloat* v ) { }
-static void null_glWindowPos2fvARB( const GLfloat* v ) { }
-static void null_glWindowPos2fvMESA( const GLfloat* v ) { }
+static void null_glWindowPos2fv( const GLfloat *v ) { }
+static void null_glWindowPos2fvARB( const GLfloat *v ) { }
+static void null_glWindowPos2fvMESA( const GLfloat *v ) { }
 static void null_glWindowPos2i( GLint x, GLint y ) { }
 static void null_glWindowPos2iARB( GLint x, GLint y ) { }
 static void null_glWindowPos2iMESA( GLint x, GLint y ) { }
-static void null_glWindowPos2iv( const GLint* v ) { }
-static void null_glWindowPos2ivARB( const GLint* v ) { }
-static void null_glWindowPos2ivMESA( const GLint* v ) { }
+static void null_glWindowPos2iv( const GLint *v ) { }
+static void null_glWindowPos2ivARB( const GLint *v ) { }
+static void null_glWindowPos2ivMESA( const GLint *v ) { }
 static void null_glWindowPos2s( GLshort x, GLshort y ) { }
 static void null_glWindowPos2sARB( GLshort x, GLshort y ) { }
 static void null_glWindowPos2sMESA( GLshort x, GLshort y ) { }
-static void null_glWindowPos2sv( const GLshort* v ) { }
-static void null_glWindowPos2svARB( const GLshort* v ) { }
-static void null_glWindowPos2svMESA( const GLshort* v ) { }
+static void null_glWindowPos2sv( const GLshort *v ) { }
+static void null_glWindowPos2svARB( const GLshort *v ) { }
+static void null_glWindowPos2svMESA( const GLshort *v ) { }
 static void null_glWindowPos3d( GLdouble x, GLdouble y, GLdouble z ) { }
 static void null_glWindowPos3dARB( GLdouble x, GLdouble y, GLdouble z ) { }
 static void null_glWindowPos3dMESA( GLdouble x, GLdouble y, GLdouble z ) { }
-static void null_glWindowPos3dv( const GLdouble* v ) { }
-static void null_glWindowPos3dvARB( const GLdouble* v ) { }
-static void null_glWindowPos3dvMESA( const GLdouble* v ) { }
+static void null_glWindowPos3dv( const GLdouble *v ) { }
+static void null_glWindowPos3dvARB( const GLdouble *v ) { }
+static void null_glWindowPos3dvMESA( const GLdouble *v ) { }
 static void null_glWindowPos3f( GLfloat x, GLfloat y, GLfloat z ) { }
 static void null_glWindowPos3fARB( GLfloat x, GLfloat y, GLfloat z ) { }
 static void null_glWindowPos3fMESA( GLfloat x, GLfloat y, GLfloat z ) { }
-static void null_glWindowPos3fv( const GLfloat* v ) { }
-static void null_glWindowPos3fvARB( const GLfloat* v ) { }
-static void null_glWindowPos3fvMESA( const GLfloat* v ) { }
+static void null_glWindowPos3fv( const GLfloat *v ) { }
+static void null_glWindowPos3fvARB( const GLfloat *v ) { }
+static void null_glWindowPos3fvMESA( const GLfloat *v ) { }
 static void null_glWindowPos3i( GLint x, GLint y, GLint z ) { }
 static void null_glWindowPos3iARB( GLint x, GLint y, GLint z ) { }
 static void null_glWindowPos3iMESA( GLint x, GLint y, GLint z ) { }
-static void null_glWindowPos3iv( const GLint* v ) { }
-static void null_glWindowPos3ivARB( const GLint* v ) { }
-static void null_glWindowPos3ivMESA( const GLint* v ) { }
+static void null_glWindowPos3iv( const GLint *v ) { }
+static void null_glWindowPos3ivARB( const GLint *v ) { }
+static void null_glWindowPos3ivMESA( const GLint *v ) { }
 static void null_glWindowPos3s( GLshort x, GLshort y, GLshort z ) { }
 static void null_glWindowPos3sARB( GLshort x, GLshort y, GLshort z ) { }
 static void null_glWindowPos3sMESA( GLshort x, GLshort y, GLshort z ) { }
-static void null_glWindowPos3sv( const GLshort* v ) { }
-static void null_glWindowPos3svARB( const GLshort* v ) { }
-static void null_glWindowPos3svMESA( const GLshort* v ) { }
+static void null_glWindowPos3sv( const GLshort *v ) { }
+static void null_glWindowPos3svARB( const GLshort *v ) { }
+static void null_glWindowPos3svMESA( const GLshort *v ) { }
 static void null_glWindowPos4dMESA( GLdouble x, GLdouble y, GLdouble z, GLdouble w ) { }
-static void null_glWindowPos4dvMESA( const GLdouble* v ) { }
+static void null_glWindowPos4dvMESA( const GLdouble *v ) { }
 static void null_glWindowPos4fMESA( GLfloat x, GLfloat y, GLfloat z, GLfloat w ) { }
-static void null_glWindowPos4fvMESA( const GLfloat* v ) { }
+static void null_glWindowPos4fvMESA( const GLfloat *v ) { }
 static void null_glWindowPos4iMESA( GLint x, GLint y, GLint z, GLint w ) { }
-static void null_glWindowPos4ivMESA( const GLint* v ) { }
+static void null_glWindowPos4ivMESA( const GLint *v ) { }
 static void null_glWindowPos4sMESA( GLshort x, GLshort y, GLshort z, GLshort w ) { }
-static void null_glWindowPos4svMESA( const GLshort* v ) { }
-static void null_glWindowRectanglesEXT( GLenum mode, GLsizei count, const GLint* box ) { }
+static void null_glWindowPos4svMESA( const GLshort *v ) { }
+static void null_glWindowRectanglesEXT( GLenum mode, GLsizei count, const GLint *box ) { }
 static void null_glWriteMaskEXT( GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW ) { }
-static void* null_wglAllocateMemoryNV( GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority ) { return 0; }
+static void * null_wglAllocateMemoryNV( GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority ) { return 0; }
 static BOOL null_wglBindTexImageARB( struct wgl_pbuffer * hPbuffer, int iBuffer ) { return 0; }
-static BOOL null_wglChoosePixelFormatARB( HDC hdc, const int* piAttribIList, const FLOAT* pfAttribFList, UINT nMaxFormats, int* piFormats, UINT* nNumFormats ) { return 0; }
-static struct wgl_context * null_wglCreateContextAttribsARB( HDC hDC, struct wgl_context * hShareContext, const int* attribList ) { return 0; }
-static struct wgl_pbuffer * null_wglCreatePbufferARB( HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int* piAttribList ) { return 0; }
+static BOOL null_wglChoosePixelFormatARB( HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats ) { return 0; }
+static struct wgl_context * null_wglCreateContextAttribsARB( HDC hDC, struct wgl_context * hShareContext, const int *attribList ) { return 0; }
+static struct wgl_pbuffer * null_wglCreatePbufferARB( HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList ) { return 0; }
 static BOOL null_wglDestroyPbufferARB( struct wgl_pbuffer * hPbuffer ) { return 0; }
-static void null_wglFreeMemoryNV( void* pointer ) { }
-static HDC null_wglGetCurrentReadDCARB( void ) { return 0; }
-static const char* null_wglGetExtensionsStringARB( HDC hdc ) { return 0; }
-static const char* null_wglGetExtensionsStringEXT( void ) { return 0; }
+static void null_wglFreeMemoryNV( void *pointer ) { }
+static HDC null_wglGetCurrentReadDCARB(void) { return 0; }
+static const char * null_wglGetExtensionsStringARB( HDC hdc ) { return 0; }
+static const char * null_wglGetExtensionsStringEXT(void) { return 0; }
 static HDC null_wglGetPbufferDCARB( struct wgl_pbuffer * hPbuffer ) { return 0; }
-static BOOL null_wglGetPixelFormatAttribfvARB( HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int* piAttributes, FLOAT* pfValues ) { return 0; }
-static BOOL null_wglGetPixelFormatAttribivARB( HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int* piAttributes, int* piValues ) { return 0; }
-static int null_wglGetSwapIntervalEXT( void ) { return 0; }
+static BOOL null_wglGetPixelFormatAttribfvARB( HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues ) { return 0; }
+static BOOL null_wglGetPixelFormatAttribivARB( HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues ) { return 0; }
+static int null_wglGetSwapIntervalEXT(void) { return 0; }
 static BOOL null_wglMakeContextCurrentARB( HDC hDrawDC, HDC hReadDC, struct wgl_context * hglrc ) { return 0; }
-static BOOL null_wglQueryCurrentRendererIntegerWINE( GLenum attribute, GLuint* value ) { return 0; }
-static const GLchar* null_wglQueryCurrentRendererStringWINE( GLenum attribute ) { return 0; }
-static BOOL null_wglQueryPbufferARB( struct wgl_pbuffer * hPbuffer, int iAttribute, int* piValue ) { return 0; }
-static BOOL null_wglQueryRendererIntegerWINE( HDC dc, GLint renderer, GLenum attribute, GLuint* value ) { return 0; }
-static const GLchar* null_wglQueryRendererStringWINE( HDC dc, GLint renderer, GLenum attribute ) { return 0; }
+static BOOL null_wglQueryCurrentRendererIntegerWINE( GLenum attribute, GLuint *value ) { return 0; }
+static const GLchar * null_wglQueryCurrentRendererStringWINE( GLenum attribute ) { return 0; }
+static BOOL null_wglQueryPbufferARB( struct wgl_pbuffer * hPbuffer, int iAttribute, int *piValue ) { return 0; }
+static BOOL null_wglQueryRendererIntegerWINE( HDC dc, GLint renderer, GLenum attribute, GLuint *value ) { return 0; }
+static const GLchar * null_wglQueryRendererStringWINE( HDC dc, GLint renderer, GLenum attribute ) { return 0; }
 static int null_wglReleasePbufferDCARB( struct wgl_pbuffer * hPbuffer, HDC hDC ) { return 0; }
 static BOOL null_wglReleaseTexImageARB( struct wgl_pbuffer * hPbuffer, int iBuffer ) { return 0; }
-static BOOL null_wglSetPbufferAttribARB( struct wgl_pbuffer * hPbuffer, const int* piAttribList ) { return 0; }
+static BOOL null_wglSetPbufferAttribARB( struct wgl_pbuffer * hPbuffer, const int *piAttribList ) { return 0; }
 static BOOL null_wglSetPixelFormatWINE( HDC hdc, int format ) { return 0; }
 static BOOL null_wglSwapIntervalEXT( int interval ) { return 0; }
 
diff --git a/include/wine/wgl.h b/include/wine/wgl.h
index fe78f13..1978183 100644
--- a/include/wine/wgl.h
+++ b/include/wine/wgl.h
@@ -7,6 +7,9 @@
 #define GLAPIENTRY __stdcall
 #endif
 
+#undef near
+#undef far
+
 typedef unsigned int           GLbitfield;
 typedef unsigned char          GLboolean;
 typedef signed char            GLbyte;
@@ -5814,342 +5817,342 @@
 #define WGL_RENDERER_VERSION_WINE                                                0x8185
 #define WGL_RENDERER_VIDEO_MEMORY_WINE                                           0x8187
 
-void       GLAPIENTRY glAccum(GLenum,GLfloat);
-void       GLAPIENTRY glAlphaFunc(GLenum,GLfloat);
-GLboolean  GLAPIENTRY glAreTexturesResident(GLsizei,const GLuint*,GLboolean*);
-void       GLAPIENTRY glArrayElement(GLint);
-void       GLAPIENTRY glBegin(GLenum);
-void       GLAPIENTRY glBindTexture(GLenum,GLuint);
-void       GLAPIENTRY glBitmap(GLsizei,GLsizei,GLfloat,GLfloat,GLfloat,GLfloat,const GLubyte*);
-void       GLAPIENTRY glBlendFunc(GLenum,GLenum);
-void       GLAPIENTRY glCallList(GLuint);
-void       GLAPIENTRY glCallLists(GLsizei,GLenum,const void*);
-void       GLAPIENTRY glClear(GLbitfield);
-void       GLAPIENTRY glClearAccum(GLfloat,GLfloat,GLfloat,GLfloat);
-void       GLAPIENTRY glClearColor(GLfloat,GLfloat,GLfloat,GLfloat);
-void       GLAPIENTRY glClearDepth(GLdouble);
-void       GLAPIENTRY glClearIndex(GLfloat);
-void       GLAPIENTRY glClearStencil(GLint);
-void       GLAPIENTRY glClipPlane(GLenum,const GLdouble*);
-void       GLAPIENTRY glColor3b(GLbyte,GLbyte,GLbyte);
-void       GLAPIENTRY glColor3bv(const GLbyte*);
-void       GLAPIENTRY glColor3d(GLdouble,GLdouble,GLdouble);
-void       GLAPIENTRY glColor3dv(const GLdouble*);
-void       GLAPIENTRY glColor3f(GLfloat,GLfloat,GLfloat);
-void       GLAPIENTRY glColor3fv(const GLfloat*);
-void       GLAPIENTRY glColor3i(GLint,GLint,GLint);
-void       GLAPIENTRY glColor3iv(const GLint*);
-void       GLAPIENTRY glColor3s(GLshort,GLshort,GLshort);
-void       GLAPIENTRY glColor3sv(const GLshort*);
-void       GLAPIENTRY glColor3ub(GLubyte,GLubyte,GLubyte);
-void       GLAPIENTRY glColor3ubv(const GLubyte*);
-void       GLAPIENTRY glColor3ui(GLuint,GLuint,GLuint);
-void       GLAPIENTRY glColor3uiv(const GLuint*);
-void       GLAPIENTRY glColor3us(GLushort,GLushort,GLushort);
-void       GLAPIENTRY glColor3usv(const GLushort*);
-void       GLAPIENTRY glColor4b(GLbyte,GLbyte,GLbyte,GLbyte);
-void       GLAPIENTRY glColor4bv(const GLbyte*);
-void       GLAPIENTRY glColor4d(GLdouble,GLdouble,GLdouble,GLdouble);
-void       GLAPIENTRY glColor4dv(const GLdouble*);
-void       GLAPIENTRY glColor4f(GLfloat,GLfloat,GLfloat,GLfloat);
-void       GLAPIENTRY glColor4fv(const GLfloat*);
-void       GLAPIENTRY glColor4i(GLint,GLint,GLint,GLint);
-void       GLAPIENTRY glColor4iv(const GLint*);
-void       GLAPIENTRY glColor4s(GLshort,GLshort,GLshort,GLshort);
-void       GLAPIENTRY glColor4sv(const GLshort*);
-void       GLAPIENTRY glColor4ub(GLubyte,GLubyte,GLubyte,GLubyte);
-void       GLAPIENTRY glColor4ubv(const GLubyte*);
-void       GLAPIENTRY glColor4ui(GLuint,GLuint,GLuint,GLuint);
-void       GLAPIENTRY glColor4uiv(const GLuint*);
-void       GLAPIENTRY glColor4us(GLushort,GLushort,GLushort,GLushort);
-void       GLAPIENTRY glColor4usv(const GLushort*);
-void       GLAPIENTRY glColorMask(GLboolean,GLboolean,GLboolean,GLboolean);
-void       GLAPIENTRY glColorMaterial(GLenum,GLenum);
-void       GLAPIENTRY glColorPointer(GLint,GLenum,GLsizei,const void*);
-void       GLAPIENTRY glCopyPixels(GLint,GLint,GLsizei,GLsizei,GLenum);
-void       GLAPIENTRY glCopyTexImage1D(GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLint);
-void       GLAPIENTRY glCopyTexImage2D(GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLsizei,GLint);
-void       GLAPIENTRY glCopyTexSubImage1D(GLenum,GLint,GLint,GLint,GLint,GLsizei);
-void       GLAPIENTRY glCopyTexSubImage2D(GLenum,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei);
-void       GLAPIENTRY glCullFace(GLenum);
-GLint      GLAPIENTRY glDebugEntry(GLint,GLint);
-void       GLAPIENTRY glDeleteLists(GLuint,GLsizei);
-void       GLAPIENTRY glDeleteTextures(GLsizei,const GLuint*);
-void       GLAPIENTRY glDepthFunc(GLenum);
-void       GLAPIENTRY glDepthMask(GLboolean);
-void       GLAPIENTRY glDepthRange(GLdouble,GLdouble);
-void       GLAPIENTRY glDisable(GLenum);
-void       GLAPIENTRY glDisableClientState(GLenum);
-void       GLAPIENTRY glDrawArrays(GLenum,GLint,GLsizei);
-void       GLAPIENTRY glDrawBuffer(GLenum);
-void       GLAPIENTRY glDrawElements(GLenum,GLsizei,GLenum,const void*);
-void       GLAPIENTRY glDrawPixels(GLsizei,GLsizei,GLenum,GLenum,const void*);
-void       GLAPIENTRY glEdgeFlag(GLboolean);
-void       GLAPIENTRY glEdgeFlagPointer(GLsizei,const void*);
-void       GLAPIENTRY glEdgeFlagv(const GLboolean*);
-void       GLAPIENTRY glEnable(GLenum);
-void       GLAPIENTRY glEnableClientState(GLenum);
+void       GLAPIENTRY glAccum( GLenum op, GLfloat value );
+void       GLAPIENTRY glAlphaFunc( GLenum func, GLfloat ref );
+GLboolean  GLAPIENTRY glAreTexturesResident( GLsizei n, const GLuint *textures, GLboolean *residences );
+void       GLAPIENTRY glArrayElement( GLint i );
+void       GLAPIENTRY glBegin( GLenum mode );
+void       GLAPIENTRY glBindTexture( GLenum target, GLuint texture );
+void       GLAPIENTRY glBitmap( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap );
+void       GLAPIENTRY glBlendFunc( GLenum sfactor, GLenum dfactor );
+void       GLAPIENTRY glCallList( GLuint list );
+void       GLAPIENTRY glCallLists( GLsizei n, GLenum type, const void *lists );
+void       GLAPIENTRY glClear( GLbitfield mask );
+void       GLAPIENTRY glClearAccum( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
+void       GLAPIENTRY glClearColor( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
+void       GLAPIENTRY glClearDepth( GLdouble depth );
+void       GLAPIENTRY glClearIndex( GLfloat c );
+void       GLAPIENTRY glClearStencil( GLint s );
+void       GLAPIENTRY glClipPlane( GLenum plane, const GLdouble *equation );
+void       GLAPIENTRY glColor3b( GLbyte red, GLbyte green, GLbyte blue );
+void       GLAPIENTRY glColor3bv( const GLbyte *v );
+void       GLAPIENTRY glColor3d( GLdouble red, GLdouble green, GLdouble blue );
+void       GLAPIENTRY glColor3dv( const GLdouble *v );
+void       GLAPIENTRY glColor3f( GLfloat red, GLfloat green, GLfloat blue );
+void       GLAPIENTRY glColor3fv( const GLfloat *v );
+void       GLAPIENTRY glColor3i( GLint red, GLint green, GLint blue );
+void       GLAPIENTRY glColor3iv( const GLint *v );
+void       GLAPIENTRY glColor3s( GLshort red, GLshort green, GLshort blue );
+void       GLAPIENTRY glColor3sv( const GLshort *v );
+void       GLAPIENTRY glColor3ub( GLubyte red, GLubyte green, GLubyte blue );
+void       GLAPIENTRY glColor3ubv( const GLubyte *v );
+void       GLAPIENTRY glColor3ui( GLuint red, GLuint green, GLuint blue );
+void       GLAPIENTRY glColor3uiv( const GLuint *v );
+void       GLAPIENTRY glColor3us( GLushort red, GLushort green, GLushort blue );
+void       GLAPIENTRY glColor3usv( const GLushort *v );
+void       GLAPIENTRY glColor4b( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha );
+void       GLAPIENTRY glColor4bv( const GLbyte *v );
+void       GLAPIENTRY glColor4d( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha );
+void       GLAPIENTRY glColor4dv( const GLdouble *v );
+void       GLAPIENTRY glColor4f( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
+void       GLAPIENTRY glColor4fv( const GLfloat *v );
+void       GLAPIENTRY glColor4i( GLint red, GLint green, GLint blue, GLint alpha );
+void       GLAPIENTRY glColor4iv( const GLint *v );
+void       GLAPIENTRY glColor4s( GLshort red, GLshort green, GLshort blue, GLshort alpha );
+void       GLAPIENTRY glColor4sv( const GLshort *v );
+void       GLAPIENTRY glColor4ub( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
+void       GLAPIENTRY glColor4ubv( const GLubyte *v );
+void       GLAPIENTRY glColor4ui( GLuint red, GLuint green, GLuint blue, GLuint alpha );
+void       GLAPIENTRY glColor4uiv( const GLuint *v );
+void       GLAPIENTRY glColor4us( GLushort red, GLushort green, GLushort blue, GLushort alpha );
+void       GLAPIENTRY glColor4usv( const GLushort *v );
+void       GLAPIENTRY glColorMask( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha );
+void       GLAPIENTRY glColorMaterial( GLenum face, GLenum mode );
+void       GLAPIENTRY glColorPointer( GLint size, GLenum type, GLsizei stride, const void *pointer );
+void       GLAPIENTRY glCopyPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type );
+void       GLAPIENTRY glCopyTexImage1D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border );
+void       GLAPIENTRY glCopyTexImage2D( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border );
+void       GLAPIENTRY glCopyTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width );
+void       GLAPIENTRY glCopyTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height );
+void       GLAPIENTRY glCullFace( GLenum mode );
+GLint      GLAPIENTRY glDebugEntry( GLint unknown1, GLint unknown2 );
+void       GLAPIENTRY glDeleteLists( GLuint list, GLsizei range );
+void       GLAPIENTRY glDeleteTextures( GLsizei n, const GLuint *textures );
+void       GLAPIENTRY glDepthFunc( GLenum func );
+void       GLAPIENTRY glDepthMask( GLboolean flag );
+void       GLAPIENTRY glDepthRange( GLdouble near, GLdouble far );
+void       GLAPIENTRY glDisable( GLenum cap );
+void       GLAPIENTRY glDisableClientState( GLenum array );
+void       GLAPIENTRY glDrawArrays( GLenum mode, GLint first, GLsizei count );
+void       GLAPIENTRY glDrawBuffer( GLenum buf );
+void       GLAPIENTRY glDrawElements( GLenum mode, GLsizei count, GLenum type, const void *indices );
+void       GLAPIENTRY glDrawPixels( GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels );
+void       GLAPIENTRY glEdgeFlag( GLboolean flag );
+void       GLAPIENTRY glEdgeFlagPointer( GLsizei stride, const void *pointer );
+void       GLAPIENTRY glEdgeFlagv( const GLboolean *flag );
+void       GLAPIENTRY glEnable( GLenum cap );
+void       GLAPIENTRY glEnableClientState( GLenum array );
 void       GLAPIENTRY glEnd(void);
 void       GLAPIENTRY glEndList(void);
-void       GLAPIENTRY glEvalCoord1d(GLdouble);
-void       GLAPIENTRY glEvalCoord1dv(const GLdouble*);
-void       GLAPIENTRY glEvalCoord1f(GLfloat);
-void       GLAPIENTRY glEvalCoord1fv(const GLfloat*);
-void       GLAPIENTRY glEvalCoord2d(GLdouble,GLdouble);
-void       GLAPIENTRY glEvalCoord2dv(const GLdouble*);
-void       GLAPIENTRY glEvalCoord2f(GLfloat,GLfloat);
-void       GLAPIENTRY glEvalCoord2fv(const GLfloat*);
-void       GLAPIENTRY glEvalMesh1(GLenum,GLint,GLint);
-void       GLAPIENTRY glEvalMesh2(GLenum,GLint,GLint,GLint,GLint);
-void       GLAPIENTRY glEvalPoint1(GLint);
-void       GLAPIENTRY glEvalPoint2(GLint,GLint);
-void       GLAPIENTRY glFeedbackBuffer(GLsizei,GLenum,GLfloat*);
+void       GLAPIENTRY glEvalCoord1d( GLdouble u );
+void       GLAPIENTRY glEvalCoord1dv( const GLdouble *u );
+void       GLAPIENTRY glEvalCoord1f( GLfloat u );
+void       GLAPIENTRY glEvalCoord1fv( const GLfloat *u );
+void       GLAPIENTRY glEvalCoord2d( GLdouble u, GLdouble v );
+void       GLAPIENTRY glEvalCoord2dv( const GLdouble *u );
+void       GLAPIENTRY glEvalCoord2f( GLfloat u, GLfloat v );
+void       GLAPIENTRY glEvalCoord2fv( const GLfloat *u );
+void       GLAPIENTRY glEvalMesh1( GLenum mode, GLint i1, GLint i2 );
+void       GLAPIENTRY glEvalMesh2( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 );
+void       GLAPIENTRY glEvalPoint1( GLint i );
+void       GLAPIENTRY glEvalPoint2( GLint i, GLint j );
+void       GLAPIENTRY glFeedbackBuffer( GLsizei size, GLenum type, GLfloat *buffer );
 void       GLAPIENTRY glFinish(void);
 void       GLAPIENTRY glFlush(void);
-void       GLAPIENTRY glFogf(GLenum,GLfloat);
-void       GLAPIENTRY glFogfv(GLenum,const GLfloat*);
-void       GLAPIENTRY glFogi(GLenum,GLint);
-void       GLAPIENTRY glFogiv(GLenum,const GLint*);
-void       GLAPIENTRY glFrontFace(GLenum);
-void       GLAPIENTRY glFrustum(GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble);
-GLuint     GLAPIENTRY glGenLists(GLsizei);
-void       GLAPIENTRY glGenTextures(GLsizei,GLuint*);
-void       GLAPIENTRY glGetBooleanv(GLenum,GLboolean*);
-void       GLAPIENTRY glGetClipPlane(GLenum,GLdouble*);
-void       GLAPIENTRY glGetDoublev(GLenum,GLdouble*);
+void       GLAPIENTRY glFogf( GLenum pname, GLfloat param );
+void       GLAPIENTRY glFogfv( GLenum pname, const GLfloat *params );
+void       GLAPIENTRY glFogi( GLenum pname, GLint param );
+void       GLAPIENTRY glFogiv( GLenum pname, const GLint *params );
+void       GLAPIENTRY glFrontFace( GLenum mode );
+void       GLAPIENTRY glFrustum( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar );
+GLuint     GLAPIENTRY glGenLists( GLsizei range );
+void       GLAPIENTRY glGenTextures( GLsizei n, GLuint *textures );
+void       GLAPIENTRY glGetBooleanv( GLenum pname, GLboolean *data );
+void       GLAPIENTRY glGetClipPlane( GLenum plane, GLdouble *equation );
+void       GLAPIENTRY glGetDoublev( GLenum pname, GLdouble *data );
 GLenum     GLAPIENTRY glGetError(void);
-void       GLAPIENTRY glGetFloatv(GLenum,GLfloat*);
-void       GLAPIENTRY glGetIntegerv(GLenum,GLint*);
-void       GLAPIENTRY glGetLightfv(GLenum,GLenum,GLfloat*);
-void       GLAPIENTRY glGetLightiv(GLenum,GLenum,GLint*);
-void       GLAPIENTRY glGetMapdv(GLenum,GLenum,GLdouble*);
-void       GLAPIENTRY glGetMapfv(GLenum,GLenum,GLfloat*);
-void       GLAPIENTRY glGetMapiv(GLenum,GLenum,GLint*);
-void       GLAPIENTRY glGetMaterialfv(GLenum,GLenum,GLfloat*);
-void       GLAPIENTRY glGetMaterialiv(GLenum,GLenum,GLint*);
-void       GLAPIENTRY glGetPixelMapfv(GLenum,GLfloat*);
-void       GLAPIENTRY glGetPixelMapuiv(GLenum,GLuint*);
-void       GLAPIENTRY glGetPixelMapusv(GLenum,GLushort*);
-void       GLAPIENTRY glGetPointerv(GLenum,void**);
-void       GLAPIENTRY glGetPolygonStipple(GLubyte*);
-const GLubyte* GLAPIENTRY glGetString(GLenum);
-void       GLAPIENTRY glGetTexEnvfv(GLenum,GLenum,GLfloat*);
-void       GLAPIENTRY glGetTexEnviv(GLenum,GLenum,GLint*);
-void       GLAPIENTRY glGetTexGendv(GLenum,GLenum,GLdouble*);
-void       GLAPIENTRY glGetTexGenfv(GLenum,GLenum,GLfloat*);
-void       GLAPIENTRY glGetTexGeniv(GLenum,GLenum,GLint*);
-void       GLAPIENTRY glGetTexImage(GLenum,GLint,GLenum,GLenum,void*);
-void       GLAPIENTRY glGetTexLevelParameterfv(GLenum,GLint,GLenum,GLfloat*);
-void       GLAPIENTRY glGetTexLevelParameteriv(GLenum,GLint,GLenum,GLint*);
-void       GLAPIENTRY glGetTexParameterfv(GLenum,GLenum,GLfloat*);
-void       GLAPIENTRY glGetTexParameteriv(GLenum,GLenum,GLint*);
-void       GLAPIENTRY glHint(GLenum,GLenum);
-void       GLAPIENTRY glIndexMask(GLuint);
-void       GLAPIENTRY glIndexPointer(GLenum,GLsizei,const void*);
-void       GLAPIENTRY glIndexd(GLdouble);
-void       GLAPIENTRY glIndexdv(const GLdouble*);
-void       GLAPIENTRY glIndexf(GLfloat);
-void       GLAPIENTRY glIndexfv(const GLfloat*);
-void       GLAPIENTRY glIndexi(GLint);
-void       GLAPIENTRY glIndexiv(const GLint*);
-void       GLAPIENTRY glIndexs(GLshort);
-void       GLAPIENTRY glIndexsv(const GLshort*);
-void       GLAPIENTRY glIndexub(GLubyte);
-void       GLAPIENTRY glIndexubv(const GLubyte*);
+void       GLAPIENTRY glGetFloatv( GLenum pname, GLfloat *data );
+void       GLAPIENTRY glGetIntegerv( GLenum pname, GLint *data );
+void       GLAPIENTRY glGetLightfv( GLenum light, GLenum pname, GLfloat *params );
+void       GLAPIENTRY glGetLightiv( GLenum light, GLenum pname, GLint *params );
+void       GLAPIENTRY glGetMapdv( GLenum target, GLenum query, GLdouble *v );
+void       GLAPIENTRY glGetMapfv( GLenum target, GLenum query, GLfloat *v );
+void       GLAPIENTRY glGetMapiv( GLenum target, GLenum query, GLint *v );
+void       GLAPIENTRY glGetMaterialfv( GLenum face, GLenum pname, GLfloat *params );
+void       GLAPIENTRY glGetMaterialiv( GLenum face, GLenum pname, GLint *params );
+void       GLAPIENTRY glGetPixelMapfv( GLenum map, GLfloat *values );
+void       GLAPIENTRY glGetPixelMapuiv( GLenum map, GLuint *values );
+void       GLAPIENTRY glGetPixelMapusv( GLenum map, GLushort *values );
+void       GLAPIENTRY glGetPointerv( GLenum pname, void **params );
+void       GLAPIENTRY glGetPolygonStipple( GLubyte *mask );
+const GLubyte * GLAPIENTRY glGetString( GLenum name );
+void       GLAPIENTRY glGetTexEnvfv( GLenum target, GLenum pname, GLfloat *params );
+void       GLAPIENTRY glGetTexEnviv( GLenum target, GLenum pname, GLint *params );
+void       GLAPIENTRY glGetTexGendv( GLenum coord, GLenum pname, GLdouble *params );
+void       GLAPIENTRY glGetTexGenfv( GLenum coord, GLenum pname, GLfloat *params );
+void       GLAPIENTRY glGetTexGeniv( GLenum coord, GLenum pname, GLint *params );
+void       GLAPIENTRY glGetTexImage( GLenum target, GLint level, GLenum format, GLenum type, void *pixels );
+void       GLAPIENTRY glGetTexLevelParameterfv( GLenum target, GLint level, GLenum pname, GLfloat *params );
+void       GLAPIENTRY glGetTexLevelParameteriv( GLenum target, GLint level, GLenum pname, GLint *params );
+void       GLAPIENTRY glGetTexParameterfv( GLenum target, GLenum pname, GLfloat *params );
+void       GLAPIENTRY glGetTexParameteriv( GLenum target, GLenum pname, GLint *params );
+void       GLAPIENTRY glHint( GLenum target, GLenum mode );
+void       GLAPIENTRY glIndexMask( GLuint mask );
+void       GLAPIENTRY glIndexPointer( GLenum type, GLsizei stride, const void *pointer );
+void       GLAPIENTRY glIndexd( GLdouble c );
+void       GLAPIENTRY glIndexdv( const GLdouble *c );
+void       GLAPIENTRY glIndexf( GLfloat c );
+void       GLAPIENTRY glIndexfv( const GLfloat *c );
+void       GLAPIENTRY glIndexi( GLint c );
+void       GLAPIENTRY glIndexiv( const GLint *c );
+void       GLAPIENTRY glIndexs( GLshort c );
+void       GLAPIENTRY glIndexsv( const GLshort *c );
+void       GLAPIENTRY glIndexub( GLubyte c );
+void       GLAPIENTRY glIndexubv( const GLubyte *c );
 void       GLAPIENTRY glInitNames(void);
-void       GLAPIENTRY glInterleavedArrays(GLenum,GLsizei,const void*);
-GLboolean  GLAPIENTRY glIsEnabled(GLenum);
-GLboolean  GLAPIENTRY glIsList(GLuint);
-GLboolean  GLAPIENTRY glIsTexture(GLuint);
-void       GLAPIENTRY glLightModelf(GLenum,GLfloat);
-void       GLAPIENTRY glLightModelfv(GLenum,const GLfloat*);
-void       GLAPIENTRY glLightModeli(GLenum,GLint);
-void       GLAPIENTRY glLightModeliv(GLenum,const GLint*);
-void       GLAPIENTRY glLightf(GLenum,GLenum,GLfloat);
-void       GLAPIENTRY glLightfv(GLenum,GLenum,const GLfloat*);
-void       GLAPIENTRY glLighti(GLenum,GLenum,GLint);
-void       GLAPIENTRY glLightiv(GLenum,GLenum,const GLint*);
-void       GLAPIENTRY glLineStipple(GLint,GLushort);
-void       GLAPIENTRY glLineWidth(GLfloat);
-void       GLAPIENTRY glListBase(GLuint);
+void       GLAPIENTRY glInterleavedArrays( GLenum format, GLsizei stride, const void *pointer );
+GLboolean  GLAPIENTRY glIsEnabled( GLenum cap );
+GLboolean  GLAPIENTRY glIsList( GLuint list );
+GLboolean  GLAPIENTRY glIsTexture( GLuint texture );
+void       GLAPIENTRY glLightModelf( GLenum pname, GLfloat param );
+void       GLAPIENTRY glLightModelfv( GLenum pname, const GLfloat *params );
+void       GLAPIENTRY glLightModeli( GLenum pname, GLint param );
+void       GLAPIENTRY glLightModeliv( GLenum pname, const GLint *params );
+void       GLAPIENTRY glLightf( GLenum light, GLenum pname, GLfloat param );
+void       GLAPIENTRY glLightfv( GLenum light, GLenum pname, const GLfloat *params );
+void       GLAPIENTRY glLighti( GLenum light, GLenum pname, GLint param );
+void       GLAPIENTRY glLightiv( GLenum light, GLenum pname, const GLint *params );
+void       GLAPIENTRY glLineStipple( GLint factor, GLushort pattern );
+void       GLAPIENTRY glLineWidth( GLfloat width );
+void       GLAPIENTRY glListBase( GLuint base );
 void       GLAPIENTRY glLoadIdentity(void);
-void       GLAPIENTRY glLoadMatrixd(const GLdouble*);
-void       GLAPIENTRY glLoadMatrixf(const GLfloat*);
-void       GLAPIENTRY glLoadName(GLuint);
-void       GLAPIENTRY glLogicOp(GLenum);
-void       GLAPIENTRY glMap1d(GLenum,GLdouble,GLdouble,GLint,GLint,const GLdouble*);
-void       GLAPIENTRY glMap1f(GLenum,GLfloat,GLfloat,GLint,GLint,const GLfloat*);
-void       GLAPIENTRY glMap2d(GLenum,GLdouble,GLdouble,GLint,GLint,GLdouble,GLdouble,GLint,GLint,const GLdouble*);
-void       GLAPIENTRY glMap2f(GLenum,GLfloat,GLfloat,GLint,GLint,GLfloat,GLfloat,GLint,GLint,const GLfloat*);
-void       GLAPIENTRY glMapGrid1d(GLint,GLdouble,GLdouble);
-void       GLAPIENTRY glMapGrid1f(GLint,GLfloat,GLfloat);
-void       GLAPIENTRY glMapGrid2d(GLint,GLdouble,GLdouble,GLint,GLdouble,GLdouble);
-void       GLAPIENTRY glMapGrid2f(GLint,GLfloat,GLfloat,GLint,GLfloat,GLfloat);
-void       GLAPIENTRY glMaterialf(GLenum,GLenum,GLfloat);
-void       GLAPIENTRY glMaterialfv(GLenum,GLenum,const GLfloat*);
-void       GLAPIENTRY glMateriali(GLenum,GLenum,GLint);
-void       GLAPIENTRY glMaterialiv(GLenum,GLenum,const GLint*);
-void       GLAPIENTRY glMatrixMode(GLenum);
-void       GLAPIENTRY glMultMatrixd(const GLdouble*);
-void       GLAPIENTRY glMultMatrixf(const GLfloat*);
-void       GLAPIENTRY glNewList(GLuint,GLenum);
-void       GLAPIENTRY glNormal3b(GLbyte,GLbyte,GLbyte);
-void       GLAPIENTRY glNormal3bv(const GLbyte*);
-void       GLAPIENTRY glNormal3d(GLdouble,GLdouble,GLdouble);
-void       GLAPIENTRY glNormal3dv(const GLdouble*);
-void       GLAPIENTRY glNormal3f(GLfloat,GLfloat,GLfloat);
-void       GLAPIENTRY glNormal3fv(const GLfloat*);
-void       GLAPIENTRY glNormal3i(GLint,GLint,GLint);
-void       GLAPIENTRY glNormal3iv(const GLint*);
-void       GLAPIENTRY glNormal3s(GLshort,GLshort,GLshort);
-void       GLAPIENTRY glNormal3sv(const GLshort*);
-void       GLAPIENTRY glNormalPointer(GLenum,GLsizei,const void*);
-void       GLAPIENTRY glOrtho(GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble);
-void       GLAPIENTRY glPassThrough(GLfloat);
-void       GLAPIENTRY glPixelMapfv(GLenum,GLsizei,const GLfloat*);
-void       GLAPIENTRY glPixelMapuiv(GLenum,GLsizei,const GLuint*);
-void       GLAPIENTRY glPixelMapusv(GLenum,GLsizei,const GLushort*);
-void       GLAPIENTRY glPixelStoref(GLenum,GLfloat);
-void       GLAPIENTRY glPixelStorei(GLenum,GLint);
-void       GLAPIENTRY glPixelTransferf(GLenum,GLfloat);
-void       GLAPIENTRY glPixelTransferi(GLenum,GLint);
-void       GLAPIENTRY glPixelZoom(GLfloat,GLfloat);
-void       GLAPIENTRY glPointSize(GLfloat);
-void       GLAPIENTRY glPolygonMode(GLenum,GLenum);
-void       GLAPIENTRY glPolygonOffset(GLfloat,GLfloat);
-void       GLAPIENTRY glPolygonStipple(const GLubyte*);
+void       GLAPIENTRY glLoadMatrixd( const GLdouble *m );
+void       GLAPIENTRY glLoadMatrixf( const GLfloat *m );
+void       GLAPIENTRY glLoadName( GLuint name );
+void       GLAPIENTRY glLogicOp( GLenum opcode );
+void       GLAPIENTRY glMap1d( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points );
+void       GLAPIENTRY glMap1f( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points );
+void       GLAPIENTRY glMap2d( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points );
+void       GLAPIENTRY glMap2f( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points );
+void       GLAPIENTRY glMapGrid1d( GLint un, GLdouble u1, GLdouble u2 );
+void       GLAPIENTRY glMapGrid1f( GLint un, GLfloat u1, GLfloat u2 );
+void       GLAPIENTRY glMapGrid2d( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 );
+void       GLAPIENTRY glMapGrid2f( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 );
+void       GLAPIENTRY glMaterialf( GLenum face, GLenum pname, GLfloat param );
+void       GLAPIENTRY glMaterialfv( GLenum face, GLenum pname, const GLfloat *params );
+void       GLAPIENTRY glMateriali( GLenum face, GLenum pname, GLint param );
+void       GLAPIENTRY glMaterialiv( GLenum face, GLenum pname, const GLint *params );
+void       GLAPIENTRY glMatrixMode( GLenum mode );
+void       GLAPIENTRY glMultMatrixd( const GLdouble *m );
+void       GLAPIENTRY glMultMatrixf( const GLfloat *m );
+void       GLAPIENTRY glNewList( GLuint list, GLenum mode );
+void       GLAPIENTRY glNormal3b( GLbyte nx, GLbyte ny, GLbyte nz );
+void       GLAPIENTRY glNormal3bv( const GLbyte *v );
+void       GLAPIENTRY glNormal3d( GLdouble nx, GLdouble ny, GLdouble nz );
+void       GLAPIENTRY glNormal3dv( const GLdouble *v );
+void       GLAPIENTRY glNormal3f( GLfloat nx, GLfloat ny, GLfloat nz );
+void       GLAPIENTRY glNormal3fv( const GLfloat *v );
+void       GLAPIENTRY glNormal3i( GLint nx, GLint ny, GLint nz );
+void       GLAPIENTRY glNormal3iv( const GLint *v );
+void       GLAPIENTRY glNormal3s( GLshort nx, GLshort ny, GLshort nz );
+void       GLAPIENTRY glNormal3sv( const GLshort *v );
+void       GLAPIENTRY glNormalPointer( GLenum type, GLsizei stride, const void *pointer );
+void       GLAPIENTRY glOrtho( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar );
+void       GLAPIENTRY glPassThrough( GLfloat token );
+void       GLAPIENTRY glPixelMapfv( GLenum map, GLsizei mapsize, const GLfloat *values );
+void       GLAPIENTRY glPixelMapuiv( GLenum map, GLsizei mapsize, const GLuint *values );
+void       GLAPIENTRY glPixelMapusv( GLenum map, GLsizei mapsize, const GLushort *values );
+void       GLAPIENTRY glPixelStoref( GLenum pname, GLfloat param );
+void       GLAPIENTRY glPixelStorei( GLenum pname, GLint param );
+void       GLAPIENTRY glPixelTransferf( GLenum pname, GLfloat param );
+void       GLAPIENTRY glPixelTransferi( GLenum pname, GLint param );
+void       GLAPIENTRY glPixelZoom( GLfloat xfactor, GLfloat yfactor );
+void       GLAPIENTRY glPointSize( GLfloat size );
+void       GLAPIENTRY glPolygonMode( GLenum face, GLenum mode );
+void       GLAPIENTRY glPolygonOffset( GLfloat factor, GLfloat units );
+void       GLAPIENTRY glPolygonStipple( const GLubyte *mask );
 void       GLAPIENTRY glPopAttrib(void);
 void       GLAPIENTRY glPopClientAttrib(void);
 void       GLAPIENTRY glPopMatrix(void);
 void       GLAPIENTRY glPopName(void);
-void       GLAPIENTRY glPrioritizeTextures(GLsizei,const GLuint*,const GLfloat*);
-void       GLAPIENTRY glPushAttrib(GLbitfield);
-void       GLAPIENTRY glPushClientAttrib(GLbitfield);
+void       GLAPIENTRY glPrioritizeTextures( GLsizei n, const GLuint *textures, const GLfloat *priorities );
+void       GLAPIENTRY glPushAttrib( GLbitfield mask );
+void       GLAPIENTRY glPushClientAttrib( GLbitfield mask );
 void       GLAPIENTRY glPushMatrix(void);
-void       GLAPIENTRY glPushName(GLuint);
-void       GLAPIENTRY glRasterPos2d(GLdouble,GLdouble);
-void       GLAPIENTRY glRasterPos2dv(const GLdouble*);
-void       GLAPIENTRY glRasterPos2f(GLfloat,GLfloat);
-void       GLAPIENTRY glRasterPos2fv(const GLfloat*);
-void       GLAPIENTRY glRasterPos2i(GLint,GLint);
-void       GLAPIENTRY glRasterPos2iv(const GLint*);
-void       GLAPIENTRY glRasterPos2s(GLshort,GLshort);
-void       GLAPIENTRY glRasterPos2sv(const GLshort*);
-void       GLAPIENTRY glRasterPos3d(GLdouble,GLdouble,GLdouble);
-void       GLAPIENTRY glRasterPos3dv(const GLdouble*);
-void       GLAPIENTRY glRasterPos3f(GLfloat,GLfloat,GLfloat);
-void       GLAPIENTRY glRasterPos3fv(const GLfloat*);
-void       GLAPIENTRY glRasterPos3i(GLint,GLint,GLint);
-void       GLAPIENTRY glRasterPos3iv(const GLint*);
-void       GLAPIENTRY glRasterPos3s(GLshort,GLshort,GLshort);
-void       GLAPIENTRY glRasterPos3sv(const GLshort*);
-void       GLAPIENTRY glRasterPos4d(GLdouble,GLdouble,GLdouble,GLdouble);
-void       GLAPIENTRY glRasterPos4dv(const GLdouble*);
-void       GLAPIENTRY glRasterPos4f(GLfloat,GLfloat,GLfloat,GLfloat);
-void       GLAPIENTRY glRasterPos4fv(const GLfloat*);
-void       GLAPIENTRY glRasterPos4i(GLint,GLint,GLint,GLint);
-void       GLAPIENTRY glRasterPos4iv(const GLint*);
-void       GLAPIENTRY glRasterPos4s(GLshort,GLshort,GLshort,GLshort);
-void       GLAPIENTRY glRasterPos4sv(const GLshort*);
-void       GLAPIENTRY glReadBuffer(GLenum);
-void       GLAPIENTRY glReadPixels(GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,void*);
-void       GLAPIENTRY glRectd(GLdouble,GLdouble,GLdouble,GLdouble);
-void       GLAPIENTRY glRectdv(const GLdouble*,const GLdouble*);
-void       GLAPIENTRY glRectf(GLfloat,GLfloat,GLfloat,GLfloat);
-void       GLAPIENTRY glRectfv(const GLfloat*,const GLfloat*);
-void       GLAPIENTRY glRecti(GLint,GLint,GLint,GLint);
-void       GLAPIENTRY glRectiv(const GLint*,const GLint*);
-void       GLAPIENTRY glRects(GLshort,GLshort,GLshort,GLshort);
-void       GLAPIENTRY glRectsv(const GLshort*,const GLshort*);
-GLint      GLAPIENTRY glRenderMode(GLenum);
-void       GLAPIENTRY glRotated(GLdouble,GLdouble,GLdouble,GLdouble);
-void       GLAPIENTRY glRotatef(GLfloat,GLfloat,GLfloat,GLfloat);
-void       GLAPIENTRY glScaled(GLdouble,GLdouble,GLdouble);
-void       GLAPIENTRY glScalef(GLfloat,GLfloat,GLfloat);
-void       GLAPIENTRY glScissor(GLint,GLint,GLsizei,GLsizei);
-void       GLAPIENTRY glSelectBuffer(GLsizei,GLuint*);
-void       GLAPIENTRY glShadeModel(GLenum);
-void       GLAPIENTRY glStencilFunc(GLenum,GLint,GLuint);
-void       GLAPIENTRY glStencilMask(GLuint);
-void       GLAPIENTRY glStencilOp(GLenum,GLenum,GLenum);
-void       GLAPIENTRY glTexCoord1d(GLdouble);
-void       GLAPIENTRY glTexCoord1dv(const GLdouble*);
-void       GLAPIENTRY glTexCoord1f(GLfloat);
-void       GLAPIENTRY glTexCoord1fv(const GLfloat*);
-void       GLAPIENTRY glTexCoord1i(GLint);
-void       GLAPIENTRY glTexCoord1iv(const GLint*);
-void       GLAPIENTRY glTexCoord1s(GLshort);
-void       GLAPIENTRY glTexCoord1sv(const GLshort*);
-void       GLAPIENTRY glTexCoord2d(GLdouble,GLdouble);
-void       GLAPIENTRY glTexCoord2dv(const GLdouble*);
-void       GLAPIENTRY glTexCoord2f(GLfloat,GLfloat);
-void       GLAPIENTRY glTexCoord2fv(const GLfloat*);
-void       GLAPIENTRY glTexCoord2i(GLint,GLint);
-void       GLAPIENTRY glTexCoord2iv(const GLint*);
-void       GLAPIENTRY glTexCoord2s(GLshort,GLshort);
-void       GLAPIENTRY glTexCoord2sv(const GLshort*);
-void       GLAPIENTRY glTexCoord3d(GLdouble,GLdouble,GLdouble);
-void       GLAPIENTRY glTexCoord3dv(const GLdouble*);
-void       GLAPIENTRY glTexCoord3f(GLfloat,GLfloat,GLfloat);
-void       GLAPIENTRY glTexCoord3fv(const GLfloat*);
-void       GLAPIENTRY glTexCoord3i(GLint,GLint,GLint);
-void       GLAPIENTRY glTexCoord3iv(const GLint*);
-void       GLAPIENTRY glTexCoord3s(GLshort,GLshort,GLshort);
-void       GLAPIENTRY glTexCoord3sv(const GLshort*);
-void       GLAPIENTRY glTexCoord4d(GLdouble,GLdouble,GLdouble,GLdouble);
-void       GLAPIENTRY glTexCoord4dv(const GLdouble*);
-void       GLAPIENTRY glTexCoord4f(GLfloat,GLfloat,GLfloat,GLfloat);
-void       GLAPIENTRY glTexCoord4fv(const GLfloat*);
-void       GLAPIENTRY glTexCoord4i(GLint,GLint,GLint,GLint);
-void       GLAPIENTRY glTexCoord4iv(const GLint*);
-void       GLAPIENTRY glTexCoord4s(GLshort,GLshort,GLshort,GLshort);
-void       GLAPIENTRY glTexCoord4sv(const GLshort*);
-void       GLAPIENTRY glTexCoordPointer(GLint,GLenum,GLsizei,const void*);
-void       GLAPIENTRY glTexEnvf(GLenum,GLenum,GLfloat);
-void       GLAPIENTRY glTexEnvfv(GLenum,GLenum,const GLfloat*);
-void       GLAPIENTRY glTexEnvi(GLenum,GLenum,GLint);
-void       GLAPIENTRY glTexEnviv(GLenum,GLenum,const GLint*);
-void       GLAPIENTRY glTexGend(GLenum,GLenum,GLdouble);
-void       GLAPIENTRY glTexGendv(GLenum,GLenum,const GLdouble*);
-void       GLAPIENTRY glTexGenf(GLenum,GLenum,GLfloat);
-void       GLAPIENTRY glTexGenfv(GLenum,GLenum,const GLfloat*);
-void       GLAPIENTRY glTexGeni(GLenum,GLenum,GLint);
-void       GLAPIENTRY glTexGeniv(GLenum,GLenum,const GLint*);
-void       GLAPIENTRY glTexImage1D(GLenum,GLint,GLint,GLsizei,GLint,GLenum,GLenum,const void*);
-void       GLAPIENTRY glTexImage2D(GLenum,GLint,GLint,GLsizei,GLsizei,GLint,GLenum,GLenum,const void*);
-void       GLAPIENTRY glTexParameterf(GLenum,GLenum,GLfloat);
-void       GLAPIENTRY glTexParameterfv(GLenum,GLenum,const GLfloat*);
-void       GLAPIENTRY glTexParameteri(GLenum,GLenum,GLint);
-void       GLAPIENTRY glTexParameteriv(GLenum,GLenum,const GLint*);
-void       GLAPIENTRY glTexSubImage1D(GLenum,GLint,GLint,GLsizei,GLenum,GLenum,const void*);
-void       GLAPIENTRY glTexSubImage2D(GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,const void*);
-void       GLAPIENTRY glTranslated(GLdouble,GLdouble,GLdouble);
-void       GLAPIENTRY glTranslatef(GLfloat,GLfloat,GLfloat);
-void       GLAPIENTRY glVertex2d(GLdouble,GLdouble);
-void       GLAPIENTRY glVertex2dv(const GLdouble*);
-void       GLAPIENTRY glVertex2f(GLfloat,GLfloat);
-void       GLAPIENTRY glVertex2fv(const GLfloat*);
-void       GLAPIENTRY glVertex2i(GLint,GLint);
-void       GLAPIENTRY glVertex2iv(const GLint*);
-void       GLAPIENTRY glVertex2s(GLshort,GLshort);
-void       GLAPIENTRY glVertex2sv(const GLshort*);
-void       GLAPIENTRY glVertex3d(GLdouble,GLdouble,GLdouble);
-void       GLAPIENTRY glVertex3dv(const GLdouble*);
-void       GLAPIENTRY glVertex3f(GLfloat,GLfloat,GLfloat);
-void       GLAPIENTRY glVertex3fv(const GLfloat*);
-void       GLAPIENTRY glVertex3i(GLint,GLint,GLint);
-void       GLAPIENTRY glVertex3iv(const GLint*);
-void       GLAPIENTRY glVertex3s(GLshort,GLshort,GLshort);
-void       GLAPIENTRY glVertex3sv(const GLshort*);
-void       GLAPIENTRY glVertex4d(GLdouble,GLdouble,GLdouble,GLdouble);
-void       GLAPIENTRY glVertex4dv(const GLdouble*);
-void       GLAPIENTRY glVertex4f(GLfloat,GLfloat,GLfloat,GLfloat);
-void       GLAPIENTRY glVertex4fv(const GLfloat*);
-void       GLAPIENTRY glVertex4i(GLint,GLint,GLint,GLint);
-void       GLAPIENTRY glVertex4iv(const GLint*);
-void       GLAPIENTRY glVertex4s(GLshort,GLshort,GLshort,GLshort);
-void       GLAPIENTRY glVertex4sv(const GLshort*);
-void       GLAPIENTRY glVertexPointer(GLint,GLenum,GLsizei,const void*);
-void       GLAPIENTRY glViewport(GLint,GLint,GLsizei,GLsizei);
+void       GLAPIENTRY glPushName( GLuint name );
+void       GLAPIENTRY glRasterPos2d( GLdouble x, GLdouble y );
+void       GLAPIENTRY glRasterPos2dv( const GLdouble *v );
+void       GLAPIENTRY glRasterPos2f( GLfloat x, GLfloat y );
+void       GLAPIENTRY glRasterPos2fv( const GLfloat *v );
+void       GLAPIENTRY glRasterPos2i( GLint x, GLint y );
+void       GLAPIENTRY glRasterPos2iv( const GLint *v );
+void       GLAPIENTRY glRasterPos2s( GLshort x, GLshort y );
+void       GLAPIENTRY glRasterPos2sv( const GLshort *v );
+void       GLAPIENTRY glRasterPos3d( GLdouble x, GLdouble y, GLdouble z );
+void       GLAPIENTRY glRasterPos3dv( const GLdouble *v );
+void       GLAPIENTRY glRasterPos3f( GLfloat x, GLfloat y, GLfloat z );
+void       GLAPIENTRY glRasterPos3fv( const GLfloat *v );
+void       GLAPIENTRY glRasterPos3i( GLint x, GLint y, GLint z );
+void       GLAPIENTRY glRasterPos3iv( const GLint *v );
+void       GLAPIENTRY glRasterPos3s( GLshort x, GLshort y, GLshort z );
+void       GLAPIENTRY glRasterPos3sv( const GLshort *v );
+void       GLAPIENTRY glRasterPos4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+void       GLAPIENTRY glRasterPos4dv( const GLdouble *v );
+void       GLAPIENTRY glRasterPos4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w );
+void       GLAPIENTRY glRasterPos4fv( const GLfloat *v );
+void       GLAPIENTRY glRasterPos4i( GLint x, GLint y, GLint z, GLint w );
+void       GLAPIENTRY glRasterPos4iv( const GLint *v );
+void       GLAPIENTRY glRasterPos4s( GLshort x, GLshort y, GLshort z, GLshort w );
+void       GLAPIENTRY glRasterPos4sv( const GLshort *v );
+void       GLAPIENTRY glReadBuffer( GLenum src );
+void       GLAPIENTRY glReadPixels( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels );
+void       GLAPIENTRY glRectd( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 );
+void       GLAPIENTRY glRectdv( const GLdouble *v1, const GLdouble *v2 );
+void       GLAPIENTRY glRectf( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 );
+void       GLAPIENTRY glRectfv( const GLfloat *v1, const GLfloat *v2 );
+void       GLAPIENTRY glRecti( GLint x1, GLint y1, GLint x2, GLint y2 );
+void       GLAPIENTRY glRectiv( const GLint *v1, const GLint *v2 );
+void       GLAPIENTRY glRects( GLshort x1, GLshort y1, GLshort x2, GLshort y2 );
+void       GLAPIENTRY glRectsv( const GLshort *v1, const GLshort *v2 );
+GLint      GLAPIENTRY glRenderMode( GLenum mode );
+void       GLAPIENTRY glRotated( GLdouble angle, GLdouble x, GLdouble y, GLdouble z );
+void       GLAPIENTRY glRotatef( GLfloat angle, GLfloat x, GLfloat y, GLfloat z );
+void       GLAPIENTRY glScaled( GLdouble x, GLdouble y, GLdouble z );
+void       GLAPIENTRY glScalef( GLfloat x, GLfloat y, GLfloat z );
+void       GLAPIENTRY glScissor( GLint x, GLint y, GLsizei width, GLsizei height );
+void       GLAPIENTRY glSelectBuffer( GLsizei size, GLuint *buffer );
+void       GLAPIENTRY glShadeModel( GLenum mode );
+void       GLAPIENTRY glStencilFunc( GLenum func, GLint ref, GLuint mask );
+void       GLAPIENTRY glStencilMask( GLuint mask );
+void       GLAPIENTRY glStencilOp( GLenum fail, GLenum zfail, GLenum zpass );
+void       GLAPIENTRY glTexCoord1d( GLdouble s );
+void       GLAPIENTRY glTexCoord1dv( const GLdouble *v );
+void       GLAPIENTRY glTexCoord1f( GLfloat s );
+void       GLAPIENTRY glTexCoord1fv( const GLfloat *v );
+void       GLAPIENTRY glTexCoord1i( GLint s );
+void       GLAPIENTRY glTexCoord1iv( const GLint *v );
+void       GLAPIENTRY glTexCoord1s( GLshort s );
+void       GLAPIENTRY glTexCoord1sv( const GLshort *v );
+void       GLAPIENTRY glTexCoord2d( GLdouble s, GLdouble t );
+void       GLAPIENTRY glTexCoord2dv( const GLdouble *v );
+void       GLAPIENTRY glTexCoord2f( GLfloat s, GLfloat t );
+void       GLAPIENTRY glTexCoord2fv( const GLfloat *v );
+void       GLAPIENTRY glTexCoord2i( GLint s, GLint t );
+void       GLAPIENTRY glTexCoord2iv( const GLint *v );
+void       GLAPIENTRY glTexCoord2s( GLshort s, GLshort t );
+void       GLAPIENTRY glTexCoord2sv( const GLshort *v );
+void       GLAPIENTRY glTexCoord3d( GLdouble s, GLdouble t, GLdouble r );
+void       GLAPIENTRY glTexCoord3dv( const GLdouble *v );
+void       GLAPIENTRY glTexCoord3f( GLfloat s, GLfloat t, GLfloat r );
+void       GLAPIENTRY glTexCoord3fv( const GLfloat *v );
+void       GLAPIENTRY glTexCoord3i( GLint s, GLint t, GLint r );
+void       GLAPIENTRY glTexCoord3iv( const GLint *v );
+void       GLAPIENTRY glTexCoord3s( GLshort s, GLshort t, GLshort r );
+void       GLAPIENTRY glTexCoord3sv( const GLshort *v );
+void       GLAPIENTRY glTexCoord4d( GLdouble s, GLdouble t, GLdouble r, GLdouble q );
+void       GLAPIENTRY glTexCoord4dv( const GLdouble *v );
+void       GLAPIENTRY glTexCoord4f( GLfloat s, GLfloat t, GLfloat r, GLfloat q );
+void       GLAPIENTRY glTexCoord4fv( const GLfloat *v );
+void       GLAPIENTRY glTexCoord4i( GLint s, GLint t, GLint r, GLint q );
+void       GLAPIENTRY glTexCoord4iv( const GLint *v );
+void       GLAPIENTRY glTexCoord4s( GLshort s, GLshort t, GLshort r, GLshort q );
+void       GLAPIENTRY glTexCoord4sv( const GLshort *v );
+void       GLAPIENTRY glTexCoordPointer( GLint size, GLenum type, GLsizei stride, const void *pointer );
+void       GLAPIENTRY glTexEnvf( GLenum target, GLenum pname, GLfloat param );
+void       GLAPIENTRY glTexEnvfv( GLenum target, GLenum pname, const GLfloat *params );
+void       GLAPIENTRY glTexEnvi( GLenum target, GLenum pname, GLint param );
+void       GLAPIENTRY glTexEnviv( GLenum target, GLenum pname, const GLint *params );
+void       GLAPIENTRY glTexGend( GLenum coord, GLenum pname, GLdouble param );
+void       GLAPIENTRY glTexGendv( GLenum coord, GLenum pname, const GLdouble *params );
+void       GLAPIENTRY glTexGenf( GLenum coord, GLenum pname, GLfloat param );
+void       GLAPIENTRY glTexGenfv( GLenum coord, GLenum pname, const GLfloat *params );
+void       GLAPIENTRY glTexGeni( GLenum coord, GLenum pname, GLint param );
+void       GLAPIENTRY glTexGeniv( GLenum coord, GLenum pname, const GLint *params );
+void       GLAPIENTRY glTexImage1D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels );
+void       GLAPIENTRY glTexImage2D( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels );
+void       GLAPIENTRY glTexParameterf( GLenum target, GLenum pname, GLfloat param );
+void       GLAPIENTRY glTexParameterfv( GLenum target, GLenum pname, const GLfloat *params );
+void       GLAPIENTRY glTexParameteri( GLenum target, GLenum pname, GLint param );
+void       GLAPIENTRY glTexParameteriv( GLenum target, GLenum pname, const GLint *params );
+void       GLAPIENTRY glTexSubImage1D( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels );
+void       GLAPIENTRY glTexSubImage2D( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels );
+void       GLAPIENTRY glTranslated( GLdouble x, GLdouble y, GLdouble z );
+void       GLAPIENTRY glTranslatef( GLfloat x, GLfloat y, GLfloat z );
+void       GLAPIENTRY glVertex2d( GLdouble x, GLdouble y );
+void       GLAPIENTRY glVertex2dv( const GLdouble *v );
+void       GLAPIENTRY glVertex2f( GLfloat x, GLfloat y );
+void       GLAPIENTRY glVertex2fv( const GLfloat *v );
+void       GLAPIENTRY glVertex2i( GLint x, GLint y );
+void       GLAPIENTRY glVertex2iv( const GLint *v );
+void       GLAPIENTRY glVertex2s( GLshort x, GLshort y );
+void       GLAPIENTRY glVertex2sv( const GLshort *v );
+void       GLAPIENTRY glVertex3d( GLdouble x, GLdouble y, GLdouble z );
+void       GLAPIENTRY glVertex3dv( const GLdouble *v );
+void       GLAPIENTRY glVertex3f( GLfloat x, GLfloat y, GLfloat z );
+void       GLAPIENTRY glVertex3fv( const GLfloat *v );
+void       GLAPIENTRY glVertex3i( GLint x, GLint y, GLint z );
+void       GLAPIENTRY glVertex3iv( const GLint *v );
+void       GLAPIENTRY glVertex3s( GLshort x, GLshort y, GLshort z );
+void       GLAPIENTRY glVertex3sv( const GLshort *v );
+void       GLAPIENTRY glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+void       GLAPIENTRY glVertex4dv( const GLdouble *v );
+void       GLAPIENTRY glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w );
+void       GLAPIENTRY glVertex4fv( const GLfloat *v );
+void       GLAPIENTRY glVertex4i( GLint x, GLint y, GLint z, GLint w );
+void       GLAPIENTRY glVertex4iv( const GLint *v );
+void       GLAPIENTRY glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w );
+void       GLAPIENTRY glVertex4sv( const GLshort *v );
+void       GLAPIENTRY glVertexPointer( GLint size, GLenum type, GLsizei stride, const void *pointer );
+void       GLAPIENTRY glViewport( GLint x, GLint y, GLsizei width, GLsizei height );
 
 #endif /* __WINE_WGL_H */
diff --git a/include/wine/wgl_driver.h b/include/wine/wgl_driver.h
index 753d134..77b82c7 100644
--- a/include/wine/wgl_driver.h
+++ b/include/wine/wgl_driver.h
@@ -16,3015 +16,3015 @@
 {
     struct
     {
-        BOOL       (WINE_GLAPI *p_wglCopyContext)(struct wgl_context *,struct wgl_context *,UINT);
-        struct wgl_context * (WINE_GLAPI *p_wglCreateContext)(HDC);
-        BOOL       (WINE_GLAPI *p_wglDeleteContext)(struct wgl_context *);
-        int        (WINE_GLAPI *p_wglDescribePixelFormat)(HDC,int,UINT,PIXELFORMATDESCRIPTOR*);
-        int        (WINE_GLAPI *p_wglGetPixelFormat)(HDC);
-        PROC       (WINE_GLAPI *p_wglGetProcAddress)(LPCSTR);
-        BOOL       (WINE_GLAPI *p_wglMakeCurrent)(HDC,struct wgl_context *);
-        BOOL       (WINE_GLAPI *p_wglSetPixelFormat)(HDC,int,const PIXELFORMATDESCRIPTOR*);
-        BOOL       (WINE_GLAPI *p_wglShareLists)(struct wgl_context *,struct wgl_context *);
-        BOOL       (WINE_GLAPI *p_wglSwapBuffers)(HDC);
+        BOOL       (WINE_GLAPI *p_wglCopyContext)( struct wgl_context * hglrcSrc, struct wgl_context * hglrcDst, UINT mask );
+        struct wgl_context * (WINE_GLAPI *p_wglCreateContext)( HDC hDc );
+        BOOL       (WINE_GLAPI *p_wglDeleteContext)( struct wgl_context * oldContext );
+        int        (WINE_GLAPI *p_wglDescribePixelFormat)( HDC hdc, int ipfd, UINT cjpfd, PIXELFORMATDESCRIPTOR *ppfd );
+        int        (WINE_GLAPI *p_wglGetPixelFormat)( HDC hdc );
+        PROC       (WINE_GLAPI *p_wglGetProcAddress)( LPCSTR lpszProc );
+        BOOL       (WINE_GLAPI *p_wglMakeCurrent)( HDC hDc, struct wgl_context * newContext );
+        BOOL       (WINE_GLAPI *p_wglSetPixelFormat)( HDC hdc, int ipfd, const PIXELFORMATDESCRIPTOR *ppfd );
+        BOOL       (WINE_GLAPI *p_wglShareLists)( struct wgl_context * hrcSrvShare, struct wgl_context * hrcSrvSource );
+        BOOL       (WINE_GLAPI *p_wglSwapBuffers)( HDC hdc );
     } wgl;
 
     struct
     {
-        void       (WINE_GLAPI *p_glAccum)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glAlphaFunc)(GLenum,GLfloat);
-        GLboolean  (WINE_GLAPI *p_glAreTexturesResident)(GLsizei,const GLuint*,GLboolean*);
-        void       (WINE_GLAPI *p_glArrayElement)(GLint);
-        void       (WINE_GLAPI *p_glBegin)(GLenum);
-        void       (WINE_GLAPI *p_glBindTexture)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glBitmap)(GLsizei,GLsizei,GLfloat,GLfloat,GLfloat,GLfloat,const GLubyte*);
-        void       (WINE_GLAPI *p_glBlendFunc)(GLenum,GLenum);
-        void       (WINE_GLAPI *p_glCallList)(GLuint);
-        void       (WINE_GLAPI *p_glCallLists)(GLsizei,GLenum,const void*);
-        void       (WINE_GLAPI *p_glClear)(GLbitfield);
-        void       (WINE_GLAPI *p_glClearAccum)(GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glClearColor)(GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glClearDepth)(GLdouble);
-        void       (WINE_GLAPI *p_glClearIndex)(GLfloat);
-        void       (WINE_GLAPI *p_glClearStencil)(GLint);
-        void       (WINE_GLAPI *p_glClipPlane)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glColor3b)(GLbyte,GLbyte,GLbyte);
-        void       (WINE_GLAPI *p_glColor3bv)(const GLbyte*);
-        void       (WINE_GLAPI *p_glColor3d)(GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glColor3dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glColor3f)(GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glColor3fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glColor3i)(GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glColor3iv)(const GLint*);
-        void       (WINE_GLAPI *p_glColor3s)(GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glColor3sv)(const GLshort*);
-        void       (WINE_GLAPI *p_glColor3ub)(GLubyte,GLubyte,GLubyte);
-        void       (WINE_GLAPI *p_glColor3ubv)(const GLubyte*);
-        void       (WINE_GLAPI *p_glColor3ui)(GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glColor3uiv)(const GLuint*);
-        void       (WINE_GLAPI *p_glColor3us)(GLushort,GLushort,GLushort);
-        void       (WINE_GLAPI *p_glColor3usv)(const GLushort*);
-        void       (WINE_GLAPI *p_glColor4b)(GLbyte,GLbyte,GLbyte,GLbyte);
-        void       (WINE_GLAPI *p_glColor4bv)(const GLbyte*);
-        void       (WINE_GLAPI *p_glColor4d)(GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glColor4dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glColor4f)(GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glColor4fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glColor4i)(GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glColor4iv)(const GLint*);
-        void       (WINE_GLAPI *p_glColor4s)(GLshort,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glColor4sv)(const GLshort*);
-        void       (WINE_GLAPI *p_glColor4ub)(GLubyte,GLubyte,GLubyte,GLubyte);
-        void       (WINE_GLAPI *p_glColor4ubv)(const GLubyte*);
-        void       (WINE_GLAPI *p_glColor4ui)(GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glColor4uiv)(const GLuint*);
-        void       (WINE_GLAPI *p_glColor4us)(GLushort,GLushort,GLushort,GLushort);
-        void       (WINE_GLAPI *p_glColor4usv)(const GLushort*);
-        void       (WINE_GLAPI *p_glColorMask)(GLboolean,GLboolean,GLboolean,GLboolean);
-        void       (WINE_GLAPI *p_glColorMaterial)(GLenum,GLenum);
-        void       (WINE_GLAPI *p_glColorPointer)(GLint,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCopyPixels)(GLint,GLint,GLsizei,GLsizei,GLenum);
-        void       (WINE_GLAPI *p_glCopyTexImage1D)(GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLint);
-        void       (WINE_GLAPI *p_glCopyTexImage2D)(GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLsizei,GLint);
-        void       (WINE_GLAPI *p_glCopyTexSubImage1D)(GLenum,GLint,GLint,GLint,GLint,GLsizei);
-        void       (WINE_GLAPI *p_glCopyTexSubImage2D)(GLenum,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glCullFace)(GLenum);
-        void       (WINE_GLAPI *p_glDeleteLists)(GLuint,GLsizei);
-        void       (WINE_GLAPI *p_glDeleteTextures)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDepthFunc)(GLenum);
-        void       (WINE_GLAPI *p_glDepthMask)(GLboolean);
-        void       (WINE_GLAPI *p_glDepthRange)(GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glDisable)(GLenum);
-        void       (WINE_GLAPI *p_glDisableClientState)(GLenum);
-        void       (WINE_GLAPI *p_glDrawArrays)(GLenum,GLint,GLsizei);
-        void       (WINE_GLAPI *p_glDrawBuffer)(GLenum);
-        void       (WINE_GLAPI *p_glDrawElements)(GLenum,GLsizei,GLenum,const void*);
-        void       (WINE_GLAPI *p_glDrawPixels)(GLsizei,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glEdgeFlag)(GLboolean);
-        void       (WINE_GLAPI *p_glEdgeFlagPointer)(GLsizei,const void*);
-        void       (WINE_GLAPI *p_glEdgeFlagv)(const GLboolean*);
-        void       (WINE_GLAPI *p_glEnable)(GLenum);
-        void       (WINE_GLAPI *p_glEnableClientState)(GLenum);
+        void       (WINE_GLAPI *p_glAccum)( GLenum op, GLfloat value );
+        void       (WINE_GLAPI *p_glAlphaFunc)( GLenum func, GLfloat ref );
+        GLboolean  (WINE_GLAPI *p_glAreTexturesResident)( GLsizei n, const GLuint *textures, GLboolean *residences );
+        void       (WINE_GLAPI *p_glArrayElement)( GLint i );
+        void       (WINE_GLAPI *p_glBegin)( GLenum mode );
+        void       (WINE_GLAPI *p_glBindTexture)( GLenum target, GLuint texture );
+        void       (WINE_GLAPI *p_glBitmap)( GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap );
+        void       (WINE_GLAPI *p_glBlendFunc)( GLenum sfactor, GLenum dfactor );
+        void       (WINE_GLAPI *p_glCallList)( GLuint list );
+        void       (WINE_GLAPI *p_glCallLists)( GLsizei n, GLenum type, const void *lists );
+        void       (WINE_GLAPI *p_glClear)( GLbitfield mask );
+        void       (WINE_GLAPI *p_glClearAccum)( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
+        void       (WINE_GLAPI *p_glClearColor)( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
+        void       (WINE_GLAPI *p_glClearDepth)( GLdouble depth );
+        void       (WINE_GLAPI *p_glClearIndex)( GLfloat c );
+        void       (WINE_GLAPI *p_glClearStencil)( GLint s );
+        void       (WINE_GLAPI *p_glClipPlane)( GLenum plane, const GLdouble *equation );
+        void       (WINE_GLAPI *p_glColor3b)( GLbyte red, GLbyte green, GLbyte blue );
+        void       (WINE_GLAPI *p_glColor3bv)( const GLbyte *v );
+        void       (WINE_GLAPI *p_glColor3d)( GLdouble red, GLdouble green, GLdouble blue );
+        void       (WINE_GLAPI *p_glColor3dv)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glColor3f)( GLfloat red, GLfloat green, GLfloat blue );
+        void       (WINE_GLAPI *p_glColor3fv)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glColor3i)( GLint red, GLint green, GLint blue );
+        void       (WINE_GLAPI *p_glColor3iv)( const GLint *v );
+        void       (WINE_GLAPI *p_glColor3s)( GLshort red, GLshort green, GLshort blue );
+        void       (WINE_GLAPI *p_glColor3sv)( const GLshort *v );
+        void       (WINE_GLAPI *p_glColor3ub)( GLubyte red, GLubyte green, GLubyte blue );
+        void       (WINE_GLAPI *p_glColor3ubv)( const GLubyte *v );
+        void       (WINE_GLAPI *p_glColor3ui)( GLuint red, GLuint green, GLuint blue );
+        void       (WINE_GLAPI *p_glColor3uiv)( const GLuint *v );
+        void       (WINE_GLAPI *p_glColor3us)( GLushort red, GLushort green, GLushort blue );
+        void       (WINE_GLAPI *p_glColor3usv)( const GLushort *v );
+        void       (WINE_GLAPI *p_glColor4b)( GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha );
+        void       (WINE_GLAPI *p_glColor4bv)( const GLbyte *v );
+        void       (WINE_GLAPI *p_glColor4d)( GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha );
+        void       (WINE_GLAPI *p_glColor4dv)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glColor4f)( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
+        void       (WINE_GLAPI *p_glColor4fv)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glColor4i)( GLint red, GLint green, GLint blue, GLint alpha );
+        void       (WINE_GLAPI *p_glColor4iv)( const GLint *v );
+        void       (WINE_GLAPI *p_glColor4s)( GLshort red, GLshort green, GLshort blue, GLshort alpha );
+        void       (WINE_GLAPI *p_glColor4sv)( const GLshort *v );
+        void       (WINE_GLAPI *p_glColor4ub)( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha );
+        void       (WINE_GLAPI *p_glColor4ubv)( const GLubyte *v );
+        void       (WINE_GLAPI *p_glColor4ui)( GLuint red, GLuint green, GLuint blue, GLuint alpha );
+        void       (WINE_GLAPI *p_glColor4uiv)( const GLuint *v );
+        void       (WINE_GLAPI *p_glColor4us)( GLushort red, GLushort green, GLushort blue, GLushort alpha );
+        void       (WINE_GLAPI *p_glColor4usv)( const GLushort *v );
+        void       (WINE_GLAPI *p_glColorMask)( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha );
+        void       (WINE_GLAPI *p_glColorMaterial)( GLenum face, GLenum mode );
+        void       (WINE_GLAPI *p_glColorPointer)( GLint size, GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glCopyPixels)( GLint x, GLint y, GLsizei width, GLsizei height, GLenum type );
+        void       (WINE_GLAPI *p_glCopyTexImage1D)( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border );
+        void       (WINE_GLAPI *p_glCopyTexImage2D)( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border );
+        void       (WINE_GLAPI *p_glCopyTexSubImage1D)( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width );
+        void       (WINE_GLAPI *p_glCopyTexSubImage2D)( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glCullFace)( GLenum mode );
+        void       (WINE_GLAPI *p_glDeleteLists)( GLuint list, GLsizei range );
+        void       (WINE_GLAPI *p_glDeleteTextures)( GLsizei n, const GLuint *textures );
+        void       (WINE_GLAPI *p_glDepthFunc)( GLenum func );
+        void       (WINE_GLAPI *p_glDepthMask)( GLboolean flag );
+        void       (WINE_GLAPI *p_glDepthRange)( GLdouble near, GLdouble far );
+        void       (WINE_GLAPI *p_glDisable)( GLenum cap );
+        void       (WINE_GLAPI *p_glDisableClientState)( GLenum array );
+        void       (WINE_GLAPI *p_glDrawArrays)( GLenum mode, GLint first, GLsizei count );
+        void       (WINE_GLAPI *p_glDrawBuffer)( GLenum buf );
+        void       (WINE_GLAPI *p_glDrawElements)( GLenum mode, GLsizei count, GLenum type, const void *indices );
+        void       (WINE_GLAPI *p_glDrawPixels)( GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glEdgeFlag)( GLboolean flag );
+        void       (WINE_GLAPI *p_glEdgeFlagPointer)( GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glEdgeFlagv)( const GLboolean *flag );
+        void       (WINE_GLAPI *p_glEnable)( GLenum cap );
+        void       (WINE_GLAPI *p_glEnableClientState)( GLenum array );
         void       (WINE_GLAPI *p_glEnd)(void);
         void       (WINE_GLAPI *p_glEndList)(void);
-        void       (WINE_GLAPI *p_glEvalCoord1d)(GLdouble);
-        void       (WINE_GLAPI *p_glEvalCoord1dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glEvalCoord1f)(GLfloat);
-        void       (WINE_GLAPI *p_glEvalCoord1fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glEvalCoord2d)(GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glEvalCoord2dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glEvalCoord2f)(GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glEvalCoord2fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glEvalMesh1)(GLenum,GLint,GLint);
-        void       (WINE_GLAPI *p_glEvalMesh2)(GLenum,GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glEvalPoint1)(GLint);
-        void       (WINE_GLAPI *p_glEvalPoint2)(GLint,GLint);
-        void       (WINE_GLAPI *p_glFeedbackBuffer)(GLsizei,GLenum,GLfloat*);
+        void       (WINE_GLAPI *p_glEvalCoord1d)( GLdouble u );
+        void       (WINE_GLAPI *p_glEvalCoord1dv)( const GLdouble *u );
+        void       (WINE_GLAPI *p_glEvalCoord1f)( GLfloat u );
+        void       (WINE_GLAPI *p_glEvalCoord1fv)( const GLfloat *u );
+        void       (WINE_GLAPI *p_glEvalCoord2d)( GLdouble u, GLdouble v );
+        void       (WINE_GLAPI *p_glEvalCoord2dv)( const GLdouble *u );
+        void       (WINE_GLAPI *p_glEvalCoord2f)( GLfloat u, GLfloat v );
+        void       (WINE_GLAPI *p_glEvalCoord2fv)( const GLfloat *u );
+        void       (WINE_GLAPI *p_glEvalMesh1)( GLenum mode, GLint i1, GLint i2 );
+        void       (WINE_GLAPI *p_glEvalMesh2)( GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2 );
+        void       (WINE_GLAPI *p_glEvalPoint1)( GLint i );
+        void       (WINE_GLAPI *p_glEvalPoint2)( GLint i, GLint j );
+        void       (WINE_GLAPI *p_glFeedbackBuffer)( GLsizei size, GLenum type, GLfloat *buffer );
         void       (WINE_GLAPI *p_glFinish)(void);
         void       (WINE_GLAPI *p_glFlush)(void);
-        void       (WINE_GLAPI *p_glFogf)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glFogfv)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glFogi)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glFogiv)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glFrontFace)(GLenum);
-        void       (WINE_GLAPI *p_glFrustum)(GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble);
-        GLuint     (WINE_GLAPI *p_glGenLists)(GLsizei);
-        void       (WINE_GLAPI *p_glGenTextures)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGetBooleanv)(GLenum,GLboolean*);
-        void       (WINE_GLAPI *p_glGetClipPlane)(GLenum,GLdouble*);
-        void       (WINE_GLAPI *p_glGetDoublev)(GLenum,GLdouble*);
+        void       (WINE_GLAPI *p_glFogf)( GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glFogfv)( GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glFogi)( GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glFogiv)( GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glFrontFace)( GLenum mode );
+        void       (WINE_GLAPI *p_glFrustum)( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar );
+        GLuint     (WINE_GLAPI *p_glGenLists)( GLsizei range );
+        void       (WINE_GLAPI *p_glGenTextures)( GLsizei n, GLuint *textures );
+        void       (WINE_GLAPI *p_glGetBooleanv)( GLenum pname, GLboolean *data );
+        void       (WINE_GLAPI *p_glGetClipPlane)( GLenum plane, GLdouble *equation );
+        void       (WINE_GLAPI *p_glGetDoublev)( GLenum pname, GLdouble *data );
         GLenum     (WINE_GLAPI *p_glGetError)(void);
-        void       (WINE_GLAPI *p_glGetFloatv)(GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetIntegerv)(GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetLightfv)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetLightiv)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetMapdv)(GLenum,GLenum,GLdouble*);
-        void       (WINE_GLAPI *p_glGetMapfv)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetMapiv)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetMaterialfv)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetMaterialiv)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetPixelMapfv)(GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetPixelMapuiv)(GLenum,GLuint*);
-        void       (WINE_GLAPI *p_glGetPixelMapusv)(GLenum,GLushort*);
-        void       (WINE_GLAPI *p_glGetPointerv)(GLenum,void**);
-        void       (WINE_GLAPI *p_glGetPolygonStipple)(GLubyte*);
-        const GLubyte* (WINE_GLAPI *p_glGetString)(GLenum);
-        void       (WINE_GLAPI *p_glGetTexEnvfv)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetTexEnviv)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetTexGendv)(GLenum,GLenum,GLdouble*);
-        void       (WINE_GLAPI *p_glGetTexGenfv)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetTexGeniv)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetTexImage)(GLenum,GLint,GLenum,GLenum,void*);
-        void       (WINE_GLAPI *p_glGetTexLevelParameterfv)(GLenum,GLint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetTexLevelParameteriv)(GLenum,GLint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetTexParameterfv)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetTexParameteriv)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glHint)(GLenum,GLenum);
-        void       (WINE_GLAPI *p_glIndexMask)(GLuint);
-        void       (WINE_GLAPI *p_glIndexPointer)(GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glIndexd)(GLdouble);
-        void       (WINE_GLAPI *p_glIndexdv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glIndexf)(GLfloat);
-        void       (WINE_GLAPI *p_glIndexfv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glIndexi)(GLint);
-        void       (WINE_GLAPI *p_glIndexiv)(const GLint*);
-        void       (WINE_GLAPI *p_glIndexs)(GLshort);
-        void       (WINE_GLAPI *p_glIndexsv)(const GLshort*);
-        void       (WINE_GLAPI *p_glIndexub)(GLubyte);
-        void       (WINE_GLAPI *p_glIndexubv)(const GLubyte*);
+        void       (WINE_GLAPI *p_glGetFloatv)( GLenum pname, GLfloat *data );
+        void       (WINE_GLAPI *p_glGetIntegerv)( GLenum pname, GLint *data );
+        void       (WINE_GLAPI *p_glGetLightfv)( GLenum light, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetLightiv)( GLenum light, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetMapdv)( GLenum target, GLenum query, GLdouble *v );
+        void       (WINE_GLAPI *p_glGetMapfv)( GLenum target, GLenum query, GLfloat *v );
+        void       (WINE_GLAPI *p_glGetMapiv)( GLenum target, GLenum query, GLint *v );
+        void       (WINE_GLAPI *p_glGetMaterialfv)( GLenum face, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetMaterialiv)( GLenum face, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetPixelMapfv)( GLenum map, GLfloat *values );
+        void       (WINE_GLAPI *p_glGetPixelMapuiv)( GLenum map, GLuint *values );
+        void       (WINE_GLAPI *p_glGetPixelMapusv)( GLenum map, GLushort *values );
+        void       (WINE_GLAPI *p_glGetPointerv)( GLenum pname, void **params );
+        void       (WINE_GLAPI *p_glGetPolygonStipple)( GLubyte *mask );
+        const GLubyte * (WINE_GLAPI *p_glGetString)( GLenum name );
+        void       (WINE_GLAPI *p_glGetTexEnvfv)( GLenum target, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetTexEnviv)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetTexGendv)( GLenum coord, GLenum pname, GLdouble *params );
+        void       (WINE_GLAPI *p_glGetTexGenfv)( GLenum coord, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetTexGeniv)( GLenum coord, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetTexImage)( GLenum target, GLint level, GLenum format, GLenum type, void *pixels );
+        void       (WINE_GLAPI *p_glGetTexLevelParameterfv)( GLenum target, GLint level, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetTexLevelParameteriv)( GLenum target, GLint level, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetTexParameterfv)( GLenum target, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetTexParameteriv)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glHint)( GLenum target, GLenum mode );
+        void       (WINE_GLAPI *p_glIndexMask)( GLuint mask );
+        void       (WINE_GLAPI *p_glIndexPointer)( GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glIndexd)( GLdouble c );
+        void       (WINE_GLAPI *p_glIndexdv)( const GLdouble *c );
+        void       (WINE_GLAPI *p_glIndexf)( GLfloat c );
+        void       (WINE_GLAPI *p_glIndexfv)( const GLfloat *c );
+        void       (WINE_GLAPI *p_glIndexi)( GLint c );
+        void       (WINE_GLAPI *p_glIndexiv)( const GLint *c );
+        void       (WINE_GLAPI *p_glIndexs)( GLshort c );
+        void       (WINE_GLAPI *p_glIndexsv)( const GLshort *c );
+        void       (WINE_GLAPI *p_glIndexub)( GLubyte c );
+        void       (WINE_GLAPI *p_glIndexubv)( const GLubyte *c );
         void       (WINE_GLAPI *p_glInitNames)(void);
-        void       (WINE_GLAPI *p_glInterleavedArrays)(GLenum,GLsizei,const void*);
-        GLboolean  (WINE_GLAPI *p_glIsEnabled)(GLenum);
-        GLboolean  (WINE_GLAPI *p_glIsList)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsTexture)(GLuint);
-        void       (WINE_GLAPI *p_glLightModelf)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glLightModelfv)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glLightModeli)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glLightModeliv)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glLightf)(GLenum,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glLightfv)(GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glLighti)(GLenum,GLenum,GLint);
-        void       (WINE_GLAPI *p_glLightiv)(GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glLineStipple)(GLint,GLushort);
-        void       (WINE_GLAPI *p_glLineWidth)(GLfloat);
-        void       (WINE_GLAPI *p_glListBase)(GLuint);
+        void       (WINE_GLAPI *p_glInterleavedArrays)( GLenum format, GLsizei stride, const void *pointer );
+        GLboolean  (WINE_GLAPI *p_glIsEnabled)( GLenum cap );
+        GLboolean  (WINE_GLAPI *p_glIsList)( GLuint list );
+        GLboolean  (WINE_GLAPI *p_glIsTexture)( GLuint texture );
+        void       (WINE_GLAPI *p_glLightModelf)( GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glLightModelfv)( GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glLightModeli)( GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glLightModeliv)( GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glLightf)( GLenum light, GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glLightfv)( GLenum light, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glLighti)( GLenum light, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glLightiv)( GLenum light, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glLineStipple)( GLint factor, GLushort pattern );
+        void       (WINE_GLAPI *p_glLineWidth)( GLfloat width );
+        void       (WINE_GLAPI *p_glListBase)( GLuint base );
         void       (WINE_GLAPI *p_glLoadIdentity)(void);
-        void       (WINE_GLAPI *p_glLoadMatrixd)(const GLdouble*);
-        void       (WINE_GLAPI *p_glLoadMatrixf)(const GLfloat*);
-        void       (WINE_GLAPI *p_glLoadName)(GLuint);
-        void       (WINE_GLAPI *p_glLogicOp)(GLenum);
-        void       (WINE_GLAPI *p_glMap1d)(GLenum,GLdouble,GLdouble,GLint,GLint,const GLdouble*);
-        void       (WINE_GLAPI *p_glMap1f)(GLenum,GLfloat,GLfloat,GLint,GLint,const GLfloat*);
-        void       (WINE_GLAPI *p_glMap2d)(GLenum,GLdouble,GLdouble,GLint,GLint,GLdouble,GLdouble,GLint,GLint,const GLdouble*);
-        void       (WINE_GLAPI *p_glMap2f)(GLenum,GLfloat,GLfloat,GLint,GLint,GLfloat,GLfloat,GLint,GLint,const GLfloat*);
-        void       (WINE_GLAPI *p_glMapGrid1d)(GLint,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glMapGrid1f)(GLint,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glMapGrid2d)(GLint,GLdouble,GLdouble,GLint,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glMapGrid2f)(GLint,GLfloat,GLfloat,GLint,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glMaterialf)(GLenum,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glMaterialfv)(GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMateriali)(GLenum,GLenum,GLint);
-        void       (WINE_GLAPI *p_glMaterialiv)(GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glMatrixMode)(GLenum);
-        void       (WINE_GLAPI *p_glMultMatrixd)(const GLdouble*);
-        void       (WINE_GLAPI *p_glMultMatrixf)(const GLfloat*);
-        void       (WINE_GLAPI *p_glNewList)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glNormal3b)(GLbyte,GLbyte,GLbyte);
-        void       (WINE_GLAPI *p_glNormal3bv)(const GLbyte*);
-        void       (WINE_GLAPI *p_glNormal3d)(GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glNormal3dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glNormal3f)(GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glNormal3fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glNormal3i)(GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glNormal3iv)(const GLint*);
-        void       (WINE_GLAPI *p_glNormal3s)(GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glNormal3sv)(const GLshort*);
-        void       (WINE_GLAPI *p_glNormalPointer)(GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glOrtho)(GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glPassThrough)(GLfloat);
-        void       (WINE_GLAPI *p_glPixelMapfv)(GLenum,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glPixelMapuiv)(GLenum,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glPixelMapusv)(GLenum,GLsizei,const GLushort*);
-        void       (WINE_GLAPI *p_glPixelStoref)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glPixelStorei)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glPixelTransferf)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glPixelTransferi)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glPixelZoom)(GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glPointSize)(GLfloat);
-        void       (WINE_GLAPI *p_glPolygonMode)(GLenum,GLenum);
-        void       (WINE_GLAPI *p_glPolygonOffset)(GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glPolygonStipple)(const GLubyte*);
+        void       (WINE_GLAPI *p_glLoadMatrixd)( const GLdouble *m );
+        void       (WINE_GLAPI *p_glLoadMatrixf)( const GLfloat *m );
+        void       (WINE_GLAPI *p_glLoadName)( GLuint name );
+        void       (WINE_GLAPI *p_glLogicOp)( GLenum opcode );
+        void       (WINE_GLAPI *p_glMap1d)( GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points );
+        void       (WINE_GLAPI *p_glMap1f)( GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points );
+        void       (WINE_GLAPI *p_glMap2d)( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points );
+        void       (WINE_GLAPI *p_glMap2f)( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points );
+        void       (WINE_GLAPI *p_glMapGrid1d)( GLint un, GLdouble u1, GLdouble u2 );
+        void       (WINE_GLAPI *p_glMapGrid1f)( GLint un, GLfloat u1, GLfloat u2 );
+        void       (WINE_GLAPI *p_glMapGrid2d)( GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2 );
+        void       (WINE_GLAPI *p_glMapGrid2f)( GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2 );
+        void       (WINE_GLAPI *p_glMaterialf)( GLenum face, GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glMaterialfv)( GLenum face, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glMateriali)( GLenum face, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glMaterialiv)( GLenum face, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glMatrixMode)( GLenum mode );
+        void       (WINE_GLAPI *p_glMultMatrixd)( const GLdouble *m );
+        void       (WINE_GLAPI *p_glMultMatrixf)( const GLfloat *m );
+        void       (WINE_GLAPI *p_glNewList)( GLuint list, GLenum mode );
+        void       (WINE_GLAPI *p_glNormal3b)( GLbyte nx, GLbyte ny, GLbyte nz );
+        void       (WINE_GLAPI *p_glNormal3bv)( const GLbyte *v );
+        void       (WINE_GLAPI *p_glNormal3d)( GLdouble nx, GLdouble ny, GLdouble nz );
+        void       (WINE_GLAPI *p_glNormal3dv)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glNormal3f)( GLfloat nx, GLfloat ny, GLfloat nz );
+        void       (WINE_GLAPI *p_glNormal3fv)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glNormal3i)( GLint nx, GLint ny, GLint nz );
+        void       (WINE_GLAPI *p_glNormal3iv)( const GLint *v );
+        void       (WINE_GLAPI *p_glNormal3s)( GLshort nx, GLshort ny, GLshort nz );
+        void       (WINE_GLAPI *p_glNormal3sv)( const GLshort *v );
+        void       (WINE_GLAPI *p_glNormalPointer)( GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glOrtho)( GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar );
+        void       (WINE_GLAPI *p_glPassThrough)( GLfloat token );
+        void       (WINE_GLAPI *p_glPixelMapfv)( GLenum map, GLsizei mapsize, const GLfloat *values );
+        void       (WINE_GLAPI *p_glPixelMapuiv)( GLenum map, GLsizei mapsize, const GLuint *values );
+        void       (WINE_GLAPI *p_glPixelMapusv)( GLenum map, GLsizei mapsize, const GLushort *values );
+        void       (WINE_GLAPI *p_glPixelStoref)( GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glPixelStorei)( GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glPixelTransferf)( GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glPixelTransferi)( GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glPixelZoom)( GLfloat xfactor, GLfloat yfactor );
+        void       (WINE_GLAPI *p_glPointSize)( GLfloat size );
+        void       (WINE_GLAPI *p_glPolygonMode)( GLenum face, GLenum mode );
+        void       (WINE_GLAPI *p_glPolygonOffset)( GLfloat factor, GLfloat units );
+        void       (WINE_GLAPI *p_glPolygonStipple)( const GLubyte *mask );
         void       (WINE_GLAPI *p_glPopAttrib)(void);
         void       (WINE_GLAPI *p_glPopClientAttrib)(void);
         void       (WINE_GLAPI *p_glPopMatrix)(void);
         void       (WINE_GLAPI *p_glPopName)(void);
-        void       (WINE_GLAPI *p_glPrioritizeTextures)(GLsizei,const GLuint*,const GLfloat*);
-        void       (WINE_GLAPI *p_glPushAttrib)(GLbitfield);
-        void       (WINE_GLAPI *p_glPushClientAttrib)(GLbitfield);
+        void       (WINE_GLAPI *p_glPrioritizeTextures)( GLsizei n, const GLuint *textures, const GLfloat *priorities );
+        void       (WINE_GLAPI *p_glPushAttrib)( GLbitfield mask );
+        void       (WINE_GLAPI *p_glPushClientAttrib)( GLbitfield mask );
         void       (WINE_GLAPI *p_glPushMatrix)(void);
-        void       (WINE_GLAPI *p_glPushName)(GLuint);
-        void       (WINE_GLAPI *p_glRasterPos2d)(GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glRasterPos2dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glRasterPos2f)(GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glRasterPos2fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glRasterPos2i)(GLint,GLint);
-        void       (WINE_GLAPI *p_glRasterPos2iv)(const GLint*);
-        void       (WINE_GLAPI *p_glRasterPos2s)(GLshort,GLshort);
-        void       (WINE_GLAPI *p_glRasterPos2sv)(const GLshort*);
-        void       (WINE_GLAPI *p_glRasterPos3d)(GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glRasterPos3dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glRasterPos3f)(GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glRasterPos3fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glRasterPos3i)(GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glRasterPos3iv)(const GLint*);
-        void       (WINE_GLAPI *p_glRasterPos3s)(GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glRasterPos3sv)(const GLshort*);
-        void       (WINE_GLAPI *p_glRasterPos4d)(GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glRasterPos4dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glRasterPos4f)(GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glRasterPos4fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glRasterPos4i)(GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glRasterPos4iv)(const GLint*);
-        void       (WINE_GLAPI *p_glRasterPos4s)(GLshort,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glRasterPos4sv)(const GLshort*);
-        void       (WINE_GLAPI *p_glReadBuffer)(GLenum);
-        void       (WINE_GLAPI *p_glReadPixels)(GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,void*);
-        void       (WINE_GLAPI *p_glRectd)(GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glRectdv)(const GLdouble*,const GLdouble*);
-        void       (WINE_GLAPI *p_glRectf)(GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glRectfv)(const GLfloat*,const GLfloat*);
-        void       (WINE_GLAPI *p_glRecti)(GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glRectiv)(const GLint*,const GLint*);
-        void       (WINE_GLAPI *p_glRects)(GLshort,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glRectsv)(const GLshort*,const GLshort*);
-        GLint      (WINE_GLAPI *p_glRenderMode)(GLenum);
-        void       (WINE_GLAPI *p_glRotated)(GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glRotatef)(GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glScaled)(GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glScalef)(GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glScissor)(GLint,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glSelectBuffer)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glShadeModel)(GLenum);
-        void       (WINE_GLAPI *p_glStencilFunc)(GLenum,GLint,GLuint);
-        void       (WINE_GLAPI *p_glStencilMask)(GLuint);
-        void       (WINE_GLAPI *p_glStencilOp)(GLenum,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glTexCoord1d)(GLdouble);
-        void       (WINE_GLAPI *p_glTexCoord1dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glTexCoord1f)(GLfloat);
-        void       (WINE_GLAPI *p_glTexCoord1fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glTexCoord1i)(GLint);
-        void       (WINE_GLAPI *p_glTexCoord1iv)(const GLint*);
-        void       (WINE_GLAPI *p_glTexCoord1s)(GLshort);
-        void       (WINE_GLAPI *p_glTexCoord1sv)(const GLshort*);
-        void       (WINE_GLAPI *p_glTexCoord2d)(GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glTexCoord2dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glTexCoord2f)(GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glTexCoord2fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glTexCoord2i)(GLint,GLint);
-        void       (WINE_GLAPI *p_glTexCoord2iv)(const GLint*);
-        void       (WINE_GLAPI *p_glTexCoord2s)(GLshort,GLshort);
-        void       (WINE_GLAPI *p_glTexCoord2sv)(const GLshort*);
-        void       (WINE_GLAPI *p_glTexCoord3d)(GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glTexCoord3dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glTexCoord3f)(GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glTexCoord3fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glTexCoord3i)(GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glTexCoord3iv)(const GLint*);
-        void       (WINE_GLAPI *p_glTexCoord3s)(GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glTexCoord3sv)(const GLshort*);
-        void       (WINE_GLAPI *p_glTexCoord4d)(GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glTexCoord4dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glTexCoord4f)(GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glTexCoord4fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glTexCoord4i)(GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glTexCoord4iv)(const GLint*);
-        void       (WINE_GLAPI *p_glTexCoord4s)(GLshort,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glTexCoord4sv)(const GLshort*);
-        void       (WINE_GLAPI *p_glTexCoordPointer)(GLint,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glTexEnvf)(GLenum,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glTexEnvfv)(GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glTexEnvi)(GLenum,GLenum,GLint);
-        void       (WINE_GLAPI *p_glTexEnviv)(GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glTexGend)(GLenum,GLenum,GLdouble);
-        void       (WINE_GLAPI *p_glTexGendv)(GLenum,GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glTexGenf)(GLenum,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glTexGenfv)(GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glTexGeni)(GLenum,GLenum,GLint);
-        void       (WINE_GLAPI *p_glTexGeniv)(GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glTexImage1D)(GLenum,GLint,GLint,GLsizei,GLint,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTexImage2D)(GLenum,GLint,GLint,GLsizei,GLsizei,GLint,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTexParameterf)(GLenum,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glTexParameterfv)(GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glTexParameteri)(GLenum,GLenum,GLint);
-        void       (WINE_GLAPI *p_glTexParameteriv)(GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glTexSubImage1D)(GLenum,GLint,GLint,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTexSubImage2D)(GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTranslated)(GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glTranslatef)(GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glVertex2d)(GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertex2dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glVertex2f)(GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glVertex2fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glVertex2i)(GLint,GLint);
-        void       (WINE_GLAPI *p_glVertex2iv)(const GLint*);
-        void       (WINE_GLAPI *p_glVertex2s)(GLshort,GLshort);
-        void       (WINE_GLAPI *p_glVertex2sv)(const GLshort*);
-        void       (WINE_GLAPI *p_glVertex3d)(GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertex3dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glVertex3f)(GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glVertex3fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glVertex3i)(GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glVertex3iv)(const GLint*);
-        void       (WINE_GLAPI *p_glVertex3s)(GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glVertex3sv)(const GLshort*);
-        void       (WINE_GLAPI *p_glVertex4d)(GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertex4dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glVertex4f)(GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glVertex4fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glVertex4i)(GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glVertex4iv)(const GLint*);
-        void       (WINE_GLAPI *p_glVertex4s)(GLshort,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glVertex4sv)(const GLshort*);
-        void       (WINE_GLAPI *p_glVertexPointer)(GLint,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glViewport)(GLint,GLint,GLsizei,GLsizei);
+        void       (WINE_GLAPI *p_glPushName)( GLuint name );
+        void       (WINE_GLAPI *p_glRasterPos2d)( GLdouble x, GLdouble y );
+        void       (WINE_GLAPI *p_glRasterPos2dv)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glRasterPos2f)( GLfloat x, GLfloat y );
+        void       (WINE_GLAPI *p_glRasterPos2fv)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glRasterPos2i)( GLint x, GLint y );
+        void       (WINE_GLAPI *p_glRasterPos2iv)( const GLint *v );
+        void       (WINE_GLAPI *p_glRasterPos2s)( GLshort x, GLshort y );
+        void       (WINE_GLAPI *p_glRasterPos2sv)( const GLshort *v );
+        void       (WINE_GLAPI *p_glRasterPos3d)( GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glRasterPos3dv)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glRasterPos3f)( GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glRasterPos3fv)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glRasterPos3i)( GLint x, GLint y, GLint z );
+        void       (WINE_GLAPI *p_glRasterPos3iv)( const GLint *v );
+        void       (WINE_GLAPI *p_glRasterPos3s)( GLshort x, GLshort y, GLshort z );
+        void       (WINE_GLAPI *p_glRasterPos3sv)( const GLshort *v );
+        void       (WINE_GLAPI *p_glRasterPos4d)( GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+        void       (WINE_GLAPI *p_glRasterPos4dv)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glRasterPos4f)( GLfloat x, GLfloat y, GLfloat z, GLfloat w );
+        void       (WINE_GLAPI *p_glRasterPos4fv)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glRasterPos4i)( GLint x, GLint y, GLint z, GLint w );
+        void       (WINE_GLAPI *p_glRasterPos4iv)( const GLint *v );
+        void       (WINE_GLAPI *p_glRasterPos4s)( GLshort x, GLshort y, GLshort z, GLshort w );
+        void       (WINE_GLAPI *p_glRasterPos4sv)( const GLshort *v );
+        void       (WINE_GLAPI *p_glReadBuffer)( GLenum src );
+        void       (WINE_GLAPI *p_glReadPixels)( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels );
+        void       (WINE_GLAPI *p_glRectd)( GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2 );
+        void       (WINE_GLAPI *p_glRectdv)( const GLdouble *v1, const GLdouble *v2 );
+        void       (WINE_GLAPI *p_glRectf)( GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2 );
+        void       (WINE_GLAPI *p_glRectfv)( const GLfloat *v1, const GLfloat *v2 );
+        void       (WINE_GLAPI *p_glRecti)( GLint x1, GLint y1, GLint x2, GLint y2 );
+        void       (WINE_GLAPI *p_glRectiv)( const GLint *v1, const GLint *v2 );
+        void       (WINE_GLAPI *p_glRects)( GLshort x1, GLshort y1, GLshort x2, GLshort y2 );
+        void       (WINE_GLAPI *p_glRectsv)( const GLshort *v1, const GLshort *v2 );
+        GLint      (WINE_GLAPI *p_glRenderMode)( GLenum mode );
+        void       (WINE_GLAPI *p_glRotated)( GLdouble angle, GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glRotatef)( GLfloat angle, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glScaled)( GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glScalef)( GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glScissor)( GLint x, GLint y, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glSelectBuffer)( GLsizei size, GLuint *buffer );
+        void       (WINE_GLAPI *p_glShadeModel)( GLenum mode );
+        void       (WINE_GLAPI *p_glStencilFunc)( GLenum func, GLint ref, GLuint mask );
+        void       (WINE_GLAPI *p_glStencilMask)( GLuint mask );
+        void       (WINE_GLAPI *p_glStencilOp)( GLenum fail, GLenum zfail, GLenum zpass );
+        void       (WINE_GLAPI *p_glTexCoord1d)( GLdouble s );
+        void       (WINE_GLAPI *p_glTexCoord1dv)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glTexCoord1f)( GLfloat s );
+        void       (WINE_GLAPI *p_glTexCoord1fv)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glTexCoord1i)( GLint s );
+        void       (WINE_GLAPI *p_glTexCoord1iv)( const GLint *v );
+        void       (WINE_GLAPI *p_glTexCoord1s)( GLshort s );
+        void       (WINE_GLAPI *p_glTexCoord1sv)( const GLshort *v );
+        void       (WINE_GLAPI *p_glTexCoord2d)( GLdouble s, GLdouble t );
+        void       (WINE_GLAPI *p_glTexCoord2dv)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glTexCoord2f)( GLfloat s, GLfloat t );
+        void       (WINE_GLAPI *p_glTexCoord2fv)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glTexCoord2i)( GLint s, GLint t );
+        void       (WINE_GLAPI *p_glTexCoord2iv)( const GLint *v );
+        void       (WINE_GLAPI *p_glTexCoord2s)( GLshort s, GLshort t );
+        void       (WINE_GLAPI *p_glTexCoord2sv)( const GLshort *v );
+        void       (WINE_GLAPI *p_glTexCoord3d)( GLdouble s, GLdouble t, GLdouble r );
+        void       (WINE_GLAPI *p_glTexCoord3dv)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glTexCoord3f)( GLfloat s, GLfloat t, GLfloat r );
+        void       (WINE_GLAPI *p_glTexCoord3fv)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glTexCoord3i)( GLint s, GLint t, GLint r );
+        void       (WINE_GLAPI *p_glTexCoord3iv)( const GLint *v );
+        void       (WINE_GLAPI *p_glTexCoord3s)( GLshort s, GLshort t, GLshort r );
+        void       (WINE_GLAPI *p_glTexCoord3sv)( const GLshort *v );
+        void       (WINE_GLAPI *p_glTexCoord4d)( GLdouble s, GLdouble t, GLdouble r, GLdouble q );
+        void       (WINE_GLAPI *p_glTexCoord4dv)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glTexCoord4f)( GLfloat s, GLfloat t, GLfloat r, GLfloat q );
+        void       (WINE_GLAPI *p_glTexCoord4fv)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glTexCoord4i)( GLint s, GLint t, GLint r, GLint q );
+        void       (WINE_GLAPI *p_glTexCoord4iv)( const GLint *v );
+        void       (WINE_GLAPI *p_glTexCoord4s)( GLshort s, GLshort t, GLshort r, GLshort q );
+        void       (WINE_GLAPI *p_glTexCoord4sv)( const GLshort *v );
+        void       (WINE_GLAPI *p_glTexCoordPointer)( GLint size, GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glTexEnvf)( GLenum target, GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glTexEnvfv)( GLenum target, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glTexEnvi)( GLenum target, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glTexEnviv)( GLenum target, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glTexGend)( GLenum coord, GLenum pname, GLdouble param );
+        void       (WINE_GLAPI *p_glTexGendv)( GLenum coord, GLenum pname, const GLdouble *params );
+        void       (WINE_GLAPI *p_glTexGenf)( GLenum coord, GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glTexGenfv)( GLenum coord, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glTexGeni)( GLenum coord, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glTexGeniv)( GLenum coord, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glTexImage1D)( GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTexImage2D)( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTexParameterf)( GLenum target, GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glTexParameterfv)( GLenum target, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glTexParameteri)( GLenum target, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glTexParameteriv)( GLenum target, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glTexSubImage1D)( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTexSubImage2D)( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTranslated)( GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glTranslatef)( GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glVertex2d)( GLdouble x, GLdouble y );
+        void       (WINE_GLAPI *p_glVertex2dv)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertex2f)( GLfloat x, GLfloat y );
+        void       (WINE_GLAPI *p_glVertex2fv)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertex2i)( GLint x, GLint y );
+        void       (WINE_GLAPI *p_glVertex2iv)( const GLint *v );
+        void       (WINE_GLAPI *p_glVertex2s)( GLshort x, GLshort y );
+        void       (WINE_GLAPI *p_glVertex2sv)( const GLshort *v );
+        void       (WINE_GLAPI *p_glVertex3d)( GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glVertex3dv)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertex3f)( GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glVertex3fv)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertex3i)( GLint x, GLint y, GLint z );
+        void       (WINE_GLAPI *p_glVertex3iv)( const GLint *v );
+        void       (WINE_GLAPI *p_glVertex3s)( GLshort x, GLshort y, GLshort z );
+        void       (WINE_GLAPI *p_glVertex3sv)( const GLshort *v );
+        void       (WINE_GLAPI *p_glVertex4d)( GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+        void       (WINE_GLAPI *p_glVertex4dv)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertex4f)( GLfloat x, GLfloat y, GLfloat z, GLfloat w );
+        void       (WINE_GLAPI *p_glVertex4fv)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertex4i)( GLint x, GLint y, GLint z, GLint w );
+        void       (WINE_GLAPI *p_glVertex4iv)( const GLint *v );
+        void       (WINE_GLAPI *p_glVertex4s)( GLshort x, GLshort y, GLshort z, GLshort w );
+        void       (WINE_GLAPI *p_glVertex4sv)( const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexPointer)( GLint size, GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glViewport)( GLint x, GLint y, GLsizei width, GLsizei height );
     } gl;
 
     struct
     {
-        void       (WINE_GLAPI *p_glAccumxOES)(GLenum,GLfixed);
-        GLboolean  (WINE_GLAPI *p_glAcquireKeyedMutexWin32EXT)(GLuint,GLuint64,GLuint);
-        void       (WINE_GLAPI *p_glActiveProgramEXT)(GLuint);
-        void       (WINE_GLAPI *p_glActiveShaderProgram)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glActiveStencilFaceEXT)(GLenum);
-        void       (WINE_GLAPI *p_glActiveTexture)(GLenum);
-        void       (WINE_GLAPI *p_glActiveTextureARB)(GLenum);
-        void       (WINE_GLAPI *p_glActiveVaryingNV)(GLuint,const GLchar*);
-        void       (WINE_GLAPI *p_glAlphaFragmentOp1ATI)(GLenum,GLuint,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glAlphaFragmentOp2ATI)(GLenum,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glAlphaFragmentOp3ATI)(GLenum,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glAlphaFuncxOES)(GLenum,GLfixed);
-        void       (WINE_GLAPI *p_glAlphaToCoverageDitherControlNV)(GLenum);
+        void       (WINE_GLAPI *p_glAccumxOES)( GLenum op, GLfixed value );
+        GLboolean  (WINE_GLAPI *p_glAcquireKeyedMutexWin32EXT)( GLuint memory, GLuint64 key, GLuint timeout );
+        void       (WINE_GLAPI *p_glActiveProgramEXT)( GLuint program );
+        void       (WINE_GLAPI *p_glActiveShaderProgram)( GLuint pipeline, GLuint program );
+        void       (WINE_GLAPI *p_glActiveStencilFaceEXT)( GLenum face );
+        void       (WINE_GLAPI *p_glActiveTexture)( GLenum texture );
+        void       (WINE_GLAPI *p_glActiveTextureARB)( GLenum texture );
+        void       (WINE_GLAPI *p_glActiveVaryingNV)( GLuint program, const GLchar *name );
+        void       (WINE_GLAPI *p_glAlphaFragmentOp1ATI)( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod );
+        void       (WINE_GLAPI *p_glAlphaFragmentOp2ATI)( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod );
+        void       (WINE_GLAPI *p_glAlphaFragmentOp3ATI)( GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod );
+        void       (WINE_GLAPI *p_glAlphaFuncxOES)( GLenum func, GLfixed ref );
+        void       (WINE_GLAPI *p_glAlphaToCoverageDitherControlNV)( GLenum mode );
         void       (WINE_GLAPI *p_glApplyFramebufferAttachmentCMAAINTEL)(void);
-        void       (WINE_GLAPI *p_glApplyTextureEXT)(GLenum);
-        GLboolean  (WINE_GLAPI *p_glAreProgramsResidentNV)(GLsizei,const GLuint*,GLboolean*);
-        GLboolean  (WINE_GLAPI *p_glAreTexturesResidentEXT)(GLsizei,const GLuint*,GLboolean*);
-        void       (WINE_GLAPI *p_glArrayElementEXT)(GLint);
-        void       (WINE_GLAPI *p_glArrayObjectATI)(GLenum,GLint,GLenum,GLsizei,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glAsyncMarkerSGIX)(GLuint);
-        void       (WINE_GLAPI *p_glAttachObjectARB)(GLhandleARB,GLhandleARB);
-        void       (WINE_GLAPI *p_glAttachShader)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glBeginConditionalRender)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glBeginConditionalRenderNV)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glBeginConditionalRenderNVX)(GLuint);
+        void       (WINE_GLAPI *p_glApplyTextureEXT)( GLenum mode );
+        GLboolean  (WINE_GLAPI *p_glAreProgramsResidentNV)( GLsizei n, const GLuint *programs, GLboolean *residences );
+        GLboolean  (WINE_GLAPI *p_glAreTexturesResidentEXT)( GLsizei n, const GLuint *textures, GLboolean *residences );
+        void       (WINE_GLAPI *p_glArrayElementEXT)( GLint i );
+        void       (WINE_GLAPI *p_glArrayObjectATI)( GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset );
+        void       (WINE_GLAPI *p_glAsyncMarkerSGIX)( GLuint marker );
+        void       (WINE_GLAPI *p_glAttachObjectARB)( GLhandleARB containerObj, GLhandleARB obj );
+        void       (WINE_GLAPI *p_glAttachShader)( GLuint program, GLuint shader );
+        void       (WINE_GLAPI *p_glBeginConditionalRender)( GLuint id, GLenum mode );
+        void       (WINE_GLAPI *p_glBeginConditionalRenderNV)( GLuint id, GLenum mode );
+        void       (WINE_GLAPI *p_glBeginConditionalRenderNVX)( GLuint id );
         void       (WINE_GLAPI *p_glBeginFragmentShaderATI)(void);
-        void       (WINE_GLAPI *p_glBeginOcclusionQueryNV)(GLuint);
-        void       (WINE_GLAPI *p_glBeginPerfMonitorAMD)(GLuint);
-        void       (WINE_GLAPI *p_glBeginPerfQueryINTEL)(GLuint);
-        void       (WINE_GLAPI *p_glBeginQuery)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glBeginQueryARB)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glBeginQueryIndexed)(GLenum,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glBeginTransformFeedback)(GLenum);
-        void       (WINE_GLAPI *p_glBeginTransformFeedbackEXT)(GLenum);
-        void       (WINE_GLAPI *p_glBeginTransformFeedbackNV)(GLenum);
+        void       (WINE_GLAPI *p_glBeginOcclusionQueryNV)( GLuint id );
+        void       (WINE_GLAPI *p_glBeginPerfMonitorAMD)( GLuint monitor );
+        void       (WINE_GLAPI *p_glBeginPerfQueryINTEL)( GLuint queryHandle );
+        void       (WINE_GLAPI *p_glBeginQuery)( GLenum target, GLuint id );
+        void       (WINE_GLAPI *p_glBeginQueryARB)( GLenum target, GLuint id );
+        void       (WINE_GLAPI *p_glBeginQueryIndexed)( GLenum target, GLuint index, GLuint id );
+        void       (WINE_GLAPI *p_glBeginTransformFeedback)( GLenum primitiveMode );
+        void       (WINE_GLAPI *p_glBeginTransformFeedbackEXT)( GLenum primitiveMode );
+        void       (WINE_GLAPI *p_glBeginTransformFeedbackNV)( GLenum primitiveMode );
         void       (WINE_GLAPI *p_glBeginVertexShaderEXT)(void);
-        void       (WINE_GLAPI *p_glBeginVideoCaptureNV)(GLuint);
-        void       (WINE_GLAPI *p_glBindAttribLocation)(GLuint,GLuint,const GLchar*);
-        void       (WINE_GLAPI *p_glBindAttribLocationARB)(GLhandleARB,GLuint,const GLcharARB*);
-        void       (WINE_GLAPI *p_glBindBuffer)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glBindBufferARB)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glBindBufferBase)(GLenum,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glBindBufferBaseEXT)(GLenum,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glBindBufferBaseNV)(GLenum,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glBindBufferOffsetEXT)(GLenum,GLuint,GLuint,GLintptr);
-        void       (WINE_GLAPI *p_glBindBufferOffsetNV)(GLenum,GLuint,GLuint,GLintptr);
-        void       (WINE_GLAPI *p_glBindBufferRange)(GLenum,GLuint,GLuint,GLintptr,GLsizeiptr);
-        void       (WINE_GLAPI *p_glBindBufferRangeEXT)(GLenum,GLuint,GLuint,GLintptr,GLsizeiptr);
-        void       (WINE_GLAPI *p_glBindBufferRangeNV)(GLenum,GLuint,GLuint,GLintptr,GLsizeiptr);
-        void       (WINE_GLAPI *p_glBindBuffersBase)(GLenum,GLuint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glBindBuffersRange)(GLenum,GLuint,GLsizei,const GLuint*,const GLintptr*,const GLsizeiptr*);
-        void       (WINE_GLAPI *p_glBindFragDataLocation)(GLuint,GLuint,const GLchar*);
-        void       (WINE_GLAPI *p_glBindFragDataLocationEXT)(GLuint,GLuint,const GLchar*);
-        void       (WINE_GLAPI *p_glBindFragDataLocationIndexed)(GLuint,GLuint,GLuint,const GLchar*);
-        void       (WINE_GLAPI *p_glBindFragmentShaderATI)(GLuint);
-        void       (WINE_GLAPI *p_glBindFramebuffer)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glBindFramebufferEXT)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glBindImageTexture)(GLuint,GLuint,GLint,GLboolean,GLint,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBindImageTextureEXT)(GLuint,GLuint,GLint,GLboolean,GLint,GLenum,GLint);
-        void       (WINE_GLAPI *p_glBindImageTextures)(GLuint,GLsizei,const GLuint*);
-        GLuint     (WINE_GLAPI *p_glBindLightParameterEXT)(GLenum,GLenum);
-        GLuint     (WINE_GLAPI *p_glBindMaterialParameterEXT)(GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBindMultiTextureEXT)(GLenum,GLenum,GLuint);
-        GLuint     (WINE_GLAPI *p_glBindParameterEXT)(GLenum);
-        void       (WINE_GLAPI *p_glBindProgramARB)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glBindProgramNV)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glBindProgramPipeline)(GLuint);
-        void       (WINE_GLAPI *p_glBindRenderbuffer)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glBindRenderbufferEXT)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glBindSampler)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glBindSamplers)(GLuint,GLsizei,const GLuint*);
-        GLuint     (WINE_GLAPI *p_glBindTexGenParameterEXT)(GLenum,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBindTextureEXT)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glBindTextureUnit)(GLuint,GLuint);
-        GLuint     (WINE_GLAPI *p_glBindTextureUnitParameterEXT)(GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBindTextures)(GLuint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glBindTransformFeedback)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glBindTransformFeedbackNV)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glBindVertexArray)(GLuint);
-        void       (WINE_GLAPI *p_glBindVertexArrayAPPLE)(GLuint);
-        void       (WINE_GLAPI *p_glBindVertexBuffer)(GLuint,GLuint,GLintptr,GLsizei);
-        void       (WINE_GLAPI *p_glBindVertexBuffers)(GLuint,GLsizei,const GLuint*,const GLintptr*,const GLsizei*);
-        void       (WINE_GLAPI *p_glBindVertexShaderEXT)(GLuint);
-        void       (WINE_GLAPI *p_glBindVideoCaptureStreamBufferNV)(GLuint,GLuint,GLenum,GLintptrARB);
-        void       (WINE_GLAPI *p_glBindVideoCaptureStreamTextureNV)(GLuint,GLuint,GLenum,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glBinormal3bEXT)(GLbyte,GLbyte,GLbyte);
-        void       (WINE_GLAPI *p_glBinormal3bvEXT)(const GLbyte*);
-        void       (WINE_GLAPI *p_glBinormal3dEXT)(GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glBinormal3dvEXT)(const GLdouble*);
-        void       (WINE_GLAPI *p_glBinormal3fEXT)(GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glBinormal3fvEXT)(const GLfloat*);
-        void       (WINE_GLAPI *p_glBinormal3iEXT)(GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glBinormal3ivEXT)(const GLint*);
-        void       (WINE_GLAPI *p_glBinormal3sEXT)(GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glBinormal3svEXT)(const GLshort*);
-        void       (WINE_GLAPI *p_glBinormalPointerEXT)(GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glBitmapxOES)(GLsizei,GLsizei,GLfixed,GLfixed,GLfixed,GLfixed,const GLubyte*);
+        void       (WINE_GLAPI *p_glBeginVideoCaptureNV)( GLuint video_capture_slot );
+        void       (WINE_GLAPI *p_glBindAttribLocation)( GLuint program, GLuint index, const GLchar *name );
+        void       (WINE_GLAPI *p_glBindAttribLocationARB)( GLhandleARB programObj, GLuint index, const GLcharARB *name );
+        void       (WINE_GLAPI *p_glBindBuffer)( GLenum target, GLuint buffer );
+        void       (WINE_GLAPI *p_glBindBufferARB)( GLenum target, GLuint buffer );
+        void       (WINE_GLAPI *p_glBindBufferBase)( GLenum target, GLuint index, GLuint buffer );
+        void       (WINE_GLAPI *p_glBindBufferBaseEXT)( GLenum target, GLuint index, GLuint buffer );
+        void       (WINE_GLAPI *p_glBindBufferBaseNV)( GLenum target, GLuint index, GLuint buffer );
+        void       (WINE_GLAPI *p_glBindBufferOffsetEXT)( GLenum target, GLuint index, GLuint buffer, GLintptr offset );
+        void       (WINE_GLAPI *p_glBindBufferOffsetNV)( GLenum target, GLuint index, GLuint buffer, GLintptr offset );
+        void       (WINE_GLAPI *p_glBindBufferRange)( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size );
+        void       (WINE_GLAPI *p_glBindBufferRangeEXT)( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size );
+        void       (WINE_GLAPI *p_glBindBufferRangeNV)( GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size );
+        void       (WINE_GLAPI *p_glBindBuffersBase)( GLenum target, GLuint first, GLsizei count, const GLuint *buffers );
+        void       (WINE_GLAPI *p_glBindBuffersRange)( GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes );
+        void       (WINE_GLAPI *p_glBindFragDataLocation)( GLuint program, GLuint color, const GLchar *name );
+        void       (WINE_GLAPI *p_glBindFragDataLocationEXT)( GLuint program, GLuint color, const GLchar *name );
+        void       (WINE_GLAPI *p_glBindFragDataLocationIndexed)( GLuint program, GLuint colorNumber, GLuint index, const GLchar *name );
+        void       (WINE_GLAPI *p_glBindFragmentShaderATI)( GLuint id );
+        void       (WINE_GLAPI *p_glBindFramebuffer)( GLenum target, GLuint framebuffer );
+        void       (WINE_GLAPI *p_glBindFramebufferEXT)( GLenum target, GLuint framebuffer );
+        void       (WINE_GLAPI *p_glBindImageTexture)( GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format );
+        void       (WINE_GLAPI *p_glBindImageTextureEXT)( GLuint index, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLint format );
+        void       (WINE_GLAPI *p_glBindImageTextures)( GLuint first, GLsizei count, const GLuint *textures );
+        GLuint     (WINE_GLAPI *p_glBindLightParameterEXT)( GLenum light, GLenum value );
+        GLuint     (WINE_GLAPI *p_glBindMaterialParameterEXT)( GLenum face, GLenum value );
+        void       (WINE_GLAPI *p_glBindMultiTextureEXT)( GLenum texunit, GLenum target, GLuint texture );
+        GLuint     (WINE_GLAPI *p_glBindParameterEXT)( GLenum value );
+        void       (WINE_GLAPI *p_glBindProgramARB)( GLenum target, GLuint program );
+        void       (WINE_GLAPI *p_glBindProgramNV)( GLenum target, GLuint id );
+        void       (WINE_GLAPI *p_glBindProgramPipeline)( GLuint pipeline );
+        void       (WINE_GLAPI *p_glBindRenderbuffer)( GLenum target, GLuint renderbuffer );
+        void       (WINE_GLAPI *p_glBindRenderbufferEXT)( GLenum target, GLuint renderbuffer );
+        void       (WINE_GLAPI *p_glBindSampler)( GLuint unit, GLuint sampler );
+        void       (WINE_GLAPI *p_glBindSamplers)( GLuint first, GLsizei count, const GLuint *samplers );
+        GLuint     (WINE_GLAPI *p_glBindTexGenParameterEXT)( GLenum unit, GLenum coord, GLenum value );
+        void       (WINE_GLAPI *p_glBindTextureEXT)( GLenum target, GLuint texture );
+        void       (WINE_GLAPI *p_glBindTextureUnit)( GLuint unit, GLuint texture );
+        GLuint     (WINE_GLAPI *p_glBindTextureUnitParameterEXT)( GLenum unit, GLenum value );
+        void       (WINE_GLAPI *p_glBindTextures)( GLuint first, GLsizei count, const GLuint *textures );
+        void       (WINE_GLAPI *p_glBindTransformFeedback)( GLenum target, GLuint id );
+        void       (WINE_GLAPI *p_glBindTransformFeedbackNV)( GLenum target, GLuint id );
+        void       (WINE_GLAPI *p_glBindVertexArray)( GLuint array );
+        void       (WINE_GLAPI *p_glBindVertexArrayAPPLE)( GLuint array );
+        void       (WINE_GLAPI *p_glBindVertexBuffer)( GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride );
+        void       (WINE_GLAPI *p_glBindVertexBuffers)( GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides );
+        void       (WINE_GLAPI *p_glBindVertexShaderEXT)( GLuint id );
+        void       (WINE_GLAPI *p_glBindVideoCaptureStreamBufferNV)( GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLintptrARB offset );
+        void       (WINE_GLAPI *p_glBindVideoCaptureStreamTextureNV)( GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLenum target, GLuint texture );
+        void       (WINE_GLAPI *p_glBinormal3bEXT)( GLbyte bx, GLbyte by, GLbyte bz );
+        void       (WINE_GLAPI *p_glBinormal3bvEXT)( const GLbyte *v );
+        void       (WINE_GLAPI *p_glBinormal3dEXT)( GLdouble bx, GLdouble by, GLdouble bz );
+        void       (WINE_GLAPI *p_glBinormal3dvEXT)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glBinormal3fEXT)( GLfloat bx, GLfloat by, GLfloat bz );
+        void       (WINE_GLAPI *p_glBinormal3fvEXT)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glBinormal3iEXT)( GLint bx, GLint by, GLint bz );
+        void       (WINE_GLAPI *p_glBinormal3ivEXT)( const GLint *v );
+        void       (WINE_GLAPI *p_glBinormal3sEXT)( GLshort bx, GLshort by, GLshort bz );
+        void       (WINE_GLAPI *p_glBinormal3svEXT)( const GLshort *v );
+        void       (WINE_GLAPI *p_glBinormalPointerEXT)( GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glBitmapxOES)( GLsizei width, GLsizei height, GLfixed xorig, GLfixed yorig, GLfixed xmove, GLfixed ymove, const GLubyte *bitmap );
         void       (WINE_GLAPI *p_glBlendBarrierKHR)(void);
         void       (WINE_GLAPI *p_glBlendBarrierNV)(void);
-        void       (WINE_GLAPI *p_glBlendColor)(GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glBlendColorEXT)(GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glBlendColorxOES)(GLfixed,GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glBlendEquation)(GLenum);
-        void       (WINE_GLAPI *p_glBlendEquationEXT)(GLenum);
-        void       (WINE_GLAPI *p_glBlendEquationIndexedAMD)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glBlendEquationSeparate)(GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBlendEquationSeparateEXT)(GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBlendEquationSeparateIndexedAMD)(GLuint,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBlendEquationSeparatei)(GLuint,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBlendEquationSeparateiARB)(GLuint,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBlendEquationi)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glBlendEquationiARB)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glBlendFuncIndexedAMD)(GLuint,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBlendFuncSeparate)(GLenum,GLenum,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBlendFuncSeparateEXT)(GLenum,GLenum,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBlendFuncSeparateINGR)(GLenum,GLenum,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBlendFuncSeparateIndexedAMD)(GLuint,GLenum,GLenum,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBlendFuncSeparatei)(GLuint,GLenum,GLenum,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBlendFuncSeparateiARB)(GLuint,GLenum,GLenum,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBlendFunci)(GLuint,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBlendFunciARB)(GLuint,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glBlendParameteriNV)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glBlitFramebuffer)(GLint,GLint,GLint,GLint,GLint,GLint,GLint,GLint,GLbitfield,GLenum);
-        void       (WINE_GLAPI *p_glBlitFramebufferEXT)(GLint,GLint,GLint,GLint,GLint,GLint,GLint,GLint,GLbitfield,GLenum);
-        void       (WINE_GLAPI *p_glBlitNamedFramebuffer)(GLuint,GLuint,GLint,GLint,GLint,GLint,GLint,GLint,GLint,GLint,GLbitfield,GLenum);
-        void       (WINE_GLAPI *p_glBufferAddressRangeNV)(GLenum,GLuint,GLuint64EXT,GLsizeiptr);
-        void       (WINE_GLAPI *p_glBufferData)(GLenum,GLsizeiptr,const void*,GLenum);
-        void       (WINE_GLAPI *p_glBufferDataARB)(GLenum,GLsizeiptrARB,const void*,GLenum);
-        void       (WINE_GLAPI *p_glBufferPageCommitmentARB)(GLenum,GLintptr,GLsizeiptr,GLboolean);
-        void       (WINE_GLAPI *p_glBufferParameteriAPPLE)(GLenum,GLenum,GLint);
+        void       (WINE_GLAPI *p_glBlendColor)( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
+        void       (WINE_GLAPI *p_glBlendColorEXT)( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha );
+        void       (WINE_GLAPI *p_glBlendColorxOES)( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha );
+        void       (WINE_GLAPI *p_glBlendEquation)( GLenum mode );
+        void       (WINE_GLAPI *p_glBlendEquationEXT)( GLenum mode );
+        void       (WINE_GLAPI *p_glBlendEquationIndexedAMD)( GLuint buf, GLenum mode );
+        void       (WINE_GLAPI *p_glBlendEquationSeparate)( GLenum modeRGB, GLenum modeAlpha );
+        void       (WINE_GLAPI *p_glBlendEquationSeparateEXT)( GLenum modeRGB, GLenum modeAlpha );
+        void       (WINE_GLAPI *p_glBlendEquationSeparateIndexedAMD)( GLuint buf, GLenum modeRGB, GLenum modeAlpha );
+        void       (WINE_GLAPI *p_glBlendEquationSeparatei)( GLuint buf, GLenum modeRGB, GLenum modeAlpha );
+        void       (WINE_GLAPI *p_glBlendEquationSeparateiARB)( GLuint buf, GLenum modeRGB, GLenum modeAlpha );
+        void       (WINE_GLAPI *p_glBlendEquationi)( GLuint buf, GLenum mode );
+        void       (WINE_GLAPI *p_glBlendEquationiARB)( GLuint buf, GLenum mode );
+        void       (WINE_GLAPI *p_glBlendFuncIndexedAMD)( GLuint buf, GLenum src, GLenum dst );
+        void       (WINE_GLAPI *p_glBlendFuncSeparate)( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha );
+        void       (WINE_GLAPI *p_glBlendFuncSeparateEXT)( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha );
+        void       (WINE_GLAPI *p_glBlendFuncSeparateINGR)( GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha );
+        void       (WINE_GLAPI *p_glBlendFuncSeparateIndexedAMD)( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha );
+        void       (WINE_GLAPI *p_glBlendFuncSeparatei)( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha );
+        void       (WINE_GLAPI *p_glBlendFuncSeparateiARB)( GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha );
+        void       (WINE_GLAPI *p_glBlendFunci)( GLuint buf, GLenum src, GLenum dst );
+        void       (WINE_GLAPI *p_glBlendFunciARB)( GLuint buf, GLenum src, GLenum dst );
+        void       (WINE_GLAPI *p_glBlendParameteriNV)( GLenum pname, GLint value );
+        void       (WINE_GLAPI *p_glBlitFramebuffer)( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter );
+        void       (WINE_GLAPI *p_glBlitFramebufferEXT)( GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter );
+        void       (WINE_GLAPI *p_glBlitNamedFramebuffer)( GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter );
+        void       (WINE_GLAPI *p_glBufferAddressRangeNV)( GLenum pname, GLuint index, GLuint64EXT address, GLsizeiptr length );
+        void       (WINE_GLAPI *p_glBufferData)( GLenum target, GLsizeiptr size, const void *data, GLenum usage );
+        void       (WINE_GLAPI *p_glBufferDataARB)( GLenum target, GLsizeiptrARB size, const void *data, GLenum usage );
+        void       (WINE_GLAPI *p_glBufferPageCommitmentARB)( GLenum target, GLintptr offset, GLsizeiptr size, GLboolean commit );
+        void       (WINE_GLAPI *p_glBufferParameteriAPPLE)( GLenum target, GLenum pname, GLint param );
         GLuint     (WINE_GLAPI *p_glBufferRegionEnabled)(void);
-        void       (WINE_GLAPI *p_glBufferStorage)(GLenum,GLsizeiptr,const void*,GLbitfield);
-        void       (WINE_GLAPI *p_glBufferStorageExternalEXT)(GLenum,GLintptr,GLsizeiptr,void *,GLbitfield);
-        void       (WINE_GLAPI *p_glBufferStorageMemEXT)(GLenum,GLsizeiptr,GLuint,GLuint64);
-        void       (WINE_GLAPI *p_glBufferSubData)(GLenum,GLintptr,GLsizeiptr,const void*);
-        void       (WINE_GLAPI *p_glBufferSubDataARB)(GLenum,GLintptrARB,GLsizeiptrARB,const void*);
-        void       (WINE_GLAPI *p_glCallCommandListNV)(GLuint);
-        GLenum     (WINE_GLAPI *p_glCheckFramebufferStatus)(GLenum);
-        GLenum     (WINE_GLAPI *p_glCheckFramebufferStatusEXT)(GLenum);
-        GLenum     (WINE_GLAPI *p_glCheckNamedFramebufferStatus)(GLuint,GLenum);
-        GLenum     (WINE_GLAPI *p_glCheckNamedFramebufferStatusEXT)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glClampColor)(GLenum,GLenum);
-        void       (WINE_GLAPI *p_glClampColorARB)(GLenum,GLenum);
-        void       (WINE_GLAPI *p_glClearAccumxOES)(GLfixed,GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glClearBufferData)(GLenum,GLenum,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glClearBufferSubData)(GLenum,GLenum,GLintptr,GLsizeiptr,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glClearBufferfi)(GLenum,GLint,GLfloat,GLint);
-        void       (WINE_GLAPI *p_glClearBufferfv)(GLenum,GLint,const GLfloat*);
-        void       (WINE_GLAPI *p_glClearBufferiv)(GLenum,GLint,const GLint*);
-        void       (WINE_GLAPI *p_glClearBufferuiv)(GLenum,GLint,const GLuint*);
-        void       (WINE_GLAPI *p_glClearColorIiEXT)(GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glClearColorIuiEXT)(GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glClearColorxOES)(GLfixed,GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glClearDepthdNV)(GLdouble);
-        void       (WINE_GLAPI *p_glClearDepthf)(GLfloat);
-        void       (WINE_GLAPI *p_glClearDepthfOES)(GLclampf);
-        void       (WINE_GLAPI *p_glClearDepthxOES)(GLfixed);
-        void       (WINE_GLAPI *p_glClearNamedBufferData)(GLuint,GLenum,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glClearNamedBufferDataEXT)(GLuint,GLenum,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glClearNamedBufferSubData)(GLuint,GLenum,GLintptr,GLsizeiptr,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glClearNamedBufferSubDataEXT)(GLuint,GLenum,GLsizeiptr,GLsizeiptr,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glClearNamedFramebufferfi)(GLuint,GLenum,GLint,GLfloat,GLint);
-        void       (WINE_GLAPI *p_glClearNamedFramebufferfv)(GLuint,GLenum,GLint,const GLfloat*);
-        void       (WINE_GLAPI *p_glClearNamedFramebufferiv)(GLuint,GLenum,GLint,const GLint*);
-        void       (WINE_GLAPI *p_glClearNamedFramebufferuiv)(GLuint,GLenum,GLint,const GLuint*);
-        void       (WINE_GLAPI *p_glClearTexImage)(GLuint,GLint,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glClearTexSubImage)(GLuint,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glClientActiveTexture)(GLenum);
-        void       (WINE_GLAPI *p_glClientActiveTextureARB)(GLenum);
-        void       (WINE_GLAPI *p_glClientActiveVertexStreamATI)(GLenum);
-        void       (WINE_GLAPI *p_glClientAttribDefaultEXT)(GLbitfield);
-        GLenum     (WINE_GLAPI *p_glClientWaitSync)(GLsync,GLbitfield,GLuint64);
-        void       (WINE_GLAPI *p_glClipControl)(GLenum,GLenum);
-        void       (WINE_GLAPI *p_glClipPlanefOES)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glClipPlanexOES)(GLenum,const GLfixed*);
-        void       (WINE_GLAPI *p_glColor3fVertex3fSUN)(GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glColor3fVertex3fvSUN)(const GLfloat*,const GLfloat*);
-        void       (WINE_GLAPI *p_glColor3hNV)(GLhalfNV,GLhalfNV,GLhalfNV);
-        void       (WINE_GLAPI *p_glColor3hvNV)(const GLhalfNV*);
-        void       (WINE_GLAPI *p_glColor3xOES)(GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glColor3xvOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glColor4fNormal3fVertex3fSUN)(GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glColor4fNormal3fVertex3fvSUN)(const GLfloat*,const GLfloat*,const GLfloat*);
-        void       (WINE_GLAPI *p_glColor4hNV)(GLhalfNV,GLhalfNV,GLhalfNV,GLhalfNV);
-        void       (WINE_GLAPI *p_glColor4hvNV)(const GLhalfNV*);
-        void       (WINE_GLAPI *p_glColor4ubVertex2fSUN)(GLubyte,GLubyte,GLubyte,GLubyte,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glColor4ubVertex2fvSUN)(const GLubyte*,const GLfloat*);
-        void       (WINE_GLAPI *p_glColor4ubVertex3fSUN)(GLubyte,GLubyte,GLubyte,GLubyte,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glColor4ubVertex3fvSUN)(const GLubyte*,const GLfloat*);
-        void       (WINE_GLAPI *p_glColor4xOES)(GLfixed,GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glColor4xvOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glColorFormatNV)(GLint,GLenum,GLsizei);
-        void       (WINE_GLAPI *p_glColorFragmentOp1ATI)(GLenum,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glColorFragmentOp2ATI)(GLenum,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glColorFragmentOp3ATI)(GLenum,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glColorMaskIndexedEXT)(GLuint,GLboolean,GLboolean,GLboolean,GLboolean);
-        void       (WINE_GLAPI *p_glColorMaski)(GLuint,GLboolean,GLboolean,GLboolean,GLboolean);
-        void       (WINE_GLAPI *p_glColorP3ui)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glColorP3uiv)(GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glColorP4ui)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glColorP4uiv)(GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glColorPointerEXT)(GLint,GLenum,GLsizei,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glColorPointerListIBM)(GLint,GLenum,GLint,const void**,GLint);
-        void       (WINE_GLAPI *p_glColorPointervINTEL)(GLint,GLenum,const void**);
-        void       (WINE_GLAPI *p_glColorSubTable)(GLenum,GLsizei,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glColorSubTableEXT)(GLenum,GLsizei,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glColorTable)(GLenum,GLenum,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glColorTableEXT)(GLenum,GLenum,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glColorTableParameterfv)(GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glColorTableParameterfvSGI)(GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glColorTableParameteriv)(GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glColorTableParameterivSGI)(GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glColorTableSGI)(GLenum,GLenum,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glCombinerInputNV)(GLenum,GLenum,GLenum,GLenum,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glCombinerOutputNV)(GLenum,GLenum,GLenum,GLenum,GLenum,GLenum,GLenum,GLboolean,GLboolean,GLboolean);
-        void       (WINE_GLAPI *p_glCombinerParameterfNV)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glCombinerParameterfvNV)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glCombinerParameteriNV)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glCombinerParameterivNV)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glCombinerStageParameterfvNV)(GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glCommandListSegmentsNV)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glCompileCommandListNV)(GLuint);
-        void       (WINE_GLAPI *p_glCompileShader)(GLuint);
-        void       (WINE_GLAPI *p_glCompileShaderARB)(GLhandleARB);
-        void       (WINE_GLAPI *p_glCompileShaderIncludeARB)(GLuint,GLsizei,const GLchar*const*,const GLint*);
-        void       (WINE_GLAPI *p_glCompressedMultiTexImage1DEXT)(GLenum,GLenum,GLint,GLenum,GLsizei,GLint,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedMultiTexImage2DEXT)(GLenum,GLenum,GLint,GLenum,GLsizei,GLsizei,GLint,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedMultiTexImage3DEXT)(GLenum,GLenum,GLint,GLenum,GLsizei,GLsizei,GLsizei,GLint,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedMultiTexSubImage1DEXT)(GLenum,GLenum,GLint,GLint,GLsizei,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedMultiTexSubImage2DEXT)(GLenum,GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedMultiTexSubImage3DEXT)(GLenum,GLenum,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTexImage1D)(GLenum,GLint,GLenum,GLsizei,GLint,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTexImage1DARB)(GLenum,GLint,GLenum,GLsizei,GLint,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTexImage2D)(GLenum,GLint,GLenum,GLsizei,GLsizei,GLint,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTexImage2DARB)(GLenum,GLint,GLenum,GLsizei,GLsizei,GLint,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTexImage3D)(GLenum,GLint,GLenum,GLsizei,GLsizei,GLsizei,GLint,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTexImage3DARB)(GLenum,GLint,GLenum,GLsizei,GLsizei,GLsizei,GLint,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTexSubImage1D)(GLenum,GLint,GLint,GLsizei,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTexSubImage1DARB)(GLenum,GLint,GLint,GLsizei,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTexSubImage2D)(GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTexSubImage2DARB)(GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTexSubImage3D)(GLenum,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTexSubImage3DARB)(GLenum,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTextureImage1DEXT)(GLuint,GLenum,GLint,GLenum,GLsizei,GLint,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTextureImage2DEXT)(GLuint,GLenum,GLint,GLenum,GLsizei,GLsizei,GLint,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTextureImage3DEXT)(GLuint,GLenum,GLint,GLenum,GLsizei,GLsizei,GLsizei,GLint,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTextureSubImage1D)(GLuint,GLint,GLint,GLsizei,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTextureSubImage1DEXT)(GLuint,GLenum,GLint,GLint,GLsizei,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTextureSubImage2D)(GLuint,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTextureSubImage2DEXT)(GLuint,GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTextureSubImage3D)(GLuint,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glCompressedTextureSubImage3DEXT)(GLuint,GLenum,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glConservativeRasterParameterfNV)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glConservativeRasterParameteriNV)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glConvolutionFilter1D)(GLenum,GLenum,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glConvolutionFilter1DEXT)(GLenum,GLenum,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glConvolutionFilter2D)(GLenum,GLenum,GLsizei,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glConvolutionFilter2DEXT)(GLenum,GLenum,GLsizei,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glConvolutionParameterf)(GLenum,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glConvolutionParameterfEXT)(GLenum,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glConvolutionParameterfv)(GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glConvolutionParameterfvEXT)(GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glConvolutionParameteri)(GLenum,GLenum,GLint);
-        void       (WINE_GLAPI *p_glConvolutionParameteriEXT)(GLenum,GLenum,GLint);
-        void       (WINE_GLAPI *p_glConvolutionParameteriv)(GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glConvolutionParameterivEXT)(GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glConvolutionParameterxOES)(GLenum,GLenum,GLfixed);
-        void       (WINE_GLAPI *p_glConvolutionParameterxvOES)(GLenum,GLenum,const GLfixed*);
-        void       (WINE_GLAPI *p_glCopyBufferSubData)(GLenum,GLenum,GLintptr,GLintptr,GLsizeiptr);
-        void       (WINE_GLAPI *p_glCopyColorSubTable)(GLenum,GLsizei,GLint,GLint,GLsizei);
-        void       (WINE_GLAPI *p_glCopyColorSubTableEXT)(GLenum,GLsizei,GLint,GLint,GLsizei);
-        void       (WINE_GLAPI *p_glCopyColorTable)(GLenum,GLenum,GLint,GLint,GLsizei);
-        void       (WINE_GLAPI *p_glCopyColorTableSGI)(GLenum,GLenum,GLint,GLint,GLsizei);
-        void       (WINE_GLAPI *p_glCopyConvolutionFilter1D)(GLenum,GLenum,GLint,GLint,GLsizei);
-        void       (WINE_GLAPI *p_glCopyConvolutionFilter1DEXT)(GLenum,GLenum,GLint,GLint,GLsizei);
-        void       (WINE_GLAPI *p_glCopyConvolutionFilter2D)(GLenum,GLenum,GLint,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glCopyConvolutionFilter2DEXT)(GLenum,GLenum,GLint,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glCopyImageSubData)(GLuint,GLenum,GLint,GLint,GLint,GLint,GLuint,GLenum,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glCopyImageSubDataNV)(GLuint,GLenum,GLint,GLint,GLint,GLint,GLuint,GLenum,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glCopyMultiTexImage1DEXT)(GLenum,GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLint);
-        void       (WINE_GLAPI *p_glCopyMultiTexImage2DEXT)(GLenum,GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLsizei,GLint);
-        void       (WINE_GLAPI *p_glCopyMultiTexSubImage1DEXT)(GLenum,GLenum,GLint,GLint,GLint,GLint,GLsizei);
-        void       (WINE_GLAPI *p_glCopyMultiTexSubImage2DEXT)(GLenum,GLenum,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glCopyMultiTexSubImage3DEXT)(GLenum,GLenum,GLint,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glCopyNamedBufferSubData)(GLuint,GLuint,GLintptr,GLintptr,GLsizeiptr);
-        void       (WINE_GLAPI *p_glCopyPathNV)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glCopyTexImage1DEXT)(GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLint);
-        void       (WINE_GLAPI *p_glCopyTexImage2DEXT)(GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLsizei,GLint);
-        void       (WINE_GLAPI *p_glCopyTexSubImage1DEXT)(GLenum,GLint,GLint,GLint,GLint,GLsizei);
-        void       (WINE_GLAPI *p_glCopyTexSubImage2DEXT)(GLenum,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glCopyTexSubImage3D)(GLenum,GLint,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glCopyTexSubImage3DEXT)(GLenum,GLint,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glCopyTextureImage1DEXT)(GLuint,GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLint);
-        void       (WINE_GLAPI *p_glCopyTextureImage2DEXT)(GLuint,GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLsizei,GLint);
-        void       (WINE_GLAPI *p_glCopyTextureSubImage1D)(GLuint,GLint,GLint,GLint,GLint,GLsizei);
-        void       (WINE_GLAPI *p_glCopyTextureSubImage1DEXT)(GLuint,GLenum,GLint,GLint,GLint,GLint,GLsizei);
-        void       (WINE_GLAPI *p_glCopyTextureSubImage2D)(GLuint,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glCopyTextureSubImage2DEXT)(GLuint,GLenum,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glCopyTextureSubImage3D)(GLuint,GLint,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glCopyTextureSubImage3DEXT)(GLuint,GLenum,GLint,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glCoverFillPathInstancedNV)(GLsizei,GLenum,const void*,GLuint,GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glCoverFillPathNV)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glCoverStrokePathInstancedNV)(GLsizei,GLenum,const void*,GLuint,GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glCoverStrokePathNV)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glCoverageModulationNV)(GLenum);
-        void       (WINE_GLAPI *p_glCoverageModulationTableNV)(GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glCreateBuffers)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glCreateCommandListsNV)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glCreateFramebuffers)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glCreateMemoryObjectsEXT)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glCreatePerfQueryINTEL)(GLuint,GLuint*);
+        void       (WINE_GLAPI *p_glBufferStorage)( GLenum target, GLsizeiptr size, const void *data, GLbitfield flags );
+        void       (WINE_GLAPI *p_glBufferStorageExternalEXT)( GLenum target, GLintptr offset, GLsizeiptr size, void * clientBuffer, GLbitfield flags );
+        void       (WINE_GLAPI *p_glBufferStorageMemEXT)( GLenum target, GLsizeiptr size, GLuint memory, GLuint64 offset );
+        void       (WINE_GLAPI *p_glBufferSubData)( GLenum target, GLintptr offset, GLsizeiptr size, const void *data );
+        void       (WINE_GLAPI *p_glBufferSubDataARB)( GLenum target, GLintptrARB offset, GLsizeiptrARB size, const void *data );
+        void       (WINE_GLAPI *p_glCallCommandListNV)( GLuint list );
+        GLenum     (WINE_GLAPI *p_glCheckFramebufferStatus)( GLenum target );
+        GLenum     (WINE_GLAPI *p_glCheckFramebufferStatusEXT)( GLenum target );
+        GLenum     (WINE_GLAPI *p_glCheckNamedFramebufferStatus)( GLuint framebuffer, GLenum target );
+        GLenum     (WINE_GLAPI *p_glCheckNamedFramebufferStatusEXT)( GLuint framebuffer, GLenum target );
+        void       (WINE_GLAPI *p_glClampColor)( GLenum target, GLenum clamp );
+        void       (WINE_GLAPI *p_glClampColorARB)( GLenum target, GLenum clamp );
+        void       (WINE_GLAPI *p_glClearAccumxOES)( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha );
+        void       (WINE_GLAPI *p_glClearBufferData)( GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data );
+        void       (WINE_GLAPI *p_glClearBufferSubData)( GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data );
+        void       (WINE_GLAPI *p_glClearBufferfi)( GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil );
+        void       (WINE_GLAPI *p_glClearBufferfv)( GLenum buffer, GLint drawbuffer, const GLfloat *value );
+        void       (WINE_GLAPI *p_glClearBufferiv)( GLenum buffer, GLint drawbuffer, const GLint *value );
+        void       (WINE_GLAPI *p_glClearBufferuiv)( GLenum buffer, GLint drawbuffer, const GLuint *value );
+        void       (WINE_GLAPI *p_glClearColorIiEXT)( GLint red, GLint green, GLint blue, GLint alpha );
+        void       (WINE_GLAPI *p_glClearColorIuiEXT)( GLuint red, GLuint green, GLuint blue, GLuint alpha );
+        void       (WINE_GLAPI *p_glClearColorxOES)( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha );
+        void       (WINE_GLAPI *p_glClearDepthdNV)( GLdouble depth );
+        void       (WINE_GLAPI *p_glClearDepthf)( GLfloat d );
+        void       (WINE_GLAPI *p_glClearDepthfOES)( GLclampf depth );
+        void       (WINE_GLAPI *p_glClearDepthxOES)( GLfixed depth );
+        void       (WINE_GLAPI *p_glClearNamedBufferData)( GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data );
+        void       (WINE_GLAPI *p_glClearNamedBufferDataEXT)( GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data );
+        void       (WINE_GLAPI *p_glClearNamedBufferSubData)( GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data );
+        void       (WINE_GLAPI *p_glClearNamedBufferSubDataEXT)( GLuint buffer, GLenum internalformat, GLsizeiptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data );
+        void       (WINE_GLAPI *p_glClearNamedFramebufferfi)( GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil );
+        void       (WINE_GLAPI *p_glClearNamedFramebufferfv)( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value );
+        void       (WINE_GLAPI *p_glClearNamedFramebufferiv)( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value );
+        void       (WINE_GLAPI *p_glClearNamedFramebufferuiv)( GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value );
+        void       (WINE_GLAPI *p_glClearTexImage)( GLuint texture, GLint level, GLenum format, GLenum type, const void *data );
+        void       (WINE_GLAPI *p_glClearTexSubImage)( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data );
+        void       (WINE_GLAPI *p_glClientActiveTexture)( GLenum texture );
+        void       (WINE_GLAPI *p_glClientActiveTextureARB)( GLenum texture );
+        void       (WINE_GLAPI *p_glClientActiveVertexStreamATI)( GLenum stream );
+        void       (WINE_GLAPI *p_glClientAttribDefaultEXT)( GLbitfield mask );
+        GLenum     (WINE_GLAPI *p_glClientWaitSync)( GLsync sync, GLbitfield flags, GLuint64 timeout );
+        void       (WINE_GLAPI *p_glClipControl)( GLenum origin, GLenum depth );
+        void       (WINE_GLAPI *p_glClipPlanefOES)( GLenum plane, const GLfloat *equation );
+        void       (WINE_GLAPI *p_glClipPlanexOES)( GLenum plane, const GLfixed *equation );
+        void       (WINE_GLAPI *p_glColor3fVertex3fSUN)( GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glColor3fVertex3fvSUN)( const GLfloat *c, const GLfloat *v );
+        void       (WINE_GLAPI *p_glColor3hNV)( GLhalfNV red, GLhalfNV green, GLhalfNV blue );
+        void       (WINE_GLAPI *p_glColor3hvNV)( const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glColor3xOES)( GLfixed red, GLfixed green, GLfixed blue );
+        void       (WINE_GLAPI *p_glColor3xvOES)( const GLfixed *components );
+        void       (WINE_GLAPI *p_glColor4fNormal3fVertex3fSUN)( GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glColor4fNormal3fVertex3fvSUN)( const GLfloat *c, const GLfloat *n, const GLfloat *v );
+        void       (WINE_GLAPI *p_glColor4hNV)( GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha );
+        void       (WINE_GLAPI *p_glColor4hvNV)( const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glColor4ubVertex2fSUN)( GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y );
+        void       (WINE_GLAPI *p_glColor4ubVertex2fvSUN)( const GLubyte *c, const GLfloat *v );
+        void       (WINE_GLAPI *p_glColor4ubVertex3fSUN)( GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glColor4ubVertex3fvSUN)( const GLubyte *c, const GLfloat *v );
+        void       (WINE_GLAPI *p_glColor4xOES)( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha );
+        void       (WINE_GLAPI *p_glColor4xvOES)( const GLfixed *components );
+        void       (WINE_GLAPI *p_glColorFormatNV)( GLint size, GLenum type, GLsizei stride );
+        void       (WINE_GLAPI *p_glColorFragmentOp1ATI)( GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod );
+        void       (WINE_GLAPI *p_glColorFragmentOp2ATI)( GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod );
+        void       (WINE_GLAPI *p_glColorFragmentOp3ATI)( GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod );
+        void       (WINE_GLAPI *p_glColorMaskIndexedEXT)( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a );
+        void       (WINE_GLAPI *p_glColorMaski)( GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a );
+        void       (WINE_GLAPI *p_glColorP3ui)( GLenum type, GLuint color );
+        void       (WINE_GLAPI *p_glColorP3uiv)( GLenum type, const GLuint *color );
+        void       (WINE_GLAPI *p_glColorP4ui)( GLenum type, GLuint color );
+        void       (WINE_GLAPI *p_glColorP4uiv)( GLenum type, const GLuint *color );
+        void       (WINE_GLAPI *p_glColorPointerEXT)( GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer );
+        void       (WINE_GLAPI *p_glColorPointerListIBM)( GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride );
+        void       (WINE_GLAPI *p_glColorPointervINTEL)( GLint size, GLenum type, const void **pointer );
+        void       (WINE_GLAPI *p_glColorSubTable)( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data );
+        void       (WINE_GLAPI *p_glColorSubTableEXT)( GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data );
+        void       (WINE_GLAPI *p_glColorTable)( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table );
+        void       (WINE_GLAPI *p_glColorTableEXT)( GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void *table );
+        void       (WINE_GLAPI *p_glColorTableParameterfv)( GLenum target, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glColorTableParameterfvSGI)( GLenum target, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glColorTableParameteriv)( GLenum target, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glColorTableParameterivSGI)( GLenum target, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glColorTableSGI)( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table );
+        void       (WINE_GLAPI *p_glCombinerInputNV)( GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage );
+        void       (WINE_GLAPI *p_glCombinerOutputNV)( GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum );
+        void       (WINE_GLAPI *p_glCombinerParameterfNV)( GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glCombinerParameterfvNV)( GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glCombinerParameteriNV)( GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glCombinerParameterivNV)( GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glCombinerStageParameterfvNV)( GLenum stage, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glCommandListSegmentsNV)( GLuint list, GLuint segments );
+        void       (WINE_GLAPI *p_glCompileCommandListNV)( GLuint list );
+        void       (WINE_GLAPI *p_glCompileShader)( GLuint shader );
+        void       (WINE_GLAPI *p_glCompileShaderARB)( GLhandleARB shaderObj );
+        void       (WINE_GLAPI *p_glCompileShaderIncludeARB)( GLuint shader, GLsizei count, const GLchar *const*path, const GLint *length );
+        void       (WINE_GLAPI *p_glCompressedMultiTexImage1DEXT)( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits );
+        void       (WINE_GLAPI *p_glCompressedMultiTexImage2DEXT)( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits );
+        void       (WINE_GLAPI *p_glCompressedMultiTexImage3DEXT)( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits );
+        void       (WINE_GLAPI *p_glCompressedMultiTexSubImage1DEXT)( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits );
+        void       (WINE_GLAPI *p_glCompressedMultiTexSubImage2DEXT)( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits );
+        void       (WINE_GLAPI *p_glCompressedMultiTexSubImage3DEXT)( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits );
+        void       (WINE_GLAPI *p_glCompressedTexImage1D)( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data );
+        void       (WINE_GLAPI *p_glCompressedTexImage1DARB)( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data );
+        void       (WINE_GLAPI *p_glCompressedTexImage2D)( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data );
+        void       (WINE_GLAPI *p_glCompressedTexImage2DARB)( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data );
+        void       (WINE_GLAPI *p_glCompressedTexImage3D)( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data );
+        void       (WINE_GLAPI *p_glCompressedTexImage3DARB)( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data );
+        void       (WINE_GLAPI *p_glCompressedTexSubImage1D)( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data );
+        void       (WINE_GLAPI *p_glCompressedTexSubImage1DARB)( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data );
+        void       (WINE_GLAPI *p_glCompressedTexSubImage2D)( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data );
+        void       (WINE_GLAPI *p_glCompressedTexSubImage2DARB)( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data );
+        void       (WINE_GLAPI *p_glCompressedTexSubImage3D)( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data );
+        void       (WINE_GLAPI *p_glCompressedTexSubImage3DARB)( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data );
+        void       (WINE_GLAPI *p_glCompressedTextureImage1DEXT)( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits );
+        void       (WINE_GLAPI *p_glCompressedTextureImage2DEXT)( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits );
+        void       (WINE_GLAPI *p_glCompressedTextureImage3DEXT)( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits );
+        void       (WINE_GLAPI *p_glCompressedTextureSubImage1D)( GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data );
+        void       (WINE_GLAPI *p_glCompressedTextureSubImage1DEXT)( GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits );
+        void       (WINE_GLAPI *p_glCompressedTextureSubImage2D)( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data );
+        void       (WINE_GLAPI *p_glCompressedTextureSubImage2DEXT)( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits );
+        void       (WINE_GLAPI *p_glCompressedTextureSubImage3D)( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data );
+        void       (WINE_GLAPI *p_glCompressedTextureSubImage3DEXT)( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits );
+        void       (WINE_GLAPI *p_glConservativeRasterParameterfNV)( GLenum pname, GLfloat value );
+        void       (WINE_GLAPI *p_glConservativeRasterParameteriNV)( GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glConvolutionFilter1D)( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image );
+        void       (WINE_GLAPI *p_glConvolutionFilter1DEXT)( GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image );
+        void       (WINE_GLAPI *p_glConvolutionFilter2D)( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image );
+        void       (WINE_GLAPI *p_glConvolutionFilter2DEXT)( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image );
+        void       (WINE_GLAPI *p_glConvolutionParameterf)( GLenum target, GLenum pname, GLfloat params );
+        void       (WINE_GLAPI *p_glConvolutionParameterfEXT)( GLenum target, GLenum pname, GLfloat params );
+        void       (WINE_GLAPI *p_glConvolutionParameterfv)( GLenum target, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glConvolutionParameterfvEXT)( GLenum target, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glConvolutionParameteri)( GLenum target, GLenum pname, GLint params );
+        void       (WINE_GLAPI *p_glConvolutionParameteriEXT)( GLenum target, GLenum pname, GLint params );
+        void       (WINE_GLAPI *p_glConvolutionParameteriv)( GLenum target, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glConvolutionParameterivEXT)( GLenum target, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glConvolutionParameterxOES)( GLenum target, GLenum pname, GLfixed param );
+        void       (WINE_GLAPI *p_glConvolutionParameterxvOES)( GLenum target, GLenum pname, const GLfixed *params );
+        void       (WINE_GLAPI *p_glCopyBufferSubData)( GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size );
+        void       (WINE_GLAPI *p_glCopyColorSubTable)( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width );
+        void       (WINE_GLAPI *p_glCopyColorSubTableEXT)( GLenum target, GLsizei start, GLint x, GLint y, GLsizei width );
+        void       (WINE_GLAPI *p_glCopyColorTable)( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width );
+        void       (WINE_GLAPI *p_glCopyColorTableSGI)( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width );
+        void       (WINE_GLAPI *p_glCopyConvolutionFilter1D)( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width );
+        void       (WINE_GLAPI *p_glCopyConvolutionFilter1DEXT)( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width );
+        void       (WINE_GLAPI *p_glCopyConvolutionFilter2D)( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glCopyConvolutionFilter2DEXT)( GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glCopyImageSubData)( GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth );
+        void       (WINE_GLAPI *p_glCopyImageSubDataNV)( GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth );
+        void       (WINE_GLAPI *p_glCopyMultiTexImage1DEXT)( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border );
+        void       (WINE_GLAPI *p_glCopyMultiTexImage2DEXT)( GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border );
+        void       (WINE_GLAPI *p_glCopyMultiTexSubImage1DEXT)( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width );
+        void       (WINE_GLAPI *p_glCopyMultiTexSubImage2DEXT)( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glCopyMultiTexSubImage3DEXT)( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glCopyNamedBufferSubData)( GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size );
+        void       (WINE_GLAPI *p_glCopyPathNV)( GLuint resultPath, GLuint srcPath );
+        void       (WINE_GLAPI *p_glCopyTexImage1DEXT)( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border );
+        void       (WINE_GLAPI *p_glCopyTexImage2DEXT)( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border );
+        void       (WINE_GLAPI *p_glCopyTexSubImage1DEXT)( GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width );
+        void       (WINE_GLAPI *p_glCopyTexSubImage2DEXT)( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glCopyTexSubImage3D)( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glCopyTexSubImage3DEXT)( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glCopyTextureImage1DEXT)( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border );
+        void       (WINE_GLAPI *p_glCopyTextureImage2DEXT)( GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border );
+        void       (WINE_GLAPI *p_glCopyTextureSubImage1D)( GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width );
+        void       (WINE_GLAPI *p_glCopyTextureSubImage1DEXT)( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width );
+        void       (WINE_GLAPI *p_glCopyTextureSubImage2D)( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glCopyTextureSubImage2DEXT)( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glCopyTextureSubImage3D)( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glCopyTextureSubImage3DEXT)( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glCoverFillPathInstancedNV)( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues );
+        void       (WINE_GLAPI *p_glCoverFillPathNV)( GLuint path, GLenum coverMode );
+        void       (WINE_GLAPI *p_glCoverStrokePathInstancedNV)( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues );
+        void       (WINE_GLAPI *p_glCoverStrokePathNV)( GLuint path, GLenum coverMode );
+        void       (WINE_GLAPI *p_glCoverageModulationNV)( GLenum components );
+        void       (WINE_GLAPI *p_glCoverageModulationTableNV)( GLsizei n, const GLfloat *v );
+        void       (WINE_GLAPI *p_glCreateBuffers)( GLsizei n, GLuint *buffers );
+        void       (WINE_GLAPI *p_glCreateCommandListsNV)( GLsizei n, GLuint *lists );
+        void       (WINE_GLAPI *p_glCreateFramebuffers)( GLsizei n, GLuint *framebuffers );
+        void       (WINE_GLAPI *p_glCreateMemoryObjectsEXT)( GLsizei n, GLuint *memoryObjects );
+        void       (WINE_GLAPI *p_glCreatePerfQueryINTEL)( GLuint queryId, GLuint *queryHandle );
         GLuint     (WINE_GLAPI *p_glCreateProgram)(void);
         GLhandleARB (WINE_GLAPI *p_glCreateProgramObjectARB)(void);
-        void       (WINE_GLAPI *p_glCreateProgramPipelines)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glCreateQueries)(GLenum,GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glCreateRenderbuffers)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glCreateSamplers)(GLsizei,GLuint*);
-        GLuint     (WINE_GLAPI *p_glCreateShader)(GLenum);
-        GLhandleARB (WINE_GLAPI *p_glCreateShaderObjectARB)(GLenum);
-        GLuint     (WINE_GLAPI *p_glCreateShaderProgramEXT)(GLenum,const GLchar*);
-        GLuint     (WINE_GLAPI *p_glCreateShaderProgramv)(GLenum,GLsizei,const GLchar*const*);
-        void       (WINE_GLAPI *p_glCreateStatesNV)(GLsizei,GLuint*);
-        GLsync     (WINE_GLAPI *p_glCreateSyncFromCLeventARB)(void*,void*,GLbitfield);
-        void       (WINE_GLAPI *p_glCreateTextures)(GLenum,GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glCreateTransformFeedbacks)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glCreateVertexArrays)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glCullParameterdvEXT)(GLenum,GLdouble*);
-        void       (WINE_GLAPI *p_glCullParameterfvEXT)(GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glCurrentPaletteMatrixARB)(GLint);
-        void       (WINE_GLAPI *p_glDebugMessageCallback)(void *,const void*);
-        void       (WINE_GLAPI *p_glDebugMessageCallbackAMD)(void *,void*);
-        void       (WINE_GLAPI *p_glDebugMessageCallbackARB)(void *,const void*);
-        void       (WINE_GLAPI *p_glDebugMessageControl)(GLenum,GLenum,GLenum,GLsizei,const GLuint*,GLboolean);
-        void       (WINE_GLAPI *p_glDebugMessageControlARB)(GLenum,GLenum,GLenum,GLsizei,const GLuint*,GLboolean);
-        void       (WINE_GLAPI *p_glDebugMessageEnableAMD)(GLenum,GLenum,GLsizei,const GLuint*,GLboolean);
-        void       (WINE_GLAPI *p_glDebugMessageInsert)(GLenum,GLenum,GLuint,GLenum,GLsizei,const GLchar*);
-        void       (WINE_GLAPI *p_glDebugMessageInsertAMD)(GLenum,GLenum,GLuint,GLsizei,const GLchar*);
-        void       (WINE_GLAPI *p_glDebugMessageInsertARB)(GLenum,GLenum,GLuint,GLenum,GLsizei,const GLchar*);
-        void       (WINE_GLAPI *p_glDeformSGIX)(GLbitfield);
-        void       (WINE_GLAPI *p_glDeformationMap3dSGIX)(GLenum,GLdouble,GLdouble,GLint,GLint,GLdouble,GLdouble,GLint,GLint,GLdouble,GLdouble,GLint,GLint,const GLdouble*);
-        void       (WINE_GLAPI *p_glDeformationMap3fSGIX)(GLenum,GLfloat,GLfloat,GLint,GLint,GLfloat,GLfloat,GLint,GLint,GLfloat,GLfloat,GLint,GLint,const GLfloat*);
-        void       (WINE_GLAPI *p_glDeleteAsyncMarkersSGIX)(GLuint,GLsizei);
-        void       (WINE_GLAPI *p_glDeleteBufferRegion)(GLenum);
-        void       (WINE_GLAPI *p_glDeleteBuffers)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteBuffersARB)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteCommandListsNV)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteFencesAPPLE)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteFencesNV)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteFragmentShaderATI)(GLuint);
-        void       (WINE_GLAPI *p_glDeleteFramebuffers)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteFramebuffersEXT)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteMemoryObjectsEXT)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteNamedStringARB)(GLint,const GLchar*);
-        void       (WINE_GLAPI *p_glDeleteNamesAMD)(GLenum,GLuint,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteObjectARB)(GLhandleARB);
-        void       (WINE_GLAPI *p_glDeleteObjectBufferATI)(GLuint);
-        void       (WINE_GLAPI *p_glDeleteOcclusionQueriesNV)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeletePathsNV)(GLuint,GLsizei);
-        void       (WINE_GLAPI *p_glDeletePerfMonitorsAMD)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glDeletePerfQueryINTEL)(GLuint);
-        void       (WINE_GLAPI *p_glDeleteProgram)(GLuint);
-        void       (WINE_GLAPI *p_glDeleteProgramPipelines)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteProgramsARB)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteProgramsNV)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteQueries)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteQueriesARB)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteQueryResourceTagNV)(GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glDeleteRenderbuffers)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteRenderbuffersEXT)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteSamplers)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteSemaphoresEXT)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteShader)(GLuint);
-        void       (WINE_GLAPI *p_glDeleteStatesNV)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteSync)(GLsync);
-        void       (WINE_GLAPI *p_glDeleteTexturesEXT)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteTransformFeedbacks)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteTransformFeedbacksNV)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteVertexArrays)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteVertexArraysAPPLE)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glDeleteVertexShaderEXT)(GLuint);
-        void       (WINE_GLAPI *p_glDepthBoundsEXT)(GLclampd,GLclampd);
-        void       (WINE_GLAPI *p_glDepthBoundsdNV)(GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glDepthRangeArrayv)(GLuint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glDepthRangeIndexed)(GLuint,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glDepthRangedNV)(GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glDepthRangef)(GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glDepthRangefOES)(GLclampf,GLclampf);
-        void       (WINE_GLAPI *p_glDepthRangexOES)(GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glDetachObjectARB)(GLhandleARB,GLhandleARB);
-        void       (WINE_GLAPI *p_glDetachShader)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glDetailTexFuncSGIS)(GLenum,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glDisableClientStateIndexedEXT)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glDisableClientStateiEXT)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glDisableIndexedEXT)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glDisableVariantClientStateEXT)(GLuint);
-        void       (WINE_GLAPI *p_glDisableVertexArrayAttrib)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glDisableVertexArrayAttribEXT)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glDisableVertexArrayEXT)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glDisableVertexAttribAPPLE)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glDisableVertexAttribArray)(GLuint);
-        void       (WINE_GLAPI *p_glDisableVertexAttribArrayARB)(GLuint);
-        void       (WINE_GLAPI *p_glDisablei)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glDispatchCompute)(GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glDispatchComputeGroupSizeARB)(GLuint,GLuint,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glDispatchComputeIndirect)(GLintptr);
-        void       (WINE_GLAPI *p_glDrawArraysEXT)(GLenum,GLint,GLsizei);
-        void       (WINE_GLAPI *p_glDrawArraysIndirect)(GLenum,const void*);
-        void       (WINE_GLAPI *p_glDrawArraysInstanced)(GLenum,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glDrawArraysInstancedARB)(GLenum,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glDrawArraysInstancedBaseInstance)(GLenum,GLint,GLsizei,GLsizei,GLuint);
-        void       (WINE_GLAPI *p_glDrawArraysInstancedEXT)(GLenum,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glDrawBufferRegion)(GLenum,GLint,GLint,GLsizei,GLsizei,GLint,GLint);
-        void       (WINE_GLAPI *p_glDrawBuffers)(GLsizei,const GLenum*);
-        void       (WINE_GLAPI *p_glDrawBuffersARB)(GLsizei,const GLenum*);
-        void       (WINE_GLAPI *p_glDrawBuffersATI)(GLsizei,const GLenum*);
-        void       (WINE_GLAPI *p_glDrawCommandsAddressNV)(GLenum,const GLuint64*,const GLsizei*,GLuint);
-        void       (WINE_GLAPI *p_glDrawCommandsNV)(GLenum,GLuint,const GLintptr*,const GLsizei*,GLuint);
-        void       (WINE_GLAPI *p_glDrawCommandsStatesAddressNV)(const GLuint64*,const GLsizei*,const GLuint*,const GLuint*,GLuint);
-        void       (WINE_GLAPI *p_glDrawCommandsStatesNV)(GLuint,const GLintptr*,const GLsizei*,const GLuint*,const GLuint*,GLuint);
-        void       (WINE_GLAPI *p_glDrawElementArrayAPPLE)(GLenum,GLint,GLsizei);
-        void       (WINE_GLAPI *p_glDrawElementArrayATI)(GLenum,GLsizei);
-        void       (WINE_GLAPI *p_glDrawElementsBaseVertex)(GLenum,GLsizei,GLenum,const void*,GLint);
-        void       (WINE_GLAPI *p_glDrawElementsIndirect)(GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glDrawElementsInstanced)(GLenum,GLsizei,GLenum,const void*,GLsizei);
-        void       (WINE_GLAPI *p_glDrawElementsInstancedARB)(GLenum,GLsizei,GLenum,const void*,GLsizei);
-        void       (WINE_GLAPI *p_glDrawElementsInstancedBaseInstance)(GLenum,GLsizei,GLenum,const void*,GLsizei,GLuint);
-        void       (WINE_GLAPI *p_glDrawElementsInstancedBaseVertex)(GLenum,GLsizei,GLenum,const void*,GLsizei,GLint);
-        void       (WINE_GLAPI *p_glDrawElementsInstancedBaseVertexBaseInstance)(GLenum,GLsizei,GLenum,const void*,GLsizei,GLint,GLuint);
-        void       (WINE_GLAPI *p_glDrawElementsInstancedEXT)(GLenum,GLsizei,GLenum,const void*,GLsizei);
-        void       (WINE_GLAPI *p_glDrawMeshArraysSUN)(GLenum,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glDrawRangeElementArrayAPPLE)(GLenum,GLuint,GLuint,GLint,GLsizei);
-        void       (WINE_GLAPI *p_glDrawRangeElementArrayATI)(GLenum,GLuint,GLuint,GLsizei);
-        void       (WINE_GLAPI *p_glDrawRangeElements)(GLenum,GLuint,GLuint,GLsizei,GLenum,const void*);
-        void       (WINE_GLAPI *p_glDrawRangeElementsBaseVertex)(GLenum,GLuint,GLuint,GLsizei,GLenum,const void*,GLint);
-        void       (WINE_GLAPI *p_glDrawRangeElementsEXT)(GLenum,GLuint,GLuint,GLsizei,GLenum,const void*);
-        void       (WINE_GLAPI *p_glDrawTextureNV)(GLuint,GLuint,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glDrawTransformFeedback)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glDrawTransformFeedbackInstanced)(GLenum,GLuint,GLsizei);
-        void       (WINE_GLAPI *p_glDrawTransformFeedbackNV)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glDrawTransformFeedbackStream)(GLenum,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glDrawTransformFeedbackStreamInstanced)(GLenum,GLuint,GLuint,GLsizei);
-        void       (WINE_GLAPI *p_glDrawVkImageNV)(GLuint64,GLuint,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glEdgeFlagFormatNV)(GLsizei);
-        void       (WINE_GLAPI *p_glEdgeFlagPointerEXT)(GLsizei,GLsizei,const GLboolean*);
-        void       (WINE_GLAPI *p_glEdgeFlagPointerListIBM)(GLint,const GLboolean**,GLint);
-        void       (WINE_GLAPI *p_glElementPointerAPPLE)(GLenum,const void*);
-        void       (WINE_GLAPI *p_glElementPointerATI)(GLenum,const void*);
-        void       (WINE_GLAPI *p_glEnableClientStateIndexedEXT)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glEnableClientStateiEXT)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glEnableIndexedEXT)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glEnableVariantClientStateEXT)(GLuint);
-        void       (WINE_GLAPI *p_glEnableVertexArrayAttrib)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glEnableVertexArrayAttribEXT)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glEnableVertexArrayEXT)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glEnableVertexAttribAPPLE)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glEnableVertexAttribArray)(GLuint);
-        void       (WINE_GLAPI *p_glEnableVertexAttribArrayARB)(GLuint);
-        void       (WINE_GLAPI *p_glEnablei)(GLenum,GLuint);
+        void       (WINE_GLAPI *p_glCreateProgramPipelines)( GLsizei n, GLuint *pipelines );
+        void       (WINE_GLAPI *p_glCreateQueries)( GLenum target, GLsizei n, GLuint *ids );
+        void       (WINE_GLAPI *p_glCreateRenderbuffers)( GLsizei n, GLuint *renderbuffers );
+        void       (WINE_GLAPI *p_glCreateSamplers)( GLsizei n, GLuint *samplers );
+        GLuint     (WINE_GLAPI *p_glCreateShader)( GLenum type );
+        GLhandleARB (WINE_GLAPI *p_glCreateShaderObjectARB)( GLenum shaderType );
+        GLuint     (WINE_GLAPI *p_glCreateShaderProgramEXT)( GLenum type, const GLchar *string );
+        GLuint     (WINE_GLAPI *p_glCreateShaderProgramv)( GLenum type, GLsizei count, const GLchar *const*strings );
+        void       (WINE_GLAPI *p_glCreateStatesNV)( GLsizei n, GLuint *states );
+        GLsync     (WINE_GLAPI *p_glCreateSyncFromCLeventARB)( void *context, void *event, GLbitfield flags );
+        void       (WINE_GLAPI *p_glCreateTextures)( GLenum target, GLsizei n, GLuint *textures );
+        void       (WINE_GLAPI *p_glCreateTransformFeedbacks)( GLsizei n, GLuint *ids );
+        void       (WINE_GLAPI *p_glCreateVertexArrays)( GLsizei n, GLuint *arrays );
+        void       (WINE_GLAPI *p_glCullParameterdvEXT)( GLenum pname, GLdouble *params );
+        void       (WINE_GLAPI *p_glCullParameterfvEXT)( GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glCurrentPaletteMatrixARB)( GLint index );
+        void       (WINE_GLAPI *p_glDebugMessageCallback)( void * callback, const void *userParam );
+        void       (WINE_GLAPI *p_glDebugMessageCallbackAMD)( void * callback, void *userParam );
+        void       (WINE_GLAPI *p_glDebugMessageCallbackARB)( void * callback, const void *userParam );
+        void       (WINE_GLAPI *p_glDebugMessageControl)( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled );
+        void       (WINE_GLAPI *p_glDebugMessageControlARB)( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled );
+        void       (WINE_GLAPI *p_glDebugMessageEnableAMD)( GLenum category, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled );
+        void       (WINE_GLAPI *p_glDebugMessageInsert)( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf );
+        void       (WINE_GLAPI *p_glDebugMessageInsertAMD)( GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar *buf );
+        void       (WINE_GLAPI *p_glDebugMessageInsertARB)( GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf );
+        void       (WINE_GLAPI *p_glDeformSGIX)( GLbitfield mask );
+        void       (WINE_GLAPI *p_glDeformationMap3dSGIX)( GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, const GLdouble *points );
+        void       (WINE_GLAPI *p_glDeformationMap3fSGIX)( GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, const GLfloat *points );
+        void       (WINE_GLAPI *p_glDeleteAsyncMarkersSGIX)( GLuint marker, GLsizei range );
+        void       (WINE_GLAPI *p_glDeleteBufferRegion)( GLenum region );
+        void       (WINE_GLAPI *p_glDeleteBuffers)( GLsizei n, const GLuint *buffers );
+        void       (WINE_GLAPI *p_glDeleteBuffersARB)( GLsizei n, const GLuint *buffers );
+        void       (WINE_GLAPI *p_glDeleteCommandListsNV)( GLsizei n, const GLuint *lists );
+        void       (WINE_GLAPI *p_glDeleteFencesAPPLE)( GLsizei n, const GLuint *fences );
+        void       (WINE_GLAPI *p_glDeleteFencesNV)( GLsizei n, const GLuint *fences );
+        void       (WINE_GLAPI *p_glDeleteFragmentShaderATI)( GLuint id );
+        void       (WINE_GLAPI *p_glDeleteFramebuffers)( GLsizei n, const GLuint *framebuffers );
+        void       (WINE_GLAPI *p_glDeleteFramebuffersEXT)( GLsizei n, const GLuint *framebuffers );
+        void       (WINE_GLAPI *p_glDeleteMemoryObjectsEXT)( GLsizei n, const GLuint *memoryObjects );
+        void       (WINE_GLAPI *p_glDeleteNamedStringARB)( GLint namelen, const GLchar *name );
+        void       (WINE_GLAPI *p_glDeleteNamesAMD)( GLenum identifier, GLuint num, const GLuint *names );
+        void       (WINE_GLAPI *p_glDeleteObjectARB)( GLhandleARB obj );
+        void       (WINE_GLAPI *p_glDeleteObjectBufferATI)( GLuint buffer );
+        void       (WINE_GLAPI *p_glDeleteOcclusionQueriesNV)( GLsizei n, const GLuint *ids );
+        void       (WINE_GLAPI *p_glDeletePathsNV)( GLuint path, GLsizei range );
+        void       (WINE_GLAPI *p_glDeletePerfMonitorsAMD)( GLsizei n, GLuint *monitors );
+        void       (WINE_GLAPI *p_glDeletePerfQueryINTEL)( GLuint queryHandle );
+        void       (WINE_GLAPI *p_glDeleteProgram)( GLuint program );
+        void       (WINE_GLAPI *p_glDeleteProgramPipelines)( GLsizei n, const GLuint *pipelines );
+        void       (WINE_GLAPI *p_glDeleteProgramsARB)( GLsizei n, const GLuint *programs );
+        void       (WINE_GLAPI *p_glDeleteProgramsNV)( GLsizei n, const GLuint *programs );
+        void       (WINE_GLAPI *p_glDeleteQueries)( GLsizei n, const GLuint *ids );
+        void       (WINE_GLAPI *p_glDeleteQueriesARB)( GLsizei n, const GLuint *ids );
+        void       (WINE_GLAPI *p_glDeleteQueryResourceTagNV)( GLsizei n, const GLint *tagIds );
+        void       (WINE_GLAPI *p_glDeleteRenderbuffers)( GLsizei n, const GLuint *renderbuffers );
+        void       (WINE_GLAPI *p_glDeleteRenderbuffersEXT)( GLsizei n, const GLuint *renderbuffers );
+        void       (WINE_GLAPI *p_glDeleteSamplers)( GLsizei count, const GLuint *samplers );
+        void       (WINE_GLAPI *p_glDeleteSemaphoresEXT)( GLsizei n, const GLuint *semaphores );
+        void       (WINE_GLAPI *p_glDeleteShader)( GLuint shader );
+        void       (WINE_GLAPI *p_glDeleteStatesNV)( GLsizei n, const GLuint *states );
+        void       (WINE_GLAPI *p_glDeleteSync)( GLsync sync );
+        void       (WINE_GLAPI *p_glDeleteTexturesEXT)( GLsizei n, const GLuint *textures );
+        void       (WINE_GLAPI *p_glDeleteTransformFeedbacks)( GLsizei n, const GLuint *ids );
+        void       (WINE_GLAPI *p_glDeleteTransformFeedbacksNV)( GLsizei n, const GLuint *ids );
+        void       (WINE_GLAPI *p_glDeleteVertexArrays)( GLsizei n, const GLuint *arrays );
+        void       (WINE_GLAPI *p_glDeleteVertexArraysAPPLE)( GLsizei n, const GLuint *arrays );
+        void       (WINE_GLAPI *p_glDeleteVertexShaderEXT)( GLuint id );
+        void       (WINE_GLAPI *p_glDepthBoundsEXT)( GLclampd zmin, GLclampd zmax );
+        void       (WINE_GLAPI *p_glDepthBoundsdNV)( GLdouble zmin, GLdouble zmax );
+        void       (WINE_GLAPI *p_glDepthRangeArrayv)( GLuint first, GLsizei count, const GLdouble *v );
+        void       (WINE_GLAPI *p_glDepthRangeIndexed)( GLuint index, GLdouble n, GLdouble f );
+        void       (WINE_GLAPI *p_glDepthRangedNV)( GLdouble zNear, GLdouble zFar );
+        void       (WINE_GLAPI *p_glDepthRangef)( GLfloat n, GLfloat f );
+        void       (WINE_GLAPI *p_glDepthRangefOES)( GLclampf n, GLclampf f );
+        void       (WINE_GLAPI *p_glDepthRangexOES)( GLfixed n, GLfixed f );
+        void       (WINE_GLAPI *p_glDetachObjectARB)( GLhandleARB containerObj, GLhandleARB attachedObj );
+        void       (WINE_GLAPI *p_glDetachShader)( GLuint program, GLuint shader );
+        void       (WINE_GLAPI *p_glDetailTexFuncSGIS)( GLenum target, GLsizei n, const GLfloat *points );
+        void       (WINE_GLAPI *p_glDisableClientStateIndexedEXT)( GLenum array, GLuint index );
+        void       (WINE_GLAPI *p_glDisableClientStateiEXT)( GLenum array, GLuint index );
+        void       (WINE_GLAPI *p_glDisableIndexedEXT)( GLenum target, GLuint index );
+        void       (WINE_GLAPI *p_glDisableVariantClientStateEXT)( GLuint id );
+        void       (WINE_GLAPI *p_glDisableVertexArrayAttrib)( GLuint vaobj, GLuint index );
+        void       (WINE_GLAPI *p_glDisableVertexArrayAttribEXT)( GLuint vaobj, GLuint index );
+        void       (WINE_GLAPI *p_glDisableVertexArrayEXT)( GLuint vaobj, GLenum array );
+        void       (WINE_GLAPI *p_glDisableVertexAttribAPPLE)( GLuint index, GLenum pname );
+        void       (WINE_GLAPI *p_glDisableVertexAttribArray)( GLuint index );
+        void       (WINE_GLAPI *p_glDisableVertexAttribArrayARB)( GLuint index );
+        void       (WINE_GLAPI *p_glDisablei)( GLenum target, GLuint index );
+        void       (WINE_GLAPI *p_glDispatchCompute)( GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z );
+        void       (WINE_GLAPI *p_glDispatchComputeGroupSizeARB)( GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z, GLuint group_size_x, GLuint group_size_y, GLuint group_size_z );
+        void       (WINE_GLAPI *p_glDispatchComputeIndirect)( GLintptr indirect );
+        void       (WINE_GLAPI *p_glDrawArraysEXT)( GLenum mode, GLint first, GLsizei count );
+        void       (WINE_GLAPI *p_glDrawArraysIndirect)( GLenum mode, const void *indirect );
+        void       (WINE_GLAPI *p_glDrawArraysInstanced)( GLenum mode, GLint first, GLsizei count, GLsizei instancecount );
+        void       (WINE_GLAPI *p_glDrawArraysInstancedARB)( GLenum mode, GLint first, GLsizei count, GLsizei primcount );
+        void       (WINE_GLAPI *p_glDrawArraysInstancedBaseInstance)( GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance );
+        void       (WINE_GLAPI *p_glDrawArraysInstancedEXT)( GLenum mode, GLint start, GLsizei count, GLsizei primcount );
+        void       (WINE_GLAPI *p_glDrawBufferRegion)( GLenum region, GLint x, GLint y, GLsizei width, GLsizei height, GLint xDest, GLint yDest );
+        void       (WINE_GLAPI *p_glDrawBuffers)( GLsizei n, const GLenum *bufs );
+        void       (WINE_GLAPI *p_glDrawBuffersARB)( GLsizei n, const GLenum *bufs );
+        void       (WINE_GLAPI *p_glDrawBuffersATI)( GLsizei n, const GLenum *bufs );
+        void       (WINE_GLAPI *p_glDrawCommandsAddressNV)( GLenum primitiveMode, const GLuint64 *indirects, const GLsizei *sizes, GLuint count );
+        void       (WINE_GLAPI *p_glDrawCommandsNV)( GLenum primitiveMode, GLuint buffer, const GLintptr *indirects, const GLsizei *sizes, GLuint count );
+        void       (WINE_GLAPI *p_glDrawCommandsStatesAddressNV)( const GLuint64 *indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count );
+        void       (WINE_GLAPI *p_glDrawCommandsStatesNV)( GLuint buffer, const GLintptr *indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count );
+        void       (WINE_GLAPI *p_glDrawElementArrayAPPLE)( GLenum mode, GLint first, GLsizei count );
+        void       (WINE_GLAPI *p_glDrawElementArrayATI)( GLenum mode, GLsizei count );
+        void       (WINE_GLAPI *p_glDrawElementsBaseVertex)( GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex );
+        void       (WINE_GLAPI *p_glDrawElementsIndirect)( GLenum mode, GLenum type, const void *indirect );
+        void       (WINE_GLAPI *p_glDrawElementsInstanced)( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount );
+        void       (WINE_GLAPI *p_glDrawElementsInstancedARB)( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount );
+        void       (WINE_GLAPI *p_glDrawElementsInstancedBaseInstance)( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance );
+        void       (WINE_GLAPI *p_glDrawElementsInstancedBaseVertex)( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex );
+        void       (WINE_GLAPI *p_glDrawElementsInstancedBaseVertexBaseInstance)( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance );
+        void       (WINE_GLAPI *p_glDrawElementsInstancedEXT)( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount );
+        void       (WINE_GLAPI *p_glDrawMeshArraysSUN)( GLenum mode, GLint first, GLsizei count, GLsizei width );
+        void       (WINE_GLAPI *p_glDrawRangeElementArrayAPPLE)( GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count );
+        void       (WINE_GLAPI *p_glDrawRangeElementArrayATI)( GLenum mode, GLuint start, GLuint end, GLsizei count );
+        void       (WINE_GLAPI *p_glDrawRangeElements)( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices );
+        void       (WINE_GLAPI *p_glDrawRangeElementsBaseVertex)( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex );
+        void       (WINE_GLAPI *p_glDrawRangeElementsEXT)( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices );
+        void       (WINE_GLAPI *p_glDrawTextureNV)( GLuint texture, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1 );
+        void       (WINE_GLAPI *p_glDrawTransformFeedback)( GLenum mode, GLuint id );
+        void       (WINE_GLAPI *p_glDrawTransformFeedbackInstanced)( GLenum mode, GLuint id, GLsizei instancecount );
+        void       (WINE_GLAPI *p_glDrawTransformFeedbackNV)( GLenum mode, GLuint id );
+        void       (WINE_GLAPI *p_glDrawTransformFeedbackStream)( GLenum mode, GLuint id, GLuint stream );
+        void       (WINE_GLAPI *p_glDrawTransformFeedbackStreamInstanced)( GLenum mode, GLuint id, GLuint stream, GLsizei instancecount );
+        void       (WINE_GLAPI *p_glDrawVkImageNV)( GLuint64 vkImage, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1 );
+        void       (WINE_GLAPI *p_glEdgeFlagFormatNV)( GLsizei stride );
+        void       (WINE_GLAPI *p_glEdgeFlagPointerEXT)( GLsizei stride, GLsizei count, const GLboolean *pointer );
+        void       (WINE_GLAPI *p_glEdgeFlagPointerListIBM)( GLint stride, const GLboolean **pointer, GLint ptrstride );
+        void       (WINE_GLAPI *p_glElementPointerAPPLE)( GLenum type, const void *pointer );
+        void       (WINE_GLAPI *p_glElementPointerATI)( GLenum type, const void *pointer );
+        void       (WINE_GLAPI *p_glEnableClientStateIndexedEXT)( GLenum array, GLuint index );
+        void       (WINE_GLAPI *p_glEnableClientStateiEXT)( GLenum array, GLuint index );
+        void       (WINE_GLAPI *p_glEnableIndexedEXT)( GLenum target, GLuint index );
+        void       (WINE_GLAPI *p_glEnableVariantClientStateEXT)( GLuint id );
+        void       (WINE_GLAPI *p_glEnableVertexArrayAttrib)( GLuint vaobj, GLuint index );
+        void       (WINE_GLAPI *p_glEnableVertexArrayAttribEXT)( GLuint vaobj, GLuint index );
+        void       (WINE_GLAPI *p_glEnableVertexArrayEXT)( GLuint vaobj, GLenum array );
+        void       (WINE_GLAPI *p_glEnableVertexAttribAPPLE)( GLuint index, GLenum pname );
+        void       (WINE_GLAPI *p_glEnableVertexAttribArray)( GLuint index );
+        void       (WINE_GLAPI *p_glEnableVertexAttribArrayARB)( GLuint index );
+        void       (WINE_GLAPI *p_glEnablei)( GLenum target, GLuint index );
         void       (WINE_GLAPI *p_glEndConditionalRender)(void);
         void       (WINE_GLAPI *p_glEndConditionalRenderNV)(void);
         void       (WINE_GLAPI *p_glEndConditionalRenderNVX)(void);
         void       (WINE_GLAPI *p_glEndFragmentShaderATI)(void);
         void       (WINE_GLAPI *p_glEndOcclusionQueryNV)(void);
-        void       (WINE_GLAPI *p_glEndPerfMonitorAMD)(GLuint);
-        void       (WINE_GLAPI *p_glEndPerfQueryINTEL)(GLuint);
-        void       (WINE_GLAPI *p_glEndQuery)(GLenum);
-        void       (WINE_GLAPI *p_glEndQueryARB)(GLenum);
-        void       (WINE_GLAPI *p_glEndQueryIndexed)(GLenum,GLuint);
+        void       (WINE_GLAPI *p_glEndPerfMonitorAMD)( GLuint monitor );
+        void       (WINE_GLAPI *p_glEndPerfQueryINTEL)( GLuint queryHandle );
+        void       (WINE_GLAPI *p_glEndQuery)( GLenum target );
+        void       (WINE_GLAPI *p_glEndQueryARB)( GLenum target );
+        void       (WINE_GLAPI *p_glEndQueryIndexed)( GLenum target, GLuint index );
         void       (WINE_GLAPI *p_glEndTransformFeedback)(void);
         void       (WINE_GLAPI *p_glEndTransformFeedbackEXT)(void);
         void       (WINE_GLAPI *p_glEndTransformFeedbackNV)(void);
         void       (WINE_GLAPI *p_glEndVertexShaderEXT)(void);
-        void       (WINE_GLAPI *p_glEndVideoCaptureNV)(GLuint);
-        void       (WINE_GLAPI *p_glEvalCoord1xOES)(GLfixed);
-        void       (WINE_GLAPI *p_glEvalCoord1xvOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glEvalCoord2xOES)(GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glEvalCoord2xvOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glEvalMapsNV)(GLenum,GLenum);
+        void       (WINE_GLAPI *p_glEndVideoCaptureNV)( GLuint video_capture_slot );
+        void       (WINE_GLAPI *p_glEvalCoord1xOES)( GLfixed u );
+        void       (WINE_GLAPI *p_glEvalCoord1xvOES)( const GLfixed *coords );
+        void       (WINE_GLAPI *p_glEvalCoord2xOES)( GLfixed u, GLfixed v );
+        void       (WINE_GLAPI *p_glEvalCoord2xvOES)( const GLfixed *coords );
+        void       (WINE_GLAPI *p_glEvalMapsNV)( GLenum target, GLenum mode );
         void       (WINE_GLAPI *p_glEvaluateDepthValuesARB)(void);
-        void       (WINE_GLAPI *p_glExecuteProgramNV)(GLenum,GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glExtractComponentEXT)(GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glFeedbackBufferxOES)(GLsizei,GLenum,const GLfixed*);
-        GLsync     (WINE_GLAPI *p_glFenceSync)(GLenum,GLbitfield);
-        void       (WINE_GLAPI *p_glFinalCombinerInputNV)(GLenum,GLenum,GLenum,GLenum);
-        GLint      (WINE_GLAPI *p_glFinishAsyncSGIX)(GLuint*);
-        void       (WINE_GLAPI *p_glFinishFenceAPPLE)(GLuint);
-        void       (WINE_GLAPI *p_glFinishFenceNV)(GLuint);
-        void       (WINE_GLAPI *p_glFinishObjectAPPLE)(GLenum,GLint);
+        void       (WINE_GLAPI *p_glExecuteProgramNV)( GLenum target, GLuint id, const GLfloat *params );
+        void       (WINE_GLAPI *p_glExtractComponentEXT)( GLuint res, GLuint src, GLuint num );
+        void       (WINE_GLAPI *p_glFeedbackBufferxOES)( GLsizei n, GLenum type, const GLfixed *buffer );
+        GLsync     (WINE_GLAPI *p_glFenceSync)( GLenum condition, GLbitfield flags );
+        void       (WINE_GLAPI *p_glFinalCombinerInputNV)( GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage );
+        GLint      (WINE_GLAPI *p_glFinishAsyncSGIX)( GLuint *markerp );
+        void       (WINE_GLAPI *p_glFinishFenceAPPLE)( GLuint fence );
+        void       (WINE_GLAPI *p_glFinishFenceNV)( GLuint fence );
+        void       (WINE_GLAPI *p_glFinishObjectAPPLE)( GLenum object, GLint name );
         void       (WINE_GLAPI *p_glFinishTextureSUNX)(void);
-        void       (WINE_GLAPI *p_glFlushMappedBufferRange)(GLenum,GLintptr,GLsizeiptr);
-        void       (WINE_GLAPI *p_glFlushMappedBufferRangeAPPLE)(GLenum,GLintptr,GLsizeiptr);
-        void       (WINE_GLAPI *p_glFlushMappedNamedBufferRange)(GLuint,GLintptr,GLsizeiptr);
-        void       (WINE_GLAPI *p_glFlushMappedNamedBufferRangeEXT)(GLuint,GLintptr,GLsizeiptr);
-        void       (WINE_GLAPI *p_glFlushPixelDataRangeNV)(GLenum);
+        void       (WINE_GLAPI *p_glFlushMappedBufferRange)( GLenum target, GLintptr offset, GLsizeiptr length );
+        void       (WINE_GLAPI *p_glFlushMappedBufferRangeAPPLE)( GLenum target, GLintptr offset, GLsizeiptr size );
+        void       (WINE_GLAPI *p_glFlushMappedNamedBufferRange)( GLuint buffer, GLintptr offset, GLsizeiptr length );
+        void       (WINE_GLAPI *p_glFlushMappedNamedBufferRangeEXT)( GLuint buffer, GLintptr offset, GLsizeiptr length );
+        void       (WINE_GLAPI *p_glFlushPixelDataRangeNV)( GLenum target );
         void       (WINE_GLAPI *p_glFlushRasterSGIX)(void);
-        void       (WINE_GLAPI *p_glFlushStaticDataIBM)(GLenum);
-        void       (WINE_GLAPI *p_glFlushVertexArrayRangeAPPLE)(GLsizei,void*);
+        void       (WINE_GLAPI *p_glFlushStaticDataIBM)( GLenum target );
+        void       (WINE_GLAPI *p_glFlushVertexArrayRangeAPPLE)( GLsizei length, void *pointer );
         void       (WINE_GLAPI *p_glFlushVertexArrayRangeNV)(void);
-        void       (WINE_GLAPI *p_glFogCoordFormatNV)(GLenum,GLsizei);
-        void       (WINE_GLAPI *p_glFogCoordPointer)(GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glFogCoordPointerEXT)(GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glFogCoordPointerListIBM)(GLenum,GLint,const void**,GLint);
-        void       (WINE_GLAPI *p_glFogCoordd)(GLdouble);
-        void       (WINE_GLAPI *p_glFogCoorddEXT)(GLdouble);
-        void       (WINE_GLAPI *p_glFogCoorddv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glFogCoorddvEXT)(const GLdouble*);
-        void       (WINE_GLAPI *p_glFogCoordf)(GLfloat);
-        void       (WINE_GLAPI *p_glFogCoordfEXT)(GLfloat);
-        void       (WINE_GLAPI *p_glFogCoordfv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glFogCoordfvEXT)(const GLfloat*);
-        void       (WINE_GLAPI *p_glFogCoordhNV)(GLhalfNV);
-        void       (WINE_GLAPI *p_glFogCoordhvNV)(const GLhalfNV*);
-        void       (WINE_GLAPI *p_glFogFuncSGIS)(GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glFogxOES)(GLenum,GLfixed);
-        void       (WINE_GLAPI *p_glFogxvOES)(GLenum,const GLfixed*);
-        void       (WINE_GLAPI *p_glFragmentColorMaterialSGIX)(GLenum,GLenum);
-        void       (WINE_GLAPI *p_glFragmentCoverageColorNV)(GLuint);
-        void       (WINE_GLAPI *p_glFragmentLightModelfSGIX)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glFragmentLightModelfvSGIX)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glFragmentLightModeliSGIX)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glFragmentLightModelivSGIX)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glFragmentLightfSGIX)(GLenum,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glFragmentLightfvSGIX)(GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glFragmentLightiSGIX)(GLenum,GLenum,GLint);
-        void       (WINE_GLAPI *p_glFragmentLightivSGIX)(GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glFragmentMaterialfSGIX)(GLenum,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glFragmentMaterialfvSGIX)(GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glFragmentMaterialiSGIX)(GLenum,GLenum,GLint);
-        void       (WINE_GLAPI *p_glFragmentMaterialivSGIX)(GLenum,GLenum,const GLint*);
+        void       (WINE_GLAPI *p_glFogCoordFormatNV)( GLenum type, GLsizei stride );
+        void       (WINE_GLAPI *p_glFogCoordPointer)( GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glFogCoordPointerEXT)( GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glFogCoordPointerListIBM)( GLenum type, GLint stride, const void **pointer, GLint ptrstride );
+        void       (WINE_GLAPI *p_glFogCoordd)( GLdouble coord );
+        void       (WINE_GLAPI *p_glFogCoorddEXT)( GLdouble coord );
+        void       (WINE_GLAPI *p_glFogCoorddv)( const GLdouble *coord );
+        void       (WINE_GLAPI *p_glFogCoorddvEXT)( const GLdouble *coord );
+        void       (WINE_GLAPI *p_glFogCoordf)( GLfloat coord );
+        void       (WINE_GLAPI *p_glFogCoordfEXT)( GLfloat coord );
+        void       (WINE_GLAPI *p_glFogCoordfv)( const GLfloat *coord );
+        void       (WINE_GLAPI *p_glFogCoordfvEXT)( const GLfloat *coord );
+        void       (WINE_GLAPI *p_glFogCoordhNV)( GLhalfNV fog );
+        void       (WINE_GLAPI *p_glFogCoordhvNV)( const GLhalfNV *fog );
+        void       (WINE_GLAPI *p_glFogFuncSGIS)( GLsizei n, const GLfloat *points );
+        void       (WINE_GLAPI *p_glFogxOES)( GLenum pname, GLfixed param );
+        void       (WINE_GLAPI *p_glFogxvOES)( GLenum pname, const GLfixed *param );
+        void       (WINE_GLAPI *p_glFragmentColorMaterialSGIX)( GLenum face, GLenum mode );
+        void       (WINE_GLAPI *p_glFragmentCoverageColorNV)( GLuint color );
+        void       (WINE_GLAPI *p_glFragmentLightModelfSGIX)( GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glFragmentLightModelfvSGIX)( GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glFragmentLightModeliSGIX)( GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glFragmentLightModelivSGIX)( GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glFragmentLightfSGIX)( GLenum light, GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glFragmentLightfvSGIX)( GLenum light, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glFragmentLightiSGIX)( GLenum light, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glFragmentLightivSGIX)( GLenum light, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glFragmentMaterialfSGIX)( GLenum face, GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glFragmentMaterialfvSGIX)( GLenum face, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glFragmentMaterialiSGIX)( GLenum face, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glFragmentMaterialivSGIX)( GLenum face, GLenum pname, const GLint *params );
         void       (WINE_GLAPI *p_glFrameTerminatorGREMEDY)(void);
-        void       (WINE_GLAPI *p_glFrameZoomSGIX)(GLint);
-        void       (WINE_GLAPI *p_glFramebufferDrawBufferEXT)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glFramebufferDrawBuffersEXT)(GLuint,GLsizei,const GLenum*);
-        void       (WINE_GLAPI *p_glFramebufferParameteri)(GLenum,GLenum,GLint);
-        void       (WINE_GLAPI *p_glFramebufferReadBufferEXT)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glFramebufferRenderbuffer)(GLenum,GLenum,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glFramebufferRenderbufferEXT)(GLenum,GLenum,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glFramebufferSampleLocationsfvARB)(GLenum,GLuint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glFramebufferSampleLocationsfvNV)(GLenum,GLuint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glFramebufferSamplePositionsfvAMD)(GLenum,GLuint,GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glFramebufferTexture)(GLenum,GLenum,GLuint,GLint);
-        void       (WINE_GLAPI *p_glFramebufferTexture1D)(GLenum,GLenum,GLenum,GLuint,GLint);
-        void       (WINE_GLAPI *p_glFramebufferTexture1DEXT)(GLenum,GLenum,GLenum,GLuint,GLint);
-        void       (WINE_GLAPI *p_glFramebufferTexture2D)(GLenum,GLenum,GLenum,GLuint,GLint);
-        void       (WINE_GLAPI *p_glFramebufferTexture2DEXT)(GLenum,GLenum,GLenum,GLuint,GLint);
-        void       (WINE_GLAPI *p_glFramebufferTexture3D)(GLenum,GLenum,GLenum,GLuint,GLint,GLint);
-        void       (WINE_GLAPI *p_glFramebufferTexture3DEXT)(GLenum,GLenum,GLenum,GLuint,GLint,GLint);
-        void       (WINE_GLAPI *p_glFramebufferTextureARB)(GLenum,GLenum,GLuint,GLint);
-        void       (WINE_GLAPI *p_glFramebufferTextureEXT)(GLenum,GLenum,GLuint,GLint);
-        void       (WINE_GLAPI *p_glFramebufferTextureFaceARB)(GLenum,GLenum,GLuint,GLint,GLenum);
-        void       (WINE_GLAPI *p_glFramebufferTextureFaceEXT)(GLenum,GLenum,GLuint,GLint,GLenum);
-        void       (WINE_GLAPI *p_glFramebufferTextureLayer)(GLenum,GLenum,GLuint,GLint,GLint);
-        void       (WINE_GLAPI *p_glFramebufferTextureLayerARB)(GLenum,GLenum,GLuint,GLint,GLint);
-        void       (WINE_GLAPI *p_glFramebufferTextureLayerEXT)(GLenum,GLenum,GLuint,GLint,GLint);
-        void       (WINE_GLAPI *p_glFramebufferTextureMultiviewOVR)(GLenum,GLenum,GLuint,GLint,GLint,GLsizei);
-        void       (WINE_GLAPI *p_glFreeObjectBufferATI)(GLuint);
-        void       (WINE_GLAPI *p_glFrustumfOES)(GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glFrustumxOES)(GLfixed,GLfixed,GLfixed,GLfixed,GLfixed,GLfixed);
-        GLuint     (WINE_GLAPI *p_glGenAsyncMarkersSGIX)(GLsizei);
-        void       (WINE_GLAPI *p_glGenBuffers)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenBuffersARB)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenFencesAPPLE)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenFencesNV)(GLsizei,GLuint*);
-        GLuint     (WINE_GLAPI *p_glGenFragmentShadersATI)(GLuint);
-        void       (WINE_GLAPI *p_glGenFramebuffers)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenFramebuffersEXT)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenNamesAMD)(GLenum,GLuint,GLuint*);
-        void       (WINE_GLAPI *p_glGenOcclusionQueriesNV)(GLsizei,GLuint*);
-        GLuint     (WINE_GLAPI *p_glGenPathsNV)(GLsizei);
-        void       (WINE_GLAPI *p_glGenPerfMonitorsAMD)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenProgramPipelines)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenProgramsARB)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenProgramsNV)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenQueries)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenQueriesARB)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenQueryResourceTagNV)(GLsizei,GLint*);
-        void       (WINE_GLAPI *p_glGenRenderbuffers)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenRenderbuffersEXT)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenSamplers)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenSemaphoresEXT)(GLsizei,GLuint*);
-        GLuint     (WINE_GLAPI *p_glGenSymbolsEXT)(GLenum,GLenum,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glGenTexturesEXT)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenTransformFeedbacks)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenTransformFeedbacksNV)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenVertexArrays)(GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGenVertexArraysAPPLE)(GLsizei,GLuint*);
-        GLuint     (WINE_GLAPI *p_glGenVertexShadersEXT)(GLuint);
-        void       (WINE_GLAPI *p_glGenerateMipmap)(GLenum);
-        void       (WINE_GLAPI *p_glGenerateMipmapEXT)(GLenum);
-        void       (WINE_GLAPI *p_glGenerateMultiTexMipmapEXT)(GLenum,GLenum);
-        void       (WINE_GLAPI *p_glGenerateTextureMipmap)(GLuint);
-        void       (WINE_GLAPI *p_glGenerateTextureMipmapEXT)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glGetActiveAtomicCounterBufferiv)(GLuint,GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetActiveAttrib)(GLuint,GLuint,GLsizei,GLsizei*,GLint*,GLenum*,GLchar*);
-        void       (WINE_GLAPI *p_glGetActiveAttribARB)(GLhandleARB,GLuint,GLsizei,GLsizei*,GLint*,GLenum*,GLcharARB*);
-        void       (WINE_GLAPI *p_glGetActiveSubroutineName)(GLuint,GLenum,GLuint,GLsizei,GLsizei*,GLchar*);
-        void       (WINE_GLAPI *p_glGetActiveSubroutineUniformName)(GLuint,GLenum,GLuint,GLsizei,GLsizei*,GLchar*);
-        void       (WINE_GLAPI *p_glGetActiveSubroutineUniformiv)(GLuint,GLenum,GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetActiveUniform)(GLuint,GLuint,GLsizei,GLsizei*,GLint*,GLenum*,GLchar*);
-        void       (WINE_GLAPI *p_glGetActiveUniformARB)(GLhandleARB,GLuint,GLsizei,GLsizei*,GLint*,GLenum*,GLcharARB*);
-        void       (WINE_GLAPI *p_glGetActiveUniformBlockName)(GLuint,GLuint,GLsizei,GLsizei*,GLchar*);
-        void       (WINE_GLAPI *p_glGetActiveUniformBlockiv)(GLuint,GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetActiveUniformName)(GLuint,GLuint,GLsizei,GLsizei*,GLchar*);
-        void       (WINE_GLAPI *p_glGetActiveUniformsiv)(GLuint,GLsizei,const GLuint*,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetActiveVaryingNV)(GLuint,GLuint,GLsizei,GLsizei*,GLsizei*,GLenum*,GLchar*);
-        void       (WINE_GLAPI *p_glGetArrayObjectfvATI)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetArrayObjectivATI)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetAttachedObjectsARB)(GLhandleARB,GLsizei,GLsizei*,GLhandleARB*);
-        void       (WINE_GLAPI *p_glGetAttachedShaders)(GLuint,GLsizei,GLsizei*,GLuint*);
-        GLint      (WINE_GLAPI *p_glGetAttribLocation)(GLuint,const GLchar*);
-        GLint      (WINE_GLAPI *p_glGetAttribLocationARB)(GLhandleARB,const GLcharARB*);
-        void       (WINE_GLAPI *p_glGetBooleanIndexedvEXT)(GLenum,GLuint,GLboolean*);
-        void       (WINE_GLAPI *p_glGetBooleani_v)(GLenum,GLuint,GLboolean*);
-        void       (WINE_GLAPI *p_glGetBufferParameteri64v)(GLenum,GLenum,GLint64*);
-        void       (WINE_GLAPI *p_glGetBufferParameteriv)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetBufferParameterivARB)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetBufferParameterui64vNV)(GLenum,GLenum,GLuint64EXT*);
-        void       (WINE_GLAPI *p_glGetBufferPointerv)(GLenum,GLenum,void**);
-        void       (WINE_GLAPI *p_glGetBufferPointervARB)(GLenum,GLenum,void**);
-        void       (WINE_GLAPI *p_glGetBufferSubData)(GLenum,GLintptr,GLsizeiptr,void*);
-        void       (WINE_GLAPI *p_glGetBufferSubDataARB)(GLenum,GLintptrARB,GLsizeiptrARB,void*);
-        void       (WINE_GLAPI *p_glGetClipPlanefOES)(GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetClipPlanexOES)(GLenum,GLfixed*);
-        void       (WINE_GLAPI *p_glGetColorTable)(GLenum,GLenum,GLenum,void*);
-        void       (WINE_GLAPI *p_glGetColorTableEXT)(GLenum,GLenum,GLenum,void*);
-        void       (WINE_GLAPI *p_glGetColorTableParameterfv)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetColorTableParameterfvEXT)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetColorTableParameterfvSGI)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetColorTableParameteriv)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetColorTableParameterivEXT)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetColorTableParameterivSGI)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetColorTableSGI)(GLenum,GLenum,GLenum,void*);
-        void       (WINE_GLAPI *p_glGetCombinerInputParameterfvNV)(GLenum,GLenum,GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetCombinerInputParameterivNV)(GLenum,GLenum,GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetCombinerOutputParameterfvNV)(GLenum,GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetCombinerOutputParameterivNV)(GLenum,GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetCombinerStageParameterfvNV)(GLenum,GLenum,GLfloat*);
-        GLuint     (WINE_GLAPI *p_glGetCommandHeaderNV)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glGetCompressedMultiTexImageEXT)(GLenum,GLenum,GLint,void*);
-        void       (WINE_GLAPI *p_glGetCompressedTexImage)(GLenum,GLint,void*);
-        void       (WINE_GLAPI *p_glGetCompressedTexImageARB)(GLenum,GLint,void*);
-        void       (WINE_GLAPI *p_glGetCompressedTextureImage)(GLuint,GLint,GLsizei,void*);
-        void       (WINE_GLAPI *p_glGetCompressedTextureImageEXT)(GLuint,GLenum,GLint,void*);
-        void       (WINE_GLAPI *p_glGetCompressedTextureSubImage)(GLuint,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLsizei,void*);
-        void       (WINE_GLAPI *p_glGetConvolutionFilter)(GLenum,GLenum,GLenum,void*);
-        void       (WINE_GLAPI *p_glGetConvolutionFilterEXT)(GLenum,GLenum,GLenum,void*);
-        void       (WINE_GLAPI *p_glGetConvolutionParameterfv)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetConvolutionParameterfvEXT)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetConvolutionParameteriv)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetConvolutionParameterivEXT)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetConvolutionParameterxvOES)(GLenum,GLenum,GLfixed*);
-        void       (WINE_GLAPI *p_glGetCoverageModulationTableNV)(GLsizei,GLfloat*);
-        GLuint     (WINE_GLAPI *p_glGetDebugMessageLog)(GLuint,GLsizei,GLenum*,GLenum*,GLuint*,GLenum*,GLsizei*,GLchar*);
-        GLuint     (WINE_GLAPI *p_glGetDebugMessageLogAMD)(GLuint,GLsizei,GLenum*,GLuint*,GLuint*,GLsizei*,GLchar*);
-        GLuint     (WINE_GLAPI *p_glGetDebugMessageLogARB)(GLuint,GLsizei,GLenum*,GLenum*,GLuint*,GLenum*,GLsizei*,GLchar*);
-        void       (WINE_GLAPI *p_glGetDetailTexFuncSGIS)(GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetDoubleIndexedvEXT)(GLenum,GLuint,GLdouble*);
-        void       (WINE_GLAPI *p_glGetDoublei_v)(GLenum,GLuint,GLdouble*);
-        void       (WINE_GLAPI *p_glGetDoublei_vEXT)(GLenum,GLuint,GLdouble*);
-        void       (WINE_GLAPI *p_glGetFenceivNV)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetFinalCombinerInputParameterfvNV)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetFinalCombinerInputParameterivNV)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetFirstPerfQueryIdINTEL)(GLuint*);
-        void       (WINE_GLAPI *p_glGetFixedvOES)(GLenum,GLfixed*);
-        void       (WINE_GLAPI *p_glGetFloatIndexedvEXT)(GLenum,GLuint,GLfloat*);
-        void       (WINE_GLAPI *p_glGetFloati_v)(GLenum,GLuint,GLfloat*);
-        void       (WINE_GLAPI *p_glGetFloati_vEXT)(GLenum,GLuint,GLfloat*);
-        void       (WINE_GLAPI *p_glGetFogFuncSGIS)(GLfloat*);
-        GLint      (WINE_GLAPI *p_glGetFragDataIndex)(GLuint,const GLchar*);
-        GLint      (WINE_GLAPI *p_glGetFragDataLocation)(GLuint,const GLchar*);
-        GLint      (WINE_GLAPI *p_glGetFragDataLocationEXT)(GLuint,const GLchar*);
-        void       (WINE_GLAPI *p_glGetFragmentLightfvSGIX)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetFragmentLightivSGIX)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetFragmentMaterialfvSGIX)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetFragmentMaterialivSGIX)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetFramebufferAttachmentParameteriv)(GLenum,GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetFramebufferAttachmentParameterivEXT)(GLenum,GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetFramebufferParameterfvAMD)(GLenum,GLenum,GLuint,GLuint,GLsizei,GLfloat*);
-        void       (WINE_GLAPI *p_glGetFramebufferParameteriv)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetFramebufferParameterivEXT)(GLuint,GLenum,GLint*);
+        void       (WINE_GLAPI *p_glFrameZoomSGIX)( GLint factor );
+        void       (WINE_GLAPI *p_glFramebufferDrawBufferEXT)( GLuint framebuffer, GLenum mode );
+        void       (WINE_GLAPI *p_glFramebufferDrawBuffersEXT)( GLuint framebuffer, GLsizei n, const GLenum *bufs );
+        void       (WINE_GLAPI *p_glFramebufferParameteri)( GLenum target, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glFramebufferReadBufferEXT)( GLuint framebuffer, GLenum mode );
+        void       (WINE_GLAPI *p_glFramebufferRenderbuffer)( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer );
+        void       (WINE_GLAPI *p_glFramebufferRenderbufferEXT)( GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer );
+        void       (WINE_GLAPI *p_glFramebufferSampleLocationsfvARB)( GLenum target, GLuint start, GLsizei count, const GLfloat *v );
+        void       (WINE_GLAPI *p_glFramebufferSampleLocationsfvNV)( GLenum target, GLuint start, GLsizei count, const GLfloat *v );
+        void       (WINE_GLAPI *p_glFramebufferSamplePositionsfvAMD)( GLenum target, GLuint numsamples, GLuint pixelindex, const GLfloat *values );
+        void       (WINE_GLAPI *p_glFramebufferTexture)( GLenum target, GLenum attachment, GLuint texture, GLint level );
+        void       (WINE_GLAPI *p_glFramebufferTexture1D)( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level );
+        void       (WINE_GLAPI *p_glFramebufferTexture1DEXT)( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level );
+        void       (WINE_GLAPI *p_glFramebufferTexture2D)( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level );
+        void       (WINE_GLAPI *p_glFramebufferTexture2DEXT)( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level );
+        void       (WINE_GLAPI *p_glFramebufferTexture3D)( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset );
+        void       (WINE_GLAPI *p_glFramebufferTexture3DEXT)( GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset );
+        void       (WINE_GLAPI *p_glFramebufferTextureARB)( GLenum target, GLenum attachment, GLuint texture, GLint level );
+        void       (WINE_GLAPI *p_glFramebufferTextureEXT)( GLenum target, GLenum attachment, GLuint texture, GLint level );
+        void       (WINE_GLAPI *p_glFramebufferTextureFaceARB)( GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face );
+        void       (WINE_GLAPI *p_glFramebufferTextureFaceEXT)( GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face );
+        void       (WINE_GLAPI *p_glFramebufferTextureLayer)( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer );
+        void       (WINE_GLAPI *p_glFramebufferTextureLayerARB)( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer );
+        void       (WINE_GLAPI *p_glFramebufferTextureLayerEXT)( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer );
+        void       (WINE_GLAPI *p_glFramebufferTextureMultiviewOVR)( GLenum target, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews );
+        void       (WINE_GLAPI *p_glFreeObjectBufferATI)( GLuint buffer );
+        void       (WINE_GLAPI *p_glFrustumfOES)( GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f );
+        void       (WINE_GLAPI *p_glFrustumxOES)( GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f );
+        GLuint     (WINE_GLAPI *p_glGenAsyncMarkersSGIX)( GLsizei range );
+        void       (WINE_GLAPI *p_glGenBuffers)( GLsizei n, GLuint *buffers );
+        void       (WINE_GLAPI *p_glGenBuffersARB)( GLsizei n, GLuint *buffers );
+        void       (WINE_GLAPI *p_glGenFencesAPPLE)( GLsizei n, GLuint *fences );
+        void       (WINE_GLAPI *p_glGenFencesNV)( GLsizei n, GLuint *fences );
+        GLuint     (WINE_GLAPI *p_glGenFragmentShadersATI)( GLuint range );
+        void       (WINE_GLAPI *p_glGenFramebuffers)( GLsizei n, GLuint *framebuffers );
+        void       (WINE_GLAPI *p_glGenFramebuffersEXT)( GLsizei n, GLuint *framebuffers );
+        void       (WINE_GLAPI *p_glGenNamesAMD)( GLenum identifier, GLuint num, GLuint *names );
+        void       (WINE_GLAPI *p_glGenOcclusionQueriesNV)( GLsizei n, GLuint *ids );
+        GLuint     (WINE_GLAPI *p_glGenPathsNV)( GLsizei range );
+        void       (WINE_GLAPI *p_glGenPerfMonitorsAMD)( GLsizei n, GLuint *monitors );
+        void       (WINE_GLAPI *p_glGenProgramPipelines)( GLsizei n, GLuint *pipelines );
+        void       (WINE_GLAPI *p_glGenProgramsARB)( GLsizei n, GLuint *programs );
+        void       (WINE_GLAPI *p_glGenProgramsNV)( GLsizei n, GLuint *programs );
+        void       (WINE_GLAPI *p_glGenQueries)( GLsizei n, GLuint *ids );
+        void       (WINE_GLAPI *p_glGenQueriesARB)( GLsizei n, GLuint *ids );
+        void       (WINE_GLAPI *p_glGenQueryResourceTagNV)( GLsizei n, GLint *tagIds );
+        void       (WINE_GLAPI *p_glGenRenderbuffers)( GLsizei n, GLuint *renderbuffers );
+        void       (WINE_GLAPI *p_glGenRenderbuffersEXT)( GLsizei n, GLuint *renderbuffers );
+        void       (WINE_GLAPI *p_glGenSamplers)( GLsizei count, GLuint *samplers );
+        void       (WINE_GLAPI *p_glGenSemaphoresEXT)( GLsizei n, GLuint *semaphores );
+        GLuint     (WINE_GLAPI *p_glGenSymbolsEXT)( GLenum datatype, GLenum storagetype, GLenum range, GLuint components );
+        void       (WINE_GLAPI *p_glGenTexturesEXT)( GLsizei n, GLuint *textures );
+        void       (WINE_GLAPI *p_glGenTransformFeedbacks)( GLsizei n, GLuint *ids );
+        void       (WINE_GLAPI *p_glGenTransformFeedbacksNV)( GLsizei n, GLuint *ids );
+        void       (WINE_GLAPI *p_glGenVertexArrays)( GLsizei n, GLuint *arrays );
+        void       (WINE_GLAPI *p_glGenVertexArraysAPPLE)( GLsizei n, GLuint *arrays );
+        GLuint     (WINE_GLAPI *p_glGenVertexShadersEXT)( GLuint range );
+        void       (WINE_GLAPI *p_glGenerateMipmap)( GLenum target );
+        void       (WINE_GLAPI *p_glGenerateMipmapEXT)( GLenum target );
+        void       (WINE_GLAPI *p_glGenerateMultiTexMipmapEXT)( GLenum texunit, GLenum target );
+        void       (WINE_GLAPI *p_glGenerateTextureMipmap)( GLuint texture );
+        void       (WINE_GLAPI *p_glGenerateTextureMipmapEXT)( GLuint texture, GLenum target );
+        void       (WINE_GLAPI *p_glGetActiveAtomicCounterBufferiv)( GLuint program, GLuint bufferIndex, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetActiveAttrib)( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name );
+        void       (WINE_GLAPI *p_glGetActiveAttribARB)( GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name );
+        void       (WINE_GLAPI *p_glGetActiveSubroutineName)( GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name );
+        void       (WINE_GLAPI *p_glGetActiveSubroutineUniformName)( GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name );
+        void       (WINE_GLAPI *p_glGetActiveSubroutineUniformiv)( GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values );
+        void       (WINE_GLAPI *p_glGetActiveUniform)( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name );
+        void       (WINE_GLAPI *p_glGetActiveUniformARB)( GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name );
+        void       (WINE_GLAPI *p_glGetActiveUniformBlockName)( GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName );
+        void       (WINE_GLAPI *p_glGetActiveUniformBlockiv)( GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetActiveUniformName)( GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName );
+        void       (WINE_GLAPI *p_glGetActiveUniformsiv)( GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetActiveVaryingNV)( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name );
+        void       (WINE_GLAPI *p_glGetArrayObjectfvATI)( GLenum array, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetArrayObjectivATI)( GLenum array, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetAttachedObjectsARB)( GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj );
+        void       (WINE_GLAPI *p_glGetAttachedShaders)( GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders );
+        GLint      (WINE_GLAPI *p_glGetAttribLocation)( GLuint program, const GLchar *name );
+        GLint      (WINE_GLAPI *p_glGetAttribLocationARB)( GLhandleARB programObj, const GLcharARB *name );
+        void       (WINE_GLAPI *p_glGetBooleanIndexedvEXT)( GLenum target, GLuint index, GLboolean *data );
+        void       (WINE_GLAPI *p_glGetBooleani_v)( GLenum target, GLuint index, GLboolean *data );
+        void       (WINE_GLAPI *p_glGetBufferParameteri64v)( GLenum target, GLenum pname, GLint64 *params );
+        void       (WINE_GLAPI *p_glGetBufferParameteriv)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetBufferParameterivARB)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetBufferParameterui64vNV)( GLenum target, GLenum pname, GLuint64EXT *params );
+        void       (WINE_GLAPI *p_glGetBufferPointerv)( GLenum target, GLenum pname, void **params );
+        void       (WINE_GLAPI *p_glGetBufferPointervARB)( GLenum target, GLenum pname, void **params );
+        void       (WINE_GLAPI *p_glGetBufferSubData)( GLenum target, GLintptr offset, GLsizeiptr size, void *data );
+        void       (WINE_GLAPI *p_glGetBufferSubDataARB)( GLenum target, GLintptrARB offset, GLsizeiptrARB size, void *data );
+        void       (WINE_GLAPI *p_glGetClipPlanefOES)( GLenum plane, GLfloat *equation );
+        void       (WINE_GLAPI *p_glGetClipPlanexOES)( GLenum plane, GLfixed *equation );
+        void       (WINE_GLAPI *p_glGetColorTable)( GLenum target, GLenum format, GLenum type, void *table );
+        void       (WINE_GLAPI *p_glGetColorTableEXT)( GLenum target, GLenum format, GLenum type, void *data );
+        void       (WINE_GLAPI *p_glGetColorTableParameterfv)( GLenum target, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetColorTableParameterfvEXT)( GLenum target, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetColorTableParameterfvSGI)( GLenum target, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetColorTableParameteriv)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetColorTableParameterivEXT)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetColorTableParameterivSGI)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetColorTableSGI)( GLenum target, GLenum format, GLenum type, void *table );
+        void       (WINE_GLAPI *p_glGetCombinerInputParameterfvNV)( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetCombinerInputParameterivNV)( GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetCombinerOutputParameterfvNV)( GLenum stage, GLenum portion, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetCombinerOutputParameterivNV)( GLenum stage, GLenum portion, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetCombinerStageParameterfvNV)( GLenum stage, GLenum pname, GLfloat *params );
+        GLuint     (WINE_GLAPI *p_glGetCommandHeaderNV)( GLenum tokenID, GLuint size );
+        void       (WINE_GLAPI *p_glGetCompressedMultiTexImageEXT)( GLenum texunit, GLenum target, GLint lod, void *img );
+        void       (WINE_GLAPI *p_glGetCompressedTexImage)( GLenum target, GLint level, void *img );
+        void       (WINE_GLAPI *p_glGetCompressedTexImageARB)( GLenum target, GLint level, void *img );
+        void       (WINE_GLAPI *p_glGetCompressedTextureImage)( GLuint texture, GLint level, GLsizei bufSize, void *pixels );
+        void       (WINE_GLAPI *p_glGetCompressedTextureImageEXT)( GLuint texture, GLenum target, GLint lod, void *img );
+        void       (WINE_GLAPI *p_glGetCompressedTextureSubImage)( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels );
+        void       (WINE_GLAPI *p_glGetConvolutionFilter)( GLenum target, GLenum format, GLenum type, void *image );
+        void       (WINE_GLAPI *p_glGetConvolutionFilterEXT)( GLenum target, GLenum format, GLenum type, void *image );
+        void       (WINE_GLAPI *p_glGetConvolutionParameterfv)( GLenum target, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetConvolutionParameterfvEXT)( GLenum target, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetConvolutionParameteriv)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetConvolutionParameterivEXT)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetConvolutionParameterxvOES)( GLenum target, GLenum pname, GLfixed *params );
+        void       (WINE_GLAPI *p_glGetCoverageModulationTableNV)( GLsizei bufsize, GLfloat *v );
+        GLuint     (WINE_GLAPI *p_glGetDebugMessageLog)( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog );
+        GLuint     (WINE_GLAPI *p_glGetDebugMessageLogAMD)( GLuint count, GLsizei bufsize, GLenum *categories, GLuint *severities, GLuint *ids, GLsizei *lengths, GLchar *message );
+        GLuint     (WINE_GLAPI *p_glGetDebugMessageLogARB)( GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog );
+        void       (WINE_GLAPI *p_glGetDetailTexFuncSGIS)( GLenum target, GLfloat *points );
+        void       (WINE_GLAPI *p_glGetDoubleIndexedvEXT)( GLenum target, GLuint index, GLdouble *data );
+        void       (WINE_GLAPI *p_glGetDoublei_v)( GLenum target, GLuint index, GLdouble *data );
+        void       (WINE_GLAPI *p_glGetDoublei_vEXT)( GLenum pname, GLuint index, GLdouble *params );
+        void       (WINE_GLAPI *p_glGetFenceivNV)( GLuint fence, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetFinalCombinerInputParameterfvNV)( GLenum variable, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetFinalCombinerInputParameterivNV)( GLenum variable, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetFirstPerfQueryIdINTEL)( GLuint *queryId );
+        void       (WINE_GLAPI *p_glGetFixedvOES)( GLenum pname, GLfixed *params );
+        void       (WINE_GLAPI *p_glGetFloatIndexedvEXT)( GLenum target, GLuint index, GLfloat *data );
+        void       (WINE_GLAPI *p_glGetFloati_v)( GLenum target, GLuint index, GLfloat *data );
+        void       (WINE_GLAPI *p_glGetFloati_vEXT)( GLenum pname, GLuint index, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetFogFuncSGIS)( GLfloat *points );
+        GLint      (WINE_GLAPI *p_glGetFragDataIndex)( GLuint program, const GLchar *name );
+        GLint      (WINE_GLAPI *p_glGetFragDataLocation)( GLuint program, const GLchar *name );
+        GLint      (WINE_GLAPI *p_glGetFragDataLocationEXT)( GLuint program, const GLchar *name );
+        void       (WINE_GLAPI *p_glGetFragmentLightfvSGIX)( GLenum light, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetFragmentLightivSGIX)( GLenum light, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetFragmentMaterialfvSGIX)( GLenum face, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetFragmentMaterialivSGIX)( GLenum face, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetFramebufferAttachmentParameteriv)( GLenum target, GLenum attachment, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetFramebufferAttachmentParameterivEXT)( GLenum target, GLenum attachment, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetFramebufferParameterfvAMD)( GLenum target, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, GLfloat *values );
+        void       (WINE_GLAPI *p_glGetFramebufferParameteriv)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetFramebufferParameterivEXT)( GLuint framebuffer, GLenum pname, GLint *params );
         GLenum     (WINE_GLAPI *p_glGetGraphicsResetStatus)(void);
         GLenum     (WINE_GLAPI *p_glGetGraphicsResetStatusARB)(void);
-        GLhandleARB (WINE_GLAPI *p_glGetHandleARB)(GLenum);
-        void       (WINE_GLAPI *p_glGetHistogram)(GLenum,GLboolean,GLenum,GLenum,void*);
-        void       (WINE_GLAPI *p_glGetHistogramEXT)(GLenum,GLboolean,GLenum,GLenum,void*);
-        void       (WINE_GLAPI *p_glGetHistogramParameterfv)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetHistogramParameterfvEXT)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetHistogramParameteriv)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetHistogramParameterivEXT)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetHistogramParameterxvOES)(GLenum,GLenum,GLfixed*);
-        GLuint64   (WINE_GLAPI *p_glGetImageHandleARB)(GLuint,GLint,GLboolean,GLint,GLenum);
-        GLuint64   (WINE_GLAPI *p_glGetImageHandleNV)(GLuint,GLint,GLboolean,GLint,GLenum);
-        void       (WINE_GLAPI *p_glGetImageTransformParameterfvHP)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetImageTransformParameterivHP)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetInfoLogARB)(GLhandleARB,GLsizei,GLsizei*,GLcharARB*);
+        GLhandleARB (WINE_GLAPI *p_glGetHandleARB)( GLenum pname );
+        void       (WINE_GLAPI *p_glGetHistogram)( GLenum target, GLboolean reset, GLenum format, GLenum type, void *values );
+        void       (WINE_GLAPI *p_glGetHistogramEXT)( GLenum target, GLboolean reset, GLenum format, GLenum type, void *values );
+        void       (WINE_GLAPI *p_glGetHistogramParameterfv)( GLenum target, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetHistogramParameterfvEXT)( GLenum target, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetHistogramParameteriv)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetHistogramParameterivEXT)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetHistogramParameterxvOES)( GLenum target, GLenum pname, GLfixed *params );
+        GLuint64   (WINE_GLAPI *p_glGetImageHandleARB)( GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format );
+        GLuint64   (WINE_GLAPI *p_glGetImageHandleNV)( GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format );
+        void       (WINE_GLAPI *p_glGetImageTransformParameterfvHP)( GLenum target, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetImageTransformParameterivHP)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetInfoLogARB)( GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog );
         GLint      (WINE_GLAPI *p_glGetInstrumentsSGIX)(void);
-        void       (WINE_GLAPI *p_glGetInteger64i_v)(GLenum,GLuint,GLint64*);
-        void       (WINE_GLAPI *p_glGetInteger64v)(GLenum,GLint64*);
-        void       (WINE_GLAPI *p_glGetIntegerIndexedvEXT)(GLenum,GLuint,GLint*);
-        void       (WINE_GLAPI *p_glGetIntegeri_v)(GLenum,GLuint,GLint*);
-        void       (WINE_GLAPI *p_glGetIntegerui64i_vNV)(GLenum,GLuint,GLuint64EXT*);
-        void       (WINE_GLAPI *p_glGetIntegerui64vNV)(GLenum,GLuint64EXT*);
-        void       (WINE_GLAPI *p_glGetInternalformatSampleivNV)(GLenum,GLenum,GLsizei,GLenum,GLsizei,GLint*);
-        void       (WINE_GLAPI *p_glGetInternalformati64v)(GLenum,GLenum,GLenum,GLsizei,GLint64*);
-        void       (WINE_GLAPI *p_glGetInternalformativ)(GLenum,GLenum,GLenum,GLsizei,GLint*);
-        void       (WINE_GLAPI *p_glGetInvariantBooleanvEXT)(GLuint,GLenum,GLboolean*);
-        void       (WINE_GLAPI *p_glGetInvariantFloatvEXT)(GLuint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetInvariantIntegervEXT)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetLightxOES)(GLenum,GLenum,GLfixed*);
-        void       (WINE_GLAPI *p_glGetListParameterfvSGIX)(GLuint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetListParameterivSGIX)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetLocalConstantBooleanvEXT)(GLuint,GLenum,GLboolean*);
-        void       (WINE_GLAPI *p_glGetLocalConstantFloatvEXT)(GLuint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetLocalConstantIntegervEXT)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetMapAttribParameterfvNV)(GLenum,GLuint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetMapAttribParameterivNV)(GLenum,GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetMapControlPointsNV)(GLenum,GLuint,GLenum,GLsizei,GLsizei,GLboolean,void*);
-        void       (WINE_GLAPI *p_glGetMapParameterfvNV)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetMapParameterivNV)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetMapxvOES)(GLenum,GLenum,GLfixed*);
-        void       (WINE_GLAPI *p_glGetMaterialxOES)(GLenum,GLenum,GLfixed);
-        void       (WINE_GLAPI *p_glGetMemoryObjectParameterivEXT)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetMinmax)(GLenum,GLboolean,GLenum,GLenum,void*);
-        void       (WINE_GLAPI *p_glGetMinmaxEXT)(GLenum,GLboolean,GLenum,GLenum,void*);
-        void       (WINE_GLAPI *p_glGetMinmaxParameterfv)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetMinmaxParameterfvEXT)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetMinmaxParameteriv)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetMinmaxParameterivEXT)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetMultiTexEnvfvEXT)(GLenum,GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetMultiTexEnvivEXT)(GLenum,GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetMultiTexGendvEXT)(GLenum,GLenum,GLenum,GLdouble*);
-        void       (WINE_GLAPI *p_glGetMultiTexGenfvEXT)(GLenum,GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetMultiTexGenivEXT)(GLenum,GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetMultiTexImageEXT)(GLenum,GLenum,GLint,GLenum,GLenum,void*);
-        void       (WINE_GLAPI *p_glGetMultiTexLevelParameterfvEXT)(GLenum,GLenum,GLint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetMultiTexLevelParameterivEXT)(GLenum,GLenum,GLint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetMultiTexParameterIivEXT)(GLenum,GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetMultiTexParameterIuivEXT)(GLenum,GLenum,GLenum,GLuint*);
-        void       (WINE_GLAPI *p_glGetMultiTexParameterfvEXT)(GLenum,GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetMultiTexParameterivEXT)(GLenum,GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetMultisamplefv)(GLenum,GLuint,GLfloat*);
-        void       (WINE_GLAPI *p_glGetMultisamplefvNV)(GLenum,GLuint,GLfloat*);
-        void       (WINE_GLAPI *p_glGetNamedBufferParameteri64v)(GLuint,GLenum,GLint64*);
-        void       (WINE_GLAPI *p_glGetNamedBufferParameteriv)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetNamedBufferParameterivEXT)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetNamedBufferParameterui64vNV)(GLuint,GLenum,GLuint64EXT*);
-        void       (WINE_GLAPI *p_glGetNamedBufferPointerv)(GLuint,GLenum,void**);
-        void       (WINE_GLAPI *p_glGetNamedBufferPointervEXT)(GLuint,GLenum,void**);
-        void       (WINE_GLAPI *p_glGetNamedBufferSubData)(GLuint,GLintptr,GLsizeiptr,void*);
-        void       (WINE_GLAPI *p_glGetNamedBufferSubDataEXT)(GLuint,GLintptr,GLsizeiptr,void*);
-        void       (WINE_GLAPI *p_glGetNamedFramebufferAttachmentParameteriv)(GLuint,GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetNamedFramebufferAttachmentParameterivEXT)(GLuint,GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetNamedFramebufferParameterfvAMD)(GLuint,GLenum,GLuint,GLuint,GLsizei,GLfloat*);
-        void       (WINE_GLAPI *p_glGetNamedFramebufferParameteriv)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetNamedFramebufferParameterivEXT)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetNamedProgramLocalParameterIivEXT)(GLuint,GLenum,GLuint,GLint*);
-        void       (WINE_GLAPI *p_glGetNamedProgramLocalParameterIuivEXT)(GLuint,GLenum,GLuint,GLuint*);
-        void       (WINE_GLAPI *p_glGetNamedProgramLocalParameterdvEXT)(GLuint,GLenum,GLuint,GLdouble*);
-        void       (WINE_GLAPI *p_glGetNamedProgramLocalParameterfvEXT)(GLuint,GLenum,GLuint,GLfloat*);
-        void       (WINE_GLAPI *p_glGetNamedProgramStringEXT)(GLuint,GLenum,GLenum,void*);
-        void       (WINE_GLAPI *p_glGetNamedProgramivEXT)(GLuint,GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetNamedRenderbufferParameteriv)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetNamedRenderbufferParameterivEXT)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetNamedStringARB)(GLint,const GLchar*,GLsizei,GLint*,GLchar*);
-        void       (WINE_GLAPI *p_glGetNamedStringivARB)(GLint,const GLchar*,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetNextPerfQueryIdINTEL)(GLuint,GLuint*);
-        void       (WINE_GLAPI *p_glGetObjectBufferfvATI)(GLuint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetObjectBufferivATI)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetObjectLabel)(GLenum,GLuint,GLsizei,GLsizei*,GLchar*);
-        void       (WINE_GLAPI *p_glGetObjectLabelEXT)(GLenum,GLuint,GLsizei,GLsizei*,GLchar*);
-        void       (WINE_GLAPI *p_glGetObjectParameterfvARB)(GLhandleARB,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetObjectParameterivAPPLE)(GLenum,GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetObjectParameterivARB)(GLhandleARB,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetObjectPtrLabel)(const void*,GLsizei,GLsizei*,GLchar*);
-        void       (WINE_GLAPI *p_glGetOcclusionQueryivNV)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetOcclusionQueryuivNV)(GLuint,GLenum,GLuint*);
-        void       (WINE_GLAPI *p_glGetPathColorGenfvNV)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetPathColorGenivNV)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetPathCommandsNV)(GLuint,GLubyte*);
-        void       (WINE_GLAPI *p_glGetPathCoordsNV)(GLuint,GLfloat*);
-        void       (WINE_GLAPI *p_glGetPathDashArrayNV)(GLuint,GLfloat*);
-        GLfloat    (WINE_GLAPI *p_glGetPathLengthNV)(GLuint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glGetPathMetricRangeNV)(GLbitfield,GLuint,GLsizei,GLsizei,GLfloat*);
-        void       (WINE_GLAPI *p_glGetPathMetricsNV)(GLbitfield,GLsizei,GLenum,const void*,GLuint,GLsizei,GLfloat*);
-        void       (WINE_GLAPI *p_glGetPathParameterfvNV)(GLuint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetPathParameterivNV)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetPathSpacingNV)(GLenum,GLsizei,GLenum,const void*,GLuint,GLfloat,GLfloat,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetPathTexGenfvNV)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetPathTexGenivNV)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetPerfCounterInfoINTEL)(GLuint,GLuint,GLuint,GLchar*,GLuint,GLchar*,GLuint*,GLuint*,GLuint*,GLuint*,GLuint64*);
-        void       (WINE_GLAPI *p_glGetPerfMonitorCounterDataAMD)(GLuint,GLenum,GLsizei,GLuint*,GLint*);
-        void       (WINE_GLAPI *p_glGetPerfMonitorCounterInfoAMD)(GLuint,GLuint,GLenum,void*);
-        void       (WINE_GLAPI *p_glGetPerfMonitorCounterStringAMD)(GLuint,GLuint,GLsizei,GLsizei*,GLchar*);
-        void       (WINE_GLAPI *p_glGetPerfMonitorCountersAMD)(GLuint,GLint*,GLint*,GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGetPerfMonitorGroupStringAMD)(GLuint,GLsizei,GLsizei*,GLchar*);
-        void       (WINE_GLAPI *p_glGetPerfMonitorGroupsAMD)(GLint*,GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGetPerfQueryDataINTEL)(GLuint,GLuint,GLsizei,GLvoid*,GLuint*);
-        void       (WINE_GLAPI *p_glGetPerfQueryIdByNameINTEL)(GLchar*,GLuint*);
-        void       (WINE_GLAPI *p_glGetPerfQueryInfoINTEL)(GLuint,GLuint,GLchar*,GLuint*,GLuint*,GLuint*,GLuint*);
-        void       (WINE_GLAPI *p_glGetPixelMapxv)(GLenum,GLint,GLfixed*);
-        void       (WINE_GLAPI *p_glGetPixelTexGenParameterfvSGIS)(GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetPixelTexGenParameterivSGIS)(GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetPixelTransformParameterfvEXT)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetPixelTransformParameterivEXT)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetPointerIndexedvEXT)(GLenum,GLuint,void**);
-        void       (WINE_GLAPI *p_glGetPointeri_vEXT)(GLenum,GLuint,void**);
-        void       (WINE_GLAPI *p_glGetPointervEXT)(GLenum,void**);
-        void       (WINE_GLAPI *p_glGetProgramBinary)(GLuint,GLsizei,GLsizei*,GLenum*,void*);
-        void       (WINE_GLAPI *p_glGetProgramEnvParameterIivNV)(GLenum,GLuint,GLint*);
-        void       (WINE_GLAPI *p_glGetProgramEnvParameterIuivNV)(GLenum,GLuint,GLuint*);
-        void       (WINE_GLAPI *p_glGetProgramEnvParameterdvARB)(GLenum,GLuint,GLdouble*);
-        void       (WINE_GLAPI *p_glGetProgramEnvParameterfvARB)(GLenum,GLuint,GLfloat*);
-        void       (WINE_GLAPI *p_glGetProgramInfoLog)(GLuint,GLsizei,GLsizei*,GLchar*);
-        void       (WINE_GLAPI *p_glGetProgramInterfaceiv)(GLuint,GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetProgramLocalParameterIivNV)(GLenum,GLuint,GLint*);
-        void       (WINE_GLAPI *p_glGetProgramLocalParameterIuivNV)(GLenum,GLuint,GLuint*);
-        void       (WINE_GLAPI *p_glGetProgramLocalParameterdvARB)(GLenum,GLuint,GLdouble*);
-        void       (WINE_GLAPI *p_glGetProgramLocalParameterfvARB)(GLenum,GLuint,GLfloat*);
-        void       (WINE_GLAPI *p_glGetProgramNamedParameterdvNV)(GLuint,GLsizei,const GLubyte*,GLdouble*);
-        void       (WINE_GLAPI *p_glGetProgramNamedParameterfvNV)(GLuint,GLsizei,const GLubyte*,GLfloat*);
-        void       (WINE_GLAPI *p_glGetProgramParameterdvNV)(GLenum,GLuint,GLenum,GLdouble*);
-        void       (WINE_GLAPI *p_glGetProgramParameterfvNV)(GLenum,GLuint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetProgramPipelineInfoLog)(GLuint,GLsizei,GLsizei*,GLchar*);
-        void       (WINE_GLAPI *p_glGetProgramPipelineiv)(GLuint,GLenum,GLint*);
-        GLuint     (WINE_GLAPI *p_glGetProgramResourceIndex)(GLuint,GLenum,const GLchar*);
-        GLint      (WINE_GLAPI *p_glGetProgramResourceLocation)(GLuint,GLenum,const GLchar*);
-        GLint      (WINE_GLAPI *p_glGetProgramResourceLocationIndex)(GLuint,GLenum,const GLchar*);
-        void       (WINE_GLAPI *p_glGetProgramResourceName)(GLuint,GLenum,GLuint,GLsizei,GLsizei*,GLchar*);
-        void       (WINE_GLAPI *p_glGetProgramResourcefvNV)(GLuint,GLenum,GLuint,GLsizei,const GLenum*,GLsizei,GLsizei*,GLfloat*);
-        void       (WINE_GLAPI *p_glGetProgramResourceiv)(GLuint,GLenum,GLuint,GLsizei,const GLenum*,GLsizei,GLsizei*,GLint*);
-        void       (WINE_GLAPI *p_glGetProgramStageiv)(GLuint,GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetProgramStringARB)(GLenum,GLenum,void*);
-        void       (WINE_GLAPI *p_glGetProgramStringNV)(GLuint,GLenum,GLubyte*);
-        void       (WINE_GLAPI *p_glGetProgramSubroutineParameteruivNV)(GLenum,GLuint,GLuint*);
-        void       (WINE_GLAPI *p_glGetProgramiv)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetProgramivARB)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetProgramivNV)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetQueryBufferObjecti64v)(GLuint,GLuint,GLenum,GLintptr);
-        void       (WINE_GLAPI *p_glGetQueryBufferObjectiv)(GLuint,GLuint,GLenum,GLintptr);
-        void       (WINE_GLAPI *p_glGetQueryBufferObjectui64v)(GLuint,GLuint,GLenum,GLintptr);
-        void       (WINE_GLAPI *p_glGetQueryBufferObjectuiv)(GLuint,GLuint,GLenum,GLintptr);
-        void       (WINE_GLAPI *p_glGetQueryIndexediv)(GLenum,GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetQueryObjecti64v)(GLuint,GLenum,GLint64*);
-        void       (WINE_GLAPI *p_glGetQueryObjecti64vEXT)(GLuint,GLenum,GLint64*);
-        void       (WINE_GLAPI *p_glGetQueryObjectiv)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetQueryObjectivARB)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetQueryObjectui64v)(GLuint,GLenum,GLuint64*);
-        void       (WINE_GLAPI *p_glGetQueryObjectui64vEXT)(GLuint,GLenum,GLuint64*);
-        void       (WINE_GLAPI *p_glGetQueryObjectuiv)(GLuint,GLenum,GLuint*);
-        void       (WINE_GLAPI *p_glGetQueryObjectuivARB)(GLuint,GLenum,GLuint*);
-        void       (WINE_GLAPI *p_glGetQueryiv)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetQueryivARB)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetRenderbufferParameteriv)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetRenderbufferParameterivEXT)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetSamplerParameterIiv)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetSamplerParameterIuiv)(GLuint,GLenum,GLuint*);
-        void       (WINE_GLAPI *p_glGetSamplerParameterfv)(GLuint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetSamplerParameteriv)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetSemaphoreParameterui64vEXT)(GLuint,GLenum,GLuint64*);
-        void       (WINE_GLAPI *p_glGetSeparableFilter)(GLenum,GLenum,GLenum,void*,void*,void*);
-        void       (WINE_GLAPI *p_glGetSeparableFilterEXT)(GLenum,GLenum,GLenum,void*,void*,void*);
-        void       (WINE_GLAPI *p_glGetShaderInfoLog)(GLuint,GLsizei,GLsizei*,GLchar*);
-        void       (WINE_GLAPI *p_glGetShaderPrecisionFormat)(GLenum,GLenum,GLint*,GLint*);
-        void       (WINE_GLAPI *p_glGetShaderSource)(GLuint,GLsizei,GLsizei*,GLchar*);
-        void       (WINE_GLAPI *p_glGetShaderSourceARB)(GLhandleARB,GLsizei,GLsizei*,GLcharARB*);
-        void       (WINE_GLAPI *p_glGetShaderiv)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetSharpenTexFuncSGIS)(GLenum,GLfloat*);
-        GLushort   (WINE_GLAPI *p_glGetStageIndexNV)(GLenum);
-        const GLubyte* (WINE_GLAPI *p_glGetStringi)(GLenum,GLuint);
-        GLuint     (WINE_GLAPI *p_glGetSubroutineIndex)(GLuint,GLenum,const GLchar*);
-        GLint      (WINE_GLAPI *p_glGetSubroutineUniformLocation)(GLuint,GLenum,const GLchar*);
-        void       (WINE_GLAPI *p_glGetSynciv)(GLsync,GLenum,GLsizei,GLsizei*,GLint*);
-        void       (WINE_GLAPI *p_glGetTexBumpParameterfvATI)(GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetTexBumpParameterivATI)(GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetTexEnvxvOES)(GLenum,GLenum,GLfixed*);
-        void       (WINE_GLAPI *p_glGetTexFilterFuncSGIS)(GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetTexGenxvOES)(GLenum,GLenum,GLfixed*);
-        void       (WINE_GLAPI *p_glGetTexLevelParameterxvOES)(GLenum,GLint,GLenum,GLfixed*);
-        void       (WINE_GLAPI *p_glGetTexParameterIiv)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetTexParameterIivEXT)(GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetTexParameterIuiv)(GLenum,GLenum,GLuint*);
-        void       (WINE_GLAPI *p_glGetTexParameterIuivEXT)(GLenum,GLenum,GLuint*);
-        void       (WINE_GLAPI *p_glGetTexParameterPointervAPPLE)(GLenum,GLenum,void**);
-        void       (WINE_GLAPI *p_glGetTexParameterxvOES)(GLenum,GLenum,GLfixed*);
-        GLuint64   (WINE_GLAPI *p_glGetTextureHandleARB)(GLuint);
-        GLuint64   (WINE_GLAPI *p_glGetTextureHandleNV)(GLuint);
-        void       (WINE_GLAPI *p_glGetTextureImage)(GLuint,GLint,GLenum,GLenum,GLsizei,void*);
-        void       (WINE_GLAPI *p_glGetTextureImageEXT)(GLuint,GLenum,GLint,GLenum,GLenum,void*);
-        void       (WINE_GLAPI *p_glGetTextureLevelParameterfv)(GLuint,GLint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetTextureLevelParameterfvEXT)(GLuint,GLenum,GLint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetTextureLevelParameteriv)(GLuint,GLint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetTextureLevelParameterivEXT)(GLuint,GLenum,GLint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetTextureParameterIiv)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetTextureParameterIivEXT)(GLuint,GLenum,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetTextureParameterIuiv)(GLuint,GLenum,GLuint*);
-        void       (WINE_GLAPI *p_glGetTextureParameterIuivEXT)(GLuint,GLenum,GLenum,GLuint*);
-        void       (WINE_GLAPI *p_glGetTextureParameterfv)(GLuint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetTextureParameterfvEXT)(GLuint,GLenum,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetTextureParameteriv)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetTextureParameterivEXT)(GLuint,GLenum,GLenum,GLint*);
-        GLuint64   (WINE_GLAPI *p_glGetTextureSamplerHandleARB)(GLuint,GLuint);
-        GLuint64   (WINE_GLAPI *p_glGetTextureSamplerHandleNV)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glGetTextureSubImage)(GLuint,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLenum,GLenum,GLsizei,void*);
-        void       (WINE_GLAPI *p_glGetTrackMatrixivNV)(GLenum,GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetTransformFeedbackVarying)(GLuint,GLuint,GLsizei,GLsizei*,GLsizei*,GLenum*,GLchar*);
-        void       (WINE_GLAPI *p_glGetTransformFeedbackVaryingEXT)(GLuint,GLuint,GLsizei,GLsizei*,GLsizei*,GLenum*,GLchar*);
-        void       (WINE_GLAPI *p_glGetTransformFeedbackVaryingNV)(GLuint,GLuint,GLint*);
-        void       (WINE_GLAPI *p_glGetTransformFeedbacki64_v)(GLuint,GLenum,GLuint,GLint64*);
-        void       (WINE_GLAPI *p_glGetTransformFeedbacki_v)(GLuint,GLenum,GLuint,GLint*);
-        void       (WINE_GLAPI *p_glGetTransformFeedbackiv)(GLuint,GLenum,GLint*);
-        GLuint     (WINE_GLAPI *p_glGetUniformBlockIndex)(GLuint,const GLchar*);
-        GLint      (WINE_GLAPI *p_glGetUniformBufferSizeEXT)(GLuint,GLint);
-        void       (WINE_GLAPI *p_glGetUniformIndices)(GLuint,GLsizei,const GLchar*const*,GLuint*);
-        GLint      (WINE_GLAPI *p_glGetUniformLocation)(GLuint,const GLchar*);
-        GLint      (WINE_GLAPI *p_glGetUniformLocationARB)(GLhandleARB,const GLcharARB*);
-        GLintptr   (WINE_GLAPI *p_glGetUniformOffsetEXT)(GLuint,GLint);
-        void       (WINE_GLAPI *p_glGetUniformSubroutineuiv)(GLenum,GLint,GLuint*);
-        void       (WINE_GLAPI *p_glGetUniformdv)(GLuint,GLint,GLdouble*);
-        void       (WINE_GLAPI *p_glGetUniformfv)(GLuint,GLint,GLfloat*);
-        void       (WINE_GLAPI *p_glGetUniformfvARB)(GLhandleARB,GLint,GLfloat*);
-        void       (WINE_GLAPI *p_glGetUniformi64vARB)(GLuint,GLint,GLint64*);
-        void       (WINE_GLAPI *p_glGetUniformi64vNV)(GLuint,GLint,GLint64EXT*);
-        void       (WINE_GLAPI *p_glGetUniformiv)(GLuint,GLint,GLint*);
-        void       (WINE_GLAPI *p_glGetUniformivARB)(GLhandleARB,GLint,GLint*);
-        void       (WINE_GLAPI *p_glGetUniformui64vARB)(GLuint,GLint,GLuint64*);
-        void       (WINE_GLAPI *p_glGetUniformui64vNV)(GLuint,GLint,GLuint64EXT*);
-        void       (WINE_GLAPI *p_glGetUniformuiv)(GLuint,GLint,GLuint*);
-        void       (WINE_GLAPI *p_glGetUniformuivEXT)(GLuint,GLint,GLuint*);
-        void       (WINE_GLAPI *p_glGetUnsignedBytei_vEXT)(GLenum,GLuint,GLubyte*);
-        void       (WINE_GLAPI *p_glGetUnsignedBytevEXT)(GLenum,GLubyte*);
-        void       (WINE_GLAPI *p_glGetVariantArrayObjectfvATI)(GLuint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetVariantArrayObjectivATI)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetVariantBooleanvEXT)(GLuint,GLenum,GLboolean*);
-        void       (WINE_GLAPI *p_glGetVariantFloatvEXT)(GLuint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetVariantIntegervEXT)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetVariantPointervEXT)(GLuint,GLenum,void**);
-        GLint      (WINE_GLAPI *p_glGetVaryingLocationNV)(GLuint,const GLchar*);
-        void       (WINE_GLAPI *p_glGetVertexArrayIndexed64iv)(GLuint,GLuint,GLenum,GLint64*);
-        void       (WINE_GLAPI *p_glGetVertexArrayIndexediv)(GLuint,GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetVertexArrayIntegeri_vEXT)(GLuint,GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetVertexArrayIntegervEXT)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetVertexArrayPointeri_vEXT)(GLuint,GLuint,GLenum,void**);
-        void       (WINE_GLAPI *p_glGetVertexArrayPointervEXT)(GLuint,GLenum,void**);
-        void       (WINE_GLAPI *p_glGetVertexArrayiv)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetVertexAttribArrayObjectfvATI)(GLuint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetVertexAttribArrayObjectivATI)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetVertexAttribIiv)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetVertexAttribIivEXT)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetVertexAttribIuiv)(GLuint,GLenum,GLuint*);
-        void       (WINE_GLAPI *p_glGetVertexAttribIuivEXT)(GLuint,GLenum,GLuint*);
-        void       (WINE_GLAPI *p_glGetVertexAttribLdv)(GLuint,GLenum,GLdouble*);
-        void       (WINE_GLAPI *p_glGetVertexAttribLdvEXT)(GLuint,GLenum,GLdouble*);
-        void       (WINE_GLAPI *p_glGetVertexAttribLi64vNV)(GLuint,GLenum,GLint64EXT*);
-        void       (WINE_GLAPI *p_glGetVertexAttribLui64vARB)(GLuint,GLenum,GLuint64EXT*);
-        void       (WINE_GLAPI *p_glGetVertexAttribLui64vNV)(GLuint,GLenum,GLuint64EXT*);
-        void       (WINE_GLAPI *p_glGetVertexAttribPointerv)(GLuint,GLenum,void**);
-        void       (WINE_GLAPI *p_glGetVertexAttribPointervARB)(GLuint,GLenum,void**);
-        void       (WINE_GLAPI *p_glGetVertexAttribPointervNV)(GLuint,GLenum,void**);
-        void       (WINE_GLAPI *p_glGetVertexAttribdv)(GLuint,GLenum,GLdouble*);
-        void       (WINE_GLAPI *p_glGetVertexAttribdvARB)(GLuint,GLenum,GLdouble*);
-        void       (WINE_GLAPI *p_glGetVertexAttribdvNV)(GLuint,GLenum,GLdouble*);
-        void       (WINE_GLAPI *p_glGetVertexAttribfv)(GLuint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetVertexAttribfvARB)(GLuint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetVertexAttribfvNV)(GLuint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetVertexAttribiv)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetVertexAttribivARB)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetVertexAttribivNV)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetVideoCaptureStreamdvNV)(GLuint,GLuint,GLenum,GLdouble*);
-        void       (WINE_GLAPI *p_glGetVideoCaptureStreamfvNV)(GLuint,GLuint,GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glGetVideoCaptureStreamivNV)(GLuint,GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetVideoCaptureivNV)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetVideoi64vNV)(GLuint,GLenum,GLint64EXT*);
-        void       (WINE_GLAPI *p_glGetVideoivNV)(GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glGetVideoui64vNV)(GLuint,GLenum,GLuint64EXT*);
-        void       (WINE_GLAPI *p_glGetVideouivNV)(GLuint,GLenum,GLuint*);
-        void *     (WINE_GLAPI *p_glGetVkProcAddrNV)(const GLchar*);
-        void       (WINE_GLAPI *p_glGetnColorTable)(GLenum,GLenum,GLenum,GLsizei,void*);
-        void       (WINE_GLAPI *p_glGetnColorTableARB)(GLenum,GLenum,GLenum,GLsizei,void*);
-        void       (WINE_GLAPI *p_glGetnCompressedTexImage)(GLenum,GLint,GLsizei,void*);
-        void       (WINE_GLAPI *p_glGetnCompressedTexImageARB)(GLenum,GLint,GLsizei,void*);
-        void       (WINE_GLAPI *p_glGetnConvolutionFilter)(GLenum,GLenum,GLenum,GLsizei,void*);
-        void       (WINE_GLAPI *p_glGetnConvolutionFilterARB)(GLenum,GLenum,GLenum,GLsizei,void*);
-        void       (WINE_GLAPI *p_glGetnHistogram)(GLenum,GLboolean,GLenum,GLenum,GLsizei,void*);
-        void       (WINE_GLAPI *p_glGetnHistogramARB)(GLenum,GLboolean,GLenum,GLenum,GLsizei,void*);
-        void       (WINE_GLAPI *p_glGetnMapdv)(GLenum,GLenum,GLsizei,GLdouble*);
-        void       (WINE_GLAPI *p_glGetnMapdvARB)(GLenum,GLenum,GLsizei,GLdouble*);
-        void       (WINE_GLAPI *p_glGetnMapfv)(GLenum,GLenum,GLsizei,GLfloat*);
-        void       (WINE_GLAPI *p_glGetnMapfvARB)(GLenum,GLenum,GLsizei,GLfloat*);
-        void       (WINE_GLAPI *p_glGetnMapiv)(GLenum,GLenum,GLsizei,GLint*);
-        void       (WINE_GLAPI *p_glGetnMapivARB)(GLenum,GLenum,GLsizei,GLint*);
-        void       (WINE_GLAPI *p_glGetnMinmax)(GLenum,GLboolean,GLenum,GLenum,GLsizei,void*);
-        void       (WINE_GLAPI *p_glGetnMinmaxARB)(GLenum,GLboolean,GLenum,GLenum,GLsizei,void*);
-        void       (WINE_GLAPI *p_glGetnPixelMapfv)(GLenum,GLsizei,GLfloat*);
-        void       (WINE_GLAPI *p_glGetnPixelMapfvARB)(GLenum,GLsizei,GLfloat*);
-        void       (WINE_GLAPI *p_glGetnPixelMapuiv)(GLenum,GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGetnPixelMapuivARB)(GLenum,GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGetnPixelMapusv)(GLenum,GLsizei,GLushort*);
-        void       (WINE_GLAPI *p_glGetnPixelMapusvARB)(GLenum,GLsizei,GLushort*);
-        void       (WINE_GLAPI *p_glGetnPolygonStipple)(GLsizei,GLubyte*);
-        void       (WINE_GLAPI *p_glGetnPolygonStippleARB)(GLsizei,GLubyte*);
-        void       (WINE_GLAPI *p_glGetnSeparableFilter)(GLenum,GLenum,GLenum,GLsizei,void*,GLsizei,void*,void*);
-        void       (WINE_GLAPI *p_glGetnSeparableFilterARB)(GLenum,GLenum,GLenum,GLsizei,void*,GLsizei,void*,void*);
-        void       (WINE_GLAPI *p_glGetnTexImage)(GLenum,GLint,GLenum,GLenum,GLsizei,void*);
-        void       (WINE_GLAPI *p_glGetnTexImageARB)(GLenum,GLint,GLenum,GLenum,GLsizei,void*);
-        void       (WINE_GLAPI *p_glGetnUniformdv)(GLuint,GLint,GLsizei,GLdouble*);
-        void       (WINE_GLAPI *p_glGetnUniformdvARB)(GLuint,GLint,GLsizei,GLdouble*);
-        void       (WINE_GLAPI *p_glGetnUniformfv)(GLuint,GLint,GLsizei,GLfloat*);
-        void       (WINE_GLAPI *p_glGetnUniformfvARB)(GLuint,GLint,GLsizei,GLfloat*);
-        void       (WINE_GLAPI *p_glGetnUniformi64vARB)(GLuint,GLint,GLsizei,GLint64*);
-        void       (WINE_GLAPI *p_glGetnUniformiv)(GLuint,GLint,GLsizei,GLint*);
-        void       (WINE_GLAPI *p_glGetnUniformivARB)(GLuint,GLint,GLsizei,GLint*);
-        void       (WINE_GLAPI *p_glGetnUniformui64vARB)(GLuint,GLint,GLsizei,GLuint64*);
-        void       (WINE_GLAPI *p_glGetnUniformuiv)(GLuint,GLint,GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGetnUniformuivARB)(GLuint,GLint,GLsizei,GLuint*);
-        void       (WINE_GLAPI *p_glGlobalAlphaFactorbSUN)(GLbyte);
-        void       (WINE_GLAPI *p_glGlobalAlphaFactordSUN)(GLdouble);
-        void       (WINE_GLAPI *p_glGlobalAlphaFactorfSUN)(GLfloat);
-        void       (WINE_GLAPI *p_glGlobalAlphaFactoriSUN)(GLint);
-        void       (WINE_GLAPI *p_glGlobalAlphaFactorsSUN)(GLshort);
-        void       (WINE_GLAPI *p_glGlobalAlphaFactorubSUN)(GLubyte);
-        void       (WINE_GLAPI *p_glGlobalAlphaFactoruiSUN)(GLuint);
-        void       (WINE_GLAPI *p_glGlobalAlphaFactorusSUN)(GLushort);
-        void       (WINE_GLAPI *p_glHintPGI)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glHistogram)(GLenum,GLsizei,GLenum,GLboolean);
-        void       (WINE_GLAPI *p_glHistogramEXT)(GLenum,GLsizei,GLenum,GLboolean);
-        void       (WINE_GLAPI *p_glIglooInterfaceSGIX)(GLenum,const void*);
-        void       (WINE_GLAPI *p_glImageTransformParameterfHP)(GLenum,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glImageTransformParameterfvHP)(GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glImageTransformParameteriHP)(GLenum,GLenum,GLint);
-        void       (WINE_GLAPI *p_glImageTransformParameterivHP)(GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glImportMemoryFdEXT)(GLuint,GLuint64,GLenum,GLint);
-        void       (WINE_GLAPI *p_glImportMemoryWin32HandleEXT)(GLuint,GLuint64,GLenum,void*);
-        void       (WINE_GLAPI *p_glImportMemoryWin32NameEXT)(GLuint,GLuint64,GLenum,const void*);
-        void       (WINE_GLAPI *p_glImportSemaphoreFdEXT)(GLuint,GLenum,GLint);
-        void       (WINE_GLAPI *p_glImportSemaphoreWin32HandleEXT)(GLuint,GLenum,void*);
-        void       (WINE_GLAPI *p_glImportSemaphoreWin32NameEXT)(GLuint,GLenum,const void*);
-        GLsync     (WINE_GLAPI *p_glImportSyncEXT)(GLenum,GLintptr,GLbitfield);
-        void       (WINE_GLAPI *p_glIndexFormatNV)(GLenum,GLsizei);
-        void       (WINE_GLAPI *p_glIndexFuncEXT)(GLenum,GLclampf);
-        void       (WINE_GLAPI *p_glIndexMaterialEXT)(GLenum,GLenum);
-        void       (WINE_GLAPI *p_glIndexPointerEXT)(GLenum,GLsizei,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glIndexPointerListIBM)(GLenum,GLint,const void**,GLint);
-        void       (WINE_GLAPI *p_glIndexxOES)(GLfixed);
-        void       (WINE_GLAPI *p_glIndexxvOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glInsertComponentEXT)(GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glInsertEventMarkerEXT)(GLsizei,const GLchar*);
-        void       (WINE_GLAPI *p_glInstrumentsBufferSGIX)(GLsizei,GLint*);
-        void       (WINE_GLAPI *p_glInterpolatePathsNV)(GLuint,GLuint,GLuint,GLfloat);
-        void       (WINE_GLAPI *p_glInvalidateBufferData)(GLuint);
-        void       (WINE_GLAPI *p_glInvalidateBufferSubData)(GLuint,GLintptr,GLsizeiptr);
-        void       (WINE_GLAPI *p_glInvalidateFramebuffer)(GLenum,GLsizei,const GLenum*);
-        void       (WINE_GLAPI *p_glInvalidateNamedFramebufferData)(GLuint,GLsizei,const GLenum*);
-        void       (WINE_GLAPI *p_glInvalidateNamedFramebufferSubData)(GLuint,GLsizei,const GLenum*,GLint,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glInvalidateSubFramebuffer)(GLenum,GLsizei,const GLenum*,GLint,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glInvalidateTexImage)(GLuint,GLint);
-        void       (WINE_GLAPI *p_glInvalidateTexSubImage)(GLuint,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei);
-        GLboolean  (WINE_GLAPI *p_glIsAsyncMarkerSGIX)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsBuffer)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsBufferARB)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsBufferResidentNV)(GLenum);
-        GLboolean  (WINE_GLAPI *p_glIsCommandListNV)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsEnabledIndexedEXT)(GLenum,GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsEnabledi)(GLenum,GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsFenceAPPLE)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsFenceNV)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsFramebuffer)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsFramebufferEXT)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsImageHandleResidentARB)(GLuint64);
-        GLboolean  (WINE_GLAPI *p_glIsImageHandleResidentNV)(GLuint64);
-        GLboolean  (WINE_GLAPI *p_glIsMemoryObjectEXT)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsNameAMD)(GLenum,GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsNamedBufferResidentNV)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsNamedStringARB)(GLint,const GLchar*);
-        GLboolean  (WINE_GLAPI *p_glIsObjectBufferATI)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsOcclusionQueryNV)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsPathNV)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsPointInFillPathNV)(GLuint,GLuint,GLfloat,GLfloat);
-        GLboolean  (WINE_GLAPI *p_glIsPointInStrokePathNV)(GLuint,GLfloat,GLfloat);
-        GLboolean  (WINE_GLAPI *p_glIsProgram)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsProgramARB)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsProgramNV)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsProgramPipeline)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsQuery)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsQueryARB)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsRenderbuffer)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsRenderbufferEXT)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsSampler)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsSemaphoreEXT)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsShader)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsStateNV)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsSync)(GLsync);
-        GLboolean  (WINE_GLAPI *p_glIsTextureEXT)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsTextureHandleResidentARB)(GLuint64);
-        GLboolean  (WINE_GLAPI *p_glIsTextureHandleResidentNV)(GLuint64);
-        GLboolean  (WINE_GLAPI *p_glIsTransformFeedback)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsTransformFeedbackNV)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsVariantEnabledEXT)(GLuint,GLenum);
-        GLboolean  (WINE_GLAPI *p_glIsVertexArray)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsVertexArrayAPPLE)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glIsVertexAttribEnabledAPPLE)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glLGPUCopyImageSubDataNVX)(GLuint,GLbitfield,GLuint,GLenum,GLint,GLint,GLint,GLint,GLuint,GLenum,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei);
+        void       (WINE_GLAPI *p_glGetInteger64i_v)( GLenum target, GLuint index, GLint64 *data );
+        void       (WINE_GLAPI *p_glGetInteger64v)( GLenum pname, GLint64 *data );
+        void       (WINE_GLAPI *p_glGetIntegerIndexedvEXT)( GLenum target, GLuint index, GLint *data );
+        void       (WINE_GLAPI *p_glGetIntegeri_v)( GLenum target, GLuint index, GLint *data );
+        void       (WINE_GLAPI *p_glGetIntegerui64i_vNV)( GLenum value, GLuint index, GLuint64EXT *result );
+        void       (WINE_GLAPI *p_glGetIntegerui64vNV)( GLenum value, GLuint64EXT *result );
+        void       (WINE_GLAPI *p_glGetInternalformatSampleivNV)( GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, GLsizei bufSize, GLint *params );
+        void       (WINE_GLAPI *p_glGetInternalformati64v)( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params );
+        void       (WINE_GLAPI *p_glGetInternalformativ)( GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params );
+        void       (WINE_GLAPI *p_glGetInvariantBooleanvEXT)( GLuint id, GLenum value, GLboolean *data );
+        void       (WINE_GLAPI *p_glGetInvariantFloatvEXT)( GLuint id, GLenum value, GLfloat *data );
+        void       (WINE_GLAPI *p_glGetInvariantIntegervEXT)( GLuint id, GLenum value, GLint *data );
+        void       (WINE_GLAPI *p_glGetLightxOES)( GLenum light, GLenum pname, GLfixed *params );
+        void       (WINE_GLAPI *p_glGetListParameterfvSGIX)( GLuint list, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetListParameterivSGIX)( GLuint list, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetLocalConstantBooleanvEXT)( GLuint id, GLenum value, GLboolean *data );
+        void       (WINE_GLAPI *p_glGetLocalConstantFloatvEXT)( GLuint id, GLenum value, GLfloat *data );
+        void       (WINE_GLAPI *p_glGetLocalConstantIntegervEXT)( GLuint id, GLenum value, GLint *data );
+        void       (WINE_GLAPI *p_glGetMapAttribParameterfvNV)( GLenum target, GLuint index, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetMapAttribParameterivNV)( GLenum target, GLuint index, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetMapControlPointsNV)( GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, void *points );
+        void       (WINE_GLAPI *p_glGetMapParameterfvNV)( GLenum target, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetMapParameterivNV)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetMapxvOES)( GLenum target, GLenum query, GLfixed *v );
+        void       (WINE_GLAPI *p_glGetMaterialxOES)( GLenum face, GLenum pname, GLfixed param );
+        void       (WINE_GLAPI *p_glGetMemoryObjectParameterivEXT)( GLuint memoryObject, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetMinmax)( GLenum target, GLboolean reset, GLenum format, GLenum type, void *values );
+        void       (WINE_GLAPI *p_glGetMinmaxEXT)( GLenum target, GLboolean reset, GLenum format, GLenum type, void *values );
+        void       (WINE_GLAPI *p_glGetMinmaxParameterfv)( GLenum target, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetMinmaxParameterfvEXT)( GLenum target, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetMinmaxParameteriv)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetMinmaxParameterivEXT)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetMultiTexEnvfvEXT)( GLenum texunit, GLenum target, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetMultiTexEnvivEXT)( GLenum texunit, GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetMultiTexGendvEXT)( GLenum texunit, GLenum coord, GLenum pname, GLdouble *params );
+        void       (WINE_GLAPI *p_glGetMultiTexGenfvEXT)( GLenum texunit, GLenum coord, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetMultiTexGenivEXT)( GLenum texunit, GLenum coord, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetMultiTexImageEXT)( GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void *pixels );
+        void       (WINE_GLAPI *p_glGetMultiTexLevelParameterfvEXT)( GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetMultiTexLevelParameterivEXT)( GLenum texunit, GLenum target, GLint level, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetMultiTexParameterIivEXT)( GLenum texunit, GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetMultiTexParameterIuivEXT)( GLenum texunit, GLenum target, GLenum pname, GLuint *params );
+        void       (WINE_GLAPI *p_glGetMultiTexParameterfvEXT)( GLenum texunit, GLenum target, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetMultiTexParameterivEXT)( GLenum texunit, GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetMultisamplefv)( GLenum pname, GLuint index, GLfloat *val );
+        void       (WINE_GLAPI *p_glGetMultisamplefvNV)( GLenum pname, GLuint index, GLfloat *val );
+        void       (WINE_GLAPI *p_glGetNamedBufferParameteri64v)( GLuint buffer, GLenum pname, GLint64 *params );
+        void       (WINE_GLAPI *p_glGetNamedBufferParameteriv)( GLuint buffer, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetNamedBufferParameterivEXT)( GLuint buffer, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetNamedBufferParameterui64vNV)( GLuint buffer, GLenum pname, GLuint64EXT *params );
+        void       (WINE_GLAPI *p_glGetNamedBufferPointerv)( GLuint buffer, GLenum pname, void **params );
+        void       (WINE_GLAPI *p_glGetNamedBufferPointervEXT)( GLuint buffer, GLenum pname, void **params );
+        void       (WINE_GLAPI *p_glGetNamedBufferSubData)( GLuint buffer, GLintptr offset, GLsizeiptr size, void *data );
+        void       (WINE_GLAPI *p_glGetNamedBufferSubDataEXT)( GLuint buffer, GLintptr offset, GLsizeiptr size, void *data );
+        void       (WINE_GLAPI *p_glGetNamedFramebufferAttachmentParameteriv)( GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetNamedFramebufferAttachmentParameterivEXT)( GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetNamedFramebufferParameterfvAMD)( GLuint framebuffer, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, GLfloat *values );
+        void       (WINE_GLAPI *p_glGetNamedFramebufferParameteriv)( GLuint framebuffer, GLenum pname, GLint *param );
+        void       (WINE_GLAPI *p_glGetNamedFramebufferParameterivEXT)( GLuint framebuffer, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetNamedProgramLocalParameterIivEXT)( GLuint program, GLenum target, GLuint index, GLint *params );
+        void       (WINE_GLAPI *p_glGetNamedProgramLocalParameterIuivEXT)( GLuint program, GLenum target, GLuint index, GLuint *params );
+        void       (WINE_GLAPI *p_glGetNamedProgramLocalParameterdvEXT)( GLuint program, GLenum target, GLuint index, GLdouble *params );
+        void       (WINE_GLAPI *p_glGetNamedProgramLocalParameterfvEXT)( GLuint program, GLenum target, GLuint index, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetNamedProgramStringEXT)( GLuint program, GLenum target, GLenum pname, void *string );
+        void       (WINE_GLAPI *p_glGetNamedProgramivEXT)( GLuint program, GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetNamedRenderbufferParameteriv)( GLuint renderbuffer, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetNamedRenderbufferParameterivEXT)( GLuint renderbuffer, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetNamedStringARB)( GLint namelen, const GLchar *name, GLsizei bufSize, GLint *stringlen, GLchar *string );
+        void       (WINE_GLAPI *p_glGetNamedStringivARB)( GLint namelen, const GLchar *name, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetNextPerfQueryIdINTEL)( GLuint queryId, GLuint *nextQueryId );
+        void       (WINE_GLAPI *p_glGetObjectBufferfvATI)( GLuint buffer, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetObjectBufferivATI)( GLuint buffer, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetObjectLabel)( GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label );
+        void       (WINE_GLAPI *p_glGetObjectLabelEXT)( GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label );
+        void       (WINE_GLAPI *p_glGetObjectParameterfvARB)( GLhandleARB obj, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetObjectParameterivAPPLE)( GLenum objectType, GLuint name, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetObjectParameterivARB)( GLhandleARB obj, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetObjectPtrLabel)( const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label );
+        void       (WINE_GLAPI *p_glGetOcclusionQueryivNV)( GLuint id, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetOcclusionQueryuivNV)( GLuint id, GLenum pname, GLuint *params );
+        void       (WINE_GLAPI *p_glGetPathColorGenfvNV)( GLenum color, GLenum pname, GLfloat *value );
+        void       (WINE_GLAPI *p_glGetPathColorGenivNV)( GLenum color, GLenum pname, GLint *value );
+        void       (WINE_GLAPI *p_glGetPathCommandsNV)( GLuint path, GLubyte *commands );
+        void       (WINE_GLAPI *p_glGetPathCoordsNV)( GLuint path, GLfloat *coords );
+        void       (WINE_GLAPI *p_glGetPathDashArrayNV)( GLuint path, GLfloat *dashArray );
+        GLfloat    (WINE_GLAPI *p_glGetPathLengthNV)( GLuint path, GLsizei startSegment, GLsizei numSegments );
+        void       (WINE_GLAPI *p_glGetPathMetricRangeNV)( GLbitfield metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat *metrics );
+        void       (WINE_GLAPI *p_glGetPathMetricsNV)( GLbitfield metricQueryMask, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLsizei stride, GLfloat *metrics );
+        void       (WINE_GLAPI *p_glGetPathParameterfvNV)( GLuint path, GLenum pname, GLfloat *value );
+        void       (WINE_GLAPI *p_glGetPathParameterivNV)( GLuint path, GLenum pname, GLint *value );
+        void       (WINE_GLAPI *p_glGetPathSpacingNV)( GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, GLfloat *returnedSpacing );
+        void       (WINE_GLAPI *p_glGetPathTexGenfvNV)( GLenum texCoordSet, GLenum pname, GLfloat *value );
+        void       (WINE_GLAPI *p_glGetPathTexGenivNV)( GLenum texCoordSet, GLenum pname, GLint *value );
+        void       (WINE_GLAPI *p_glGetPerfCounterInfoINTEL)( GLuint queryId, GLuint counterId, GLuint counterNameLength, GLchar *counterName, GLuint counterDescLength, GLchar *counterDesc, GLuint *counterOffset, GLuint *counterDataSize, GLuint *counterTypeEnum, GLuint *counterDataTypeEnum, GLuint64 *rawCounterMaxValue );
+        void       (WINE_GLAPI *p_glGetPerfMonitorCounterDataAMD)( GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten );
+        void       (WINE_GLAPI *p_glGetPerfMonitorCounterInfoAMD)( GLuint group, GLuint counter, GLenum pname, void *data );
+        void       (WINE_GLAPI *p_glGetPerfMonitorCounterStringAMD)( GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString );
+        void       (WINE_GLAPI *p_glGetPerfMonitorCountersAMD)( GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters );
+        void       (WINE_GLAPI *p_glGetPerfMonitorGroupStringAMD)( GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString );
+        void       (WINE_GLAPI *p_glGetPerfMonitorGroupsAMD)( GLint *numGroups, GLsizei groupsSize, GLuint *groups );
+        void       (WINE_GLAPI *p_glGetPerfQueryDataINTEL)( GLuint queryHandle, GLuint flags, GLsizei dataSize, GLvoid *data, GLuint *bytesWritten );
+        void       (WINE_GLAPI *p_glGetPerfQueryIdByNameINTEL)( GLchar *queryName, GLuint *queryId );
+        void       (WINE_GLAPI *p_glGetPerfQueryInfoINTEL)( GLuint queryId, GLuint queryNameLength, GLchar *queryName, GLuint *dataSize, GLuint *noCounters, GLuint *noInstances, GLuint *capsMask );
+        void       (WINE_GLAPI *p_glGetPixelMapxv)( GLenum map, GLint size, GLfixed *values );
+        void       (WINE_GLAPI *p_glGetPixelTexGenParameterfvSGIS)( GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetPixelTexGenParameterivSGIS)( GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetPixelTransformParameterfvEXT)( GLenum target, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetPixelTransformParameterivEXT)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetPointerIndexedvEXT)( GLenum target, GLuint index, void **data );
+        void       (WINE_GLAPI *p_glGetPointeri_vEXT)( GLenum pname, GLuint index, void **params );
+        void       (WINE_GLAPI *p_glGetPointervEXT)( GLenum pname, void **params );
+        void       (WINE_GLAPI *p_glGetProgramBinary)( GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary );
+        void       (WINE_GLAPI *p_glGetProgramEnvParameterIivNV)( GLenum target, GLuint index, GLint *params );
+        void       (WINE_GLAPI *p_glGetProgramEnvParameterIuivNV)( GLenum target, GLuint index, GLuint *params );
+        void       (WINE_GLAPI *p_glGetProgramEnvParameterdvARB)( GLenum target, GLuint index, GLdouble *params );
+        void       (WINE_GLAPI *p_glGetProgramEnvParameterfvARB)( GLenum target, GLuint index, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetProgramInfoLog)( GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog );
+        void       (WINE_GLAPI *p_glGetProgramInterfaceiv)( GLuint program, GLenum programInterface, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetProgramLocalParameterIivNV)( GLenum target, GLuint index, GLint *params );
+        void       (WINE_GLAPI *p_glGetProgramLocalParameterIuivNV)( GLenum target, GLuint index, GLuint *params );
+        void       (WINE_GLAPI *p_glGetProgramLocalParameterdvARB)( GLenum target, GLuint index, GLdouble *params );
+        void       (WINE_GLAPI *p_glGetProgramLocalParameterfvARB)( GLenum target, GLuint index, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetProgramNamedParameterdvNV)( GLuint id, GLsizei len, const GLubyte *name, GLdouble *params );
+        void       (WINE_GLAPI *p_glGetProgramNamedParameterfvNV)( GLuint id, GLsizei len, const GLubyte *name, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetProgramParameterdvNV)( GLenum target, GLuint index, GLenum pname, GLdouble *params );
+        void       (WINE_GLAPI *p_glGetProgramParameterfvNV)( GLenum target, GLuint index, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetProgramPipelineInfoLog)( GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog );
+        void       (WINE_GLAPI *p_glGetProgramPipelineiv)( GLuint pipeline, GLenum pname, GLint *params );
+        GLuint     (WINE_GLAPI *p_glGetProgramResourceIndex)( GLuint program, GLenum programInterface, const GLchar *name );
+        GLint      (WINE_GLAPI *p_glGetProgramResourceLocation)( GLuint program, GLenum programInterface, const GLchar *name );
+        GLint      (WINE_GLAPI *p_glGetProgramResourceLocationIndex)( GLuint program, GLenum programInterface, const GLchar *name );
+        void       (WINE_GLAPI *p_glGetProgramResourceName)( GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name );
+        void       (WINE_GLAPI *p_glGetProgramResourcefvNV)( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetProgramResourceiv)( GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params );
+        void       (WINE_GLAPI *p_glGetProgramStageiv)( GLuint program, GLenum shadertype, GLenum pname, GLint *values );
+        void       (WINE_GLAPI *p_glGetProgramStringARB)( GLenum target, GLenum pname, void *string );
+        void       (WINE_GLAPI *p_glGetProgramStringNV)( GLuint id, GLenum pname, GLubyte *program );
+        void       (WINE_GLAPI *p_glGetProgramSubroutineParameteruivNV)( GLenum target, GLuint index, GLuint *param );
+        void       (WINE_GLAPI *p_glGetProgramiv)( GLuint program, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetProgramivARB)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetProgramivNV)( GLuint id, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetQueryBufferObjecti64v)( GLuint id, GLuint buffer, GLenum pname, GLintptr offset );
+        void       (WINE_GLAPI *p_glGetQueryBufferObjectiv)( GLuint id, GLuint buffer, GLenum pname, GLintptr offset );
+        void       (WINE_GLAPI *p_glGetQueryBufferObjectui64v)( GLuint id, GLuint buffer, GLenum pname, GLintptr offset );
+        void       (WINE_GLAPI *p_glGetQueryBufferObjectuiv)( GLuint id, GLuint buffer, GLenum pname, GLintptr offset );
+        void       (WINE_GLAPI *p_glGetQueryIndexediv)( GLenum target, GLuint index, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetQueryObjecti64v)( GLuint id, GLenum pname, GLint64 *params );
+        void       (WINE_GLAPI *p_glGetQueryObjecti64vEXT)( GLuint id, GLenum pname, GLint64 *params );
+        void       (WINE_GLAPI *p_glGetQueryObjectiv)( GLuint id, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetQueryObjectivARB)( GLuint id, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetQueryObjectui64v)( GLuint id, GLenum pname, GLuint64 *params );
+        void       (WINE_GLAPI *p_glGetQueryObjectui64vEXT)( GLuint id, GLenum pname, GLuint64 *params );
+        void       (WINE_GLAPI *p_glGetQueryObjectuiv)( GLuint id, GLenum pname, GLuint *params );
+        void       (WINE_GLAPI *p_glGetQueryObjectuivARB)( GLuint id, GLenum pname, GLuint *params );
+        void       (WINE_GLAPI *p_glGetQueryiv)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetQueryivARB)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetRenderbufferParameteriv)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetRenderbufferParameterivEXT)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetSamplerParameterIiv)( GLuint sampler, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetSamplerParameterIuiv)( GLuint sampler, GLenum pname, GLuint *params );
+        void       (WINE_GLAPI *p_glGetSamplerParameterfv)( GLuint sampler, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetSamplerParameteriv)( GLuint sampler, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetSemaphoreParameterui64vEXT)( GLuint semaphore, GLenum pname, GLuint64 *params );
+        void       (WINE_GLAPI *p_glGetSeparableFilter)( GLenum target, GLenum format, GLenum type, void *row, void *column, void *span );
+        void       (WINE_GLAPI *p_glGetSeparableFilterEXT)( GLenum target, GLenum format, GLenum type, void *row, void *column, void *span );
+        void       (WINE_GLAPI *p_glGetShaderInfoLog)( GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog );
+        void       (WINE_GLAPI *p_glGetShaderPrecisionFormat)( GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision );
+        void       (WINE_GLAPI *p_glGetShaderSource)( GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source );
+        void       (WINE_GLAPI *p_glGetShaderSourceARB)( GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *source );
+        void       (WINE_GLAPI *p_glGetShaderiv)( GLuint shader, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetSharpenTexFuncSGIS)( GLenum target, GLfloat *points );
+        GLushort   (WINE_GLAPI *p_glGetStageIndexNV)( GLenum shadertype );
+        const GLubyte * (WINE_GLAPI *p_glGetStringi)( GLenum name, GLuint index );
+        GLuint     (WINE_GLAPI *p_glGetSubroutineIndex)( GLuint program, GLenum shadertype, const GLchar *name );
+        GLint      (WINE_GLAPI *p_glGetSubroutineUniformLocation)( GLuint program, GLenum shadertype, const GLchar *name );
+        void       (WINE_GLAPI *p_glGetSynciv)( GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values );
+        void       (WINE_GLAPI *p_glGetTexBumpParameterfvATI)( GLenum pname, GLfloat *param );
+        void       (WINE_GLAPI *p_glGetTexBumpParameterivATI)( GLenum pname, GLint *param );
+        void       (WINE_GLAPI *p_glGetTexEnvxvOES)( GLenum target, GLenum pname, GLfixed *params );
+        void       (WINE_GLAPI *p_glGetTexFilterFuncSGIS)( GLenum target, GLenum filter, GLfloat *weights );
+        void       (WINE_GLAPI *p_glGetTexGenxvOES)( GLenum coord, GLenum pname, GLfixed *params );
+        void       (WINE_GLAPI *p_glGetTexLevelParameterxvOES)( GLenum target, GLint level, GLenum pname, GLfixed *params );
+        void       (WINE_GLAPI *p_glGetTexParameterIiv)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetTexParameterIivEXT)( GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetTexParameterIuiv)( GLenum target, GLenum pname, GLuint *params );
+        void       (WINE_GLAPI *p_glGetTexParameterIuivEXT)( GLenum target, GLenum pname, GLuint *params );
+        void       (WINE_GLAPI *p_glGetTexParameterPointervAPPLE)( GLenum target, GLenum pname, void **params );
+        void       (WINE_GLAPI *p_glGetTexParameterxvOES)( GLenum target, GLenum pname, GLfixed *params );
+        GLuint64   (WINE_GLAPI *p_glGetTextureHandleARB)( GLuint texture );
+        GLuint64   (WINE_GLAPI *p_glGetTextureHandleNV)( GLuint texture );
+        void       (WINE_GLAPI *p_glGetTextureImage)( GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels );
+        void       (WINE_GLAPI *p_glGetTextureImageEXT)( GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void *pixels );
+        void       (WINE_GLAPI *p_glGetTextureLevelParameterfv)( GLuint texture, GLint level, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetTextureLevelParameterfvEXT)( GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetTextureLevelParameteriv)( GLuint texture, GLint level, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetTextureLevelParameterivEXT)( GLuint texture, GLenum target, GLint level, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetTextureParameterIiv)( GLuint texture, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetTextureParameterIivEXT)( GLuint texture, GLenum target, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetTextureParameterIuiv)( GLuint texture, GLenum pname, GLuint *params );
+        void       (WINE_GLAPI *p_glGetTextureParameterIuivEXT)( GLuint texture, GLenum target, GLenum pname, GLuint *params );
+        void       (WINE_GLAPI *p_glGetTextureParameterfv)( GLuint texture, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetTextureParameterfvEXT)( GLuint texture, GLenum target, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetTextureParameteriv)( GLuint texture, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetTextureParameterivEXT)( GLuint texture, GLenum target, GLenum pname, GLint *params );
+        GLuint64   (WINE_GLAPI *p_glGetTextureSamplerHandleARB)( GLuint texture, GLuint sampler );
+        GLuint64   (WINE_GLAPI *p_glGetTextureSamplerHandleNV)( GLuint texture, GLuint sampler );
+        void       (WINE_GLAPI *p_glGetTextureSubImage)( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels );
+        void       (WINE_GLAPI *p_glGetTrackMatrixivNV)( GLenum target, GLuint address, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetTransformFeedbackVarying)( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name );
+        void       (WINE_GLAPI *p_glGetTransformFeedbackVaryingEXT)( GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name );
+        void       (WINE_GLAPI *p_glGetTransformFeedbackVaryingNV)( GLuint program, GLuint index, GLint *location );
+        void       (WINE_GLAPI *p_glGetTransformFeedbacki64_v)( GLuint xfb, GLenum pname, GLuint index, GLint64 *param );
+        void       (WINE_GLAPI *p_glGetTransformFeedbacki_v)( GLuint xfb, GLenum pname, GLuint index, GLint *param );
+        void       (WINE_GLAPI *p_glGetTransformFeedbackiv)( GLuint xfb, GLenum pname, GLint *param );
+        GLuint     (WINE_GLAPI *p_glGetUniformBlockIndex)( GLuint program, const GLchar *uniformBlockName );
+        GLint      (WINE_GLAPI *p_glGetUniformBufferSizeEXT)( GLuint program, GLint location );
+        void       (WINE_GLAPI *p_glGetUniformIndices)( GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices );
+        GLint      (WINE_GLAPI *p_glGetUniformLocation)( GLuint program, const GLchar *name );
+        GLint      (WINE_GLAPI *p_glGetUniformLocationARB)( GLhandleARB programObj, const GLcharARB *name );
+        GLintptr   (WINE_GLAPI *p_glGetUniformOffsetEXT)( GLuint program, GLint location );
+        void       (WINE_GLAPI *p_glGetUniformSubroutineuiv)( GLenum shadertype, GLint location, GLuint *params );
+        void       (WINE_GLAPI *p_glGetUniformdv)( GLuint program, GLint location, GLdouble *params );
+        void       (WINE_GLAPI *p_glGetUniformfv)( GLuint program, GLint location, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetUniformfvARB)( GLhandleARB programObj, GLint location, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetUniformi64vARB)( GLuint program, GLint location, GLint64 *params );
+        void       (WINE_GLAPI *p_glGetUniformi64vNV)( GLuint program, GLint location, GLint64EXT *params );
+        void       (WINE_GLAPI *p_glGetUniformiv)( GLuint program, GLint location, GLint *params );
+        void       (WINE_GLAPI *p_glGetUniformivARB)( GLhandleARB programObj, GLint location, GLint *params );
+        void       (WINE_GLAPI *p_glGetUniformui64vARB)( GLuint program, GLint location, GLuint64 *params );
+        void       (WINE_GLAPI *p_glGetUniformui64vNV)( GLuint program, GLint location, GLuint64EXT *params );
+        void       (WINE_GLAPI *p_glGetUniformuiv)( GLuint program, GLint location, GLuint *params );
+        void       (WINE_GLAPI *p_glGetUniformuivEXT)( GLuint program, GLint location, GLuint *params );
+        void       (WINE_GLAPI *p_glGetUnsignedBytei_vEXT)( GLenum target, GLuint index, GLubyte *data );
+        void       (WINE_GLAPI *p_glGetUnsignedBytevEXT)( GLenum pname, GLubyte *data );
+        void       (WINE_GLAPI *p_glGetVariantArrayObjectfvATI)( GLuint id, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetVariantArrayObjectivATI)( GLuint id, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetVariantBooleanvEXT)( GLuint id, GLenum value, GLboolean *data );
+        void       (WINE_GLAPI *p_glGetVariantFloatvEXT)( GLuint id, GLenum value, GLfloat *data );
+        void       (WINE_GLAPI *p_glGetVariantIntegervEXT)( GLuint id, GLenum value, GLint *data );
+        void       (WINE_GLAPI *p_glGetVariantPointervEXT)( GLuint id, GLenum value, void **data );
+        GLint      (WINE_GLAPI *p_glGetVaryingLocationNV)( GLuint program, const GLchar *name );
+        void       (WINE_GLAPI *p_glGetVertexArrayIndexed64iv)( GLuint vaobj, GLuint index, GLenum pname, GLint64 *param );
+        void       (WINE_GLAPI *p_glGetVertexArrayIndexediv)( GLuint vaobj, GLuint index, GLenum pname, GLint *param );
+        void       (WINE_GLAPI *p_glGetVertexArrayIntegeri_vEXT)( GLuint vaobj, GLuint index, GLenum pname, GLint *param );
+        void       (WINE_GLAPI *p_glGetVertexArrayIntegervEXT)( GLuint vaobj, GLenum pname, GLint *param );
+        void       (WINE_GLAPI *p_glGetVertexArrayPointeri_vEXT)( GLuint vaobj, GLuint index, GLenum pname, void **param );
+        void       (WINE_GLAPI *p_glGetVertexArrayPointervEXT)( GLuint vaobj, GLenum pname, void **param );
+        void       (WINE_GLAPI *p_glGetVertexArrayiv)( GLuint vaobj, GLenum pname, GLint *param );
+        void       (WINE_GLAPI *p_glGetVertexAttribArrayObjectfvATI)( GLuint index, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribArrayObjectivATI)( GLuint index, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribIiv)( GLuint index, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribIivEXT)( GLuint index, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribIuiv)( GLuint index, GLenum pname, GLuint *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribIuivEXT)( GLuint index, GLenum pname, GLuint *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribLdv)( GLuint index, GLenum pname, GLdouble *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribLdvEXT)( GLuint index, GLenum pname, GLdouble *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribLi64vNV)( GLuint index, GLenum pname, GLint64EXT *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribLui64vARB)( GLuint index, GLenum pname, GLuint64EXT *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribLui64vNV)( GLuint index, GLenum pname, GLuint64EXT *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribPointerv)( GLuint index, GLenum pname, void **pointer );
+        void       (WINE_GLAPI *p_glGetVertexAttribPointervARB)( GLuint index, GLenum pname, void **pointer );
+        void       (WINE_GLAPI *p_glGetVertexAttribPointervNV)( GLuint index, GLenum pname, void **pointer );
+        void       (WINE_GLAPI *p_glGetVertexAttribdv)( GLuint index, GLenum pname, GLdouble *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribdvARB)( GLuint index, GLenum pname, GLdouble *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribdvNV)( GLuint index, GLenum pname, GLdouble *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribfv)( GLuint index, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribfvARB)( GLuint index, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribfvNV)( GLuint index, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribiv)( GLuint index, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribivARB)( GLuint index, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetVertexAttribivNV)( GLuint index, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetVideoCaptureStreamdvNV)( GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble *params );
+        void       (WINE_GLAPI *p_glGetVideoCaptureStreamfvNV)( GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetVideoCaptureStreamivNV)( GLuint video_capture_slot, GLuint stream, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetVideoCaptureivNV)( GLuint video_capture_slot, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetVideoi64vNV)( GLuint video_slot, GLenum pname, GLint64EXT *params );
+        void       (WINE_GLAPI *p_glGetVideoivNV)( GLuint video_slot, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glGetVideoui64vNV)( GLuint video_slot, GLenum pname, GLuint64EXT *params );
+        void       (WINE_GLAPI *p_glGetVideouivNV)( GLuint video_slot, GLenum pname, GLuint *params );
+        void *     (WINE_GLAPI *p_glGetVkProcAddrNV)( const GLchar *name );
+        void       (WINE_GLAPI *p_glGetnColorTable)( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table );
+        void       (WINE_GLAPI *p_glGetnColorTableARB)( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table );
+        void       (WINE_GLAPI *p_glGetnCompressedTexImage)( GLenum target, GLint lod, GLsizei bufSize, void *pixels );
+        void       (WINE_GLAPI *p_glGetnCompressedTexImageARB)( GLenum target, GLint lod, GLsizei bufSize, void *img );
+        void       (WINE_GLAPI *p_glGetnConvolutionFilter)( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image );
+        void       (WINE_GLAPI *p_glGetnConvolutionFilterARB)( GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image );
+        void       (WINE_GLAPI *p_glGetnHistogram)( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values );
+        void       (WINE_GLAPI *p_glGetnHistogramARB)( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values );
+        void       (WINE_GLAPI *p_glGetnMapdv)( GLenum target, GLenum query, GLsizei bufSize, GLdouble *v );
+        void       (WINE_GLAPI *p_glGetnMapdvARB)( GLenum target, GLenum query, GLsizei bufSize, GLdouble *v );
+        void       (WINE_GLAPI *p_glGetnMapfv)( GLenum target, GLenum query, GLsizei bufSize, GLfloat *v );
+        void       (WINE_GLAPI *p_glGetnMapfvARB)( GLenum target, GLenum query, GLsizei bufSize, GLfloat *v );
+        void       (WINE_GLAPI *p_glGetnMapiv)( GLenum target, GLenum query, GLsizei bufSize, GLint *v );
+        void       (WINE_GLAPI *p_glGetnMapivARB)( GLenum target, GLenum query, GLsizei bufSize, GLint *v );
+        void       (WINE_GLAPI *p_glGetnMinmax)( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values );
+        void       (WINE_GLAPI *p_glGetnMinmaxARB)( GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values );
+        void       (WINE_GLAPI *p_glGetnPixelMapfv)( GLenum map, GLsizei bufSize, GLfloat *values );
+        void       (WINE_GLAPI *p_glGetnPixelMapfvARB)( GLenum map, GLsizei bufSize, GLfloat *values );
+        void       (WINE_GLAPI *p_glGetnPixelMapuiv)( GLenum map, GLsizei bufSize, GLuint *values );
+        void       (WINE_GLAPI *p_glGetnPixelMapuivARB)( GLenum map, GLsizei bufSize, GLuint *values );
+        void       (WINE_GLAPI *p_glGetnPixelMapusv)( GLenum map, GLsizei bufSize, GLushort *values );
+        void       (WINE_GLAPI *p_glGetnPixelMapusvARB)( GLenum map, GLsizei bufSize, GLushort *values );
+        void       (WINE_GLAPI *p_glGetnPolygonStipple)( GLsizei bufSize, GLubyte *pattern );
+        void       (WINE_GLAPI *p_glGetnPolygonStippleARB)( GLsizei bufSize, GLubyte *pattern );
+        void       (WINE_GLAPI *p_glGetnSeparableFilter)( GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void *row, GLsizei columnBufSize, void *column, void *span );
+        void       (WINE_GLAPI *p_glGetnSeparableFilterARB)( GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void *row, GLsizei columnBufSize, void *column, void *span );
+        void       (WINE_GLAPI *p_glGetnTexImage)( GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels );
+        void       (WINE_GLAPI *p_glGetnTexImageARB)( GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *img );
+        void       (WINE_GLAPI *p_glGetnUniformdv)( GLuint program, GLint location, GLsizei bufSize, GLdouble *params );
+        void       (WINE_GLAPI *p_glGetnUniformdvARB)( GLuint program, GLint location, GLsizei bufSize, GLdouble *params );
+        void       (WINE_GLAPI *p_glGetnUniformfv)( GLuint program, GLint location, GLsizei bufSize, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetnUniformfvARB)( GLuint program, GLint location, GLsizei bufSize, GLfloat *params );
+        void       (WINE_GLAPI *p_glGetnUniformi64vARB)( GLuint program, GLint location, GLsizei bufSize, GLint64 *params );
+        void       (WINE_GLAPI *p_glGetnUniformiv)( GLuint program, GLint location, GLsizei bufSize, GLint *params );
+        void       (WINE_GLAPI *p_glGetnUniformivARB)( GLuint program, GLint location, GLsizei bufSize, GLint *params );
+        void       (WINE_GLAPI *p_glGetnUniformui64vARB)( GLuint program, GLint location, GLsizei bufSize, GLuint64 *params );
+        void       (WINE_GLAPI *p_glGetnUniformuiv)( GLuint program, GLint location, GLsizei bufSize, GLuint *params );
+        void       (WINE_GLAPI *p_glGetnUniformuivARB)( GLuint program, GLint location, GLsizei bufSize, GLuint *params );
+        void       (WINE_GLAPI *p_glGlobalAlphaFactorbSUN)( GLbyte factor );
+        void       (WINE_GLAPI *p_glGlobalAlphaFactordSUN)( GLdouble factor );
+        void       (WINE_GLAPI *p_glGlobalAlphaFactorfSUN)( GLfloat factor );
+        void       (WINE_GLAPI *p_glGlobalAlphaFactoriSUN)( GLint factor );
+        void       (WINE_GLAPI *p_glGlobalAlphaFactorsSUN)( GLshort factor );
+        void       (WINE_GLAPI *p_glGlobalAlphaFactorubSUN)( GLubyte factor );
+        void       (WINE_GLAPI *p_glGlobalAlphaFactoruiSUN)( GLuint factor );
+        void       (WINE_GLAPI *p_glGlobalAlphaFactorusSUN)( GLushort factor );
+        void       (WINE_GLAPI *p_glHintPGI)( GLenum target, GLint mode );
+        void       (WINE_GLAPI *p_glHistogram)( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink );
+        void       (WINE_GLAPI *p_glHistogramEXT)( GLenum target, GLsizei width, GLenum internalformat, GLboolean sink );
+        void       (WINE_GLAPI *p_glIglooInterfaceSGIX)( GLenum pname, const void *params );
+        void       (WINE_GLAPI *p_glImageTransformParameterfHP)( GLenum target, GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glImageTransformParameterfvHP)( GLenum target, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glImageTransformParameteriHP)( GLenum target, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glImageTransformParameterivHP)( GLenum target, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glImportMemoryFdEXT)( GLuint memory, GLuint64 size, GLenum handleType, GLint fd );
+        void       (WINE_GLAPI *p_glImportMemoryWin32HandleEXT)( GLuint memory, GLuint64 size, GLenum handleType, void *handle );
+        void       (WINE_GLAPI *p_glImportMemoryWin32NameEXT)( GLuint memory, GLuint64 size, GLenum handleType, const void *name );
+        void       (WINE_GLAPI *p_glImportSemaphoreFdEXT)( GLuint semaphore, GLenum handleType, GLint fd );
+        void       (WINE_GLAPI *p_glImportSemaphoreWin32HandleEXT)( GLuint semaphore, GLenum handleType, void *handle );
+        void       (WINE_GLAPI *p_glImportSemaphoreWin32NameEXT)( GLuint semaphore, GLenum handleType, const void *name );
+        GLsync     (WINE_GLAPI *p_glImportSyncEXT)( GLenum external_sync_type, GLintptr external_sync, GLbitfield flags );
+        void       (WINE_GLAPI *p_glIndexFormatNV)( GLenum type, GLsizei stride );
+        void       (WINE_GLAPI *p_glIndexFuncEXT)( GLenum func, GLclampf ref );
+        void       (WINE_GLAPI *p_glIndexMaterialEXT)( GLenum face, GLenum mode );
+        void       (WINE_GLAPI *p_glIndexPointerEXT)( GLenum type, GLsizei stride, GLsizei count, const void *pointer );
+        void       (WINE_GLAPI *p_glIndexPointerListIBM)( GLenum type, GLint stride, const void **pointer, GLint ptrstride );
+        void       (WINE_GLAPI *p_glIndexxOES)( GLfixed component );
+        void       (WINE_GLAPI *p_glIndexxvOES)( const GLfixed *component );
+        void       (WINE_GLAPI *p_glInsertComponentEXT)( GLuint res, GLuint src, GLuint num );
+        void       (WINE_GLAPI *p_glInsertEventMarkerEXT)( GLsizei length, const GLchar *marker );
+        void       (WINE_GLAPI *p_glInstrumentsBufferSGIX)( GLsizei size, GLint *buffer );
+        void       (WINE_GLAPI *p_glInterpolatePathsNV)( GLuint resultPath, GLuint pathA, GLuint pathB, GLfloat weight );
+        void       (WINE_GLAPI *p_glInvalidateBufferData)( GLuint buffer );
+        void       (WINE_GLAPI *p_glInvalidateBufferSubData)( GLuint buffer, GLintptr offset, GLsizeiptr length );
+        void       (WINE_GLAPI *p_glInvalidateFramebuffer)( GLenum target, GLsizei numAttachments, const GLenum *attachments );
+        void       (WINE_GLAPI *p_glInvalidateNamedFramebufferData)( GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments );
+        void       (WINE_GLAPI *p_glInvalidateNamedFramebufferSubData)( GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glInvalidateSubFramebuffer)( GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glInvalidateTexImage)( GLuint texture, GLint level );
+        void       (WINE_GLAPI *p_glInvalidateTexSubImage)( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth );
+        GLboolean  (WINE_GLAPI *p_glIsAsyncMarkerSGIX)( GLuint marker );
+        GLboolean  (WINE_GLAPI *p_glIsBuffer)( GLuint buffer );
+        GLboolean  (WINE_GLAPI *p_glIsBufferARB)( GLuint buffer );
+        GLboolean  (WINE_GLAPI *p_glIsBufferResidentNV)( GLenum target );
+        GLboolean  (WINE_GLAPI *p_glIsCommandListNV)( GLuint list );
+        GLboolean  (WINE_GLAPI *p_glIsEnabledIndexedEXT)( GLenum target, GLuint index );
+        GLboolean  (WINE_GLAPI *p_glIsEnabledi)( GLenum target, GLuint index );
+        GLboolean  (WINE_GLAPI *p_glIsFenceAPPLE)( GLuint fence );
+        GLboolean  (WINE_GLAPI *p_glIsFenceNV)( GLuint fence );
+        GLboolean  (WINE_GLAPI *p_glIsFramebuffer)( GLuint framebuffer );
+        GLboolean  (WINE_GLAPI *p_glIsFramebufferEXT)( GLuint framebuffer );
+        GLboolean  (WINE_GLAPI *p_glIsImageHandleResidentARB)( GLuint64 handle );
+        GLboolean  (WINE_GLAPI *p_glIsImageHandleResidentNV)( GLuint64 handle );
+        GLboolean  (WINE_GLAPI *p_glIsMemoryObjectEXT)( GLuint memoryObject );
+        GLboolean  (WINE_GLAPI *p_glIsNameAMD)( GLenum identifier, GLuint name );
+        GLboolean  (WINE_GLAPI *p_glIsNamedBufferResidentNV)( GLuint buffer );
+        GLboolean  (WINE_GLAPI *p_glIsNamedStringARB)( GLint namelen, const GLchar *name );
+        GLboolean  (WINE_GLAPI *p_glIsObjectBufferATI)( GLuint buffer );
+        GLboolean  (WINE_GLAPI *p_glIsOcclusionQueryNV)( GLuint id );
+        GLboolean  (WINE_GLAPI *p_glIsPathNV)( GLuint path );
+        GLboolean  (WINE_GLAPI *p_glIsPointInFillPathNV)( GLuint path, GLuint mask, GLfloat x, GLfloat y );
+        GLboolean  (WINE_GLAPI *p_glIsPointInStrokePathNV)( GLuint path, GLfloat x, GLfloat y );
+        GLboolean  (WINE_GLAPI *p_glIsProgram)( GLuint program );
+        GLboolean  (WINE_GLAPI *p_glIsProgramARB)( GLuint program );
+        GLboolean  (WINE_GLAPI *p_glIsProgramNV)( GLuint id );
+        GLboolean  (WINE_GLAPI *p_glIsProgramPipeline)( GLuint pipeline );
+        GLboolean  (WINE_GLAPI *p_glIsQuery)( GLuint id );
+        GLboolean  (WINE_GLAPI *p_glIsQueryARB)( GLuint id );
+        GLboolean  (WINE_GLAPI *p_glIsRenderbuffer)( GLuint renderbuffer );
+        GLboolean  (WINE_GLAPI *p_glIsRenderbufferEXT)( GLuint renderbuffer );
+        GLboolean  (WINE_GLAPI *p_glIsSampler)( GLuint sampler );
+        GLboolean  (WINE_GLAPI *p_glIsSemaphoreEXT)( GLuint semaphore );
+        GLboolean  (WINE_GLAPI *p_glIsShader)( GLuint shader );
+        GLboolean  (WINE_GLAPI *p_glIsStateNV)( GLuint state );
+        GLboolean  (WINE_GLAPI *p_glIsSync)( GLsync sync );
+        GLboolean  (WINE_GLAPI *p_glIsTextureEXT)( GLuint texture );
+        GLboolean  (WINE_GLAPI *p_glIsTextureHandleResidentARB)( GLuint64 handle );
+        GLboolean  (WINE_GLAPI *p_glIsTextureHandleResidentNV)( GLuint64 handle );
+        GLboolean  (WINE_GLAPI *p_glIsTransformFeedback)( GLuint id );
+        GLboolean  (WINE_GLAPI *p_glIsTransformFeedbackNV)( GLuint id );
+        GLboolean  (WINE_GLAPI *p_glIsVariantEnabledEXT)( GLuint id, GLenum cap );
+        GLboolean  (WINE_GLAPI *p_glIsVertexArray)( GLuint array );
+        GLboolean  (WINE_GLAPI *p_glIsVertexArrayAPPLE)( GLuint array );
+        GLboolean  (WINE_GLAPI *p_glIsVertexAttribEnabledAPPLE)( GLuint index, GLenum pname );
+        void       (WINE_GLAPI *p_glLGPUCopyImageSubDataNVX)( GLuint sourceGpu, GLbitfield destinationGpuMask, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srxY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth );
         void       (WINE_GLAPI *p_glLGPUInterlockNVX)(void);
-        void       (WINE_GLAPI *p_glLGPUNamedBufferSubDataNVX)(GLbitfield,GLuint,GLintptr,GLsizeiptr,const void*);
-        void       (WINE_GLAPI *p_glLabelObjectEXT)(GLenum,GLuint,GLsizei,const GLchar*);
-        void       (WINE_GLAPI *p_glLightEnviSGIX)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glLightModelxOES)(GLenum,GLfixed);
-        void       (WINE_GLAPI *p_glLightModelxvOES)(GLenum,const GLfixed*);
-        void       (WINE_GLAPI *p_glLightxOES)(GLenum,GLenum,GLfixed);
-        void       (WINE_GLAPI *p_glLightxvOES)(GLenum,GLenum,const GLfixed*);
-        void       (WINE_GLAPI *p_glLineWidthxOES)(GLfixed);
-        void       (WINE_GLAPI *p_glLinkProgram)(GLuint);
-        void       (WINE_GLAPI *p_glLinkProgramARB)(GLhandleARB);
-        void       (WINE_GLAPI *p_glListDrawCommandsStatesClientNV)(GLuint,GLuint,const void**,const GLsizei*,const GLuint*,const GLuint*,GLuint);
-        void       (WINE_GLAPI *p_glListParameterfSGIX)(GLuint,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glListParameterfvSGIX)(GLuint,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glListParameteriSGIX)(GLuint,GLenum,GLint);
-        void       (WINE_GLAPI *p_glListParameterivSGIX)(GLuint,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glLoadIdentityDeformationMapSGIX)(GLbitfield);
-        void       (WINE_GLAPI *p_glLoadMatrixxOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glLoadProgramNV)(GLenum,GLuint,GLsizei,const GLubyte*);
-        void       (WINE_GLAPI *p_glLoadTransposeMatrixd)(const GLdouble*);
-        void       (WINE_GLAPI *p_glLoadTransposeMatrixdARB)(const GLdouble*);
-        void       (WINE_GLAPI *p_glLoadTransposeMatrixf)(const GLfloat*);
-        void       (WINE_GLAPI *p_glLoadTransposeMatrixfARB)(const GLfloat*);
-        void       (WINE_GLAPI *p_glLoadTransposeMatrixxOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glLockArraysEXT)(GLint,GLsizei);
-        void       (WINE_GLAPI *p_glMTexCoord2fSGIS)(GLenum,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glMTexCoord2fvSGIS)(GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glMakeBufferNonResidentNV)(GLenum);
-        void       (WINE_GLAPI *p_glMakeBufferResidentNV)(GLenum,GLenum);
-        void       (WINE_GLAPI *p_glMakeImageHandleNonResidentARB)(GLuint64);
-        void       (WINE_GLAPI *p_glMakeImageHandleNonResidentNV)(GLuint64);
-        void       (WINE_GLAPI *p_glMakeImageHandleResidentARB)(GLuint64,GLenum);
-        void       (WINE_GLAPI *p_glMakeImageHandleResidentNV)(GLuint64,GLenum);
-        void       (WINE_GLAPI *p_glMakeNamedBufferNonResidentNV)(GLuint);
-        void       (WINE_GLAPI *p_glMakeNamedBufferResidentNV)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glMakeTextureHandleNonResidentARB)(GLuint64);
-        void       (WINE_GLAPI *p_glMakeTextureHandleNonResidentNV)(GLuint64);
-        void       (WINE_GLAPI *p_glMakeTextureHandleResidentARB)(GLuint64);
-        void       (WINE_GLAPI *p_glMakeTextureHandleResidentNV)(GLuint64);
-        void       (WINE_GLAPI *p_glMap1xOES)(GLenum,GLfixed,GLfixed,GLint,GLint,GLfixed);
-        void       (WINE_GLAPI *p_glMap2xOES)(GLenum,GLfixed,GLfixed,GLint,GLint,GLfixed,GLfixed,GLint,GLint,GLfixed);
-        void*      (WINE_GLAPI *p_glMapBuffer)(GLenum,GLenum);
-        void*      (WINE_GLAPI *p_glMapBufferARB)(GLenum,GLenum);
-        void*      (WINE_GLAPI *p_glMapBufferRange)(GLenum,GLintptr,GLsizeiptr,GLbitfield);
-        void       (WINE_GLAPI *p_glMapControlPointsNV)(GLenum,GLuint,GLenum,GLsizei,GLsizei,GLint,GLint,GLboolean,const void*);
-        void       (WINE_GLAPI *p_glMapGrid1xOES)(GLint,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glMapGrid2xOES)(GLint,GLfixed,GLfixed,GLfixed,GLfixed);
-        void*      (WINE_GLAPI *p_glMapNamedBuffer)(GLuint,GLenum);
-        void*      (WINE_GLAPI *p_glMapNamedBufferEXT)(GLuint,GLenum);
-        void*      (WINE_GLAPI *p_glMapNamedBufferRange)(GLuint,GLintptr,GLsizeiptr,GLbitfield);
-        void*      (WINE_GLAPI *p_glMapNamedBufferRangeEXT)(GLuint,GLintptr,GLsizeiptr,GLbitfield);
-        void*      (WINE_GLAPI *p_glMapObjectBufferATI)(GLuint);
-        void       (WINE_GLAPI *p_glMapParameterfvNV)(GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMapParameterivNV)(GLenum,GLenum,const GLint*);
-        void*      (WINE_GLAPI *p_glMapTexture2DINTEL)(GLuint,GLint,GLbitfield,GLint*,GLenum*);
-        void       (WINE_GLAPI *p_glMapVertexAttrib1dAPPLE)(GLuint,GLuint,GLdouble,GLdouble,GLint,GLint,const GLdouble*);
-        void       (WINE_GLAPI *p_glMapVertexAttrib1fAPPLE)(GLuint,GLuint,GLfloat,GLfloat,GLint,GLint,const GLfloat*);
-        void       (WINE_GLAPI *p_glMapVertexAttrib2dAPPLE)(GLuint,GLuint,GLdouble,GLdouble,GLint,GLint,GLdouble,GLdouble,GLint,GLint,const GLdouble*);
-        void       (WINE_GLAPI *p_glMapVertexAttrib2fAPPLE)(GLuint,GLuint,GLfloat,GLfloat,GLint,GLint,GLfloat,GLfloat,GLint,GLint,const GLfloat*);
-        void       (WINE_GLAPI *p_glMaterialxOES)(GLenum,GLenum,GLfixed);
-        void       (WINE_GLAPI *p_glMaterialxvOES)(GLenum,GLenum,const GLfixed*);
-        void       (WINE_GLAPI *p_glMatrixFrustumEXT)(GLenum,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glMatrixIndexPointerARB)(GLint,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glMatrixIndexubvARB)(GLint,const GLubyte*);
-        void       (WINE_GLAPI *p_glMatrixIndexuivARB)(GLint,const GLuint*);
-        void       (WINE_GLAPI *p_glMatrixIndexusvARB)(GLint,const GLushort*);
-        void       (WINE_GLAPI *p_glMatrixLoad3x2fNV)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMatrixLoad3x3fNV)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMatrixLoadIdentityEXT)(GLenum);
-        void       (WINE_GLAPI *p_glMatrixLoadTranspose3x3fNV)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMatrixLoadTransposedEXT)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glMatrixLoadTransposefEXT)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMatrixLoaddEXT)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glMatrixLoadfEXT)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMatrixMult3x2fNV)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMatrixMult3x3fNV)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMatrixMultTranspose3x3fNV)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMatrixMultTransposedEXT)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glMatrixMultTransposefEXT)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMatrixMultdEXT)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glMatrixMultfEXT)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMatrixOrthoEXT)(GLenum,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glMatrixPopEXT)(GLenum);
-        void       (WINE_GLAPI *p_glMatrixPushEXT)(GLenum);
-        void       (WINE_GLAPI *p_glMatrixRotatedEXT)(GLenum,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glMatrixRotatefEXT)(GLenum,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glMatrixScaledEXT)(GLenum,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glMatrixScalefEXT)(GLenum,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glMatrixTranslatedEXT)(GLenum,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glMatrixTranslatefEXT)(GLenum,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glMaxShaderCompilerThreadsARB)(GLuint);
-        void       (WINE_GLAPI *p_glMaxShaderCompilerThreadsKHR)(GLuint);
-        void       (WINE_GLAPI *p_glMemoryBarrier)(GLbitfield);
-        void       (WINE_GLAPI *p_glMemoryBarrierByRegion)(GLbitfield);
-        void       (WINE_GLAPI *p_glMemoryBarrierEXT)(GLbitfield);
-        void       (WINE_GLAPI *p_glMemoryObjectParameterivEXT)(GLuint,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glMinSampleShading)(GLfloat);
-        void       (WINE_GLAPI *p_glMinSampleShadingARB)(GLfloat);
-        void       (WINE_GLAPI *p_glMinmax)(GLenum,GLenum,GLboolean);
-        void       (WINE_GLAPI *p_glMinmaxEXT)(GLenum,GLenum,GLboolean);
-        void       (WINE_GLAPI *p_glMultMatrixxOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glMultTransposeMatrixd)(const GLdouble*);
-        void       (WINE_GLAPI *p_glMultTransposeMatrixdARB)(const GLdouble*);
-        void       (WINE_GLAPI *p_glMultTransposeMatrixf)(const GLfloat*);
-        void       (WINE_GLAPI *p_glMultTransposeMatrixfARB)(const GLfloat*);
-        void       (WINE_GLAPI *p_glMultTransposeMatrixxOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glMultiDrawArrays)(GLenum,const GLint*,const GLsizei*,GLsizei);
-        void       (WINE_GLAPI *p_glMultiDrawArraysEXT)(GLenum,const GLint*,const GLsizei*,GLsizei);
-        void       (WINE_GLAPI *p_glMultiDrawArraysIndirect)(GLenum,const void*,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glMultiDrawArraysIndirectAMD)(GLenum,const void*,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glMultiDrawArraysIndirectBindlessCountNV)(GLenum,const void*,GLsizei,GLsizei,GLsizei,GLint);
-        void       (WINE_GLAPI *p_glMultiDrawArraysIndirectBindlessNV)(GLenum,const void*,GLsizei,GLsizei,GLint);
-        void       (WINE_GLAPI *p_glMultiDrawArraysIndirectCount)(GLenum,const void*,GLintptr,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glMultiDrawArraysIndirectCountARB)(GLenum,const void*,GLintptr,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glMultiDrawElementArrayAPPLE)(GLenum,const GLint*,const GLsizei*,GLsizei);
-        void       (WINE_GLAPI *p_glMultiDrawElements)(GLenum,const GLsizei*,GLenum,const void*const*,GLsizei);
-        void       (WINE_GLAPI *p_glMultiDrawElementsBaseVertex)(GLenum,const GLsizei*,GLenum,const void*const*,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glMultiDrawElementsEXT)(GLenum,const GLsizei*,GLenum,const void*const*,GLsizei);
-        void       (WINE_GLAPI *p_glMultiDrawElementsIndirect)(GLenum,GLenum,const void*,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glMultiDrawElementsIndirectAMD)(GLenum,GLenum,const void*,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glMultiDrawElementsIndirectBindlessCountNV)(GLenum,GLenum,const void*,GLsizei,GLsizei,GLsizei,GLint);
-        void       (WINE_GLAPI *p_glMultiDrawElementsIndirectBindlessNV)(GLenum,GLenum,const void*,GLsizei,GLsizei,GLint);
-        void       (WINE_GLAPI *p_glMultiDrawElementsIndirectCount)(GLenum,GLenum,const void*,GLintptr,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glMultiDrawElementsIndirectCountARB)(GLenum,GLenum,const void*,GLintptr,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glMultiDrawRangeElementArrayAPPLE)(GLenum,GLuint,GLuint,const GLint*,const GLsizei*,GLsizei);
-        void       (WINE_GLAPI *p_glMultiModeDrawArraysIBM)(const GLenum*,const GLint*,const GLsizei*,GLsizei,GLint);
-        void       (WINE_GLAPI *p_glMultiModeDrawElementsIBM)(const GLenum*,const GLsizei*,GLenum,const void*const*,GLsizei,GLint);
-        void       (WINE_GLAPI *p_glMultiTexBufferEXT)(GLenum,GLenum,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glMultiTexCoord1bOES)(GLenum,GLbyte);
-        void       (WINE_GLAPI *p_glMultiTexCoord1bvOES)(GLenum,const GLbyte*);
-        void       (WINE_GLAPI *p_glMultiTexCoord1d)(GLenum,GLdouble);
-        void       (WINE_GLAPI *p_glMultiTexCoord1dARB)(GLenum,GLdouble);
-        void       (WINE_GLAPI *p_glMultiTexCoord1dSGIS)(GLenum,GLdouble);
-        void       (WINE_GLAPI *p_glMultiTexCoord1dv)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glMultiTexCoord1dvARB)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glMultiTexCoord1dvSGIS)(GLenum,GLdouble*);
-        void       (WINE_GLAPI *p_glMultiTexCoord1f)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glMultiTexCoord1fARB)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glMultiTexCoord1fSGIS)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glMultiTexCoord1fv)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMultiTexCoord1fvARB)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMultiTexCoord1fvSGIS)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMultiTexCoord1hNV)(GLenum,GLhalfNV);
-        void       (WINE_GLAPI *p_glMultiTexCoord1hvNV)(GLenum,const GLhalfNV*);
-        void       (WINE_GLAPI *p_glMultiTexCoord1i)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glMultiTexCoord1iARB)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glMultiTexCoord1iSGIS)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glMultiTexCoord1iv)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glMultiTexCoord1ivARB)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glMultiTexCoord1ivSGIS)(GLenum,GLint*);
-        void       (WINE_GLAPI *p_glMultiTexCoord1s)(GLenum,GLshort);
-        void       (WINE_GLAPI *p_glMultiTexCoord1sARB)(GLenum,GLshort);
-        void       (WINE_GLAPI *p_glMultiTexCoord1sSGIS)(GLenum,GLshort);
-        void       (WINE_GLAPI *p_glMultiTexCoord1sv)(GLenum,const GLshort*);
-        void       (WINE_GLAPI *p_glMultiTexCoord1svARB)(GLenum,const GLshort*);
-        void       (WINE_GLAPI *p_glMultiTexCoord1svSGIS)(GLenum,GLshort*);
-        void       (WINE_GLAPI *p_glMultiTexCoord1xOES)(GLenum,GLfixed);
-        void       (WINE_GLAPI *p_glMultiTexCoord1xvOES)(GLenum,const GLfixed*);
-        void       (WINE_GLAPI *p_glMultiTexCoord2bOES)(GLenum,GLbyte,GLbyte);
-        void       (WINE_GLAPI *p_glMultiTexCoord2bvOES)(GLenum,const GLbyte*);
-        void       (WINE_GLAPI *p_glMultiTexCoord2d)(GLenum,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glMultiTexCoord2dARB)(GLenum,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glMultiTexCoord2dSGIS)(GLenum,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glMultiTexCoord2dv)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glMultiTexCoord2dvARB)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glMultiTexCoord2dvSGIS)(GLenum,GLdouble*);
-        void       (WINE_GLAPI *p_glMultiTexCoord2f)(GLenum,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glMultiTexCoord2fARB)(GLenum,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glMultiTexCoord2fSGIS)(GLenum,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glMultiTexCoord2fv)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMultiTexCoord2fvARB)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMultiTexCoord2fvSGIS)(GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glMultiTexCoord2hNV)(GLenum,GLhalfNV,GLhalfNV);
-        void       (WINE_GLAPI *p_glMultiTexCoord2hvNV)(GLenum,const GLhalfNV*);
-        void       (WINE_GLAPI *p_glMultiTexCoord2i)(GLenum,GLint,GLint);
-        void       (WINE_GLAPI *p_glMultiTexCoord2iARB)(GLenum,GLint,GLint);
-        void       (WINE_GLAPI *p_glMultiTexCoord2iSGIS)(GLenum,GLint,GLint);
-        void       (WINE_GLAPI *p_glMultiTexCoord2iv)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glMultiTexCoord2ivARB)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glMultiTexCoord2ivSGIS)(GLenum,GLint*);
-        void       (WINE_GLAPI *p_glMultiTexCoord2s)(GLenum,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glMultiTexCoord2sARB)(GLenum,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glMultiTexCoord2sSGIS)(GLenum,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glMultiTexCoord2sv)(GLenum,const GLshort*);
-        void       (WINE_GLAPI *p_glMultiTexCoord2svARB)(GLenum,const GLshort*);
-        void       (WINE_GLAPI *p_glMultiTexCoord2svSGIS)(GLenum,GLshort*);
-        void       (WINE_GLAPI *p_glMultiTexCoord2xOES)(GLenum,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glMultiTexCoord2xvOES)(GLenum,const GLfixed*);
-        void       (WINE_GLAPI *p_glMultiTexCoord3bOES)(GLenum,GLbyte,GLbyte,GLbyte);
-        void       (WINE_GLAPI *p_glMultiTexCoord3bvOES)(GLenum,const GLbyte*);
-        void       (WINE_GLAPI *p_glMultiTexCoord3d)(GLenum,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glMultiTexCoord3dARB)(GLenum,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glMultiTexCoord3dSGIS)(GLenum,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glMultiTexCoord3dv)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glMultiTexCoord3dvARB)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glMultiTexCoord3dvSGIS)(GLenum,GLdouble*);
-        void       (WINE_GLAPI *p_glMultiTexCoord3f)(GLenum,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glMultiTexCoord3fARB)(GLenum,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glMultiTexCoord3fSGIS)(GLenum,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glMultiTexCoord3fv)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMultiTexCoord3fvARB)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMultiTexCoord3fvSGIS)(GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glMultiTexCoord3hNV)(GLenum,GLhalfNV,GLhalfNV,GLhalfNV);
-        void       (WINE_GLAPI *p_glMultiTexCoord3hvNV)(GLenum,const GLhalfNV*);
-        void       (WINE_GLAPI *p_glMultiTexCoord3i)(GLenum,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glMultiTexCoord3iARB)(GLenum,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glMultiTexCoord3iSGIS)(GLenum,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glMultiTexCoord3iv)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glMultiTexCoord3ivARB)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glMultiTexCoord3ivSGIS)(GLenum,GLint*);
-        void       (WINE_GLAPI *p_glMultiTexCoord3s)(GLenum,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glMultiTexCoord3sARB)(GLenum,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glMultiTexCoord3sSGIS)(GLenum,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glMultiTexCoord3sv)(GLenum,const GLshort*);
-        void       (WINE_GLAPI *p_glMultiTexCoord3svARB)(GLenum,const GLshort*);
-        void       (WINE_GLAPI *p_glMultiTexCoord3svSGIS)(GLenum,GLshort*);
-        void       (WINE_GLAPI *p_glMultiTexCoord3xOES)(GLenum,GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glMultiTexCoord3xvOES)(GLenum,const GLfixed*);
-        void       (WINE_GLAPI *p_glMultiTexCoord4bOES)(GLenum,GLbyte,GLbyte,GLbyte,GLbyte);
-        void       (WINE_GLAPI *p_glMultiTexCoord4bvOES)(GLenum,const GLbyte*);
-        void       (WINE_GLAPI *p_glMultiTexCoord4d)(GLenum,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glMultiTexCoord4dARB)(GLenum,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glMultiTexCoord4dSGIS)(GLenum,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glMultiTexCoord4dv)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glMultiTexCoord4dvARB)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glMultiTexCoord4dvSGIS)(GLenum,GLdouble*);
-        void       (WINE_GLAPI *p_glMultiTexCoord4f)(GLenum,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glMultiTexCoord4fARB)(GLenum,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glMultiTexCoord4fSGIS)(GLenum,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glMultiTexCoord4fv)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMultiTexCoord4fvARB)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMultiTexCoord4fvSGIS)(GLenum,GLfloat*);
-        void       (WINE_GLAPI *p_glMultiTexCoord4hNV)(GLenum,GLhalfNV,GLhalfNV,GLhalfNV,GLhalfNV);
-        void       (WINE_GLAPI *p_glMultiTexCoord4hvNV)(GLenum,const GLhalfNV*);
-        void       (WINE_GLAPI *p_glMultiTexCoord4i)(GLenum,GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glMultiTexCoord4iARB)(GLenum,GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glMultiTexCoord4iSGIS)(GLenum,GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glMultiTexCoord4iv)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glMultiTexCoord4ivARB)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glMultiTexCoord4ivSGIS)(GLenum,GLint*);
-        void       (WINE_GLAPI *p_glMultiTexCoord4s)(GLenum,GLshort,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glMultiTexCoord4sARB)(GLenum,GLshort,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glMultiTexCoord4sSGIS)(GLenum,GLshort,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glMultiTexCoord4sv)(GLenum,const GLshort*);
-        void       (WINE_GLAPI *p_glMultiTexCoord4svARB)(GLenum,const GLshort*);
-        void       (WINE_GLAPI *p_glMultiTexCoord4svSGIS)(GLenum,GLshort*);
-        void       (WINE_GLAPI *p_glMultiTexCoord4xOES)(GLenum,GLfixed,GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glMultiTexCoord4xvOES)(GLenum,const GLfixed*);
-        void       (WINE_GLAPI *p_glMultiTexCoordP1ui)(GLenum,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glMultiTexCoordP1uiv)(GLenum,GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glMultiTexCoordP2ui)(GLenum,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glMultiTexCoordP2uiv)(GLenum,GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glMultiTexCoordP3ui)(GLenum,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glMultiTexCoordP3uiv)(GLenum,GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glMultiTexCoordP4ui)(GLenum,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glMultiTexCoordP4uiv)(GLenum,GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glMultiTexCoordPointerEXT)(GLenum,GLint,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glMultiTexCoordPointerSGIS)(GLenum,GLint,GLenum,GLsizei,GLvoid*);
-        void       (WINE_GLAPI *p_glMultiTexEnvfEXT)(GLenum,GLenum,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glMultiTexEnvfvEXT)(GLenum,GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMultiTexEnviEXT)(GLenum,GLenum,GLenum,GLint);
-        void       (WINE_GLAPI *p_glMultiTexEnvivEXT)(GLenum,GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glMultiTexGendEXT)(GLenum,GLenum,GLenum,GLdouble);
-        void       (WINE_GLAPI *p_glMultiTexGendvEXT)(GLenum,GLenum,GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glMultiTexGenfEXT)(GLenum,GLenum,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glMultiTexGenfvEXT)(GLenum,GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMultiTexGeniEXT)(GLenum,GLenum,GLenum,GLint);
-        void       (WINE_GLAPI *p_glMultiTexGenivEXT)(GLenum,GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glMultiTexImage1DEXT)(GLenum,GLenum,GLint,GLint,GLsizei,GLint,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glMultiTexImage2DEXT)(GLenum,GLenum,GLint,GLint,GLsizei,GLsizei,GLint,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glMultiTexImage3DEXT)(GLenum,GLenum,GLint,GLint,GLsizei,GLsizei,GLsizei,GLint,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glMultiTexParameterIivEXT)(GLenum,GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glMultiTexParameterIuivEXT)(GLenum,GLenum,GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glMultiTexParameterfEXT)(GLenum,GLenum,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glMultiTexParameterfvEXT)(GLenum,GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glMultiTexParameteriEXT)(GLenum,GLenum,GLenum,GLint);
-        void       (WINE_GLAPI *p_glMultiTexParameterivEXT)(GLenum,GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glMultiTexRenderbufferEXT)(GLenum,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glMultiTexSubImage1DEXT)(GLenum,GLenum,GLint,GLint,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glMultiTexSubImage2DEXT)(GLenum,GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glMultiTexSubImage3DEXT)(GLenum,GLenum,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLenum,GLenum,const void*);
+        void       (WINE_GLAPI *p_glLGPUNamedBufferSubDataNVX)( GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data );
+        void       (WINE_GLAPI *p_glLabelObjectEXT)( GLenum type, GLuint object, GLsizei length, const GLchar *label );
+        void       (WINE_GLAPI *p_glLightEnviSGIX)( GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glLightModelxOES)( GLenum pname, GLfixed param );
+        void       (WINE_GLAPI *p_glLightModelxvOES)( GLenum pname, const GLfixed *param );
+        void       (WINE_GLAPI *p_glLightxOES)( GLenum light, GLenum pname, GLfixed param );
+        void       (WINE_GLAPI *p_glLightxvOES)( GLenum light, GLenum pname, const GLfixed *params );
+        void       (WINE_GLAPI *p_glLineWidthxOES)( GLfixed width );
+        void       (WINE_GLAPI *p_glLinkProgram)( GLuint program );
+        void       (WINE_GLAPI *p_glLinkProgramARB)( GLhandleARB programObj );
+        void       (WINE_GLAPI *p_glListDrawCommandsStatesClientNV)( GLuint list, GLuint segment, const void **indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count );
+        void       (WINE_GLAPI *p_glListParameterfSGIX)( GLuint list, GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glListParameterfvSGIX)( GLuint list, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glListParameteriSGIX)( GLuint list, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glListParameterivSGIX)( GLuint list, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glLoadIdentityDeformationMapSGIX)( GLbitfield mask );
+        void       (WINE_GLAPI *p_glLoadMatrixxOES)( const GLfixed *m );
+        void       (WINE_GLAPI *p_glLoadProgramNV)( GLenum target, GLuint id, GLsizei len, const GLubyte *program );
+        void       (WINE_GLAPI *p_glLoadTransposeMatrixd)( const GLdouble *m );
+        void       (WINE_GLAPI *p_glLoadTransposeMatrixdARB)( const GLdouble *m );
+        void       (WINE_GLAPI *p_glLoadTransposeMatrixf)( const GLfloat *m );
+        void       (WINE_GLAPI *p_glLoadTransposeMatrixfARB)( const GLfloat *m );
+        void       (WINE_GLAPI *p_glLoadTransposeMatrixxOES)( const GLfixed *m );
+        void       (WINE_GLAPI *p_glLockArraysEXT)( GLint first, GLsizei count );
+        void       (WINE_GLAPI *p_glMTexCoord2fSGIS)( GLenum target, GLfloat s, GLfloat t );
+        void       (WINE_GLAPI *p_glMTexCoord2fvSGIS)( GLenum target, GLfloat * v );
+        void       (WINE_GLAPI *p_glMakeBufferNonResidentNV)( GLenum target );
+        void       (WINE_GLAPI *p_glMakeBufferResidentNV)( GLenum target, GLenum access );
+        void       (WINE_GLAPI *p_glMakeImageHandleNonResidentARB)( GLuint64 handle );
+        void       (WINE_GLAPI *p_glMakeImageHandleNonResidentNV)( GLuint64 handle );
+        void       (WINE_GLAPI *p_glMakeImageHandleResidentARB)( GLuint64 handle, GLenum access );
+        void       (WINE_GLAPI *p_glMakeImageHandleResidentNV)( GLuint64 handle, GLenum access );
+        void       (WINE_GLAPI *p_glMakeNamedBufferNonResidentNV)( GLuint buffer );
+        void       (WINE_GLAPI *p_glMakeNamedBufferResidentNV)( GLuint buffer, GLenum access );
+        void       (WINE_GLAPI *p_glMakeTextureHandleNonResidentARB)( GLuint64 handle );
+        void       (WINE_GLAPI *p_glMakeTextureHandleNonResidentNV)( GLuint64 handle );
+        void       (WINE_GLAPI *p_glMakeTextureHandleResidentARB)( GLuint64 handle );
+        void       (WINE_GLAPI *p_glMakeTextureHandleResidentNV)( GLuint64 handle );
+        void       (WINE_GLAPI *p_glMap1xOES)( GLenum target, GLfixed u1, GLfixed u2, GLint stride, GLint order, GLfixed points );
+        void       (WINE_GLAPI *p_glMap2xOES)( GLenum target, GLfixed u1, GLfixed u2, GLint ustride, GLint uorder, GLfixed v1, GLfixed v2, GLint vstride, GLint vorder, GLfixed points );
+        void *     (WINE_GLAPI *p_glMapBuffer)( GLenum target, GLenum access );
+        void *     (WINE_GLAPI *p_glMapBufferARB)( GLenum target, GLenum access );
+        void *     (WINE_GLAPI *p_glMapBufferRange)( GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access );
+        void       (WINE_GLAPI *p_glMapControlPointsNV)( GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const void *points );
+        void       (WINE_GLAPI *p_glMapGrid1xOES)( GLint n, GLfixed u1, GLfixed u2 );
+        void       (WINE_GLAPI *p_glMapGrid2xOES)( GLint n, GLfixed u1, GLfixed u2, GLfixed v1, GLfixed v2 );
+        void *     (WINE_GLAPI *p_glMapNamedBuffer)( GLuint buffer, GLenum access );
+        void *     (WINE_GLAPI *p_glMapNamedBufferEXT)( GLuint buffer, GLenum access );
+        void *     (WINE_GLAPI *p_glMapNamedBufferRange)( GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access );
+        void *     (WINE_GLAPI *p_glMapNamedBufferRangeEXT)( GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access );
+        void *     (WINE_GLAPI *p_glMapObjectBufferATI)( GLuint buffer );
+        void       (WINE_GLAPI *p_glMapParameterfvNV)( GLenum target, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glMapParameterivNV)( GLenum target, GLenum pname, const GLint *params );
+        void *     (WINE_GLAPI *p_glMapTexture2DINTEL)( GLuint texture, GLint level, GLbitfield access, GLint *stride, GLenum *layout );
+        void       (WINE_GLAPI *p_glMapVertexAttrib1dAPPLE)( GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points );
+        void       (WINE_GLAPI *p_glMapVertexAttrib1fAPPLE)( GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points );
+        void       (WINE_GLAPI *p_glMapVertexAttrib2dAPPLE)( GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points );
+        void       (WINE_GLAPI *p_glMapVertexAttrib2fAPPLE)( GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points );
+        void       (WINE_GLAPI *p_glMaterialxOES)( GLenum face, GLenum pname, GLfixed param );
+        void       (WINE_GLAPI *p_glMaterialxvOES)( GLenum face, GLenum pname, const GLfixed *param );
+        void       (WINE_GLAPI *p_glMatrixFrustumEXT)( GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar );
+        void       (WINE_GLAPI *p_glMatrixIndexPointerARB)( GLint size, GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glMatrixIndexubvARB)( GLint size, const GLubyte *indices );
+        void       (WINE_GLAPI *p_glMatrixIndexuivARB)( GLint size, const GLuint *indices );
+        void       (WINE_GLAPI *p_glMatrixIndexusvARB)( GLint size, const GLushort *indices );
+        void       (WINE_GLAPI *p_glMatrixLoad3x2fNV)( GLenum matrixMode, const GLfloat *m );
+        void       (WINE_GLAPI *p_glMatrixLoad3x3fNV)( GLenum matrixMode, const GLfloat *m );
+        void       (WINE_GLAPI *p_glMatrixLoadIdentityEXT)( GLenum mode );
+        void       (WINE_GLAPI *p_glMatrixLoadTranspose3x3fNV)( GLenum matrixMode, const GLfloat *m );
+        void       (WINE_GLAPI *p_glMatrixLoadTransposedEXT)( GLenum mode, const GLdouble *m );
+        void       (WINE_GLAPI *p_glMatrixLoadTransposefEXT)( GLenum mode, const GLfloat *m );
+        void       (WINE_GLAPI *p_glMatrixLoaddEXT)( GLenum mode, const GLdouble *m );
+        void       (WINE_GLAPI *p_glMatrixLoadfEXT)( GLenum mode, const GLfloat *m );
+        void       (WINE_GLAPI *p_glMatrixMult3x2fNV)( GLenum matrixMode, const GLfloat *m );
+        void       (WINE_GLAPI *p_glMatrixMult3x3fNV)( GLenum matrixMode, const GLfloat *m );
+        void       (WINE_GLAPI *p_glMatrixMultTranspose3x3fNV)( GLenum matrixMode, const GLfloat *m );
+        void       (WINE_GLAPI *p_glMatrixMultTransposedEXT)( GLenum mode, const GLdouble *m );
+        void       (WINE_GLAPI *p_glMatrixMultTransposefEXT)( GLenum mode, const GLfloat *m );
+        void       (WINE_GLAPI *p_glMatrixMultdEXT)( GLenum mode, const GLdouble *m );
+        void       (WINE_GLAPI *p_glMatrixMultfEXT)( GLenum mode, const GLfloat *m );
+        void       (WINE_GLAPI *p_glMatrixOrthoEXT)( GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar );
+        void       (WINE_GLAPI *p_glMatrixPopEXT)( GLenum mode );
+        void       (WINE_GLAPI *p_glMatrixPushEXT)( GLenum mode );
+        void       (WINE_GLAPI *p_glMatrixRotatedEXT)( GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glMatrixRotatefEXT)( GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glMatrixScaledEXT)( GLenum mode, GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glMatrixScalefEXT)( GLenum mode, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glMatrixTranslatedEXT)( GLenum mode, GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glMatrixTranslatefEXT)( GLenum mode, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glMaxShaderCompilerThreadsARB)( GLuint count );
+        void       (WINE_GLAPI *p_glMaxShaderCompilerThreadsKHR)( GLuint count );
+        void       (WINE_GLAPI *p_glMemoryBarrier)( GLbitfield barriers );
+        void       (WINE_GLAPI *p_glMemoryBarrierByRegion)( GLbitfield barriers );
+        void       (WINE_GLAPI *p_glMemoryBarrierEXT)( GLbitfield barriers );
+        void       (WINE_GLAPI *p_glMemoryObjectParameterivEXT)( GLuint memoryObject, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glMinSampleShading)( GLfloat value );
+        void       (WINE_GLAPI *p_glMinSampleShadingARB)( GLfloat value );
+        void       (WINE_GLAPI *p_glMinmax)( GLenum target, GLenum internalformat, GLboolean sink );
+        void       (WINE_GLAPI *p_glMinmaxEXT)( GLenum target, GLenum internalformat, GLboolean sink );
+        void       (WINE_GLAPI *p_glMultMatrixxOES)( const GLfixed *m );
+        void       (WINE_GLAPI *p_glMultTransposeMatrixd)( const GLdouble *m );
+        void       (WINE_GLAPI *p_glMultTransposeMatrixdARB)( const GLdouble *m );
+        void       (WINE_GLAPI *p_glMultTransposeMatrixf)( const GLfloat *m );
+        void       (WINE_GLAPI *p_glMultTransposeMatrixfARB)( const GLfloat *m );
+        void       (WINE_GLAPI *p_glMultTransposeMatrixxOES)( const GLfixed *m );
+        void       (WINE_GLAPI *p_glMultiDrawArrays)( GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount );
+        void       (WINE_GLAPI *p_glMultiDrawArraysEXT)( GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount );
+        void       (WINE_GLAPI *p_glMultiDrawArraysIndirect)( GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride );
+        void       (WINE_GLAPI *p_glMultiDrawArraysIndirectAMD)( GLenum mode, const void *indirect, GLsizei primcount, GLsizei stride );
+        void       (WINE_GLAPI *p_glMultiDrawArraysIndirectBindlessCountNV)( GLenum mode, const void *indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount );
+        void       (WINE_GLAPI *p_glMultiDrawArraysIndirectBindlessNV)( GLenum mode, const void *indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount );
+        void       (WINE_GLAPI *p_glMultiDrawArraysIndirectCount)( GLenum mode, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride );
+        void       (WINE_GLAPI *p_glMultiDrawArraysIndirectCountARB)( GLenum mode, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride );
+        void       (WINE_GLAPI *p_glMultiDrawElementArrayAPPLE)( GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount );
+        void       (WINE_GLAPI *p_glMultiDrawElements)( GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount );
+        void       (WINE_GLAPI *p_glMultiDrawElementsBaseVertex)( GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex );
+        void       (WINE_GLAPI *p_glMultiDrawElementsEXT)( GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei primcount );
+        void       (WINE_GLAPI *p_glMultiDrawElementsIndirect)( GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride );
+        void       (WINE_GLAPI *p_glMultiDrawElementsIndirectAMD)( GLenum mode, GLenum type, const void *indirect, GLsizei primcount, GLsizei stride );
+        void       (WINE_GLAPI *p_glMultiDrawElementsIndirectBindlessCountNV)( GLenum mode, GLenum type, const void *indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount );
+        void       (WINE_GLAPI *p_glMultiDrawElementsIndirectBindlessNV)( GLenum mode, GLenum type, const void *indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount );
+        void       (WINE_GLAPI *p_glMultiDrawElementsIndirectCount)( GLenum mode, GLenum type, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride );
+        void       (WINE_GLAPI *p_glMultiDrawElementsIndirectCountARB)( GLenum mode, GLenum type, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride );
+        void       (WINE_GLAPI *p_glMultiDrawRangeElementArrayAPPLE)( GLenum mode, GLuint start, GLuint end, const GLint *first, const GLsizei *count, GLsizei primcount );
+        void       (WINE_GLAPI *p_glMultiModeDrawArraysIBM)( const GLenum *mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride );
+        void       (WINE_GLAPI *p_glMultiModeDrawElementsIBM)( const GLenum *mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei primcount, GLint modestride );
+        void       (WINE_GLAPI *p_glMultiTexBufferEXT)( GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer );
+        void       (WINE_GLAPI *p_glMultiTexCoord1bOES)( GLenum texture, GLbyte s );
+        void       (WINE_GLAPI *p_glMultiTexCoord1bvOES)( GLenum texture, const GLbyte *coords );
+        void       (WINE_GLAPI *p_glMultiTexCoord1d)( GLenum target, GLdouble s );
+        void       (WINE_GLAPI *p_glMultiTexCoord1dARB)( GLenum target, GLdouble s );
+        void       (WINE_GLAPI *p_glMultiTexCoord1dSGIS)( GLenum target, GLdouble s );
+        void       (WINE_GLAPI *p_glMultiTexCoord1dv)( GLenum target, const GLdouble *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord1dvARB)( GLenum target, const GLdouble *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord1dvSGIS)( GLenum target, GLdouble * v );
+        void       (WINE_GLAPI *p_glMultiTexCoord1f)( GLenum target, GLfloat s );
+        void       (WINE_GLAPI *p_glMultiTexCoord1fARB)( GLenum target, GLfloat s );
+        void       (WINE_GLAPI *p_glMultiTexCoord1fSGIS)( GLenum target, GLfloat s );
+        void       (WINE_GLAPI *p_glMultiTexCoord1fv)( GLenum target, const GLfloat *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord1fvARB)( GLenum target, const GLfloat *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord1fvSGIS)( GLenum target, const GLfloat * v );
+        void       (WINE_GLAPI *p_glMultiTexCoord1hNV)( GLenum target, GLhalfNV s );
+        void       (WINE_GLAPI *p_glMultiTexCoord1hvNV)( GLenum target, const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord1i)( GLenum target, GLint s );
+        void       (WINE_GLAPI *p_glMultiTexCoord1iARB)( GLenum target, GLint s );
+        void       (WINE_GLAPI *p_glMultiTexCoord1iSGIS)( GLenum target, GLint s );
+        void       (WINE_GLAPI *p_glMultiTexCoord1iv)( GLenum target, const GLint *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord1ivARB)( GLenum target, const GLint *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord1ivSGIS)( GLenum target, GLint * v );
+        void       (WINE_GLAPI *p_glMultiTexCoord1s)( GLenum target, GLshort s );
+        void       (WINE_GLAPI *p_glMultiTexCoord1sARB)( GLenum target, GLshort s );
+        void       (WINE_GLAPI *p_glMultiTexCoord1sSGIS)( GLenum target, GLshort s );
+        void       (WINE_GLAPI *p_glMultiTexCoord1sv)( GLenum target, const GLshort *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord1svARB)( GLenum target, const GLshort *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord1svSGIS)( GLenum target, GLshort * v );
+        void       (WINE_GLAPI *p_glMultiTexCoord1xOES)( GLenum texture, GLfixed s );
+        void       (WINE_GLAPI *p_glMultiTexCoord1xvOES)( GLenum texture, const GLfixed *coords );
+        void       (WINE_GLAPI *p_glMultiTexCoord2bOES)( GLenum texture, GLbyte s, GLbyte t );
+        void       (WINE_GLAPI *p_glMultiTexCoord2bvOES)( GLenum texture, const GLbyte *coords );
+        void       (WINE_GLAPI *p_glMultiTexCoord2d)( GLenum target, GLdouble s, GLdouble t );
+        void       (WINE_GLAPI *p_glMultiTexCoord2dARB)( GLenum target, GLdouble s, GLdouble t );
+        void       (WINE_GLAPI *p_glMultiTexCoord2dSGIS)( GLenum target, GLdouble s, GLdouble t );
+        void       (WINE_GLAPI *p_glMultiTexCoord2dv)( GLenum target, const GLdouble *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord2dvARB)( GLenum target, const GLdouble *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord2dvSGIS)( GLenum target, GLdouble * v );
+        void       (WINE_GLAPI *p_glMultiTexCoord2f)( GLenum target, GLfloat s, GLfloat t );
+        void       (WINE_GLAPI *p_glMultiTexCoord2fARB)( GLenum target, GLfloat s, GLfloat t );
+        void       (WINE_GLAPI *p_glMultiTexCoord2fSGIS)( GLenum target, GLfloat s, GLfloat t );
+        void       (WINE_GLAPI *p_glMultiTexCoord2fv)( GLenum target, const GLfloat *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord2fvARB)( GLenum target, const GLfloat *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord2fvSGIS)( GLenum target, GLfloat * v );
+        void       (WINE_GLAPI *p_glMultiTexCoord2hNV)( GLenum target, GLhalfNV s, GLhalfNV t );
+        void       (WINE_GLAPI *p_glMultiTexCoord2hvNV)( GLenum target, const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord2i)( GLenum target, GLint s, GLint t );
+        void       (WINE_GLAPI *p_glMultiTexCoord2iARB)( GLenum target, GLint s, GLint t );
+        void       (WINE_GLAPI *p_glMultiTexCoord2iSGIS)( GLenum target, GLint s, GLint t );
+        void       (WINE_GLAPI *p_glMultiTexCoord2iv)( GLenum target, const GLint *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord2ivARB)( GLenum target, const GLint *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord2ivSGIS)( GLenum target, GLint * v );
+        void       (WINE_GLAPI *p_glMultiTexCoord2s)( GLenum target, GLshort s, GLshort t );
+        void       (WINE_GLAPI *p_glMultiTexCoord2sARB)( GLenum target, GLshort s, GLshort t );
+        void       (WINE_GLAPI *p_glMultiTexCoord2sSGIS)( GLenum target, GLshort s, GLshort t );
+        void       (WINE_GLAPI *p_glMultiTexCoord2sv)( GLenum target, const GLshort *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord2svARB)( GLenum target, const GLshort *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord2svSGIS)( GLenum target, GLshort * v );
+        void       (WINE_GLAPI *p_glMultiTexCoord2xOES)( GLenum texture, GLfixed s, GLfixed t );
+        void       (WINE_GLAPI *p_glMultiTexCoord2xvOES)( GLenum texture, const GLfixed *coords );
+        void       (WINE_GLAPI *p_glMultiTexCoord3bOES)( GLenum texture, GLbyte s, GLbyte t, GLbyte r );
+        void       (WINE_GLAPI *p_glMultiTexCoord3bvOES)( GLenum texture, const GLbyte *coords );
+        void       (WINE_GLAPI *p_glMultiTexCoord3d)( GLenum target, GLdouble s, GLdouble t, GLdouble r );
+        void       (WINE_GLAPI *p_glMultiTexCoord3dARB)( GLenum target, GLdouble s, GLdouble t, GLdouble r );
+        void       (WINE_GLAPI *p_glMultiTexCoord3dSGIS)( GLenum target, GLdouble s, GLdouble t, GLdouble r );
+        void       (WINE_GLAPI *p_glMultiTexCoord3dv)( GLenum target, const GLdouble *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord3dvARB)( GLenum target, const GLdouble *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord3dvSGIS)( GLenum target, GLdouble * v );
+        void       (WINE_GLAPI *p_glMultiTexCoord3f)( GLenum target, GLfloat s, GLfloat t, GLfloat r );
+        void       (WINE_GLAPI *p_glMultiTexCoord3fARB)( GLenum target, GLfloat s, GLfloat t, GLfloat r );
+        void       (WINE_GLAPI *p_glMultiTexCoord3fSGIS)( GLenum target, GLfloat s, GLfloat t, GLfloat r );
+        void       (WINE_GLAPI *p_glMultiTexCoord3fv)( GLenum target, const GLfloat *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord3fvARB)( GLenum target, const GLfloat *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord3fvSGIS)( GLenum target, GLfloat * v );
+        void       (WINE_GLAPI *p_glMultiTexCoord3hNV)( GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r );
+        void       (WINE_GLAPI *p_glMultiTexCoord3hvNV)( GLenum target, const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord3i)( GLenum target, GLint s, GLint t, GLint r );
+        void       (WINE_GLAPI *p_glMultiTexCoord3iARB)( GLenum target, GLint s, GLint t, GLint r );
+        void       (WINE_GLAPI *p_glMultiTexCoord3iSGIS)( GLenum target, GLint s, GLint t, GLint r );
+        void       (WINE_GLAPI *p_glMultiTexCoord3iv)( GLenum target, const GLint *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord3ivARB)( GLenum target, const GLint *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord3ivSGIS)( GLenum target, GLint * v );
+        void       (WINE_GLAPI *p_glMultiTexCoord3s)( GLenum target, GLshort s, GLshort t, GLshort r );
+        void       (WINE_GLAPI *p_glMultiTexCoord3sARB)( GLenum target, GLshort s, GLshort t, GLshort r );
+        void       (WINE_GLAPI *p_glMultiTexCoord3sSGIS)( GLenum target, GLshort s, GLshort t, GLshort r );
+        void       (WINE_GLAPI *p_glMultiTexCoord3sv)( GLenum target, const GLshort *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord3svARB)( GLenum target, const GLshort *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord3svSGIS)( GLenum target, GLshort * v );
+        void       (WINE_GLAPI *p_glMultiTexCoord3xOES)( GLenum texture, GLfixed s, GLfixed t, GLfixed r );
+        void       (WINE_GLAPI *p_glMultiTexCoord3xvOES)( GLenum texture, const GLfixed *coords );
+        void       (WINE_GLAPI *p_glMultiTexCoord4bOES)( GLenum texture, GLbyte s, GLbyte t, GLbyte r, GLbyte q );
+        void       (WINE_GLAPI *p_glMultiTexCoord4bvOES)( GLenum texture, const GLbyte *coords );
+        void       (WINE_GLAPI *p_glMultiTexCoord4d)( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q );
+        void       (WINE_GLAPI *p_glMultiTexCoord4dARB)( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q );
+        void       (WINE_GLAPI *p_glMultiTexCoord4dSGIS)( GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q );
+        void       (WINE_GLAPI *p_glMultiTexCoord4dv)( GLenum target, const GLdouble *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord4dvARB)( GLenum target, const GLdouble *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord4dvSGIS)( GLenum target, GLdouble * v );
+        void       (WINE_GLAPI *p_glMultiTexCoord4f)( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q );
+        void       (WINE_GLAPI *p_glMultiTexCoord4fARB)( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q );
+        void       (WINE_GLAPI *p_glMultiTexCoord4fSGIS)( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q );
+        void       (WINE_GLAPI *p_glMultiTexCoord4fv)( GLenum target, const GLfloat *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord4fvARB)( GLenum target, const GLfloat *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord4fvSGIS)( GLenum target, GLfloat * v );
+        void       (WINE_GLAPI *p_glMultiTexCoord4hNV)( GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q );
+        void       (WINE_GLAPI *p_glMultiTexCoord4hvNV)( GLenum target, const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord4i)( GLenum target, GLint s, GLint t, GLint r, GLint q );
+        void       (WINE_GLAPI *p_glMultiTexCoord4iARB)( GLenum target, GLint s, GLint t, GLint r, GLint q );
+        void       (WINE_GLAPI *p_glMultiTexCoord4iSGIS)( GLenum target, GLint s, GLint t, GLint r, GLint q );
+        void       (WINE_GLAPI *p_glMultiTexCoord4iv)( GLenum target, const GLint *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord4ivARB)( GLenum target, const GLint *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord4ivSGIS)( GLenum target, GLint * v );
+        void       (WINE_GLAPI *p_glMultiTexCoord4s)( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q );
+        void       (WINE_GLAPI *p_glMultiTexCoord4sARB)( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q );
+        void       (WINE_GLAPI *p_glMultiTexCoord4sSGIS)( GLenum target, GLshort s, GLshort t, GLshort r, GLshort q );
+        void       (WINE_GLAPI *p_glMultiTexCoord4sv)( GLenum target, const GLshort *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord4svARB)( GLenum target, const GLshort *v );
+        void       (WINE_GLAPI *p_glMultiTexCoord4svSGIS)( GLenum target, GLshort * v );
+        void       (WINE_GLAPI *p_glMultiTexCoord4xOES)( GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q );
+        void       (WINE_GLAPI *p_glMultiTexCoord4xvOES)( GLenum texture, const GLfixed *coords );
+        void       (WINE_GLAPI *p_glMultiTexCoordP1ui)( GLenum texture, GLenum type, GLuint coords );
+        void       (WINE_GLAPI *p_glMultiTexCoordP1uiv)( GLenum texture, GLenum type, const GLuint *coords );
+        void       (WINE_GLAPI *p_glMultiTexCoordP2ui)( GLenum texture, GLenum type, GLuint coords );
+        void       (WINE_GLAPI *p_glMultiTexCoordP2uiv)( GLenum texture, GLenum type, const GLuint *coords );
+        void       (WINE_GLAPI *p_glMultiTexCoordP3ui)( GLenum texture, GLenum type, GLuint coords );
+        void       (WINE_GLAPI *p_glMultiTexCoordP3uiv)( GLenum texture, GLenum type, const GLuint *coords );
+        void       (WINE_GLAPI *p_glMultiTexCoordP4ui)( GLenum texture, GLenum type, GLuint coords );
+        void       (WINE_GLAPI *p_glMultiTexCoordP4uiv)( GLenum texture, GLenum type, const GLuint *coords );
+        void       (WINE_GLAPI *p_glMultiTexCoordPointerEXT)( GLenum texunit, GLint size, GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glMultiTexCoordPointerSGIS)( GLenum target, GLint size, GLenum type, GLsizei stride, GLvoid * pointer );
+        void       (WINE_GLAPI *p_glMultiTexEnvfEXT)( GLenum texunit, GLenum target, GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glMultiTexEnvfvEXT)( GLenum texunit, GLenum target, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glMultiTexEnviEXT)( GLenum texunit, GLenum target, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glMultiTexEnvivEXT)( GLenum texunit, GLenum target, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glMultiTexGendEXT)( GLenum texunit, GLenum coord, GLenum pname, GLdouble param );
+        void       (WINE_GLAPI *p_glMultiTexGendvEXT)( GLenum texunit, GLenum coord, GLenum pname, const GLdouble *params );
+        void       (WINE_GLAPI *p_glMultiTexGenfEXT)( GLenum texunit, GLenum coord, GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glMultiTexGenfvEXT)( GLenum texunit, GLenum coord, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glMultiTexGeniEXT)( GLenum texunit, GLenum coord, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glMultiTexGenivEXT)( GLenum texunit, GLenum coord, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glMultiTexImage1DEXT)( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glMultiTexImage2DEXT)( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glMultiTexImage3DEXT)( GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glMultiTexParameterIivEXT)( GLenum texunit, GLenum target, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glMultiTexParameterIuivEXT)( GLenum texunit, GLenum target, GLenum pname, const GLuint *params );
+        void       (WINE_GLAPI *p_glMultiTexParameterfEXT)( GLenum texunit, GLenum target, GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glMultiTexParameterfvEXT)( GLenum texunit, GLenum target, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glMultiTexParameteriEXT)( GLenum texunit, GLenum target, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glMultiTexParameterivEXT)( GLenum texunit, GLenum target, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glMultiTexRenderbufferEXT)( GLenum texunit, GLenum target, GLuint renderbuffer );
+        void       (WINE_GLAPI *p_glMultiTexSubImage1DEXT)( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glMultiTexSubImage2DEXT)( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glMultiTexSubImage3DEXT)( GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels );
         void       (WINE_GLAPI *p_glMulticastBarrierNV)(void);
-        void       (WINE_GLAPI *p_glMulticastBlitFramebufferNV)(GLuint,GLuint,GLint,GLint,GLint,GLint,GLint,GLint,GLint,GLint,GLbitfield,GLenum);
-        void       (WINE_GLAPI *p_glMulticastBufferSubDataNV)(GLbitfield,GLuint,GLintptr,GLsizeiptr,const GLvoid*);
-        void       (WINE_GLAPI *p_glMulticastCopyBufferSubDataNV)(GLuint,GLbitfield,GLuint,GLuint,GLintptr,GLintptr,GLsizeiptr);
-        void       (WINE_GLAPI *p_glMulticastCopyImageSubDataNV)(GLuint,GLbitfield,GLuint,GLenum,GLint,GLint,GLint,GLint,GLuint,GLenum,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glMulticastFramebufferSampleLocationsfvNV)(GLuint,GLuint,GLuint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glMulticastGetQueryObjecti64vNV)(GLuint,GLuint,GLenum,GLint64*);
-        void       (WINE_GLAPI *p_glMulticastGetQueryObjectivNV)(GLuint,GLuint,GLenum,GLint*);
-        void       (WINE_GLAPI *p_glMulticastGetQueryObjectui64vNV)(GLuint,GLuint,GLenum,GLuint64*);
-        void       (WINE_GLAPI *p_glMulticastGetQueryObjectuivNV)(GLuint,GLuint,GLenum,GLuint*);
-        void       (WINE_GLAPI *p_glMulticastWaitSyncNV)(GLuint,GLbitfield);
-        void       (WINE_GLAPI *p_glNamedBufferData)(GLuint,GLsizeiptr,const void*,GLenum);
-        void       (WINE_GLAPI *p_glNamedBufferDataEXT)(GLuint,GLsizeiptr,const void*,GLenum);
-        void       (WINE_GLAPI *p_glNamedBufferPageCommitmentARB)(GLuint,GLintptr,GLsizeiptr,GLboolean);
-        void       (WINE_GLAPI *p_glNamedBufferPageCommitmentEXT)(GLuint,GLintptr,GLsizeiptr,GLboolean);
-        void       (WINE_GLAPI *p_glNamedBufferStorage)(GLuint,GLsizeiptr,const void*,GLbitfield);
-        void       (WINE_GLAPI *p_glNamedBufferStorageEXT)(GLuint,GLsizeiptr,const void*,GLbitfield);
-        void       (WINE_GLAPI *p_glNamedBufferStorageExternalEXT)(GLuint,GLintptr,GLsizeiptr,void *,GLbitfield);
-        void       (WINE_GLAPI *p_glNamedBufferStorageMemEXT)(GLuint,GLsizeiptr,GLuint,GLuint64);
-        void       (WINE_GLAPI *p_glNamedBufferSubData)(GLuint,GLintptr,GLsizeiptr,const void*);
-        void       (WINE_GLAPI *p_glNamedBufferSubDataEXT)(GLuint,GLintptr,GLsizeiptr,const void*);
-        void       (WINE_GLAPI *p_glNamedCopyBufferSubDataEXT)(GLuint,GLuint,GLintptr,GLintptr,GLsizeiptr);
-        void       (WINE_GLAPI *p_glNamedFramebufferDrawBuffer)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glNamedFramebufferDrawBuffers)(GLuint,GLsizei,const GLenum*);
-        void       (WINE_GLAPI *p_glNamedFramebufferParameteri)(GLuint,GLenum,GLint);
-        void       (WINE_GLAPI *p_glNamedFramebufferParameteriEXT)(GLuint,GLenum,GLint);
-        void       (WINE_GLAPI *p_glNamedFramebufferReadBuffer)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glNamedFramebufferRenderbuffer)(GLuint,GLenum,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glNamedFramebufferRenderbufferEXT)(GLuint,GLenum,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glNamedFramebufferSampleLocationsfvARB)(GLuint,GLuint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glNamedFramebufferSampleLocationsfvNV)(GLuint,GLuint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glNamedFramebufferSamplePositionsfvAMD)(GLuint,GLuint,GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glNamedFramebufferTexture)(GLuint,GLenum,GLuint,GLint);
-        void       (WINE_GLAPI *p_glNamedFramebufferTexture1DEXT)(GLuint,GLenum,GLenum,GLuint,GLint);
-        void       (WINE_GLAPI *p_glNamedFramebufferTexture2DEXT)(GLuint,GLenum,GLenum,GLuint,GLint);
-        void       (WINE_GLAPI *p_glNamedFramebufferTexture3DEXT)(GLuint,GLenum,GLenum,GLuint,GLint,GLint);
-        void       (WINE_GLAPI *p_glNamedFramebufferTextureEXT)(GLuint,GLenum,GLuint,GLint);
-        void       (WINE_GLAPI *p_glNamedFramebufferTextureFaceEXT)(GLuint,GLenum,GLuint,GLint,GLenum);
-        void       (WINE_GLAPI *p_glNamedFramebufferTextureLayer)(GLuint,GLenum,GLuint,GLint,GLint);
-        void       (WINE_GLAPI *p_glNamedFramebufferTextureLayerEXT)(GLuint,GLenum,GLuint,GLint,GLint);
-        void       (WINE_GLAPI *p_glNamedProgramLocalParameter4dEXT)(GLuint,GLenum,GLuint,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glNamedProgramLocalParameter4dvEXT)(GLuint,GLenum,GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glNamedProgramLocalParameter4fEXT)(GLuint,GLenum,GLuint,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glNamedProgramLocalParameter4fvEXT)(GLuint,GLenum,GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glNamedProgramLocalParameterI4iEXT)(GLuint,GLenum,GLuint,GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glNamedProgramLocalParameterI4ivEXT)(GLuint,GLenum,GLuint,const GLint*);
-        void       (WINE_GLAPI *p_glNamedProgramLocalParameterI4uiEXT)(GLuint,GLenum,GLuint,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glNamedProgramLocalParameterI4uivEXT)(GLuint,GLenum,GLuint,const GLuint*);
-        void       (WINE_GLAPI *p_glNamedProgramLocalParameters4fvEXT)(GLuint,GLenum,GLuint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glNamedProgramLocalParametersI4ivEXT)(GLuint,GLenum,GLuint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glNamedProgramLocalParametersI4uivEXT)(GLuint,GLenum,GLuint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glNamedProgramStringEXT)(GLuint,GLenum,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glNamedRenderbufferStorage)(GLuint,GLenum,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glNamedRenderbufferStorageEXT)(GLuint,GLenum,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glNamedRenderbufferStorageMultisample)(GLuint,GLsizei,GLenum,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glNamedRenderbufferStorageMultisampleCoverageEXT)(GLuint,GLsizei,GLsizei,GLenum,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glNamedRenderbufferStorageMultisampleEXT)(GLuint,GLsizei,GLenum,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glNamedStringARB)(GLenum,GLint,const GLchar*,GLint,const GLchar*);
-        GLuint     (WINE_GLAPI *p_glNewBufferRegion)(GLenum);
-        GLuint     (WINE_GLAPI *p_glNewObjectBufferATI)(GLsizei,const void*,GLenum);
-        void       (WINE_GLAPI *p_glNormal3fVertex3fSUN)(GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glNormal3fVertex3fvSUN)(const GLfloat*,const GLfloat*);
-        void       (WINE_GLAPI *p_glNormal3hNV)(GLhalfNV,GLhalfNV,GLhalfNV);
-        void       (WINE_GLAPI *p_glNormal3hvNV)(const GLhalfNV*);
-        void       (WINE_GLAPI *p_glNormal3xOES)(GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glNormal3xvOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glNormalFormatNV)(GLenum,GLsizei);
-        void       (WINE_GLAPI *p_glNormalP3ui)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glNormalP3uiv)(GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glNormalPointerEXT)(GLenum,GLsizei,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glNormalPointerListIBM)(GLenum,GLint,const void**,GLint);
-        void       (WINE_GLAPI *p_glNormalPointervINTEL)(GLenum,const void**);
-        void       (WINE_GLAPI *p_glNormalStream3bATI)(GLenum,GLbyte,GLbyte,GLbyte);
-        void       (WINE_GLAPI *p_glNormalStream3bvATI)(GLenum,const GLbyte*);
-        void       (WINE_GLAPI *p_glNormalStream3dATI)(GLenum,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glNormalStream3dvATI)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glNormalStream3fATI)(GLenum,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glNormalStream3fvATI)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glNormalStream3iATI)(GLenum,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glNormalStream3ivATI)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glNormalStream3sATI)(GLenum,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glNormalStream3svATI)(GLenum,const GLshort*);
-        void       (WINE_GLAPI *p_glObjectLabel)(GLenum,GLuint,GLsizei,const GLchar*);
-        void       (WINE_GLAPI *p_glObjectPtrLabel)(const void*,GLsizei,const GLchar*);
-        GLenum     (WINE_GLAPI *p_glObjectPurgeableAPPLE)(GLenum,GLuint,GLenum);
-        GLenum     (WINE_GLAPI *p_glObjectUnpurgeableAPPLE)(GLenum,GLuint,GLenum);
-        void       (WINE_GLAPI *p_glOrthofOES)(GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glOrthoxOES)(GLfixed,GLfixed,GLfixed,GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glPNTrianglesfATI)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glPNTrianglesiATI)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glPassTexCoordATI)(GLuint,GLuint,GLenum);
-        void       (WINE_GLAPI *p_glPassThroughxOES)(GLfixed);
-        void       (WINE_GLAPI *p_glPatchParameterfv)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glPatchParameteri)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glPathColorGenNV)(GLenum,GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glPathCommandsNV)(GLuint,GLsizei,const GLubyte*,GLsizei,GLenum,const void*);
-        void       (WINE_GLAPI *p_glPathCoordsNV)(GLuint,GLsizei,GLenum,const void*);
-        void       (WINE_GLAPI *p_glPathCoverDepthFuncNV)(GLenum);
-        void       (WINE_GLAPI *p_glPathDashArrayNV)(GLuint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glPathFogGenNV)(GLenum);
-        GLenum     (WINE_GLAPI *p_glPathGlyphIndexArrayNV)(GLuint,GLenum,const void*,GLbitfield,GLuint,GLsizei,GLuint,GLfloat);
-        GLenum     (WINE_GLAPI *p_glPathGlyphIndexRangeNV)(GLenum,const void*,GLbitfield,GLuint,GLfloat,GLuint[2]);
-        void       (WINE_GLAPI *p_glPathGlyphRangeNV)(GLuint,GLenum,const void*,GLbitfield,GLuint,GLsizei,GLenum,GLuint,GLfloat);
-        void       (WINE_GLAPI *p_glPathGlyphsNV)(GLuint,GLenum,const void*,GLbitfield,GLsizei,GLenum,const void*,GLenum,GLuint,GLfloat);
-        GLenum     (WINE_GLAPI *p_glPathMemoryGlyphIndexArrayNV)(GLuint,GLenum,GLsizeiptr,const void*,GLsizei,GLuint,GLsizei,GLuint,GLfloat);
-        void       (WINE_GLAPI *p_glPathParameterfNV)(GLuint,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glPathParameterfvNV)(GLuint,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glPathParameteriNV)(GLuint,GLenum,GLint);
-        void       (WINE_GLAPI *p_glPathParameterivNV)(GLuint,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glPathStencilDepthOffsetNV)(GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glPathStencilFuncNV)(GLenum,GLint,GLuint);
-        void       (WINE_GLAPI *p_glPathStringNV)(GLuint,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glPathSubCommandsNV)(GLuint,GLsizei,GLsizei,GLsizei,const GLubyte*,GLsizei,GLenum,const void*);
-        void       (WINE_GLAPI *p_glPathSubCoordsNV)(GLuint,GLsizei,GLsizei,GLenum,const void*);
-        void       (WINE_GLAPI *p_glPathTexGenNV)(GLenum,GLenum,GLint,const GLfloat*);
+        void       (WINE_GLAPI *p_glMulticastBlitFramebufferNV)( GLuint srcGpu, GLuint dstGpu, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter );
+        void       (WINE_GLAPI *p_glMulticastBufferSubDataNV)( GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, const GLvoid *data );
+        void       (WINE_GLAPI *p_glMulticastCopyBufferSubDataNV)( GLuint readGpu, GLbitfield writeGpuMask, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size );
+        void       (WINE_GLAPI *p_glMulticastCopyImageSubDataNV)( GLuint srcGpu, GLbitfield dstGpuMask, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth );
+        void       (WINE_GLAPI *p_glMulticastFramebufferSampleLocationsfvNV)( GLuint gpu, GLuint framebuffer, GLuint start, GLsizei count, const GLfloat *v );
+        void       (WINE_GLAPI *p_glMulticastGetQueryObjecti64vNV)( GLuint gpu, GLuint id, GLenum pname, GLint64 *params );
+        void       (WINE_GLAPI *p_glMulticastGetQueryObjectivNV)( GLuint gpu, GLuint id, GLenum pname, GLint *params );
+        void       (WINE_GLAPI *p_glMulticastGetQueryObjectui64vNV)( GLuint gpu, GLuint id, GLenum pname, GLuint64 *params );
+        void       (WINE_GLAPI *p_glMulticastGetQueryObjectuivNV)( GLuint gpu, GLuint id, GLenum pname, GLuint *params );
+        void       (WINE_GLAPI *p_glMulticastWaitSyncNV)( GLuint signalGpu, GLbitfield waitGpuMask );
+        void       (WINE_GLAPI *p_glNamedBufferData)( GLuint buffer, GLsizeiptr size, const void *data, GLenum usage );
+        void       (WINE_GLAPI *p_glNamedBufferDataEXT)( GLuint buffer, GLsizeiptr size, const void *data, GLenum usage );
+        void       (WINE_GLAPI *p_glNamedBufferPageCommitmentARB)( GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit );
+        void       (WINE_GLAPI *p_glNamedBufferPageCommitmentEXT)( GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit );
+        void       (WINE_GLAPI *p_glNamedBufferStorage)( GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags );
+        void       (WINE_GLAPI *p_glNamedBufferStorageEXT)( GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags );
+        void       (WINE_GLAPI *p_glNamedBufferStorageExternalEXT)( GLuint buffer, GLintptr offset, GLsizeiptr size, void * clientBuffer, GLbitfield flags );
+        void       (WINE_GLAPI *p_glNamedBufferStorageMemEXT)( GLuint buffer, GLsizeiptr size, GLuint memory, GLuint64 offset );
+        void       (WINE_GLAPI *p_glNamedBufferSubData)( GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data );
+        void       (WINE_GLAPI *p_glNamedBufferSubDataEXT)( GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data );
+        void       (WINE_GLAPI *p_glNamedCopyBufferSubDataEXT)( GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size );
+        void       (WINE_GLAPI *p_glNamedFramebufferDrawBuffer)( GLuint framebuffer, GLenum buf );
+        void       (WINE_GLAPI *p_glNamedFramebufferDrawBuffers)( GLuint framebuffer, GLsizei n, const GLenum *bufs );
+        void       (WINE_GLAPI *p_glNamedFramebufferParameteri)( GLuint framebuffer, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glNamedFramebufferParameteriEXT)( GLuint framebuffer, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glNamedFramebufferReadBuffer)( GLuint framebuffer, GLenum src );
+        void       (WINE_GLAPI *p_glNamedFramebufferRenderbuffer)( GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer );
+        void       (WINE_GLAPI *p_glNamedFramebufferRenderbufferEXT)( GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer );
+        void       (WINE_GLAPI *p_glNamedFramebufferSampleLocationsfvARB)( GLuint framebuffer, GLuint start, GLsizei count, const GLfloat *v );
+        void       (WINE_GLAPI *p_glNamedFramebufferSampleLocationsfvNV)( GLuint framebuffer, GLuint start, GLsizei count, const GLfloat *v );
+        void       (WINE_GLAPI *p_glNamedFramebufferSamplePositionsfvAMD)( GLuint framebuffer, GLuint numsamples, GLuint pixelindex, const GLfloat *values );
+        void       (WINE_GLAPI *p_glNamedFramebufferTexture)( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level );
+        void       (WINE_GLAPI *p_glNamedFramebufferTexture1DEXT)( GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level );
+        void       (WINE_GLAPI *p_glNamedFramebufferTexture2DEXT)( GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level );
+        void       (WINE_GLAPI *p_glNamedFramebufferTexture3DEXT)( GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset );
+        void       (WINE_GLAPI *p_glNamedFramebufferTextureEXT)( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level );
+        void       (WINE_GLAPI *p_glNamedFramebufferTextureFaceEXT)( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face );
+        void       (WINE_GLAPI *p_glNamedFramebufferTextureLayer)( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer );
+        void       (WINE_GLAPI *p_glNamedFramebufferTextureLayerEXT)( GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer );
+        void       (WINE_GLAPI *p_glNamedProgramLocalParameter4dEXT)( GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+        void       (WINE_GLAPI *p_glNamedProgramLocalParameter4dvEXT)( GLuint program, GLenum target, GLuint index, const GLdouble *params );
+        void       (WINE_GLAPI *p_glNamedProgramLocalParameter4fEXT)( GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
+        void       (WINE_GLAPI *p_glNamedProgramLocalParameter4fvEXT)( GLuint program, GLenum target, GLuint index, const GLfloat *params );
+        void       (WINE_GLAPI *p_glNamedProgramLocalParameterI4iEXT)( GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w );
+        void       (WINE_GLAPI *p_glNamedProgramLocalParameterI4ivEXT)( GLuint program, GLenum target, GLuint index, const GLint *params );
+        void       (WINE_GLAPI *p_glNamedProgramLocalParameterI4uiEXT)( GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w );
+        void       (WINE_GLAPI *p_glNamedProgramLocalParameterI4uivEXT)( GLuint program, GLenum target, GLuint index, const GLuint *params );
+        void       (WINE_GLAPI *p_glNamedProgramLocalParameters4fvEXT)( GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat *params );
+        void       (WINE_GLAPI *p_glNamedProgramLocalParametersI4ivEXT)( GLuint program, GLenum target, GLuint index, GLsizei count, const GLint *params );
+        void       (WINE_GLAPI *p_glNamedProgramLocalParametersI4uivEXT)( GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint *params );
+        void       (WINE_GLAPI *p_glNamedProgramStringEXT)( GLuint program, GLenum target, GLenum format, GLsizei len, const void *string );
+        void       (WINE_GLAPI *p_glNamedRenderbufferStorage)( GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glNamedRenderbufferStorageEXT)( GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glNamedRenderbufferStorageMultisample)( GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glNamedRenderbufferStorageMultisampleCoverageEXT)( GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glNamedRenderbufferStorageMultisampleEXT)( GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glNamedStringARB)( GLenum type, GLint namelen, const GLchar *name, GLint stringlen, const GLchar *string );
+        GLuint     (WINE_GLAPI *p_glNewBufferRegion)( GLenum type );
+        GLuint     (WINE_GLAPI *p_glNewObjectBufferATI)( GLsizei size, const void *pointer, GLenum usage );
+        void       (WINE_GLAPI *p_glNormal3fVertex3fSUN)( GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glNormal3fVertex3fvSUN)( const GLfloat *n, const GLfloat *v );
+        void       (WINE_GLAPI *p_glNormal3hNV)( GLhalfNV nx, GLhalfNV ny, GLhalfNV nz );
+        void       (WINE_GLAPI *p_glNormal3hvNV)( const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glNormal3xOES)( GLfixed nx, GLfixed ny, GLfixed nz );
+        void       (WINE_GLAPI *p_glNormal3xvOES)( const GLfixed *coords );
+        void       (WINE_GLAPI *p_glNormalFormatNV)( GLenum type, GLsizei stride );
+        void       (WINE_GLAPI *p_glNormalP3ui)( GLenum type, GLuint coords );
+        void       (WINE_GLAPI *p_glNormalP3uiv)( GLenum type, const GLuint *coords );
+        void       (WINE_GLAPI *p_glNormalPointerEXT)( GLenum type, GLsizei stride, GLsizei count, const void *pointer );
+        void       (WINE_GLAPI *p_glNormalPointerListIBM)( GLenum type, GLint stride, const void **pointer, GLint ptrstride );
+        void       (WINE_GLAPI *p_glNormalPointervINTEL)( GLenum type, const void **pointer );
+        void       (WINE_GLAPI *p_glNormalStream3bATI)( GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz );
+        void       (WINE_GLAPI *p_glNormalStream3bvATI)( GLenum stream, const GLbyte *coords );
+        void       (WINE_GLAPI *p_glNormalStream3dATI)( GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz );
+        void       (WINE_GLAPI *p_glNormalStream3dvATI)( GLenum stream, const GLdouble *coords );
+        void       (WINE_GLAPI *p_glNormalStream3fATI)( GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz );
+        void       (WINE_GLAPI *p_glNormalStream3fvATI)( GLenum stream, const GLfloat *coords );
+        void       (WINE_GLAPI *p_glNormalStream3iATI)( GLenum stream, GLint nx, GLint ny, GLint nz );
+        void       (WINE_GLAPI *p_glNormalStream3ivATI)( GLenum stream, const GLint *coords );
+        void       (WINE_GLAPI *p_glNormalStream3sATI)( GLenum stream, GLshort nx, GLshort ny, GLshort nz );
+        void       (WINE_GLAPI *p_glNormalStream3svATI)( GLenum stream, const GLshort *coords );
+        void       (WINE_GLAPI *p_glObjectLabel)( GLenum identifier, GLuint name, GLsizei length, const GLchar *label );
+        void       (WINE_GLAPI *p_glObjectPtrLabel)( const void *ptr, GLsizei length, const GLchar *label );
+        GLenum     (WINE_GLAPI *p_glObjectPurgeableAPPLE)( GLenum objectType, GLuint name, GLenum option );
+        GLenum     (WINE_GLAPI *p_glObjectUnpurgeableAPPLE)( GLenum objectType, GLuint name, GLenum option );
+        void       (WINE_GLAPI *p_glOrthofOES)( GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f );
+        void       (WINE_GLAPI *p_glOrthoxOES)( GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f );
+        void       (WINE_GLAPI *p_glPNTrianglesfATI)( GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glPNTrianglesiATI)( GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glPassTexCoordATI)( GLuint dst, GLuint coord, GLenum swizzle );
+        void       (WINE_GLAPI *p_glPassThroughxOES)( GLfixed token );
+        void       (WINE_GLAPI *p_glPatchParameterfv)( GLenum pname, const GLfloat *values );
+        void       (WINE_GLAPI *p_glPatchParameteri)( GLenum pname, GLint value );
+        void       (WINE_GLAPI *p_glPathColorGenNV)( GLenum color, GLenum genMode, GLenum colorFormat, const GLfloat *coeffs );
+        void       (WINE_GLAPI *p_glPathCommandsNV)( GLuint path, GLsizei numCommands, const GLubyte *commands, GLsizei numCoords, GLenum coordType, const void *coords );
+        void       (WINE_GLAPI *p_glPathCoordsNV)( GLuint path, GLsizei numCoords, GLenum coordType, const void *coords );
+        void       (WINE_GLAPI *p_glPathCoverDepthFuncNV)( GLenum func );
+        void       (WINE_GLAPI *p_glPathDashArrayNV)( GLuint path, GLsizei dashCount, const GLfloat *dashArray );
+        void       (WINE_GLAPI *p_glPathFogGenNV)( GLenum genMode );
+        GLenum     (WINE_GLAPI *p_glPathGlyphIndexArrayNV)( GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale );
+        GLenum     (WINE_GLAPI *p_glPathGlyphIndexRangeNV)( GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint baseAndCount[2] );
+        void       (WINE_GLAPI *p_glPathGlyphRangeNV)( GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale );
+        void       (WINE_GLAPI *p_glPathGlyphsNV)( GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLsizei numGlyphs, GLenum type, const void *charcodes, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale );
+        GLenum     (WINE_GLAPI *p_glPathMemoryGlyphIndexArrayNV)( GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, const void *fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale );
+        void       (WINE_GLAPI *p_glPathParameterfNV)( GLuint path, GLenum pname, GLfloat value );
+        void       (WINE_GLAPI *p_glPathParameterfvNV)( GLuint path, GLenum pname, const GLfloat *value );
+        void       (WINE_GLAPI *p_glPathParameteriNV)( GLuint path, GLenum pname, GLint value );
+        void       (WINE_GLAPI *p_glPathParameterivNV)( GLuint path, GLenum pname, const GLint *value );
+        void       (WINE_GLAPI *p_glPathStencilDepthOffsetNV)( GLfloat factor, GLfloat units );
+        void       (WINE_GLAPI *p_glPathStencilFuncNV)( GLenum func, GLint ref, GLuint mask );
+        void       (WINE_GLAPI *p_glPathStringNV)( GLuint path, GLenum format, GLsizei length, const void *pathString );
+        void       (WINE_GLAPI *p_glPathSubCommandsNV)( GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, const GLubyte *commands, GLsizei numCoords, GLenum coordType, const void *coords );
+        void       (WINE_GLAPI *p_glPathSubCoordsNV)( GLuint path, GLsizei coordStart, GLsizei numCoords, GLenum coordType, const void *coords );
+        void       (WINE_GLAPI *p_glPathTexGenNV)( GLenum texCoordSet, GLenum genMode, GLint components, const GLfloat *coeffs );
         void       (WINE_GLAPI *p_glPauseTransformFeedback)(void);
         void       (WINE_GLAPI *p_glPauseTransformFeedbackNV)(void);
-        void       (WINE_GLAPI *p_glPixelDataRangeNV)(GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glPixelMapx)(GLenum,GLint,const GLfixed*);
-        void       (WINE_GLAPI *p_glPixelStorex)(GLenum,GLfixed);
-        void       (WINE_GLAPI *p_glPixelTexGenParameterfSGIS)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glPixelTexGenParameterfvSGIS)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glPixelTexGenParameteriSGIS)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glPixelTexGenParameterivSGIS)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glPixelTexGenSGIX)(GLenum);
-        void       (WINE_GLAPI *p_glPixelTransferxOES)(GLenum,GLfixed);
-        void       (WINE_GLAPI *p_glPixelTransformParameterfEXT)(GLenum,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glPixelTransformParameterfvEXT)(GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glPixelTransformParameteriEXT)(GLenum,GLenum,GLint);
-        void       (WINE_GLAPI *p_glPixelTransformParameterivEXT)(GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glPixelZoomxOES)(GLfixed,GLfixed);
-        GLboolean  (WINE_GLAPI *p_glPointAlongPathNV)(GLuint,GLsizei,GLsizei,GLfloat,GLfloat*,GLfloat*,GLfloat*,GLfloat*);
-        void       (WINE_GLAPI *p_glPointParameterf)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glPointParameterfARB)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glPointParameterfEXT)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glPointParameterfSGIS)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glPointParameterfv)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glPointParameterfvARB)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glPointParameterfvEXT)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glPointParameterfvSGIS)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glPointParameteri)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glPointParameteriNV)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glPointParameteriv)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glPointParameterivNV)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glPointParameterxvOES)(GLenum,const GLfixed*);
-        void       (WINE_GLAPI *p_glPointSizexOES)(GLfixed);
-        GLint      (WINE_GLAPI *p_glPollAsyncSGIX)(GLuint*);
-        GLint      (WINE_GLAPI *p_glPollInstrumentsSGIX)(GLint*);
-        void       (WINE_GLAPI *p_glPolygonOffsetClamp)(GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glPolygonOffsetClampEXT)(GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glPolygonOffsetEXT)(GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glPolygonOffsetxOES)(GLfixed,GLfixed);
+        void       (WINE_GLAPI *p_glPixelDataRangeNV)( GLenum target, GLsizei length, const void *pointer );
+        void       (WINE_GLAPI *p_glPixelMapx)( GLenum map, GLint size, const GLfixed *values );
+        void       (WINE_GLAPI *p_glPixelStorex)( GLenum pname, GLfixed param );
+        void       (WINE_GLAPI *p_glPixelTexGenParameterfSGIS)( GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glPixelTexGenParameterfvSGIS)( GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glPixelTexGenParameteriSGIS)( GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glPixelTexGenParameterivSGIS)( GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glPixelTexGenSGIX)( GLenum mode );
+        void       (WINE_GLAPI *p_glPixelTransferxOES)( GLenum pname, GLfixed param );
+        void       (WINE_GLAPI *p_glPixelTransformParameterfEXT)( GLenum target, GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glPixelTransformParameterfvEXT)( GLenum target, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glPixelTransformParameteriEXT)( GLenum target, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glPixelTransformParameterivEXT)( GLenum target, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glPixelZoomxOES)( GLfixed xfactor, GLfixed yfactor );
+        GLboolean  (WINE_GLAPI *p_glPointAlongPathNV)( GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat *x, GLfloat *y, GLfloat *tangentX, GLfloat *tangentY );
+        void       (WINE_GLAPI *p_glPointParameterf)( GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glPointParameterfARB)( GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glPointParameterfEXT)( GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glPointParameterfSGIS)( GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glPointParameterfv)( GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glPointParameterfvARB)( GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glPointParameterfvEXT)( GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glPointParameterfvSGIS)( GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glPointParameteri)( GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glPointParameteriNV)( GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glPointParameteriv)( GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glPointParameterivNV)( GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glPointParameterxvOES)( GLenum pname, const GLfixed *params );
+        void       (WINE_GLAPI *p_glPointSizexOES)( GLfixed size );
+        GLint      (WINE_GLAPI *p_glPollAsyncSGIX)( GLuint *markerp );
+        GLint      (WINE_GLAPI *p_glPollInstrumentsSGIX)( GLint *marker_p );
+        void       (WINE_GLAPI *p_glPolygonOffsetClamp)( GLfloat factor, GLfloat units, GLfloat clamp );
+        void       (WINE_GLAPI *p_glPolygonOffsetClampEXT)( GLfloat factor, GLfloat units, GLfloat clamp );
+        void       (WINE_GLAPI *p_glPolygonOffsetEXT)( GLfloat factor, GLfloat bias );
+        void       (WINE_GLAPI *p_glPolygonOffsetxOES)( GLfixed factor, GLfixed units );
         void       (WINE_GLAPI *p_glPopDebugGroup)(void);
         void       (WINE_GLAPI *p_glPopGroupMarkerEXT)(void);
-        void       (WINE_GLAPI *p_glPresentFrameDualFillNV)(GLuint,GLuint64EXT,GLuint,GLuint,GLenum,GLenum,GLuint,GLenum,GLuint,GLenum,GLuint,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glPresentFrameKeyedNV)(GLuint,GLuint64EXT,GLuint,GLuint,GLenum,GLenum,GLuint,GLuint,GLenum,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glPrimitiveBoundingBoxARB)(GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glPrimitiveRestartIndex)(GLuint);
-        void       (WINE_GLAPI *p_glPrimitiveRestartIndexNV)(GLuint);
+        void       (WINE_GLAPI *p_glPresentFrameDualFillNV)( GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLenum target1, GLuint fill1, GLenum target2, GLuint fill2, GLenum target3, GLuint fill3 );
+        void       (WINE_GLAPI *p_glPresentFrameKeyedNV)( GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1 );
+        void       (WINE_GLAPI *p_glPrimitiveBoundingBoxARB)( GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW );
+        void       (WINE_GLAPI *p_glPrimitiveRestartIndex)( GLuint index );
+        void       (WINE_GLAPI *p_glPrimitiveRestartIndexNV)( GLuint index );
         void       (WINE_GLAPI *p_glPrimitiveRestartNV)(void);
-        void       (WINE_GLAPI *p_glPrioritizeTexturesEXT)(GLsizei,const GLuint*,const GLclampf*);
-        void       (WINE_GLAPI *p_glPrioritizeTexturesxOES)(GLsizei,const GLuint*,const GLfixed*);
-        void       (WINE_GLAPI *p_glProgramBinary)(GLuint,GLenum,const void*,GLsizei);
-        void       (WINE_GLAPI *p_glProgramBufferParametersIivNV)(GLenum,GLuint,GLuint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glProgramBufferParametersIuivNV)(GLenum,GLuint,GLuint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glProgramBufferParametersfvNV)(GLenum,GLuint,GLuint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramEnvParameter4dARB)(GLenum,GLuint,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glProgramEnvParameter4dvARB)(GLenum,GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramEnvParameter4fARB)(GLenum,GLuint,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glProgramEnvParameter4fvARB)(GLenum,GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramEnvParameterI4iNV)(GLenum,GLuint,GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glProgramEnvParameterI4ivNV)(GLenum,GLuint,const GLint*);
-        void       (WINE_GLAPI *p_glProgramEnvParameterI4uiNV)(GLenum,GLuint,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glProgramEnvParameterI4uivNV)(GLenum,GLuint,const GLuint*);
-        void       (WINE_GLAPI *p_glProgramEnvParameters4fvEXT)(GLenum,GLuint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramEnvParametersI4ivNV)(GLenum,GLuint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glProgramEnvParametersI4uivNV)(GLenum,GLuint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glProgramLocalParameter4dARB)(GLenum,GLuint,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glProgramLocalParameter4dvARB)(GLenum,GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramLocalParameter4fARB)(GLenum,GLuint,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glProgramLocalParameter4fvARB)(GLenum,GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramLocalParameterI4iNV)(GLenum,GLuint,GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glProgramLocalParameterI4ivNV)(GLenum,GLuint,const GLint*);
-        void       (WINE_GLAPI *p_glProgramLocalParameterI4uiNV)(GLenum,GLuint,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glProgramLocalParameterI4uivNV)(GLenum,GLuint,const GLuint*);
-        void       (WINE_GLAPI *p_glProgramLocalParameters4fvEXT)(GLenum,GLuint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramLocalParametersI4ivNV)(GLenum,GLuint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glProgramLocalParametersI4uivNV)(GLenum,GLuint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glProgramNamedParameter4dNV)(GLuint,GLsizei,const GLubyte*,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glProgramNamedParameter4dvNV)(GLuint,GLsizei,const GLubyte*,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramNamedParameter4fNV)(GLuint,GLsizei,const GLubyte*,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glProgramNamedParameter4fvNV)(GLuint,GLsizei,const GLubyte*,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramParameter4dNV)(GLenum,GLuint,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glProgramParameter4dvNV)(GLenum,GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramParameter4fNV)(GLenum,GLuint,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glProgramParameter4fvNV)(GLenum,GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramParameteri)(GLuint,GLenum,GLint);
-        void       (WINE_GLAPI *p_glProgramParameteriARB)(GLuint,GLenum,GLint);
-        void       (WINE_GLAPI *p_glProgramParameteriEXT)(GLuint,GLenum,GLint);
-        void       (WINE_GLAPI *p_glProgramParameters4dvNV)(GLenum,GLuint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramParameters4fvNV)(GLenum,GLuint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramPathFragmentInputGenNV)(GLuint,GLint,GLenum,GLint,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramStringARB)(GLenum,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glProgramSubroutineParametersuivNV)(GLenum,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glProgramUniform1d)(GLuint,GLint,GLdouble);
-        void       (WINE_GLAPI *p_glProgramUniform1dEXT)(GLuint,GLint,GLdouble);
-        void       (WINE_GLAPI *p_glProgramUniform1dv)(GLuint,GLint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniform1dvEXT)(GLuint,GLint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniform1f)(GLuint,GLint,GLfloat);
-        void       (WINE_GLAPI *p_glProgramUniform1fEXT)(GLuint,GLint,GLfloat);
-        void       (WINE_GLAPI *p_glProgramUniform1fv)(GLuint,GLint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniform1fvEXT)(GLuint,GLint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniform1i)(GLuint,GLint,GLint);
-        void       (WINE_GLAPI *p_glProgramUniform1i64ARB)(GLuint,GLint,GLint64);
-        void       (WINE_GLAPI *p_glProgramUniform1i64NV)(GLuint,GLint,GLint64EXT);
-        void       (WINE_GLAPI *p_glProgramUniform1i64vARB)(GLuint,GLint,GLsizei,const GLint64*);
-        void       (WINE_GLAPI *p_glProgramUniform1i64vNV)(GLuint,GLint,GLsizei,const GLint64EXT*);
-        void       (WINE_GLAPI *p_glProgramUniform1iEXT)(GLuint,GLint,GLint);
-        void       (WINE_GLAPI *p_glProgramUniform1iv)(GLuint,GLint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glProgramUniform1ivEXT)(GLuint,GLint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glProgramUniform1ui)(GLuint,GLint,GLuint);
-        void       (WINE_GLAPI *p_glProgramUniform1ui64ARB)(GLuint,GLint,GLuint64);
-        void       (WINE_GLAPI *p_glProgramUniform1ui64NV)(GLuint,GLint,GLuint64EXT);
-        void       (WINE_GLAPI *p_glProgramUniform1ui64vARB)(GLuint,GLint,GLsizei,const GLuint64*);
-        void       (WINE_GLAPI *p_glProgramUniform1ui64vNV)(GLuint,GLint,GLsizei,const GLuint64EXT*);
-        void       (WINE_GLAPI *p_glProgramUniform1uiEXT)(GLuint,GLint,GLuint);
-        void       (WINE_GLAPI *p_glProgramUniform1uiv)(GLuint,GLint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glProgramUniform1uivEXT)(GLuint,GLint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glProgramUniform2d)(GLuint,GLint,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glProgramUniform2dEXT)(GLuint,GLint,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glProgramUniform2dv)(GLuint,GLint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniform2dvEXT)(GLuint,GLint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniform2f)(GLuint,GLint,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glProgramUniform2fEXT)(GLuint,GLint,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glProgramUniform2fv)(GLuint,GLint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniform2fvEXT)(GLuint,GLint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniform2i)(GLuint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glProgramUniform2i64ARB)(GLuint,GLint,GLint64,GLint64);
-        void       (WINE_GLAPI *p_glProgramUniform2i64NV)(GLuint,GLint,GLint64EXT,GLint64EXT);
-        void       (WINE_GLAPI *p_glProgramUniform2i64vARB)(GLuint,GLint,GLsizei,const GLint64*);
-        void       (WINE_GLAPI *p_glProgramUniform2i64vNV)(GLuint,GLint,GLsizei,const GLint64EXT*);
-        void       (WINE_GLAPI *p_glProgramUniform2iEXT)(GLuint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glProgramUniform2iv)(GLuint,GLint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glProgramUniform2ivEXT)(GLuint,GLint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glProgramUniform2ui)(GLuint,GLint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glProgramUniform2ui64ARB)(GLuint,GLint,GLuint64,GLuint64);
-        void       (WINE_GLAPI *p_glProgramUniform2ui64NV)(GLuint,GLint,GLuint64EXT,GLuint64EXT);
-        void       (WINE_GLAPI *p_glProgramUniform2ui64vARB)(GLuint,GLint,GLsizei,const GLuint64*);
-        void       (WINE_GLAPI *p_glProgramUniform2ui64vNV)(GLuint,GLint,GLsizei,const GLuint64EXT*);
-        void       (WINE_GLAPI *p_glProgramUniform2uiEXT)(GLuint,GLint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glProgramUniform2uiv)(GLuint,GLint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glProgramUniform2uivEXT)(GLuint,GLint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glProgramUniform3d)(GLuint,GLint,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glProgramUniform3dEXT)(GLuint,GLint,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glProgramUniform3dv)(GLuint,GLint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniform3dvEXT)(GLuint,GLint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniform3f)(GLuint,GLint,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glProgramUniform3fEXT)(GLuint,GLint,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glProgramUniform3fv)(GLuint,GLint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniform3fvEXT)(GLuint,GLint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniform3i)(GLuint,GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glProgramUniform3i64ARB)(GLuint,GLint,GLint64,GLint64,GLint64);
-        void       (WINE_GLAPI *p_glProgramUniform3i64NV)(GLuint,GLint,GLint64EXT,GLint64EXT,GLint64EXT);
-        void       (WINE_GLAPI *p_glProgramUniform3i64vARB)(GLuint,GLint,GLsizei,const GLint64*);
-        void       (WINE_GLAPI *p_glProgramUniform3i64vNV)(GLuint,GLint,GLsizei,const GLint64EXT*);
-        void       (WINE_GLAPI *p_glProgramUniform3iEXT)(GLuint,GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glProgramUniform3iv)(GLuint,GLint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glProgramUniform3ivEXT)(GLuint,GLint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glProgramUniform3ui)(GLuint,GLint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glProgramUniform3ui64ARB)(GLuint,GLint,GLuint64,GLuint64,GLuint64);
-        void       (WINE_GLAPI *p_glProgramUniform3ui64NV)(GLuint,GLint,GLuint64EXT,GLuint64EXT,GLuint64EXT);
-        void       (WINE_GLAPI *p_glProgramUniform3ui64vARB)(GLuint,GLint,GLsizei,const GLuint64*);
-        void       (WINE_GLAPI *p_glProgramUniform3ui64vNV)(GLuint,GLint,GLsizei,const GLuint64EXT*);
-        void       (WINE_GLAPI *p_glProgramUniform3uiEXT)(GLuint,GLint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glProgramUniform3uiv)(GLuint,GLint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glProgramUniform3uivEXT)(GLuint,GLint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glProgramUniform4d)(GLuint,GLint,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glProgramUniform4dEXT)(GLuint,GLint,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glProgramUniform4dv)(GLuint,GLint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniform4dvEXT)(GLuint,GLint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniform4f)(GLuint,GLint,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glProgramUniform4fEXT)(GLuint,GLint,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glProgramUniform4fv)(GLuint,GLint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniform4fvEXT)(GLuint,GLint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniform4i)(GLuint,GLint,GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glProgramUniform4i64ARB)(GLuint,GLint,GLint64,GLint64,GLint64,GLint64);
-        void       (WINE_GLAPI *p_glProgramUniform4i64NV)(GLuint,GLint,GLint64EXT,GLint64EXT,GLint64EXT,GLint64EXT);
-        void       (WINE_GLAPI *p_glProgramUniform4i64vARB)(GLuint,GLint,GLsizei,const GLint64*);
-        void       (WINE_GLAPI *p_glProgramUniform4i64vNV)(GLuint,GLint,GLsizei,const GLint64EXT*);
-        void       (WINE_GLAPI *p_glProgramUniform4iEXT)(GLuint,GLint,GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glProgramUniform4iv)(GLuint,GLint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glProgramUniform4ivEXT)(GLuint,GLint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glProgramUniform4ui)(GLuint,GLint,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glProgramUniform4ui64ARB)(GLuint,GLint,GLuint64,GLuint64,GLuint64,GLuint64);
-        void       (WINE_GLAPI *p_glProgramUniform4ui64NV)(GLuint,GLint,GLuint64EXT,GLuint64EXT,GLuint64EXT,GLuint64EXT);
-        void       (WINE_GLAPI *p_glProgramUniform4ui64vARB)(GLuint,GLint,GLsizei,const GLuint64*);
-        void       (WINE_GLAPI *p_glProgramUniform4ui64vNV)(GLuint,GLint,GLsizei,const GLuint64EXT*);
-        void       (WINE_GLAPI *p_glProgramUniform4uiEXT)(GLuint,GLint,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glProgramUniform4uiv)(GLuint,GLint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glProgramUniform4uivEXT)(GLuint,GLint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glProgramUniformHandleui64ARB)(GLuint,GLint,GLuint64);
-        void       (WINE_GLAPI *p_glProgramUniformHandleui64NV)(GLuint,GLint,GLuint64);
-        void       (WINE_GLAPI *p_glProgramUniformHandleui64vARB)(GLuint,GLint,GLsizei,const GLuint64*);
-        void       (WINE_GLAPI *p_glProgramUniformHandleui64vNV)(GLuint,GLint,GLsizei,const GLuint64*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix2dv)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix2dvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix2fv)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix2fvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix2x3dv)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix2x3dvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix2x3fv)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix2x3fvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix2x4dv)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix2x4dvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix2x4fv)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix2x4fvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix3dv)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix3dvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix3fv)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix3fvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix3x2dv)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix3x2dvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix3x2fv)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix3x2fvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix3x4dv)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix3x4dvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix3x4fv)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix3x4fvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix4dv)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix4dvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix4fv)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix4fvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix4x2dv)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix4x2dvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix4x2fv)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix4x2fvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix4x3dv)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix4x3dvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix4x3fv)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformMatrix4x3fvEXT)(GLuint,GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glProgramUniformui64NV)(GLuint,GLint,GLuint64EXT);
-        void       (WINE_GLAPI *p_glProgramUniformui64vNV)(GLuint,GLint,GLsizei,const GLuint64EXT*);
-        void       (WINE_GLAPI *p_glProgramVertexLimitNV)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glProvokingVertex)(GLenum);
-        void       (WINE_GLAPI *p_glProvokingVertexEXT)(GLenum);
-        void       (WINE_GLAPI *p_glPushClientAttribDefaultEXT)(GLbitfield);
-        void       (WINE_GLAPI *p_glPushDebugGroup)(GLenum,GLuint,GLsizei,const GLchar*);
-        void       (WINE_GLAPI *p_glPushGroupMarkerEXT)(GLsizei,const GLchar*);
-        void       (WINE_GLAPI *p_glQueryCounter)(GLuint,GLenum);
-        GLbitfield (WINE_GLAPI *p_glQueryMatrixxOES)(GLfixed*,GLint*);
-        void       (WINE_GLAPI *p_glQueryObjectParameteruiAMD)(GLenum,GLuint,GLenum,GLuint);
-        GLint      (WINE_GLAPI *p_glQueryResourceNV)(GLenum,GLint,GLuint,GLint*);
-        void       (WINE_GLAPI *p_glQueryResourceTagNV)(GLint,const GLchar*);
-        void       (WINE_GLAPI *p_glRasterPos2xOES)(GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glRasterPos2xvOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glRasterPos3xOES)(GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glRasterPos3xvOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glRasterPos4xOES)(GLfixed,GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glRasterPos4xvOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glRasterSamplesEXT)(GLuint,GLboolean);
-        void       (WINE_GLAPI *p_glReadBufferRegion)(GLenum,GLint,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glReadInstrumentsSGIX)(GLint);
-        void       (WINE_GLAPI *p_glReadnPixels)(GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,GLsizei,void*);
-        void       (WINE_GLAPI *p_glReadnPixelsARB)(GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,GLsizei,void*);
-        void       (WINE_GLAPI *p_glRectxOES)(GLfixed,GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glRectxvOES)(const GLfixed*,const GLfixed*);
-        void       (WINE_GLAPI *p_glReferencePlaneSGIX)(const GLdouble*);
-        GLboolean  (WINE_GLAPI *p_glReleaseKeyedMutexWin32EXT)(GLuint,GLuint64);
+        void       (WINE_GLAPI *p_glPrioritizeTexturesEXT)( GLsizei n, const GLuint *textures, const GLclampf *priorities );
+        void       (WINE_GLAPI *p_glPrioritizeTexturesxOES)( GLsizei n, const GLuint *textures, const GLfixed *priorities );
+        void       (WINE_GLAPI *p_glProgramBinary)( GLuint program, GLenum binaryFormat, const void *binary, GLsizei length );
+        void       (WINE_GLAPI *p_glProgramBufferParametersIivNV)( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLint *params );
+        void       (WINE_GLAPI *p_glProgramBufferParametersIuivNV)( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLuint *params );
+        void       (WINE_GLAPI *p_glProgramBufferParametersfvNV)( GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLfloat *params );
+        void       (WINE_GLAPI *p_glProgramEnvParameter4dARB)( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+        void       (WINE_GLAPI *p_glProgramEnvParameter4dvARB)( GLenum target, GLuint index, const GLdouble *params );
+        void       (WINE_GLAPI *p_glProgramEnvParameter4fARB)( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
+        void       (WINE_GLAPI *p_glProgramEnvParameter4fvARB)( GLenum target, GLuint index, const GLfloat *params );
+        void       (WINE_GLAPI *p_glProgramEnvParameterI4iNV)( GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w );
+        void       (WINE_GLAPI *p_glProgramEnvParameterI4ivNV)( GLenum target, GLuint index, const GLint *params );
+        void       (WINE_GLAPI *p_glProgramEnvParameterI4uiNV)( GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w );
+        void       (WINE_GLAPI *p_glProgramEnvParameterI4uivNV)( GLenum target, GLuint index, const GLuint *params );
+        void       (WINE_GLAPI *p_glProgramEnvParameters4fvEXT)( GLenum target, GLuint index, GLsizei count, const GLfloat *params );
+        void       (WINE_GLAPI *p_glProgramEnvParametersI4ivNV)( GLenum target, GLuint index, GLsizei count, const GLint *params );
+        void       (WINE_GLAPI *p_glProgramEnvParametersI4uivNV)( GLenum target, GLuint index, GLsizei count, const GLuint *params );
+        void       (WINE_GLAPI *p_glProgramLocalParameter4dARB)( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+        void       (WINE_GLAPI *p_glProgramLocalParameter4dvARB)( GLenum target, GLuint index, const GLdouble *params );
+        void       (WINE_GLAPI *p_glProgramLocalParameter4fARB)( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
+        void       (WINE_GLAPI *p_glProgramLocalParameter4fvARB)( GLenum target, GLuint index, const GLfloat *params );
+        void       (WINE_GLAPI *p_glProgramLocalParameterI4iNV)( GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w );
+        void       (WINE_GLAPI *p_glProgramLocalParameterI4ivNV)( GLenum target, GLuint index, const GLint *params );
+        void       (WINE_GLAPI *p_glProgramLocalParameterI4uiNV)( GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w );
+        void       (WINE_GLAPI *p_glProgramLocalParameterI4uivNV)( GLenum target, GLuint index, const GLuint *params );
+        void       (WINE_GLAPI *p_glProgramLocalParameters4fvEXT)( GLenum target, GLuint index, GLsizei count, const GLfloat *params );
+        void       (WINE_GLAPI *p_glProgramLocalParametersI4ivNV)( GLenum target, GLuint index, GLsizei count, const GLint *params );
+        void       (WINE_GLAPI *p_glProgramLocalParametersI4uivNV)( GLenum target, GLuint index, GLsizei count, const GLuint *params );
+        void       (WINE_GLAPI *p_glProgramNamedParameter4dNV)( GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+        void       (WINE_GLAPI *p_glProgramNamedParameter4dvNV)( GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v );
+        void       (WINE_GLAPI *p_glProgramNamedParameter4fNV)( GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
+        void       (WINE_GLAPI *p_glProgramNamedParameter4fvNV)( GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v );
+        void       (WINE_GLAPI *p_glProgramParameter4dNV)( GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+        void       (WINE_GLAPI *p_glProgramParameter4dvNV)( GLenum target, GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glProgramParameter4fNV)( GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
+        void       (WINE_GLAPI *p_glProgramParameter4fvNV)( GLenum target, GLuint index, const GLfloat *v );
+        void       (WINE_GLAPI *p_glProgramParameteri)( GLuint program, GLenum pname, GLint value );
+        void       (WINE_GLAPI *p_glProgramParameteriARB)( GLuint program, GLenum pname, GLint value );
+        void       (WINE_GLAPI *p_glProgramParameteriEXT)( GLuint program, GLenum pname, GLint value );
+        void       (WINE_GLAPI *p_glProgramParameters4dvNV)( GLenum target, GLuint index, GLsizei count, const GLdouble *v );
+        void       (WINE_GLAPI *p_glProgramParameters4fvNV)( GLenum target, GLuint index, GLsizei count, const GLfloat *v );
+        void       (WINE_GLAPI *p_glProgramPathFragmentInputGenNV)( GLuint program, GLint location, GLenum genMode, GLint components, const GLfloat *coeffs );
+        void       (WINE_GLAPI *p_glProgramStringARB)( GLenum target, GLenum format, GLsizei len, const void *string );
+        void       (WINE_GLAPI *p_glProgramSubroutineParametersuivNV)( GLenum target, GLsizei count, const GLuint *params );
+        void       (WINE_GLAPI *p_glProgramUniform1d)( GLuint program, GLint location, GLdouble v0 );
+        void       (WINE_GLAPI *p_glProgramUniform1dEXT)( GLuint program, GLint location, GLdouble x );
+        void       (WINE_GLAPI *p_glProgramUniform1dv)( GLuint program, GLint location, GLsizei count, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniform1dvEXT)( GLuint program, GLint location, GLsizei count, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniform1f)( GLuint program, GLint location, GLfloat v0 );
+        void       (WINE_GLAPI *p_glProgramUniform1fEXT)( GLuint program, GLint location, GLfloat v0 );
+        void       (WINE_GLAPI *p_glProgramUniform1fv)( GLuint program, GLint location, GLsizei count, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniform1fvEXT)( GLuint program, GLint location, GLsizei count, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniform1i)( GLuint program, GLint location, GLint v0 );
+        void       (WINE_GLAPI *p_glProgramUniform1i64ARB)( GLuint program, GLint location, GLint64 x );
+        void       (WINE_GLAPI *p_glProgramUniform1i64NV)( GLuint program, GLint location, GLint64EXT x );
+        void       (WINE_GLAPI *p_glProgramUniform1i64vARB)( GLuint program, GLint location, GLsizei count, const GLint64 *value );
+        void       (WINE_GLAPI *p_glProgramUniform1i64vNV)( GLuint program, GLint location, GLsizei count, const GLint64EXT *value );
+        void       (WINE_GLAPI *p_glProgramUniform1iEXT)( GLuint program, GLint location, GLint v0 );
+        void       (WINE_GLAPI *p_glProgramUniform1iv)( GLuint program, GLint location, GLsizei count, const GLint *value );
+        void       (WINE_GLAPI *p_glProgramUniform1ivEXT)( GLuint program, GLint location, GLsizei count, const GLint *value );
+        void       (WINE_GLAPI *p_glProgramUniform1ui)( GLuint program, GLint location, GLuint v0 );
+        void       (WINE_GLAPI *p_glProgramUniform1ui64ARB)( GLuint program, GLint location, GLuint64 x );
+        void       (WINE_GLAPI *p_glProgramUniform1ui64NV)( GLuint program, GLint location, GLuint64EXT x );
+        void       (WINE_GLAPI *p_glProgramUniform1ui64vARB)( GLuint program, GLint location, GLsizei count, const GLuint64 *value );
+        void       (WINE_GLAPI *p_glProgramUniform1ui64vNV)( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value );
+        void       (WINE_GLAPI *p_glProgramUniform1uiEXT)( GLuint program, GLint location, GLuint v0 );
+        void       (WINE_GLAPI *p_glProgramUniform1uiv)( GLuint program, GLint location, GLsizei count, const GLuint *value );
+        void       (WINE_GLAPI *p_glProgramUniform1uivEXT)( GLuint program, GLint location, GLsizei count, const GLuint *value );
+        void       (WINE_GLAPI *p_glProgramUniform2d)( GLuint program, GLint location, GLdouble v0, GLdouble v1 );
+        void       (WINE_GLAPI *p_glProgramUniform2dEXT)( GLuint program, GLint location, GLdouble x, GLdouble y );
+        void       (WINE_GLAPI *p_glProgramUniform2dv)( GLuint program, GLint location, GLsizei count, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniform2dvEXT)( GLuint program, GLint location, GLsizei count, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniform2f)( GLuint program, GLint location, GLfloat v0, GLfloat v1 );
+        void       (WINE_GLAPI *p_glProgramUniform2fEXT)( GLuint program, GLint location, GLfloat v0, GLfloat v1 );
+        void       (WINE_GLAPI *p_glProgramUniform2fv)( GLuint program, GLint location, GLsizei count, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniform2fvEXT)( GLuint program, GLint location, GLsizei count, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniform2i)( GLuint program, GLint location, GLint v0, GLint v1 );
+        void       (WINE_GLAPI *p_glProgramUniform2i64ARB)( GLuint program, GLint location, GLint64 x, GLint64 y );
+        void       (WINE_GLAPI *p_glProgramUniform2i64NV)( GLuint program, GLint location, GLint64EXT x, GLint64EXT y );
+        void       (WINE_GLAPI *p_glProgramUniform2i64vARB)( GLuint program, GLint location, GLsizei count, const GLint64 *value );
+        void       (WINE_GLAPI *p_glProgramUniform2i64vNV)( GLuint program, GLint location, GLsizei count, const GLint64EXT *value );
+        void       (WINE_GLAPI *p_glProgramUniform2iEXT)( GLuint program, GLint location, GLint v0, GLint v1 );
+        void       (WINE_GLAPI *p_glProgramUniform2iv)( GLuint program, GLint location, GLsizei count, const GLint *value );
+        void       (WINE_GLAPI *p_glProgramUniform2ivEXT)( GLuint program, GLint location, GLsizei count, const GLint *value );
+        void       (WINE_GLAPI *p_glProgramUniform2ui)( GLuint program, GLint location, GLuint v0, GLuint v1 );
+        void       (WINE_GLAPI *p_glProgramUniform2ui64ARB)( GLuint program, GLint location, GLuint64 x, GLuint64 y );
+        void       (WINE_GLAPI *p_glProgramUniform2ui64NV)( GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y );
+        void       (WINE_GLAPI *p_glProgramUniform2ui64vARB)( GLuint program, GLint location, GLsizei count, const GLuint64 *value );
+        void       (WINE_GLAPI *p_glProgramUniform2ui64vNV)( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value );
+        void       (WINE_GLAPI *p_glProgramUniform2uiEXT)( GLuint program, GLint location, GLuint v0, GLuint v1 );
+        void       (WINE_GLAPI *p_glProgramUniform2uiv)( GLuint program, GLint location, GLsizei count, const GLuint *value );
+        void       (WINE_GLAPI *p_glProgramUniform2uivEXT)( GLuint program, GLint location, GLsizei count, const GLuint *value );
+        void       (WINE_GLAPI *p_glProgramUniform3d)( GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2 );
+        void       (WINE_GLAPI *p_glProgramUniform3dEXT)( GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glProgramUniform3dv)( GLuint program, GLint location, GLsizei count, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniform3dvEXT)( GLuint program, GLint location, GLsizei count, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniform3f)( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 );
+        void       (WINE_GLAPI *p_glProgramUniform3fEXT)( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2 );
+        void       (WINE_GLAPI *p_glProgramUniform3fv)( GLuint program, GLint location, GLsizei count, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniform3fvEXT)( GLuint program, GLint location, GLsizei count, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniform3i)( GLuint program, GLint location, GLint v0, GLint v1, GLint v2 );
+        void       (WINE_GLAPI *p_glProgramUniform3i64ARB)( GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z );
+        void       (WINE_GLAPI *p_glProgramUniform3i64NV)( GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z );
+        void       (WINE_GLAPI *p_glProgramUniform3i64vARB)( GLuint program, GLint location, GLsizei count, const GLint64 *value );
+        void       (WINE_GLAPI *p_glProgramUniform3i64vNV)( GLuint program, GLint location, GLsizei count, const GLint64EXT *value );
+        void       (WINE_GLAPI *p_glProgramUniform3iEXT)( GLuint program, GLint location, GLint v0, GLint v1, GLint v2 );
+        void       (WINE_GLAPI *p_glProgramUniform3iv)( GLuint program, GLint location, GLsizei count, const GLint *value );
+        void       (WINE_GLAPI *p_glProgramUniform3ivEXT)( GLuint program, GLint location, GLsizei count, const GLint *value );
+        void       (WINE_GLAPI *p_glProgramUniform3ui)( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 );
+        void       (WINE_GLAPI *p_glProgramUniform3ui64ARB)( GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z );
+        void       (WINE_GLAPI *p_glProgramUniform3ui64NV)( GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z );
+        void       (WINE_GLAPI *p_glProgramUniform3ui64vARB)( GLuint program, GLint location, GLsizei count, const GLuint64 *value );
+        void       (WINE_GLAPI *p_glProgramUniform3ui64vNV)( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value );
+        void       (WINE_GLAPI *p_glProgramUniform3uiEXT)( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2 );
+        void       (WINE_GLAPI *p_glProgramUniform3uiv)( GLuint program, GLint location, GLsizei count, const GLuint *value );
+        void       (WINE_GLAPI *p_glProgramUniform3uivEXT)( GLuint program, GLint location, GLsizei count, const GLuint *value );
+        void       (WINE_GLAPI *p_glProgramUniform4d)( GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3 );
+        void       (WINE_GLAPI *p_glProgramUniform4dEXT)( GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+        void       (WINE_GLAPI *p_glProgramUniform4dv)( GLuint program, GLint location, GLsizei count, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniform4dvEXT)( GLuint program, GLint location, GLsizei count, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniform4f)( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 );
+        void       (WINE_GLAPI *p_glProgramUniform4fEXT)( GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 );
+        void       (WINE_GLAPI *p_glProgramUniform4fv)( GLuint program, GLint location, GLsizei count, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniform4fvEXT)( GLuint program, GLint location, GLsizei count, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniform4i)( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 );
+        void       (WINE_GLAPI *p_glProgramUniform4i64ARB)( GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w );
+        void       (WINE_GLAPI *p_glProgramUniform4i64NV)( GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w );
+        void       (WINE_GLAPI *p_glProgramUniform4i64vARB)( GLuint program, GLint location, GLsizei count, const GLint64 *value );
+        void       (WINE_GLAPI *p_glProgramUniform4i64vNV)( GLuint program, GLint location, GLsizei count, const GLint64EXT *value );
+        void       (WINE_GLAPI *p_glProgramUniform4iEXT)( GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3 );
+        void       (WINE_GLAPI *p_glProgramUniform4iv)( GLuint program, GLint location, GLsizei count, const GLint *value );
+        void       (WINE_GLAPI *p_glProgramUniform4ivEXT)( GLuint program, GLint location, GLsizei count, const GLint *value );
+        void       (WINE_GLAPI *p_glProgramUniform4ui)( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 );
+        void       (WINE_GLAPI *p_glProgramUniform4ui64ARB)( GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w );
+        void       (WINE_GLAPI *p_glProgramUniform4ui64NV)( GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w );
+        void       (WINE_GLAPI *p_glProgramUniform4ui64vARB)( GLuint program, GLint location, GLsizei count, const GLuint64 *value );
+        void       (WINE_GLAPI *p_glProgramUniform4ui64vNV)( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value );
+        void       (WINE_GLAPI *p_glProgramUniform4uiEXT)( GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 );
+        void       (WINE_GLAPI *p_glProgramUniform4uiv)( GLuint program, GLint location, GLsizei count, const GLuint *value );
+        void       (WINE_GLAPI *p_glProgramUniform4uivEXT)( GLuint program, GLint location, GLsizei count, const GLuint *value );
+        void       (WINE_GLAPI *p_glProgramUniformHandleui64ARB)( GLuint program, GLint location, GLuint64 value );
+        void       (WINE_GLAPI *p_glProgramUniformHandleui64NV)( GLuint program, GLint location, GLuint64 value );
+        void       (WINE_GLAPI *p_glProgramUniformHandleui64vARB)( GLuint program, GLint location, GLsizei count, const GLuint64 *values );
+        void       (WINE_GLAPI *p_glProgramUniformHandleui64vNV)( GLuint program, GLint location, GLsizei count, const GLuint64 *values );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix2dv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix2dvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix2fv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix2fvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix2x3dv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix2x3dvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix2x3fv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix2x3fvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix2x4dv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix2x4dvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix2x4fv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix2x4fvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix3dv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix3dvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix3fv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix3fvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix3x2dv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix3x2dvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix3x2fv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix3x2fvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix3x4dv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix3x4dvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix3x4fv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix3x4fvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix4dv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix4dvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix4fv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix4fvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix4x2dv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix4x2dvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix4x2fv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix4x2fvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix4x3dv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix4x3dvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix4x3fv)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformMatrix4x3fvEXT)( GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glProgramUniformui64NV)( GLuint program, GLint location, GLuint64EXT value );
+        void       (WINE_GLAPI *p_glProgramUniformui64vNV)( GLuint program, GLint location, GLsizei count, const GLuint64EXT *value );
+        void       (WINE_GLAPI *p_glProgramVertexLimitNV)( GLenum target, GLint limit );
+        void       (WINE_GLAPI *p_glProvokingVertex)( GLenum mode );
+        void       (WINE_GLAPI *p_glProvokingVertexEXT)( GLenum mode );
+        void       (WINE_GLAPI *p_glPushClientAttribDefaultEXT)( GLbitfield mask );
+        void       (WINE_GLAPI *p_glPushDebugGroup)( GLenum source, GLuint id, GLsizei length, const GLchar *message );
+        void       (WINE_GLAPI *p_glPushGroupMarkerEXT)( GLsizei length, const GLchar *marker );
+        void       (WINE_GLAPI *p_glQueryCounter)( GLuint id, GLenum target );
+        GLbitfield (WINE_GLAPI *p_glQueryMatrixxOES)( GLfixed *mantissa, GLint *exponent );
+        void       (WINE_GLAPI *p_glQueryObjectParameteruiAMD)( GLenum target, GLuint id, GLenum pname, GLuint param );
+        GLint      (WINE_GLAPI *p_glQueryResourceNV)( GLenum queryType, GLint tagId, GLuint bufSize, GLint *buffer );
+        void       (WINE_GLAPI *p_glQueryResourceTagNV)( GLint tagId, const GLchar *tagString );
+        void       (WINE_GLAPI *p_glRasterPos2xOES)( GLfixed x, GLfixed y );
+        void       (WINE_GLAPI *p_glRasterPos2xvOES)( const GLfixed *coords );
+        void       (WINE_GLAPI *p_glRasterPos3xOES)( GLfixed x, GLfixed y, GLfixed z );
+        void       (WINE_GLAPI *p_glRasterPos3xvOES)( const GLfixed *coords );
+        void       (WINE_GLAPI *p_glRasterPos4xOES)( GLfixed x, GLfixed y, GLfixed z, GLfixed w );
+        void       (WINE_GLAPI *p_glRasterPos4xvOES)( const GLfixed *coords );
+        void       (WINE_GLAPI *p_glRasterSamplesEXT)( GLuint samples, GLboolean fixedsamplelocations );
+        void       (WINE_GLAPI *p_glReadBufferRegion)( GLenum region, GLint x, GLint y, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glReadInstrumentsSGIX)( GLint marker );
+        void       (WINE_GLAPI *p_glReadnPixels)( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data );
+        void       (WINE_GLAPI *p_glReadnPixelsARB)( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data );
+        void       (WINE_GLAPI *p_glRectxOES)( GLfixed x1, GLfixed y1, GLfixed x2, GLfixed y2 );
+        void       (WINE_GLAPI *p_glRectxvOES)( const GLfixed *v1, const GLfixed *v2 );
+        void       (WINE_GLAPI *p_glReferencePlaneSGIX)( const GLdouble *equation );
+        GLboolean  (WINE_GLAPI *p_glReleaseKeyedMutexWin32EXT)( GLuint memory, GLuint64 key );
         void       (WINE_GLAPI *p_glReleaseShaderCompiler)(void);
-        void       (WINE_GLAPI *p_glRenderGpuMaskNV)(GLbitfield);
-        void       (WINE_GLAPI *p_glRenderbufferStorage)(GLenum,GLenum,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glRenderbufferStorageEXT)(GLenum,GLenum,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glRenderbufferStorageMultisample)(GLenum,GLsizei,GLenum,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glRenderbufferStorageMultisampleCoverageNV)(GLenum,GLsizei,GLsizei,GLenum,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glRenderbufferStorageMultisampleEXT)(GLenum,GLsizei,GLenum,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glReplacementCodePointerSUN)(GLenum,GLsizei,const void**);
-        void       (WINE_GLAPI *p_glReplacementCodeubSUN)(GLubyte);
-        void       (WINE_GLAPI *p_glReplacementCodeubvSUN)(const GLubyte*);
-        void       (WINE_GLAPI *p_glReplacementCodeuiColor3fVertex3fSUN)(GLuint,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glReplacementCodeuiColor3fVertex3fvSUN)(const GLuint*,const GLfloat*,const GLfloat*);
-        void       (WINE_GLAPI *p_glReplacementCodeuiColor4fNormal3fVertex3fSUN)(GLuint,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glReplacementCodeuiColor4fNormal3fVertex3fvSUN)(const GLuint*,const GLfloat*,const GLfloat*,const GLfloat*);
-        void       (WINE_GLAPI *p_glReplacementCodeuiColor4ubVertex3fSUN)(GLuint,GLubyte,GLubyte,GLubyte,GLubyte,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glReplacementCodeuiColor4ubVertex3fvSUN)(const GLuint*,const GLubyte*,const GLfloat*);
-        void       (WINE_GLAPI *p_glReplacementCodeuiNormal3fVertex3fSUN)(GLuint,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glReplacementCodeuiNormal3fVertex3fvSUN)(const GLuint*,const GLfloat*,const GLfloat*);
-        void       (WINE_GLAPI *p_glReplacementCodeuiSUN)(GLuint);
-        void       (WINE_GLAPI *p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN)(GLuint,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN)(const GLuint*,const GLfloat*,const GLfloat*,const GLfloat*,const GLfloat*);
-        void       (WINE_GLAPI *p_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN)(GLuint,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN)(const GLuint*,const GLfloat*,const GLfloat*,const GLfloat*);
-        void       (WINE_GLAPI *p_glReplacementCodeuiTexCoord2fVertex3fSUN)(GLuint,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glReplacementCodeuiTexCoord2fVertex3fvSUN)(const GLuint*,const GLfloat*,const GLfloat*);
-        void       (WINE_GLAPI *p_glReplacementCodeuiVertex3fSUN)(GLuint,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glReplacementCodeuiVertex3fvSUN)(const GLuint*,const GLfloat*);
-        void       (WINE_GLAPI *p_glReplacementCodeuivSUN)(const GLuint*);
-        void       (WINE_GLAPI *p_glReplacementCodeusSUN)(GLushort);
-        void       (WINE_GLAPI *p_glReplacementCodeusvSUN)(const GLushort*);
-        void       (WINE_GLAPI *p_glRequestResidentProgramsNV)(GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glResetHistogram)(GLenum);
-        void       (WINE_GLAPI *p_glResetHistogramEXT)(GLenum);
-        void       (WINE_GLAPI *p_glResetMinmax)(GLenum);
-        void       (WINE_GLAPI *p_glResetMinmaxEXT)(GLenum);
+        void       (WINE_GLAPI *p_glRenderGpuMaskNV)( GLbitfield mask );
+        void       (WINE_GLAPI *p_glRenderbufferStorage)( GLenum target, GLenum internalformat, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glRenderbufferStorageEXT)( GLenum target, GLenum internalformat, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glRenderbufferStorageMultisample)( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glRenderbufferStorageMultisampleCoverageNV)( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glRenderbufferStorageMultisampleEXT)( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glReplacementCodePointerSUN)( GLenum type, GLsizei stride, const void **pointer );
+        void       (WINE_GLAPI *p_glReplacementCodeubSUN)( GLubyte code );
+        void       (WINE_GLAPI *p_glReplacementCodeubvSUN)( const GLubyte *code );
+        void       (WINE_GLAPI *p_glReplacementCodeuiColor3fVertex3fSUN)( GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glReplacementCodeuiColor3fVertex3fvSUN)( const GLuint *rc, const GLfloat *c, const GLfloat *v );
+        void       (WINE_GLAPI *p_glReplacementCodeuiColor4fNormal3fVertex3fSUN)( GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glReplacementCodeuiColor4fNormal3fVertex3fvSUN)( const GLuint *rc, const GLfloat *c, const GLfloat *n, const GLfloat *v );
+        void       (WINE_GLAPI *p_glReplacementCodeuiColor4ubVertex3fSUN)( GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glReplacementCodeuiColor4ubVertex3fvSUN)( const GLuint *rc, const GLubyte *c, const GLfloat *v );
+        void       (WINE_GLAPI *p_glReplacementCodeuiNormal3fVertex3fSUN)( GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glReplacementCodeuiNormal3fVertex3fvSUN)( const GLuint *rc, const GLfloat *n, const GLfloat *v );
+        void       (WINE_GLAPI *p_glReplacementCodeuiSUN)( GLuint code );
+        void       (WINE_GLAPI *p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN)( GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN)( const GLuint *rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v );
+        void       (WINE_GLAPI *p_glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN)( GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN)( const GLuint *rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v );
+        void       (WINE_GLAPI *p_glReplacementCodeuiTexCoord2fVertex3fSUN)( GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glReplacementCodeuiTexCoord2fVertex3fvSUN)( const GLuint *rc, const GLfloat *tc, const GLfloat *v );
+        void       (WINE_GLAPI *p_glReplacementCodeuiVertex3fSUN)( GLuint rc, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glReplacementCodeuiVertex3fvSUN)( const GLuint *rc, const GLfloat *v );
+        void       (WINE_GLAPI *p_glReplacementCodeuivSUN)( const GLuint *code );
+        void       (WINE_GLAPI *p_glReplacementCodeusSUN)( GLushort code );
+        void       (WINE_GLAPI *p_glReplacementCodeusvSUN)( const GLushort *code );
+        void       (WINE_GLAPI *p_glRequestResidentProgramsNV)( GLsizei n, const GLuint *programs );
+        void       (WINE_GLAPI *p_glResetHistogram)( GLenum target );
+        void       (WINE_GLAPI *p_glResetHistogramEXT)( GLenum target );
+        void       (WINE_GLAPI *p_glResetMinmax)( GLenum target );
+        void       (WINE_GLAPI *p_glResetMinmaxEXT)( GLenum target );
         void       (WINE_GLAPI *p_glResizeBuffersMESA)(void);
         void       (WINE_GLAPI *p_glResolveDepthValuesNV)(void);
         void       (WINE_GLAPI *p_glResumeTransformFeedback)(void);
         void       (WINE_GLAPI *p_glResumeTransformFeedbackNV)(void);
-        void       (WINE_GLAPI *p_glRotatexOES)(GLfixed,GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glSampleCoverage)(GLfloat,GLboolean);
-        void       (WINE_GLAPI *p_glSampleCoverageARB)(GLfloat,GLboolean);
-        void       (WINE_GLAPI *p_glSampleMapATI)(GLuint,GLuint,GLenum);
-        void       (WINE_GLAPI *p_glSampleMaskEXT)(GLclampf,GLboolean);
-        void       (WINE_GLAPI *p_glSampleMaskIndexedNV)(GLuint,GLbitfield);
-        void       (WINE_GLAPI *p_glSampleMaskSGIS)(GLclampf,GLboolean);
-        void       (WINE_GLAPI *p_glSampleMaski)(GLuint,GLbitfield);
-        void       (WINE_GLAPI *p_glSamplePatternEXT)(GLenum);
-        void       (WINE_GLAPI *p_glSamplePatternSGIS)(GLenum);
-        void       (WINE_GLAPI *p_glSamplerParameterIiv)(GLuint,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glSamplerParameterIuiv)(GLuint,GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glSamplerParameterf)(GLuint,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glSamplerParameterfv)(GLuint,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glSamplerParameteri)(GLuint,GLenum,GLint);
-        void       (WINE_GLAPI *p_glSamplerParameteriv)(GLuint,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glScalexOES)(GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glScissorArrayv)(GLuint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glScissorIndexed)(GLuint,GLint,GLint,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glScissorIndexedv)(GLuint,const GLint*);
-        void       (WINE_GLAPI *p_glSecondaryColor3b)(GLbyte,GLbyte,GLbyte);
-        void       (WINE_GLAPI *p_glSecondaryColor3bEXT)(GLbyte,GLbyte,GLbyte);
-        void       (WINE_GLAPI *p_glSecondaryColor3bv)(const GLbyte*);
-        void       (WINE_GLAPI *p_glSecondaryColor3bvEXT)(const GLbyte*);
-        void       (WINE_GLAPI *p_glSecondaryColor3d)(GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glSecondaryColor3dEXT)(GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glSecondaryColor3dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glSecondaryColor3dvEXT)(const GLdouble*);
-        void       (WINE_GLAPI *p_glSecondaryColor3f)(GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glSecondaryColor3fEXT)(GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glSecondaryColor3fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glSecondaryColor3fvEXT)(const GLfloat*);
-        void       (WINE_GLAPI *p_glSecondaryColor3hNV)(GLhalfNV,GLhalfNV,GLhalfNV);
-        void       (WINE_GLAPI *p_glSecondaryColor3hvNV)(const GLhalfNV*);
-        void       (WINE_GLAPI *p_glSecondaryColor3i)(GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glSecondaryColor3iEXT)(GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glSecondaryColor3iv)(const GLint*);
-        void       (WINE_GLAPI *p_glSecondaryColor3ivEXT)(const GLint*);
-        void       (WINE_GLAPI *p_glSecondaryColor3s)(GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glSecondaryColor3sEXT)(GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glSecondaryColor3sv)(const GLshort*);
-        void       (WINE_GLAPI *p_glSecondaryColor3svEXT)(const GLshort*);
-        void       (WINE_GLAPI *p_glSecondaryColor3ub)(GLubyte,GLubyte,GLubyte);
-        void       (WINE_GLAPI *p_glSecondaryColor3ubEXT)(GLubyte,GLubyte,GLubyte);
-        void       (WINE_GLAPI *p_glSecondaryColor3ubv)(const GLubyte*);
-        void       (WINE_GLAPI *p_glSecondaryColor3ubvEXT)(const GLubyte*);
-        void       (WINE_GLAPI *p_glSecondaryColor3ui)(GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glSecondaryColor3uiEXT)(GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glSecondaryColor3uiv)(const GLuint*);
-        void       (WINE_GLAPI *p_glSecondaryColor3uivEXT)(const GLuint*);
-        void       (WINE_GLAPI *p_glSecondaryColor3us)(GLushort,GLushort,GLushort);
-        void       (WINE_GLAPI *p_glSecondaryColor3usEXT)(GLushort,GLushort,GLushort);
-        void       (WINE_GLAPI *p_glSecondaryColor3usv)(const GLushort*);
-        void       (WINE_GLAPI *p_glSecondaryColor3usvEXT)(const GLushort*);
-        void       (WINE_GLAPI *p_glSecondaryColorFormatNV)(GLint,GLenum,GLsizei);
-        void       (WINE_GLAPI *p_glSecondaryColorP3ui)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glSecondaryColorP3uiv)(GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glSecondaryColorPointer)(GLint,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glSecondaryColorPointerEXT)(GLint,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glSecondaryColorPointerListIBM)(GLint,GLenum,GLint,const void**,GLint);
-        void       (WINE_GLAPI *p_glSelectPerfMonitorCountersAMD)(GLuint,GLboolean,GLuint,GLint,GLuint*);
-        void       (WINE_GLAPI *p_glSelectTextureCoordSetSGIS)(GLenum);
-        void       (WINE_GLAPI *p_glSelectTextureSGIS)(GLenum);
-        void       (WINE_GLAPI *p_glSemaphoreParameterui64vEXT)(GLuint,GLenum,const GLuint64*);
-        void       (WINE_GLAPI *p_glSeparableFilter2D)(GLenum,GLenum,GLsizei,GLsizei,GLenum,GLenum,const void*,const void*);
-        void       (WINE_GLAPI *p_glSeparableFilter2DEXT)(GLenum,GLenum,GLsizei,GLsizei,GLenum,GLenum,const void*,const void*);
-        void       (WINE_GLAPI *p_glSetFenceAPPLE)(GLuint);
-        void       (WINE_GLAPI *p_glSetFenceNV)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glSetFragmentShaderConstantATI)(GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glSetInvariantEXT)(GLuint,GLenum,const void*);
-        void       (WINE_GLAPI *p_glSetLocalConstantEXT)(GLuint,GLenum,const void*);
-        void       (WINE_GLAPI *p_glSetMultisamplefvAMD)(GLenum,GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glShaderBinary)(GLsizei,const GLuint*,GLenum,const void*,GLsizei);
-        void       (WINE_GLAPI *p_glShaderOp1EXT)(GLenum,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glShaderOp2EXT)(GLenum,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glShaderOp3EXT)(GLenum,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glShaderSource)(GLuint,GLsizei,const GLchar*const*,const GLint*);
-        void       (WINE_GLAPI *p_glShaderSourceARB)(GLhandleARB,GLsizei,const GLcharARB**,const GLint*);
-        void       (WINE_GLAPI *p_glShaderStorageBlockBinding)(GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glSharpenTexFuncSGIS)(GLenum,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glSignalSemaphoreEXT)(GLuint,GLuint,const GLuint*,GLuint,const GLuint*,const GLenum*);
-        void       (WINE_GLAPI *p_glSignalVkFenceNV)(GLuint64);
-        void       (WINE_GLAPI *p_glSignalVkSemaphoreNV)(GLuint64);
-        void       (WINE_GLAPI *p_glSpecializeShader)(GLuint,const GLchar*,GLuint,const GLuint*,const GLuint*);
-        void       (WINE_GLAPI *p_glSpecializeShaderARB)(GLuint,const GLchar*,GLuint,const GLuint*,const GLuint*);
-        void       (WINE_GLAPI *p_glSpriteParameterfSGIX)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glSpriteParameterfvSGIX)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glSpriteParameteriSGIX)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glSpriteParameterivSGIX)(GLenum,const GLint*);
+        void       (WINE_GLAPI *p_glRotatexOES)( GLfixed angle, GLfixed x, GLfixed y, GLfixed z );
+        void       (WINE_GLAPI *p_glSampleCoverage)( GLfloat value, GLboolean invert );
+        void       (WINE_GLAPI *p_glSampleCoverageARB)( GLfloat value, GLboolean invert );
+        void       (WINE_GLAPI *p_glSampleMapATI)( GLuint dst, GLuint interp, GLenum swizzle );
+        void       (WINE_GLAPI *p_glSampleMaskEXT)( GLclampf value, GLboolean invert );
+        void       (WINE_GLAPI *p_glSampleMaskIndexedNV)( GLuint index, GLbitfield mask );
+        void       (WINE_GLAPI *p_glSampleMaskSGIS)( GLclampf value, GLboolean invert );
+        void       (WINE_GLAPI *p_glSampleMaski)( GLuint maskNumber, GLbitfield mask );
+        void       (WINE_GLAPI *p_glSamplePatternEXT)( GLenum pattern );
+        void       (WINE_GLAPI *p_glSamplePatternSGIS)( GLenum pattern );
+        void       (WINE_GLAPI *p_glSamplerParameterIiv)( GLuint sampler, GLenum pname, const GLint *param );
+        void       (WINE_GLAPI *p_glSamplerParameterIuiv)( GLuint sampler, GLenum pname, const GLuint *param );
+        void       (WINE_GLAPI *p_glSamplerParameterf)( GLuint sampler, GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glSamplerParameterfv)( GLuint sampler, GLenum pname, const GLfloat *param );
+        void       (WINE_GLAPI *p_glSamplerParameteri)( GLuint sampler, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glSamplerParameteriv)( GLuint sampler, GLenum pname, const GLint *param );
+        void       (WINE_GLAPI *p_glScalexOES)( GLfixed x, GLfixed y, GLfixed z );
+        void       (WINE_GLAPI *p_glScissorArrayv)( GLuint first, GLsizei count, const GLint *v );
+        void       (WINE_GLAPI *p_glScissorIndexed)( GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glScissorIndexedv)( GLuint index, const GLint *v );
+        void       (WINE_GLAPI *p_glSecondaryColor3b)( GLbyte red, GLbyte green, GLbyte blue );
+        void       (WINE_GLAPI *p_glSecondaryColor3bEXT)( GLbyte red, GLbyte green, GLbyte blue );
+        void       (WINE_GLAPI *p_glSecondaryColor3bv)( const GLbyte *v );
+        void       (WINE_GLAPI *p_glSecondaryColor3bvEXT)( const GLbyte *v );
+        void       (WINE_GLAPI *p_glSecondaryColor3d)( GLdouble red, GLdouble green, GLdouble blue );
+        void       (WINE_GLAPI *p_glSecondaryColor3dEXT)( GLdouble red, GLdouble green, GLdouble blue );
+        void       (WINE_GLAPI *p_glSecondaryColor3dv)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glSecondaryColor3dvEXT)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glSecondaryColor3f)( GLfloat red, GLfloat green, GLfloat blue );
+        void       (WINE_GLAPI *p_glSecondaryColor3fEXT)( GLfloat red, GLfloat green, GLfloat blue );
+        void       (WINE_GLAPI *p_glSecondaryColor3fv)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glSecondaryColor3fvEXT)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glSecondaryColor3hNV)( GLhalfNV red, GLhalfNV green, GLhalfNV blue );
+        void       (WINE_GLAPI *p_glSecondaryColor3hvNV)( const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glSecondaryColor3i)( GLint red, GLint green, GLint blue );
+        void       (WINE_GLAPI *p_glSecondaryColor3iEXT)( GLint red, GLint green, GLint blue );
+        void       (WINE_GLAPI *p_glSecondaryColor3iv)( const GLint *v );
+        void       (WINE_GLAPI *p_glSecondaryColor3ivEXT)( const GLint *v );
+        void       (WINE_GLAPI *p_glSecondaryColor3s)( GLshort red, GLshort green, GLshort blue );
+        void       (WINE_GLAPI *p_glSecondaryColor3sEXT)( GLshort red, GLshort green, GLshort blue );
+        void       (WINE_GLAPI *p_glSecondaryColor3sv)( const GLshort *v );
+        void       (WINE_GLAPI *p_glSecondaryColor3svEXT)( const GLshort *v );
+        void       (WINE_GLAPI *p_glSecondaryColor3ub)( GLubyte red, GLubyte green, GLubyte blue );
+        void       (WINE_GLAPI *p_glSecondaryColor3ubEXT)( GLubyte red, GLubyte green, GLubyte blue );
+        void       (WINE_GLAPI *p_glSecondaryColor3ubv)( const GLubyte *v );
+        void       (WINE_GLAPI *p_glSecondaryColor3ubvEXT)( const GLubyte *v );
+        void       (WINE_GLAPI *p_glSecondaryColor3ui)( GLuint red, GLuint green, GLuint blue );
+        void       (WINE_GLAPI *p_glSecondaryColor3uiEXT)( GLuint red, GLuint green, GLuint blue );
+        void       (WINE_GLAPI *p_glSecondaryColor3uiv)( const GLuint *v );
+        void       (WINE_GLAPI *p_glSecondaryColor3uivEXT)( const GLuint *v );
+        void       (WINE_GLAPI *p_glSecondaryColor3us)( GLushort red, GLushort green, GLushort blue );
+        void       (WINE_GLAPI *p_glSecondaryColor3usEXT)( GLushort red, GLushort green, GLushort blue );
+        void       (WINE_GLAPI *p_glSecondaryColor3usv)( const GLushort *v );
+        void       (WINE_GLAPI *p_glSecondaryColor3usvEXT)( const GLushort *v );
+        void       (WINE_GLAPI *p_glSecondaryColorFormatNV)( GLint size, GLenum type, GLsizei stride );
+        void       (WINE_GLAPI *p_glSecondaryColorP3ui)( GLenum type, GLuint color );
+        void       (WINE_GLAPI *p_glSecondaryColorP3uiv)( GLenum type, const GLuint *color );
+        void       (WINE_GLAPI *p_glSecondaryColorPointer)( GLint size, GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glSecondaryColorPointerEXT)( GLint size, GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glSecondaryColorPointerListIBM)( GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride );
+        void       (WINE_GLAPI *p_glSelectPerfMonitorCountersAMD)( GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint *counterList );
+        void       (WINE_GLAPI *p_glSelectTextureCoordSetSGIS)( GLenum target );
+        void       (WINE_GLAPI *p_glSelectTextureSGIS)( GLenum target );
+        void       (WINE_GLAPI *p_glSemaphoreParameterui64vEXT)( GLuint semaphore, GLenum pname, const GLuint64 *params );
+        void       (WINE_GLAPI *p_glSeparableFilter2D)( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column );
+        void       (WINE_GLAPI *p_glSeparableFilter2DEXT)( GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column );
+        void       (WINE_GLAPI *p_glSetFenceAPPLE)( GLuint fence );
+        void       (WINE_GLAPI *p_glSetFenceNV)( GLuint fence, GLenum condition );
+        void       (WINE_GLAPI *p_glSetFragmentShaderConstantATI)( GLuint dst, const GLfloat *value );
+        void       (WINE_GLAPI *p_glSetInvariantEXT)( GLuint id, GLenum type, const void *addr );
+        void       (WINE_GLAPI *p_glSetLocalConstantEXT)( GLuint id, GLenum type, const void *addr );
+        void       (WINE_GLAPI *p_glSetMultisamplefvAMD)( GLenum pname, GLuint index, const GLfloat *val );
+        void       (WINE_GLAPI *p_glShaderBinary)( GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length );
+        void       (WINE_GLAPI *p_glShaderOp1EXT)( GLenum op, GLuint res, GLuint arg1 );
+        void       (WINE_GLAPI *p_glShaderOp2EXT)( GLenum op, GLuint res, GLuint arg1, GLuint arg2 );
+        void       (WINE_GLAPI *p_glShaderOp3EXT)( GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3 );
+        void       (WINE_GLAPI *p_glShaderSource)( GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length );
+        void       (WINE_GLAPI *p_glShaderSourceARB)( GLhandleARB shaderObj, GLsizei count, const GLcharARB **string, const GLint *length );
+        void       (WINE_GLAPI *p_glShaderStorageBlockBinding)( GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding );
+        void       (WINE_GLAPI *p_glSharpenTexFuncSGIS)( GLenum target, GLsizei n, const GLfloat *points );
+        void       (WINE_GLAPI *p_glSignalSemaphoreEXT)( GLuint semaphore, GLuint numBufferBarriers, const GLuint *buffers, GLuint numTextureBarriers, const GLuint *textures, const GLenum *dstLayouts );
+        void       (WINE_GLAPI *p_glSignalVkFenceNV)( GLuint64 vkFence );
+        void       (WINE_GLAPI *p_glSignalVkSemaphoreNV)( GLuint64 vkSemaphore );
+        void       (WINE_GLAPI *p_glSpecializeShader)( GLuint shader, const GLchar *pEntryPoint, GLuint numSpecializationConstants, const GLuint *pConstantIndex, const GLuint *pConstantValue );
+        void       (WINE_GLAPI *p_glSpecializeShaderARB)( GLuint shader, const GLchar *pEntryPoint, GLuint numSpecializationConstants, const GLuint *pConstantIndex, const GLuint *pConstantValue );
+        void       (WINE_GLAPI *p_glSpriteParameterfSGIX)( GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glSpriteParameterfvSGIX)( GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glSpriteParameteriSGIX)( GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glSpriteParameterivSGIX)( GLenum pname, const GLint *params );
         void       (WINE_GLAPI *p_glStartInstrumentsSGIX)(void);
-        void       (WINE_GLAPI *p_glStateCaptureNV)(GLuint,GLenum);
-        void       (WINE_GLAPI *p_glStencilClearTagEXT)(GLsizei,GLuint);
-        void       (WINE_GLAPI *p_glStencilFillPathInstancedNV)(GLsizei,GLenum,const void*,GLuint,GLenum,GLuint,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glStencilFillPathNV)(GLuint,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glStencilFuncSeparate)(GLenum,GLenum,GLint,GLuint);
-        void       (WINE_GLAPI *p_glStencilFuncSeparateATI)(GLenum,GLenum,GLint,GLuint);
-        void       (WINE_GLAPI *p_glStencilMaskSeparate)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glStencilOpSeparate)(GLenum,GLenum,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glStencilOpSeparateATI)(GLenum,GLenum,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glStencilOpValueAMD)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glStencilStrokePathInstancedNV)(GLsizei,GLenum,const void*,GLuint,GLint,GLuint,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glStencilStrokePathNV)(GLuint,GLint,GLuint);
-        void       (WINE_GLAPI *p_glStencilThenCoverFillPathInstancedNV)(GLsizei,GLenum,const void*,GLuint,GLenum,GLuint,GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glStencilThenCoverFillPathNV)(GLuint,GLenum,GLuint,GLenum);
-        void       (WINE_GLAPI *p_glStencilThenCoverStrokePathInstancedNV)(GLsizei,GLenum,const void*,GLuint,GLint,GLuint,GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glStencilThenCoverStrokePathNV)(GLuint,GLint,GLuint,GLenum);
-        void       (WINE_GLAPI *p_glStopInstrumentsSGIX)(GLint);
-        void       (WINE_GLAPI *p_glStringMarkerGREMEDY)(GLsizei,const void*);
-        void       (WINE_GLAPI *p_glSubpixelPrecisionBiasNV)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glSwizzleEXT)(GLuint,GLuint,GLenum,GLenum,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glSyncTextureINTEL)(GLuint);
+        void       (WINE_GLAPI *p_glStateCaptureNV)( GLuint state, GLenum mode );
+        void       (WINE_GLAPI *p_glStencilClearTagEXT)( GLsizei stencilTagBits, GLuint stencilClearTag );
+        void       (WINE_GLAPI *p_glStencilFillPathInstancedNV)( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, const GLfloat *transformValues );
+        void       (WINE_GLAPI *p_glStencilFillPathNV)( GLuint path, GLenum fillMode, GLuint mask );
+        void       (WINE_GLAPI *p_glStencilFuncSeparate)( GLenum face, GLenum func, GLint ref, GLuint mask );
+        void       (WINE_GLAPI *p_glStencilFuncSeparateATI)( GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask );
+        void       (WINE_GLAPI *p_glStencilMaskSeparate)( GLenum face, GLuint mask );
+        void       (WINE_GLAPI *p_glStencilOpSeparate)( GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass );
+        void       (WINE_GLAPI *p_glStencilOpSeparateATI)( GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass );
+        void       (WINE_GLAPI *p_glStencilOpValueAMD)( GLenum face, GLuint value );
+        void       (WINE_GLAPI *p_glStencilStrokePathInstancedNV)( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, const GLfloat *transformValues );
+        void       (WINE_GLAPI *p_glStencilStrokePathNV)( GLuint path, GLint reference, GLuint mask );
+        void       (WINE_GLAPI *p_glStencilThenCoverFillPathInstancedNV)( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat *transformValues );
+        void       (WINE_GLAPI *p_glStencilThenCoverFillPathNV)( GLuint path, GLenum fillMode, GLuint mask, GLenum coverMode );
+        void       (WINE_GLAPI *p_glStencilThenCoverStrokePathInstancedNV)( GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLint reference, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat *transformValues );
+        void       (WINE_GLAPI *p_glStencilThenCoverStrokePathNV)( GLuint path, GLint reference, GLuint mask, GLenum coverMode );
+        void       (WINE_GLAPI *p_glStopInstrumentsSGIX)( GLint marker );
+        void       (WINE_GLAPI *p_glStringMarkerGREMEDY)( GLsizei len, const void *string );
+        void       (WINE_GLAPI *p_glSubpixelPrecisionBiasNV)( GLuint xbits, GLuint ybits );
+        void       (WINE_GLAPI *p_glSwizzleEXT)( GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW );
+        void       (WINE_GLAPI *p_glSyncTextureINTEL)( GLuint texture );
         void       (WINE_GLAPI *p_glTagSampleBufferSGIX)(void);
-        void       (WINE_GLAPI *p_glTangent3bEXT)(GLbyte,GLbyte,GLbyte);
-        void       (WINE_GLAPI *p_glTangent3bvEXT)(const GLbyte*);
-        void       (WINE_GLAPI *p_glTangent3dEXT)(GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glTangent3dvEXT)(const GLdouble*);
-        void       (WINE_GLAPI *p_glTangent3fEXT)(GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glTangent3fvEXT)(const GLfloat*);
-        void       (WINE_GLAPI *p_glTangent3iEXT)(GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glTangent3ivEXT)(const GLint*);
-        void       (WINE_GLAPI *p_glTangent3sEXT)(GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glTangent3svEXT)(const GLshort*);
-        void       (WINE_GLAPI *p_glTangentPointerEXT)(GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glTbufferMask3DFX)(GLuint);
-        void       (WINE_GLAPI *p_glTessellationFactorAMD)(GLfloat);
-        void       (WINE_GLAPI *p_glTessellationModeAMD)(GLenum);
-        GLboolean  (WINE_GLAPI *p_glTestFenceAPPLE)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glTestFenceNV)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glTestObjectAPPLE)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glTexBuffer)(GLenum,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glTexBufferARB)(GLenum,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glTexBufferEXT)(GLenum,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glTexBufferRange)(GLenum,GLenum,GLuint,GLintptr,GLsizeiptr);
-        void       (WINE_GLAPI *p_glTexBumpParameterfvATI)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glTexBumpParameterivATI)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glTexCoord1bOES)(GLbyte);
-        void       (WINE_GLAPI *p_glTexCoord1bvOES)(const GLbyte*);
-        void       (WINE_GLAPI *p_glTexCoord1hNV)(GLhalfNV);
-        void       (WINE_GLAPI *p_glTexCoord1hvNV)(const GLhalfNV*);
-        void       (WINE_GLAPI *p_glTexCoord1xOES)(GLfixed);
-        void       (WINE_GLAPI *p_glTexCoord1xvOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glTexCoord2bOES)(GLbyte,GLbyte);
-        void       (WINE_GLAPI *p_glTexCoord2bvOES)(const GLbyte*);
-        void       (WINE_GLAPI *p_glTexCoord2fColor3fVertex3fSUN)(GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glTexCoord2fColor3fVertex3fvSUN)(const GLfloat*,const GLfloat*,const GLfloat*);
-        void       (WINE_GLAPI *p_glTexCoord2fColor4fNormal3fVertex3fSUN)(GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glTexCoord2fColor4fNormal3fVertex3fvSUN)(const GLfloat*,const GLfloat*,const GLfloat*,const GLfloat*);
-        void       (WINE_GLAPI *p_glTexCoord2fColor4ubVertex3fSUN)(GLfloat,GLfloat,GLubyte,GLubyte,GLubyte,GLubyte,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glTexCoord2fColor4ubVertex3fvSUN)(const GLfloat*,const GLubyte*,const GLfloat*);
-        void       (WINE_GLAPI *p_glTexCoord2fNormal3fVertex3fSUN)(GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glTexCoord2fNormal3fVertex3fvSUN)(const GLfloat*,const GLfloat*,const GLfloat*);
-        void       (WINE_GLAPI *p_glTexCoord2fVertex3fSUN)(GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glTexCoord2fVertex3fvSUN)(const GLfloat*,const GLfloat*);
-        void       (WINE_GLAPI *p_glTexCoord2hNV)(GLhalfNV,GLhalfNV);
-        void       (WINE_GLAPI *p_glTexCoord2hvNV)(const GLhalfNV*);
-        void       (WINE_GLAPI *p_glTexCoord2xOES)(GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glTexCoord2xvOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glTexCoord3bOES)(GLbyte,GLbyte,GLbyte);
-        void       (WINE_GLAPI *p_glTexCoord3bvOES)(const GLbyte*);
-        void       (WINE_GLAPI *p_glTexCoord3hNV)(GLhalfNV,GLhalfNV,GLhalfNV);
-        void       (WINE_GLAPI *p_glTexCoord3hvNV)(const GLhalfNV*);
-        void       (WINE_GLAPI *p_glTexCoord3xOES)(GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glTexCoord3xvOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glTexCoord4bOES)(GLbyte,GLbyte,GLbyte,GLbyte);
-        void       (WINE_GLAPI *p_glTexCoord4bvOES)(const GLbyte*);
-        void       (WINE_GLAPI *p_glTexCoord4fColor4fNormal3fVertex4fSUN)(GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glTexCoord4fColor4fNormal3fVertex4fvSUN)(const GLfloat*,const GLfloat*,const GLfloat*,const GLfloat*);
-        void       (WINE_GLAPI *p_glTexCoord4fVertex4fSUN)(GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glTexCoord4fVertex4fvSUN)(const GLfloat*,const GLfloat*);
-        void       (WINE_GLAPI *p_glTexCoord4hNV)(GLhalfNV,GLhalfNV,GLhalfNV,GLhalfNV);
-        void       (WINE_GLAPI *p_glTexCoord4hvNV)(const GLhalfNV*);
-        void       (WINE_GLAPI *p_glTexCoord4xOES)(GLfixed,GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glTexCoord4xvOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glTexCoordFormatNV)(GLint,GLenum,GLsizei);
-        void       (WINE_GLAPI *p_glTexCoordP1ui)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glTexCoordP1uiv)(GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glTexCoordP2ui)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glTexCoordP2uiv)(GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glTexCoordP3ui)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glTexCoordP3uiv)(GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glTexCoordP4ui)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glTexCoordP4uiv)(GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glTexCoordPointerEXT)(GLint,GLenum,GLsizei,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glTexCoordPointerListIBM)(GLint,GLenum,GLint,const void**,GLint);
-        void       (WINE_GLAPI *p_glTexCoordPointervINTEL)(GLint,GLenum,const void**);
-        void       (WINE_GLAPI *p_glTexEnvxOES)(GLenum,GLenum,GLfixed);
-        void       (WINE_GLAPI *p_glTexEnvxvOES)(GLenum,GLenum,const GLfixed*);
-        void       (WINE_GLAPI *p_glTexFilterFuncSGIS)(GLenum,GLenum,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glTexGenxOES)(GLenum,GLenum,GLfixed);
-        void       (WINE_GLAPI *p_glTexGenxvOES)(GLenum,GLenum,const GLfixed*);
-        void       (WINE_GLAPI *p_glTexImage2DMultisample)(GLenum,GLsizei,GLenum,GLsizei,GLsizei,GLboolean);
-        void       (WINE_GLAPI *p_glTexImage2DMultisampleCoverageNV)(GLenum,GLsizei,GLsizei,GLint,GLsizei,GLsizei,GLboolean);
-        void       (WINE_GLAPI *p_glTexImage3D)(GLenum,GLint,GLint,GLsizei,GLsizei,GLsizei,GLint,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTexImage3DEXT)(GLenum,GLint,GLenum,GLsizei,GLsizei,GLsizei,GLint,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTexImage3DMultisample)(GLenum,GLsizei,GLenum,GLsizei,GLsizei,GLsizei,GLboolean);
-        void       (WINE_GLAPI *p_glTexImage3DMultisampleCoverageNV)(GLenum,GLsizei,GLsizei,GLint,GLsizei,GLsizei,GLsizei,GLboolean);
-        void       (WINE_GLAPI *p_glTexImage4DSGIS)(GLenum,GLint,GLenum,GLsizei,GLsizei,GLsizei,GLsizei,GLint,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTexPageCommitmentARB)(GLenum,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLboolean);
-        void       (WINE_GLAPI *p_glTexParameterIiv)(GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glTexParameterIivEXT)(GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glTexParameterIuiv)(GLenum,GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glTexParameterIuivEXT)(GLenum,GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glTexParameterxOES)(GLenum,GLenum,GLfixed);
-        void       (WINE_GLAPI *p_glTexParameterxvOES)(GLenum,GLenum,const GLfixed*);
-        void       (WINE_GLAPI *p_glTexRenderbufferNV)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glTexStorage1D)(GLenum,GLsizei,GLenum,GLsizei);
-        void       (WINE_GLAPI *p_glTexStorage2D)(GLenum,GLsizei,GLenum,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glTexStorage2DMultisample)(GLenum,GLsizei,GLenum,GLsizei,GLsizei,GLboolean);
-        void       (WINE_GLAPI *p_glTexStorage3D)(GLenum,GLsizei,GLenum,GLsizei,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glTexStorage3DMultisample)(GLenum,GLsizei,GLenum,GLsizei,GLsizei,GLsizei,GLboolean);
-        void       (WINE_GLAPI *p_glTexStorageMem1DEXT)(GLenum,GLsizei,GLenum,GLsizei,GLuint,GLuint64);
-        void       (WINE_GLAPI *p_glTexStorageMem2DEXT)(GLenum,GLsizei,GLenum,GLsizei,GLsizei,GLuint,GLuint64);
-        void       (WINE_GLAPI *p_glTexStorageMem2DMultisampleEXT)(GLenum,GLsizei,GLenum,GLsizei,GLsizei,GLboolean,GLuint,GLuint64);
-        void       (WINE_GLAPI *p_glTexStorageMem3DEXT)(GLenum,GLsizei,GLenum,GLsizei,GLsizei,GLsizei,GLuint,GLuint64);
-        void       (WINE_GLAPI *p_glTexStorageMem3DMultisampleEXT)(GLenum,GLsizei,GLenum,GLsizei,GLsizei,GLsizei,GLboolean,GLuint,GLuint64);
-        void       (WINE_GLAPI *p_glTexStorageSparseAMD)(GLenum,GLenum,GLsizei,GLsizei,GLsizei,GLsizei,GLbitfield);
-        void       (WINE_GLAPI *p_glTexSubImage1DEXT)(GLenum,GLint,GLint,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTexSubImage2DEXT)(GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTexSubImage3D)(GLenum,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTexSubImage3DEXT)(GLenum,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTexSubImage4DSGIS)(GLenum,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLsizei,GLenum,GLenum,const void*);
+        void       (WINE_GLAPI *p_glTangent3bEXT)( GLbyte tx, GLbyte ty, GLbyte tz );
+        void       (WINE_GLAPI *p_glTangent3bvEXT)( const GLbyte *v );
+        void       (WINE_GLAPI *p_glTangent3dEXT)( GLdouble tx, GLdouble ty, GLdouble tz );
+        void       (WINE_GLAPI *p_glTangent3dvEXT)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glTangent3fEXT)( GLfloat tx, GLfloat ty, GLfloat tz );
+        void       (WINE_GLAPI *p_glTangent3fvEXT)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glTangent3iEXT)( GLint tx, GLint ty, GLint tz );
+        void       (WINE_GLAPI *p_glTangent3ivEXT)( const GLint *v );
+        void       (WINE_GLAPI *p_glTangent3sEXT)( GLshort tx, GLshort ty, GLshort tz );
+        void       (WINE_GLAPI *p_glTangent3svEXT)( const GLshort *v );
+        void       (WINE_GLAPI *p_glTangentPointerEXT)( GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glTbufferMask3DFX)( GLuint mask );
+        void       (WINE_GLAPI *p_glTessellationFactorAMD)( GLfloat factor );
+        void       (WINE_GLAPI *p_glTessellationModeAMD)( GLenum mode );
+        GLboolean  (WINE_GLAPI *p_glTestFenceAPPLE)( GLuint fence );
+        GLboolean  (WINE_GLAPI *p_glTestFenceNV)( GLuint fence );
+        GLboolean  (WINE_GLAPI *p_glTestObjectAPPLE)( GLenum object, GLuint name );
+        void       (WINE_GLAPI *p_glTexBuffer)( GLenum target, GLenum internalformat, GLuint buffer );
+        void       (WINE_GLAPI *p_glTexBufferARB)( GLenum target, GLenum internalformat, GLuint buffer );
+        void       (WINE_GLAPI *p_glTexBufferEXT)( GLenum target, GLenum internalformat, GLuint buffer );
+        void       (WINE_GLAPI *p_glTexBufferRange)( GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size );
+        void       (WINE_GLAPI *p_glTexBumpParameterfvATI)( GLenum pname, const GLfloat *param );
+        void       (WINE_GLAPI *p_glTexBumpParameterivATI)( GLenum pname, const GLint *param );
+        void       (WINE_GLAPI *p_glTexCoord1bOES)( GLbyte s );
+        void       (WINE_GLAPI *p_glTexCoord1bvOES)( const GLbyte *coords );
+        void       (WINE_GLAPI *p_glTexCoord1hNV)( GLhalfNV s );
+        void       (WINE_GLAPI *p_glTexCoord1hvNV)( const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glTexCoord1xOES)( GLfixed s );
+        void       (WINE_GLAPI *p_glTexCoord1xvOES)( const GLfixed *coords );
+        void       (WINE_GLAPI *p_glTexCoord2bOES)( GLbyte s, GLbyte t );
+        void       (WINE_GLAPI *p_glTexCoord2bvOES)( const GLbyte *coords );
+        void       (WINE_GLAPI *p_glTexCoord2fColor3fVertex3fSUN)( GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glTexCoord2fColor3fVertex3fvSUN)( const GLfloat *tc, const GLfloat *c, const GLfloat *v );
+        void       (WINE_GLAPI *p_glTexCoord2fColor4fNormal3fVertex3fSUN)( GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glTexCoord2fColor4fNormal3fVertex3fvSUN)( const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v );
+        void       (WINE_GLAPI *p_glTexCoord2fColor4ubVertex3fSUN)( GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glTexCoord2fColor4ubVertex3fvSUN)( const GLfloat *tc, const GLubyte *c, const GLfloat *v );
+        void       (WINE_GLAPI *p_glTexCoord2fNormal3fVertex3fSUN)( GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glTexCoord2fNormal3fVertex3fvSUN)( const GLfloat *tc, const GLfloat *n, const GLfloat *v );
+        void       (WINE_GLAPI *p_glTexCoord2fVertex3fSUN)( GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glTexCoord2fVertex3fvSUN)( const GLfloat *tc, const GLfloat *v );
+        void       (WINE_GLAPI *p_glTexCoord2hNV)( GLhalfNV s, GLhalfNV t );
+        void       (WINE_GLAPI *p_glTexCoord2hvNV)( const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glTexCoord2xOES)( GLfixed s, GLfixed t );
+        void       (WINE_GLAPI *p_glTexCoord2xvOES)( const GLfixed *coords );
+        void       (WINE_GLAPI *p_glTexCoord3bOES)( GLbyte s, GLbyte t, GLbyte r );
+        void       (WINE_GLAPI *p_glTexCoord3bvOES)( const GLbyte *coords );
+        void       (WINE_GLAPI *p_glTexCoord3hNV)( GLhalfNV s, GLhalfNV t, GLhalfNV r );
+        void       (WINE_GLAPI *p_glTexCoord3hvNV)( const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glTexCoord3xOES)( GLfixed s, GLfixed t, GLfixed r );
+        void       (WINE_GLAPI *p_glTexCoord3xvOES)( const GLfixed *coords );
+        void       (WINE_GLAPI *p_glTexCoord4bOES)( GLbyte s, GLbyte t, GLbyte r, GLbyte q );
+        void       (WINE_GLAPI *p_glTexCoord4bvOES)( const GLbyte *coords );
+        void       (WINE_GLAPI *p_glTexCoord4fColor4fNormal3fVertex4fSUN)( GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
+        void       (WINE_GLAPI *p_glTexCoord4fColor4fNormal3fVertex4fvSUN)( const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v );
+        void       (WINE_GLAPI *p_glTexCoord4fVertex4fSUN)( GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
+        void       (WINE_GLAPI *p_glTexCoord4fVertex4fvSUN)( const GLfloat *tc, const GLfloat *v );
+        void       (WINE_GLAPI *p_glTexCoord4hNV)( GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q );
+        void       (WINE_GLAPI *p_glTexCoord4hvNV)( const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glTexCoord4xOES)( GLfixed s, GLfixed t, GLfixed r, GLfixed q );
+        void       (WINE_GLAPI *p_glTexCoord4xvOES)( const GLfixed *coords );
+        void       (WINE_GLAPI *p_glTexCoordFormatNV)( GLint size, GLenum type, GLsizei stride );
+        void       (WINE_GLAPI *p_glTexCoordP1ui)( GLenum type, GLuint coords );
+        void       (WINE_GLAPI *p_glTexCoordP1uiv)( GLenum type, const GLuint *coords );
+        void       (WINE_GLAPI *p_glTexCoordP2ui)( GLenum type, GLuint coords );
+        void       (WINE_GLAPI *p_glTexCoordP2uiv)( GLenum type, const GLuint *coords );
+        void       (WINE_GLAPI *p_glTexCoordP3ui)( GLenum type, GLuint coords );
+        void       (WINE_GLAPI *p_glTexCoordP3uiv)( GLenum type, const GLuint *coords );
+        void       (WINE_GLAPI *p_glTexCoordP4ui)( GLenum type, GLuint coords );
+        void       (WINE_GLAPI *p_glTexCoordP4uiv)( GLenum type, const GLuint *coords );
+        void       (WINE_GLAPI *p_glTexCoordPointerEXT)( GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer );
+        void       (WINE_GLAPI *p_glTexCoordPointerListIBM)( GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride );
+        void       (WINE_GLAPI *p_glTexCoordPointervINTEL)( GLint size, GLenum type, const void **pointer );
+        void       (WINE_GLAPI *p_glTexEnvxOES)( GLenum target, GLenum pname, GLfixed param );
+        void       (WINE_GLAPI *p_glTexEnvxvOES)( GLenum target, GLenum pname, const GLfixed *params );
+        void       (WINE_GLAPI *p_glTexFilterFuncSGIS)( GLenum target, GLenum filter, GLsizei n, const GLfloat *weights );
+        void       (WINE_GLAPI *p_glTexGenxOES)( GLenum coord, GLenum pname, GLfixed param );
+        void       (WINE_GLAPI *p_glTexGenxvOES)( GLenum coord, GLenum pname, const GLfixed *params );
+        void       (WINE_GLAPI *p_glTexImage2DMultisample)( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations );
+        void       (WINE_GLAPI *p_glTexImage2DMultisampleCoverageNV)( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations );
+        void       (WINE_GLAPI *p_glTexImage3D)( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTexImage3DEXT)( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTexImage3DMultisample)( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations );
+        void       (WINE_GLAPI *p_glTexImage3DMultisampleCoverageNV)( GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations );
+        void       (WINE_GLAPI *p_glTexImage4DSGIS)( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTexPageCommitmentARB)( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit );
+        void       (WINE_GLAPI *p_glTexParameterIiv)( GLenum target, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glTexParameterIivEXT)( GLenum target, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glTexParameterIuiv)( GLenum target, GLenum pname, const GLuint *params );
+        void       (WINE_GLAPI *p_glTexParameterIuivEXT)( GLenum target, GLenum pname, const GLuint *params );
+        void       (WINE_GLAPI *p_glTexParameterxOES)( GLenum target, GLenum pname, GLfixed param );
+        void       (WINE_GLAPI *p_glTexParameterxvOES)( GLenum target, GLenum pname, const GLfixed *params );
+        void       (WINE_GLAPI *p_glTexRenderbufferNV)( GLenum target, GLuint renderbuffer );
+        void       (WINE_GLAPI *p_glTexStorage1D)( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width );
+        void       (WINE_GLAPI *p_glTexStorage2D)( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glTexStorage2DMultisample)( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations );
+        void       (WINE_GLAPI *p_glTexStorage3D)( GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth );
+        void       (WINE_GLAPI *p_glTexStorage3DMultisample)( GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations );
+        void       (WINE_GLAPI *p_glTexStorageMem1DEXT)( GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLuint memory, GLuint64 offset );
+        void       (WINE_GLAPI *p_glTexStorageMem2DEXT)( GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLuint memory, GLuint64 offset );
+        void       (WINE_GLAPI *p_glTexStorageMem2DMultisampleEXT)( GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset );
+        void       (WINE_GLAPI *p_glTexStorageMem3DEXT)( GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset );
+        void       (WINE_GLAPI *p_glTexStorageMem3DMultisampleEXT)( GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset );
+        void       (WINE_GLAPI *p_glTexStorageSparseAMD)( GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags );
+        void       (WINE_GLAPI *p_glTexSubImage1DEXT)( GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTexSubImage2DEXT)( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTexSubImage3D)( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTexSubImage3DEXT)( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTexSubImage4DSGIS)( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const void *pixels );
         void       (WINE_GLAPI *p_glTextureBarrier)(void);
         void       (WINE_GLAPI *p_glTextureBarrierNV)(void);
-        void       (WINE_GLAPI *p_glTextureBuffer)(GLuint,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glTextureBufferEXT)(GLuint,GLenum,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glTextureBufferRange)(GLuint,GLenum,GLuint,GLintptr,GLsizeiptr);
-        void       (WINE_GLAPI *p_glTextureBufferRangeEXT)(GLuint,GLenum,GLenum,GLuint,GLintptr,GLsizeiptr);
-        void       (WINE_GLAPI *p_glTextureColorMaskSGIS)(GLboolean,GLboolean,GLboolean,GLboolean);
-        void       (WINE_GLAPI *p_glTextureImage1DEXT)(GLuint,GLenum,GLint,GLint,GLsizei,GLint,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTextureImage2DEXT)(GLuint,GLenum,GLint,GLint,GLsizei,GLsizei,GLint,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTextureImage2DMultisampleCoverageNV)(GLuint,GLenum,GLsizei,GLsizei,GLint,GLsizei,GLsizei,GLboolean);
-        void       (WINE_GLAPI *p_glTextureImage2DMultisampleNV)(GLuint,GLenum,GLsizei,GLint,GLsizei,GLsizei,GLboolean);
-        void       (WINE_GLAPI *p_glTextureImage3DEXT)(GLuint,GLenum,GLint,GLint,GLsizei,GLsizei,GLsizei,GLint,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTextureImage3DMultisampleCoverageNV)(GLuint,GLenum,GLsizei,GLsizei,GLint,GLsizei,GLsizei,GLsizei,GLboolean);
-        void       (WINE_GLAPI *p_glTextureImage3DMultisampleNV)(GLuint,GLenum,GLsizei,GLint,GLsizei,GLsizei,GLsizei,GLboolean);
-        void       (WINE_GLAPI *p_glTextureLightEXT)(GLenum);
-        void       (WINE_GLAPI *p_glTextureMaterialEXT)(GLenum,GLenum);
-        void       (WINE_GLAPI *p_glTextureNormalEXT)(GLenum);
-        void       (WINE_GLAPI *p_glTexturePageCommitmentEXT)(GLuint,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLboolean);
-        void       (WINE_GLAPI *p_glTextureParameterIiv)(GLuint,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glTextureParameterIivEXT)(GLuint,GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glTextureParameterIuiv)(GLuint,GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glTextureParameterIuivEXT)(GLuint,GLenum,GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glTextureParameterf)(GLuint,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glTextureParameterfEXT)(GLuint,GLenum,GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glTextureParameterfv)(GLuint,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glTextureParameterfvEXT)(GLuint,GLenum,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glTextureParameteri)(GLuint,GLenum,GLint);
-        void       (WINE_GLAPI *p_glTextureParameteriEXT)(GLuint,GLenum,GLenum,GLint);
-        void       (WINE_GLAPI *p_glTextureParameteriv)(GLuint,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glTextureParameterivEXT)(GLuint,GLenum,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glTextureRangeAPPLE)(GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glTextureRenderbufferEXT)(GLuint,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glTextureStorage1D)(GLuint,GLsizei,GLenum,GLsizei);
-        void       (WINE_GLAPI *p_glTextureStorage1DEXT)(GLuint,GLenum,GLsizei,GLenum,GLsizei);
-        void       (WINE_GLAPI *p_glTextureStorage2D)(GLuint,GLsizei,GLenum,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glTextureStorage2DEXT)(GLuint,GLenum,GLsizei,GLenum,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glTextureStorage2DMultisample)(GLuint,GLsizei,GLenum,GLsizei,GLsizei,GLboolean);
-        void       (WINE_GLAPI *p_glTextureStorage2DMultisampleEXT)(GLuint,GLenum,GLsizei,GLenum,GLsizei,GLsizei,GLboolean);
-        void       (WINE_GLAPI *p_glTextureStorage3D)(GLuint,GLsizei,GLenum,GLsizei,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glTextureStorage3DEXT)(GLuint,GLenum,GLsizei,GLenum,GLsizei,GLsizei,GLsizei);
-        void       (WINE_GLAPI *p_glTextureStorage3DMultisample)(GLuint,GLsizei,GLenum,GLsizei,GLsizei,GLsizei,GLboolean);
-        void       (WINE_GLAPI *p_glTextureStorage3DMultisampleEXT)(GLuint,GLenum,GLsizei,GLenum,GLsizei,GLsizei,GLsizei,GLboolean);
-        void       (WINE_GLAPI *p_glTextureStorageMem1DEXT)(GLuint,GLsizei,GLenum,GLsizei,GLuint,GLuint64);
-        void       (WINE_GLAPI *p_glTextureStorageMem2DEXT)(GLuint,GLsizei,GLenum,GLsizei,GLsizei,GLuint,GLuint64);
-        void       (WINE_GLAPI *p_glTextureStorageMem2DMultisampleEXT)(GLuint,GLsizei,GLenum,GLsizei,GLsizei,GLboolean,GLuint,GLuint64);
-        void       (WINE_GLAPI *p_glTextureStorageMem3DEXT)(GLuint,GLsizei,GLenum,GLsizei,GLsizei,GLsizei,GLuint,GLuint64);
-        void       (WINE_GLAPI *p_glTextureStorageMem3DMultisampleEXT)(GLuint,GLsizei,GLenum,GLsizei,GLsizei,GLsizei,GLboolean,GLuint,GLuint64);
-        void       (WINE_GLAPI *p_glTextureStorageSparseAMD)(GLuint,GLenum,GLenum,GLsizei,GLsizei,GLsizei,GLsizei,GLbitfield);
-        void       (WINE_GLAPI *p_glTextureSubImage1D)(GLuint,GLint,GLint,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTextureSubImage1DEXT)(GLuint,GLenum,GLint,GLint,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTextureSubImage2D)(GLuint,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTextureSubImage2DEXT)(GLuint,GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTextureSubImage3D)(GLuint,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTextureSubImage3DEXT)(GLuint,GLenum,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLenum,GLenum,const void*);
-        void       (WINE_GLAPI *p_glTextureView)(GLuint,GLenum,GLuint,GLenum,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glTrackMatrixNV)(GLenum,GLuint,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glTransformFeedbackAttribsNV)(GLsizei,const GLint*,GLenum);
-        void       (WINE_GLAPI *p_glTransformFeedbackBufferBase)(GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glTransformFeedbackBufferRange)(GLuint,GLuint,GLuint,GLintptr,GLsizeiptr);
-        void       (WINE_GLAPI *p_glTransformFeedbackStreamAttribsNV)(GLsizei,const GLint*,GLsizei,const GLint*,GLenum);
-        void       (WINE_GLAPI *p_glTransformFeedbackVaryings)(GLuint,GLsizei,const GLchar*const*,GLenum);
-        void       (WINE_GLAPI *p_glTransformFeedbackVaryingsEXT)(GLuint,GLsizei,const GLchar*const*,GLenum);
-        void       (WINE_GLAPI *p_glTransformFeedbackVaryingsNV)(GLuint,GLsizei,const GLint*,GLenum);
-        void       (WINE_GLAPI *p_glTransformPathNV)(GLuint,GLuint,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glTranslatexOES)(GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glUniform1d)(GLint,GLdouble);
-        void       (WINE_GLAPI *p_glUniform1dv)(GLint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glUniform1f)(GLint,GLfloat);
-        void       (WINE_GLAPI *p_glUniform1fARB)(GLint,GLfloat);
-        void       (WINE_GLAPI *p_glUniform1fv)(GLint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniform1fvARB)(GLint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniform1i)(GLint,GLint);
-        void       (WINE_GLAPI *p_glUniform1i64ARB)(GLint,GLint64);
-        void       (WINE_GLAPI *p_glUniform1i64NV)(GLint,GLint64EXT);
-        void       (WINE_GLAPI *p_glUniform1i64vARB)(GLint,GLsizei,const GLint64*);
-        void       (WINE_GLAPI *p_glUniform1i64vNV)(GLint,GLsizei,const GLint64EXT*);
-        void       (WINE_GLAPI *p_glUniform1iARB)(GLint,GLint);
-        void       (WINE_GLAPI *p_glUniform1iv)(GLint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glUniform1ivARB)(GLint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glUniform1ui)(GLint,GLuint);
-        void       (WINE_GLAPI *p_glUniform1ui64ARB)(GLint,GLuint64);
-        void       (WINE_GLAPI *p_glUniform1ui64NV)(GLint,GLuint64EXT);
-        void       (WINE_GLAPI *p_glUniform1ui64vARB)(GLint,GLsizei,const GLuint64*);
-        void       (WINE_GLAPI *p_glUniform1ui64vNV)(GLint,GLsizei,const GLuint64EXT*);
-        void       (WINE_GLAPI *p_glUniform1uiEXT)(GLint,GLuint);
-        void       (WINE_GLAPI *p_glUniform1uiv)(GLint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glUniform1uivEXT)(GLint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glUniform2d)(GLint,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glUniform2dv)(GLint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glUniform2f)(GLint,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glUniform2fARB)(GLint,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glUniform2fv)(GLint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniform2fvARB)(GLint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniform2i)(GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glUniform2i64ARB)(GLint,GLint64,GLint64);
-        void       (WINE_GLAPI *p_glUniform2i64NV)(GLint,GLint64EXT,GLint64EXT);
-        void       (WINE_GLAPI *p_glUniform2i64vARB)(GLint,GLsizei,const GLint64*);
-        void       (WINE_GLAPI *p_glUniform2i64vNV)(GLint,GLsizei,const GLint64EXT*);
-        void       (WINE_GLAPI *p_glUniform2iARB)(GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glUniform2iv)(GLint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glUniform2ivARB)(GLint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glUniform2ui)(GLint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glUniform2ui64ARB)(GLint,GLuint64,GLuint64);
-        void       (WINE_GLAPI *p_glUniform2ui64NV)(GLint,GLuint64EXT,GLuint64EXT);
-        void       (WINE_GLAPI *p_glUniform2ui64vARB)(GLint,GLsizei,const GLuint64*);
-        void       (WINE_GLAPI *p_glUniform2ui64vNV)(GLint,GLsizei,const GLuint64EXT*);
-        void       (WINE_GLAPI *p_glUniform2uiEXT)(GLint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glUniform2uiv)(GLint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glUniform2uivEXT)(GLint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glUniform3d)(GLint,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glUniform3dv)(GLint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glUniform3f)(GLint,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glUniform3fARB)(GLint,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glUniform3fv)(GLint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniform3fvARB)(GLint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniform3i)(GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glUniform3i64ARB)(GLint,GLint64,GLint64,GLint64);
-        void       (WINE_GLAPI *p_glUniform3i64NV)(GLint,GLint64EXT,GLint64EXT,GLint64EXT);
-        void       (WINE_GLAPI *p_glUniform3i64vARB)(GLint,GLsizei,const GLint64*);
-        void       (WINE_GLAPI *p_glUniform3i64vNV)(GLint,GLsizei,const GLint64EXT*);
-        void       (WINE_GLAPI *p_glUniform3iARB)(GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glUniform3iv)(GLint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glUniform3ivARB)(GLint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glUniform3ui)(GLint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glUniform3ui64ARB)(GLint,GLuint64,GLuint64,GLuint64);
-        void       (WINE_GLAPI *p_glUniform3ui64NV)(GLint,GLuint64EXT,GLuint64EXT,GLuint64EXT);
-        void       (WINE_GLAPI *p_glUniform3ui64vARB)(GLint,GLsizei,const GLuint64*);
-        void       (WINE_GLAPI *p_glUniform3ui64vNV)(GLint,GLsizei,const GLuint64EXT*);
-        void       (WINE_GLAPI *p_glUniform3uiEXT)(GLint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glUniform3uiv)(GLint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glUniform3uivEXT)(GLint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glUniform4d)(GLint,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glUniform4dv)(GLint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glUniform4f)(GLint,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glUniform4fARB)(GLint,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glUniform4fv)(GLint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniform4fvARB)(GLint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniform4i)(GLint,GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glUniform4i64ARB)(GLint,GLint64,GLint64,GLint64,GLint64);
-        void       (WINE_GLAPI *p_glUniform4i64NV)(GLint,GLint64EXT,GLint64EXT,GLint64EXT,GLint64EXT);
-        void       (WINE_GLAPI *p_glUniform4i64vARB)(GLint,GLsizei,const GLint64*);
-        void       (WINE_GLAPI *p_glUniform4i64vNV)(GLint,GLsizei,const GLint64EXT*);
-        void       (WINE_GLAPI *p_glUniform4iARB)(GLint,GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glUniform4iv)(GLint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glUniform4ivARB)(GLint,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glUniform4ui)(GLint,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glUniform4ui64ARB)(GLint,GLuint64,GLuint64,GLuint64,GLuint64);
-        void       (WINE_GLAPI *p_glUniform4ui64NV)(GLint,GLuint64EXT,GLuint64EXT,GLuint64EXT,GLuint64EXT);
-        void       (WINE_GLAPI *p_glUniform4ui64vARB)(GLint,GLsizei,const GLuint64*);
-        void       (WINE_GLAPI *p_glUniform4ui64vNV)(GLint,GLsizei,const GLuint64EXT*);
-        void       (WINE_GLAPI *p_glUniform4uiEXT)(GLint,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glUniform4uiv)(GLint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glUniform4uivEXT)(GLint,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glUniformBlockBinding)(GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glUniformBufferEXT)(GLuint,GLint,GLuint);
-        void       (WINE_GLAPI *p_glUniformHandleui64ARB)(GLint,GLuint64);
-        void       (WINE_GLAPI *p_glUniformHandleui64NV)(GLint,GLuint64);
-        void       (WINE_GLAPI *p_glUniformHandleui64vARB)(GLint,GLsizei,const GLuint64*);
-        void       (WINE_GLAPI *p_glUniformHandleui64vNV)(GLint,GLsizei,const GLuint64*);
-        void       (WINE_GLAPI *p_glUniformMatrix2dv)(GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glUniformMatrix2fv)(GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniformMatrix2fvARB)(GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniformMatrix2x3dv)(GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glUniformMatrix2x3fv)(GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniformMatrix2x4dv)(GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glUniformMatrix2x4fv)(GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniformMatrix3dv)(GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glUniformMatrix3fv)(GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniformMatrix3fvARB)(GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniformMatrix3x2dv)(GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glUniformMatrix3x2fv)(GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniformMatrix3x4dv)(GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glUniformMatrix3x4fv)(GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniformMatrix4dv)(GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glUniformMatrix4fv)(GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniformMatrix4fvARB)(GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniformMatrix4x2dv)(GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glUniformMatrix4x2fv)(GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniformMatrix4x3dv)(GLint,GLsizei,GLboolean,const GLdouble*);
-        void       (WINE_GLAPI *p_glUniformMatrix4x3fv)(GLint,GLsizei,GLboolean,const GLfloat*);
-        void       (WINE_GLAPI *p_glUniformSubroutinesuiv)(GLenum,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glUniformui64NV)(GLint,GLuint64EXT);
-        void       (WINE_GLAPI *p_glUniformui64vNV)(GLint,GLsizei,const GLuint64EXT*);
+        void       (WINE_GLAPI *p_glTextureBuffer)( GLuint texture, GLenum internalformat, GLuint buffer );
+        void       (WINE_GLAPI *p_glTextureBufferEXT)( GLuint texture, GLenum target, GLenum internalformat, GLuint buffer );
+        void       (WINE_GLAPI *p_glTextureBufferRange)( GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size );
+        void       (WINE_GLAPI *p_glTextureBufferRangeEXT)( GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size );
+        void       (WINE_GLAPI *p_glTextureColorMaskSGIS)( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha );
+        void       (WINE_GLAPI *p_glTextureImage1DEXT)( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTextureImage2DEXT)( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTextureImage2DMultisampleCoverageNV)( GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations );
+        void       (WINE_GLAPI *p_glTextureImage2DMultisampleNV)( GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations );
+        void       (WINE_GLAPI *p_glTextureImage3DEXT)( GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTextureImage3DMultisampleCoverageNV)( GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations );
+        void       (WINE_GLAPI *p_glTextureImage3DMultisampleNV)( GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations );
+        void       (WINE_GLAPI *p_glTextureLightEXT)( GLenum pname );
+        void       (WINE_GLAPI *p_glTextureMaterialEXT)( GLenum face, GLenum mode );
+        void       (WINE_GLAPI *p_glTextureNormalEXT)( GLenum mode );
+        void       (WINE_GLAPI *p_glTexturePageCommitmentEXT)( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit );
+        void       (WINE_GLAPI *p_glTextureParameterIiv)( GLuint texture, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glTextureParameterIivEXT)( GLuint texture, GLenum target, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glTextureParameterIuiv)( GLuint texture, GLenum pname, const GLuint *params );
+        void       (WINE_GLAPI *p_glTextureParameterIuivEXT)( GLuint texture, GLenum target, GLenum pname, const GLuint *params );
+        void       (WINE_GLAPI *p_glTextureParameterf)( GLuint texture, GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glTextureParameterfEXT)( GLuint texture, GLenum target, GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glTextureParameterfv)( GLuint texture, GLenum pname, const GLfloat *param );
+        void       (WINE_GLAPI *p_glTextureParameterfvEXT)( GLuint texture, GLenum target, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glTextureParameteri)( GLuint texture, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glTextureParameteriEXT)( GLuint texture, GLenum target, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glTextureParameteriv)( GLuint texture, GLenum pname, const GLint *param );
+        void       (WINE_GLAPI *p_glTextureParameterivEXT)( GLuint texture, GLenum target, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glTextureRangeAPPLE)( GLenum target, GLsizei length, const void *pointer );
+        void       (WINE_GLAPI *p_glTextureRenderbufferEXT)( GLuint texture, GLenum target, GLuint renderbuffer );
+        void       (WINE_GLAPI *p_glTextureStorage1D)( GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width );
+        void       (WINE_GLAPI *p_glTextureStorage1DEXT)( GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width );
+        void       (WINE_GLAPI *p_glTextureStorage2D)( GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glTextureStorage2DEXT)( GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height );
+        void       (WINE_GLAPI *p_glTextureStorage2DMultisample)( GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations );
+        void       (WINE_GLAPI *p_glTextureStorage2DMultisampleEXT)( GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations );
+        void       (WINE_GLAPI *p_glTextureStorage3D)( GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth );
+        void       (WINE_GLAPI *p_glTextureStorage3DEXT)( GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth );
+        void       (WINE_GLAPI *p_glTextureStorage3DMultisample)( GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations );
+        void       (WINE_GLAPI *p_glTextureStorage3DMultisampleEXT)( GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations );
+        void       (WINE_GLAPI *p_glTextureStorageMem1DEXT)( GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLuint memory, GLuint64 offset );
+        void       (WINE_GLAPI *p_glTextureStorageMem2DEXT)( GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLuint memory, GLuint64 offset );
+        void       (WINE_GLAPI *p_glTextureStorageMem2DMultisampleEXT)( GLuint texture, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset );
+        void       (WINE_GLAPI *p_glTextureStorageMem3DEXT)( GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset );
+        void       (WINE_GLAPI *p_glTextureStorageMem3DMultisampleEXT)( GLuint texture, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset );
+        void       (WINE_GLAPI *p_glTextureStorageSparseAMD)( GLuint texture, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags );
+        void       (WINE_GLAPI *p_glTextureSubImage1D)( GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTextureSubImage1DEXT)( GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTextureSubImage2D)( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTextureSubImage2DEXT)( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTextureSubImage3D)( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTextureSubImage3DEXT)( GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels );
+        void       (WINE_GLAPI *p_glTextureView)( GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers );
+        void       (WINE_GLAPI *p_glTrackMatrixNV)( GLenum target, GLuint address, GLenum matrix, GLenum transform );
+        void       (WINE_GLAPI *p_glTransformFeedbackAttribsNV)( GLsizei count, const GLint *attribs, GLenum bufferMode );
+        void       (WINE_GLAPI *p_glTransformFeedbackBufferBase)( GLuint xfb, GLuint index, GLuint buffer );
+        void       (WINE_GLAPI *p_glTransformFeedbackBufferRange)( GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size );
+        void       (WINE_GLAPI *p_glTransformFeedbackStreamAttribsNV)( GLsizei count, const GLint *attribs, GLsizei nbuffers, const GLint *bufstreams, GLenum bufferMode );
+        void       (WINE_GLAPI *p_glTransformFeedbackVaryings)( GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode );
+        void       (WINE_GLAPI *p_glTransformFeedbackVaryingsEXT)( GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode );
+        void       (WINE_GLAPI *p_glTransformFeedbackVaryingsNV)( GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode );
+        void       (WINE_GLAPI *p_glTransformPathNV)( GLuint resultPath, GLuint srcPath, GLenum transformType, const GLfloat *transformValues );
+        void       (WINE_GLAPI *p_glTranslatexOES)( GLfixed x, GLfixed y, GLfixed z );
+        void       (WINE_GLAPI *p_glUniform1d)( GLint location, GLdouble x );
+        void       (WINE_GLAPI *p_glUniform1dv)( GLint location, GLsizei count, const GLdouble *value );
+        void       (WINE_GLAPI *p_glUniform1f)( GLint location, GLfloat v0 );
+        void       (WINE_GLAPI *p_glUniform1fARB)( GLint location, GLfloat v0 );
+        void       (WINE_GLAPI *p_glUniform1fv)( GLint location, GLsizei count, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniform1fvARB)( GLint location, GLsizei count, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniform1i)( GLint location, GLint v0 );
+        void       (WINE_GLAPI *p_glUniform1i64ARB)( GLint location, GLint64 x );
+        void       (WINE_GLAPI *p_glUniform1i64NV)( GLint location, GLint64EXT x );
+        void       (WINE_GLAPI *p_glUniform1i64vARB)( GLint location, GLsizei count, const GLint64 *value );
+        void       (WINE_GLAPI *p_glUniform1i64vNV)( GLint location, GLsizei count, const GLint64EXT *value );
+        void       (WINE_GLAPI *p_glUniform1iARB)( GLint location, GLint v0 );
+        void       (WINE_GLAPI *p_glUniform1iv)( GLint location, GLsizei count, const GLint *value );
+        void       (WINE_GLAPI *p_glUniform1ivARB)( GLint location, GLsizei count, const GLint *value );
+        void       (WINE_GLAPI *p_glUniform1ui)( GLint location, GLuint v0 );
+        void       (WINE_GLAPI *p_glUniform1ui64ARB)( GLint location, GLuint64 x );
+        void       (WINE_GLAPI *p_glUniform1ui64NV)( GLint location, GLuint64EXT x );
+        void       (WINE_GLAPI *p_glUniform1ui64vARB)( GLint location, GLsizei count, const GLuint64 *value );
+        void       (WINE_GLAPI *p_glUniform1ui64vNV)( GLint location, GLsizei count, const GLuint64EXT *value );
+        void       (WINE_GLAPI *p_glUniform1uiEXT)( GLint location, GLuint v0 );
+        void       (WINE_GLAPI *p_glUniform1uiv)( GLint location, GLsizei count, const GLuint *value );
+        void       (WINE_GLAPI *p_glUniform1uivEXT)( GLint location, GLsizei count, const GLuint *value );
+        void       (WINE_GLAPI *p_glUniform2d)( GLint location, GLdouble x, GLdouble y );
+        void       (WINE_GLAPI *p_glUniform2dv)( GLint location, GLsizei count, const GLdouble *value );
+        void       (WINE_GLAPI *p_glUniform2f)( GLint location, GLfloat v0, GLfloat v1 );
+        void       (WINE_GLAPI *p_glUniform2fARB)( GLint location, GLfloat v0, GLfloat v1 );
+        void       (WINE_GLAPI *p_glUniform2fv)( GLint location, GLsizei count, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniform2fvARB)( GLint location, GLsizei count, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniform2i)( GLint location, GLint v0, GLint v1 );
+        void       (WINE_GLAPI *p_glUniform2i64ARB)( GLint location, GLint64 x, GLint64 y );
+        void       (WINE_GLAPI *p_glUniform2i64NV)( GLint location, GLint64EXT x, GLint64EXT y );
+        void       (WINE_GLAPI *p_glUniform2i64vARB)( GLint location, GLsizei count, const GLint64 *value );
+        void       (WINE_GLAPI *p_glUniform2i64vNV)( GLint location, GLsizei count, const GLint64EXT *value );
+        void       (WINE_GLAPI *p_glUniform2iARB)( GLint location, GLint v0, GLint v1 );
+        void       (WINE_GLAPI *p_glUniform2iv)( GLint location, GLsizei count, const GLint *value );
+        void       (WINE_GLAPI *p_glUniform2ivARB)( GLint location, GLsizei count, const GLint *value );
+        void       (WINE_GLAPI *p_glUniform2ui)( GLint location, GLuint v0, GLuint v1 );
+        void       (WINE_GLAPI *p_glUniform2ui64ARB)( GLint location, GLuint64 x, GLuint64 y );
+        void       (WINE_GLAPI *p_glUniform2ui64NV)( GLint location, GLuint64EXT x, GLuint64EXT y );
+        void       (WINE_GLAPI *p_glUniform2ui64vARB)( GLint location, GLsizei count, const GLuint64 *value );
+        void       (WINE_GLAPI *p_glUniform2ui64vNV)( GLint location, GLsizei count, const GLuint64EXT *value );
+        void       (WINE_GLAPI *p_glUniform2uiEXT)( GLint location, GLuint v0, GLuint v1 );
+        void       (WINE_GLAPI *p_glUniform2uiv)( GLint location, GLsizei count, const GLuint *value );
+        void       (WINE_GLAPI *p_glUniform2uivEXT)( GLint location, GLsizei count, const GLuint *value );
+        void       (WINE_GLAPI *p_glUniform3d)( GLint location, GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glUniform3dv)( GLint location, GLsizei count, const GLdouble *value );
+        void       (WINE_GLAPI *p_glUniform3f)( GLint location, GLfloat v0, GLfloat v1, GLfloat v2 );
+        void       (WINE_GLAPI *p_glUniform3fARB)( GLint location, GLfloat v0, GLfloat v1, GLfloat v2 );
+        void       (WINE_GLAPI *p_glUniform3fv)( GLint location, GLsizei count, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniform3fvARB)( GLint location, GLsizei count, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniform3i)( GLint location, GLint v0, GLint v1, GLint v2 );
+        void       (WINE_GLAPI *p_glUniform3i64ARB)( GLint location, GLint64 x, GLint64 y, GLint64 z );
+        void       (WINE_GLAPI *p_glUniform3i64NV)( GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z );
+        void       (WINE_GLAPI *p_glUniform3i64vARB)( GLint location, GLsizei count, const GLint64 *value );
+        void       (WINE_GLAPI *p_glUniform3i64vNV)( GLint location, GLsizei count, const GLint64EXT *value );
+        void       (WINE_GLAPI *p_glUniform3iARB)( GLint location, GLint v0, GLint v1, GLint v2 );
+        void       (WINE_GLAPI *p_glUniform3iv)( GLint location, GLsizei count, const GLint *value );
+        void       (WINE_GLAPI *p_glUniform3ivARB)( GLint location, GLsizei count, const GLint *value );
+        void       (WINE_GLAPI *p_glUniform3ui)( GLint location, GLuint v0, GLuint v1, GLuint v2 );
+        void       (WINE_GLAPI *p_glUniform3ui64ARB)( GLint location, GLuint64 x, GLuint64 y, GLuint64 z );
+        void       (WINE_GLAPI *p_glUniform3ui64NV)( GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z );
+        void       (WINE_GLAPI *p_glUniform3ui64vARB)( GLint location, GLsizei count, const GLuint64 *value );
+        void       (WINE_GLAPI *p_glUniform3ui64vNV)( GLint location, GLsizei count, const GLuint64EXT *value );
+        void       (WINE_GLAPI *p_glUniform3uiEXT)( GLint location, GLuint v0, GLuint v1, GLuint v2 );
+        void       (WINE_GLAPI *p_glUniform3uiv)( GLint location, GLsizei count, const GLuint *value );
+        void       (WINE_GLAPI *p_glUniform3uivEXT)( GLint location, GLsizei count, const GLuint *value );
+        void       (WINE_GLAPI *p_glUniform4d)( GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+        void       (WINE_GLAPI *p_glUniform4dv)( GLint location, GLsizei count, const GLdouble *value );
+        void       (WINE_GLAPI *p_glUniform4f)( GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 );
+        void       (WINE_GLAPI *p_glUniform4fARB)( GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3 );
+        void       (WINE_GLAPI *p_glUniform4fv)( GLint location, GLsizei count, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniform4fvARB)( GLint location, GLsizei count, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniform4i)( GLint location, GLint v0, GLint v1, GLint v2, GLint v3 );
+        void       (WINE_GLAPI *p_glUniform4i64ARB)( GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w );
+        void       (WINE_GLAPI *p_glUniform4i64NV)( GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w );
+        void       (WINE_GLAPI *p_glUniform4i64vARB)( GLint location, GLsizei count, const GLint64 *value );
+        void       (WINE_GLAPI *p_glUniform4i64vNV)( GLint location, GLsizei count, const GLint64EXT *value );
+        void       (WINE_GLAPI *p_glUniform4iARB)( GLint location, GLint v0, GLint v1, GLint v2, GLint v3 );
+        void       (WINE_GLAPI *p_glUniform4iv)( GLint location, GLsizei count, const GLint *value );
+        void       (WINE_GLAPI *p_glUniform4ivARB)( GLint location, GLsizei count, const GLint *value );
+        void       (WINE_GLAPI *p_glUniform4ui)( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 );
+        void       (WINE_GLAPI *p_glUniform4ui64ARB)( GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w );
+        void       (WINE_GLAPI *p_glUniform4ui64NV)( GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w );
+        void       (WINE_GLAPI *p_glUniform4ui64vARB)( GLint location, GLsizei count, const GLuint64 *value );
+        void       (WINE_GLAPI *p_glUniform4ui64vNV)( GLint location, GLsizei count, const GLuint64EXT *value );
+        void       (WINE_GLAPI *p_glUniform4uiEXT)( GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3 );
+        void       (WINE_GLAPI *p_glUniform4uiv)( GLint location, GLsizei count, const GLuint *value );
+        void       (WINE_GLAPI *p_glUniform4uivEXT)( GLint location, GLsizei count, const GLuint *value );
+        void       (WINE_GLAPI *p_glUniformBlockBinding)( GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding );
+        void       (WINE_GLAPI *p_glUniformBufferEXT)( GLuint program, GLint location, GLuint buffer );
+        void       (WINE_GLAPI *p_glUniformHandleui64ARB)( GLint location, GLuint64 value );
+        void       (WINE_GLAPI *p_glUniformHandleui64NV)( GLint location, GLuint64 value );
+        void       (WINE_GLAPI *p_glUniformHandleui64vARB)( GLint location, GLsizei count, const GLuint64 *value );
+        void       (WINE_GLAPI *p_glUniformHandleui64vNV)( GLint location, GLsizei count, const GLuint64 *value );
+        void       (WINE_GLAPI *p_glUniformMatrix2dv)( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glUniformMatrix2fv)( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniformMatrix2fvARB)( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniformMatrix2x3dv)( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glUniformMatrix2x3fv)( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniformMatrix2x4dv)( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glUniformMatrix2x4fv)( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniformMatrix3dv)( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glUniformMatrix3fv)( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniformMatrix3fvARB)( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniformMatrix3x2dv)( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glUniformMatrix3x2fv)( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniformMatrix3x4dv)( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glUniformMatrix3x4fv)( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniformMatrix4dv)( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glUniformMatrix4fv)( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniformMatrix4fvARB)( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniformMatrix4x2dv)( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glUniformMatrix4x2fv)( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniformMatrix4x3dv)( GLint location, GLsizei count, GLboolean transpose, const GLdouble *value );
+        void       (WINE_GLAPI *p_glUniformMatrix4x3fv)( GLint location, GLsizei count, GLboolean transpose, const GLfloat *value );
+        void       (WINE_GLAPI *p_glUniformSubroutinesuiv)( GLenum shadertype, GLsizei count, const GLuint *indices );
+        void       (WINE_GLAPI *p_glUniformui64NV)( GLint location, GLuint64EXT value );
+        void       (WINE_GLAPI *p_glUniformui64vNV)( GLint location, GLsizei count, const GLuint64EXT *value );
         void       (WINE_GLAPI *p_glUnlockArraysEXT)(void);
-        GLboolean  (WINE_GLAPI *p_glUnmapBuffer)(GLenum);
-        GLboolean  (WINE_GLAPI *p_glUnmapBufferARB)(GLenum);
-        GLboolean  (WINE_GLAPI *p_glUnmapNamedBuffer)(GLuint);
-        GLboolean  (WINE_GLAPI *p_glUnmapNamedBufferEXT)(GLuint);
-        void       (WINE_GLAPI *p_glUnmapObjectBufferATI)(GLuint);
-        void       (WINE_GLAPI *p_glUnmapTexture2DINTEL)(GLuint,GLint);
-        void       (WINE_GLAPI *p_glUpdateObjectBufferATI)(GLuint,GLuint,GLsizei,const void*,GLenum);
-        void       (WINE_GLAPI *p_glUseProgram)(GLuint);
-        void       (WINE_GLAPI *p_glUseProgramObjectARB)(GLhandleARB);
-        void       (WINE_GLAPI *p_glUseProgramStages)(GLuint,GLbitfield,GLuint);
-        void       (WINE_GLAPI *p_glUseShaderProgramEXT)(GLenum,GLuint);
+        GLboolean  (WINE_GLAPI *p_glUnmapBuffer)( GLenum target );
+        GLboolean  (WINE_GLAPI *p_glUnmapBufferARB)( GLenum target );
+        GLboolean  (WINE_GLAPI *p_glUnmapNamedBuffer)( GLuint buffer );
+        GLboolean  (WINE_GLAPI *p_glUnmapNamedBufferEXT)( GLuint buffer );
+        void       (WINE_GLAPI *p_glUnmapObjectBufferATI)( GLuint buffer );
+        void       (WINE_GLAPI *p_glUnmapTexture2DINTEL)( GLuint texture, GLint level );
+        void       (WINE_GLAPI *p_glUpdateObjectBufferATI)( GLuint buffer, GLuint offset, GLsizei size, const void *pointer, GLenum preserve );
+        void       (WINE_GLAPI *p_glUseProgram)( GLuint program );
+        void       (WINE_GLAPI *p_glUseProgramObjectARB)( GLhandleARB programObj );
+        void       (WINE_GLAPI *p_glUseProgramStages)( GLuint pipeline, GLbitfield stages, GLuint program );
+        void       (WINE_GLAPI *p_glUseShaderProgramEXT)( GLenum type, GLuint program );
         void       (WINE_GLAPI *p_glVDPAUFiniNV)(void);
-        void       (WINE_GLAPI *p_glVDPAUGetSurfaceivNV)(GLvdpauSurfaceNV,GLenum,GLsizei,GLsizei*,GLint*);
-        void       (WINE_GLAPI *p_glVDPAUInitNV)(const void*,const void*);
-        GLboolean  (WINE_GLAPI *p_glVDPAUIsSurfaceNV)(GLvdpauSurfaceNV);
-        void       (WINE_GLAPI *p_glVDPAUMapSurfacesNV)(GLsizei,const GLvdpauSurfaceNV*);
-        GLvdpauSurfaceNV (WINE_GLAPI *p_glVDPAURegisterOutputSurfaceNV)(const void*,GLenum,GLsizei,const GLuint*);
-        GLvdpauSurfaceNV (WINE_GLAPI *p_glVDPAURegisterVideoSurfaceNV)(const void*,GLenum,GLsizei,const GLuint*);
-        void       (WINE_GLAPI *p_glVDPAUSurfaceAccessNV)(GLvdpauSurfaceNV,GLenum);
-        void       (WINE_GLAPI *p_glVDPAUUnmapSurfacesNV)(GLsizei,const GLvdpauSurfaceNV*);
-        void       (WINE_GLAPI *p_glVDPAUUnregisterSurfaceNV)(GLvdpauSurfaceNV);
-        void       (WINE_GLAPI *p_glValidateProgram)(GLuint);
-        void       (WINE_GLAPI *p_glValidateProgramARB)(GLhandleARB);
-        void       (WINE_GLAPI *p_glValidateProgramPipeline)(GLuint);
-        void       (WINE_GLAPI *p_glVariantArrayObjectATI)(GLuint,GLenum,GLsizei,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVariantPointerEXT)(GLuint,GLenum,GLuint,const void*);
-        void       (WINE_GLAPI *p_glVariantbvEXT)(GLuint,const GLbyte*);
-        void       (WINE_GLAPI *p_glVariantdvEXT)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVariantfvEXT)(GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glVariantivEXT)(GLuint,const GLint*);
-        void       (WINE_GLAPI *p_glVariantsvEXT)(GLuint,const GLshort*);
-        void       (WINE_GLAPI *p_glVariantubvEXT)(GLuint,const GLubyte*);
-        void       (WINE_GLAPI *p_glVariantuivEXT)(GLuint,const GLuint*);
-        void       (WINE_GLAPI *p_glVariantusvEXT)(GLuint,const GLushort*);
-        void       (WINE_GLAPI *p_glVertex2bOES)(GLbyte,GLbyte);
-        void       (WINE_GLAPI *p_glVertex2bvOES)(const GLbyte*);
-        void       (WINE_GLAPI *p_glVertex2hNV)(GLhalfNV,GLhalfNV);
-        void       (WINE_GLAPI *p_glVertex2hvNV)(const GLhalfNV*);
-        void       (WINE_GLAPI *p_glVertex2xOES)(GLfixed);
-        void       (WINE_GLAPI *p_glVertex2xvOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glVertex3bOES)(GLbyte,GLbyte,GLbyte);
-        void       (WINE_GLAPI *p_glVertex3bvOES)(const GLbyte*);
-        void       (WINE_GLAPI *p_glVertex3hNV)(GLhalfNV,GLhalfNV,GLhalfNV);
-        void       (WINE_GLAPI *p_glVertex3hvNV)(const GLhalfNV*);
-        void       (WINE_GLAPI *p_glVertex3xOES)(GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glVertex3xvOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glVertex4bOES)(GLbyte,GLbyte,GLbyte,GLbyte);
-        void       (WINE_GLAPI *p_glVertex4bvOES)(const GLbyte*);
-        void       (WINE_GLAPI *p_glVertex4hNV)(GLhalfNV,GLhalfNV,GLhalfNV,GLhalfNV);
-        void       (WINE_GLAPI *p_glVertex4hvNV)(const GLhalfNV*);
-        void       (WINE_GLAPI *p_glVertex4xOES)(GLfixed,GLfixed,GLfixed);
-        void       (WINE_GLAPI *p_glVertex4xvOES)(const GLfixed*);
-        void       (WINE_GLAPI *p_glVertexArrayAttribBinding)(GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexArrayAttribFormat)(GLuint,GLuint,GLint,GLenum,GLboolean,GLuint);
-        void       (WINE_GLAPI *p_glVertexArrayAttribIFormat)(GLuint,GLuint,GLint,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glVertexArrayAttribLFormat)(GLuint,GLuint,GLint,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glVertexArrayBindVertexBufferEXT)(GLuint,GLuint,GLuint,GLintptr,GLsizei);
-        void       (WINE_GLAPI *p_glVertexArrayBindingDivisor)(GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexArrayColorOffsetEXT)(GLuint,GLuint,GLint,GLenum,GLsizei,GLintptr);
-        void       (WINE_GLAPI *p_glVertexArrayEdgeFlagOffsetEXT)(GLuint,GLuint,GLsizei,GLintptr);
-        void       (WINE_GLAPI *p_glVertexArrayElementBuffer)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexArrayFogCoordOffsetEXT)(GLuint,GLuint,GLenum,GLsizei,GLintptr);
-        void       (WINE_GLAPI *p_glVertexArrayIndexOffsetEXT)(GLuint,GLuint,GLenum,GLsizei,GLintptr);
-        void       (WINE_GLAPI *p_glVertexArrayMultiTexCoordOffsetEXT)(GLuint,GLuint,GLenum,GLint,GLenum,GLsizei,GLintptr);
-        void       (WINE_GLAPI *p_glVertexArrayNormalOffsetEXT)(GLuint,GLuint,GLenum,GLsizei,GLintptr);
-        void       (WINE_GLAPI *p_glVertexArrayParameteriAPPLE)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glVertexArrayRangeAPPLE)(GLsizei,void*);
-        void       (WINE_GLAPI *p_glVertexArrayRangeNV)(GLsizei,const void*);
-        void       (WINE_GLAPI *p_glVertexArraySecondaryColorOffsetEXT)(GLuint,GLuint,GLint,GLenum,GLsizei,GLintptr);
-        void       (WINE_GLAPI *p_glVertexArrayTexCoordOffsetEXT)(GLuint,GLuint,GLint,GLenum,GLsizei,GLintptr);
-        void       (WINE_GLAPI *p_glVertexArrayVertexAttribBindingEXT)(GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexArrayVertexAttribDivisorEXT)(GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexArrayVertexAttribFormatEXT)(GLuint,GLuint,GLint,GLenum,GLboolean,GLuint);
-        void       (WINE_GLAPI *p_glVertexArrayVertexAttribIFormatEXT)(GLuint,GLuint,GLint,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glVertexArrayVertexAttribIOffsetEXT)(GLuint,GLuint,GLuint,GLint,GLenum,GLsizei,GLintptr);
-        void       (WINE_GLAPI *p_glVertexArrayVertexAttribLFormatEXT)(GLuint,GLuint,GLint,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glVertexArrayVertexAttribLOffsetEXT)(GLuint,GLuint,GLuint,GLint,GLenum,GLsizei,GLintptr);
-        void       (WINE_GLAPI *p_glVertexArrayVertexAttribOffsetEXT)(GLuint,GLuint,GLuint,GLint,GLenum,GLboolean,GLsizei,GLintptr);
-        void       (WINE_GLAPI *p_glVertexArrayVertexBindingDivisorEXT)(GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexArrayVertexBuffer)(GLuint,GLuint,GLuint,GLintptr,GLsizei);
-        void       (WINE_GLAPI *p_glVertexArrayVertexBuffers)(GLuint,GLuint,GLsizei,const GLuint*,const GLintptr*,const GLsizei*);
-        void       (WINE_GLAPI *p_glVertexArrayVertexOffsetEXT)(GLuint,GLuint,GLint,GLenum,GLsizei,GLintptr);
-        void       (WINE_GLAPI *p_glVertexAttrib1d)(GLuint,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttrib1dARB)(GLuint,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttrib1dNV)(GLuint,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttrib1dv)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttrib1dvARB)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttrib1dvNV)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttrib1f)(GLuint,GLfloat);
-        void       (WINE_GLAPI *p_glVertexAttrib1fARB)(GLuint,GLfloat);
-        void       (WINE_GLAPI *p_glVertexAttrib1fNV)(GLuint,GLfloat);
-        void       (WINE_GLAPI *p_glVertexAttrib1fv)(GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexAttrib1fvARB)(GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexAttrib1fvNV)(GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexAttrib1hNV)(GLuint,GLhalfNV);
-        void       (WINE_GLAPI *p_glVertexAttrib1hvNV)(GLuint,const GLhalfNV*);
-        void       (WINE_GLAPI *p_glVertexAttrib1s)(GLuint,GLshort);
-        void       (WINE_GLAPI *p_glVertexAttrib1sARB)(GLuint,GLshort);
-        void       (WINE_GLAPI *p_glVertexAttrib1sNV)(GLuint,GLshort);
-        void       (WINE_GLAPI *p_glVertexAttrib1sv)(GLuint,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttrib1svARB)(GLuint,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttrib1svNV)(GLuint,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttrib2d)(GLuint,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttrib2dARB)(GLuint,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttrib2dNV)(GLuint,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttrib2dv)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttrib2dvARB)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttrib2dvNV)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttrib2f)(GLuint,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glVertexAttrib2fARB)(GLuint,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glVertexAttrib2fNV)(GLuint,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glVertexAttrib2fv)(GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexAttrib2fvARB)(GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexAttrib2fvNV)(GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexAttrib2hNV)(GLuint,GLhalfNV,GLhalfNV);
-        void       (WINE_GLAPI *p_glVertexAttrib2hvNV)(GLuint,const GLhalfNV*);
-        void       (WINE_GLAPI *p_glVertexAttrib2s)(GLuint,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glVertexAttrib2sARB)(GLuint,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glVertexAttrib2sNV)(GLuint,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glVertexAttrib2sv)(GLuint,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttrib2svARB)(GLuint,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttrib2svNV)(GLuint,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttrib3d)(GLuint,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttrib3dARB)(GLuint,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttrib3dNV)(GLuint,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttrib3dv)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttrib3dvARB)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttrib3dvNV)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttrib3f)(GLuint,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glVertexAttrib3fARB)(GLuint,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glVertexAttrib3fNV)(GLuint,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glVertexAttrib3fv)(GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexAttrib3fvARB)(GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexAttrib3fvNV)(GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexAttrib3hNV)(GLuint,GLhalfNV,GLhalfNV,GLhalfNV);
-        void       (WINE_GLAPI *p_glVertexAttrib3hvNV)(GLuint,const GLhalfNV*);
-        void       (WINE_GLAPI *p_glVertexAttrib3s)(GLuint,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glVertexAttrib3sARB)(GLuint,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glVertexAttrib3sNV)(GLuint,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glVertexAttrib3sv)(GLuint,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttrib3svARB)(GLuint,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttrib3svNV)(GLuint,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttrib4Nbv)(GLuint,const GLbyte*);
-        void       (WINE_GLAPI *p_glVertexAttrib4NbvARB)(GLuint,const GLbyte*);
-        void       (WINE_GLAPI *p_glVertexAttrib4Niv)(GLuint,const GLint*);
-        void       (WINE_GLAPI *p_glVertexAttrib4NivARB)(GLuint,const GLint*);
-        void       (WINE_GLAPI *p_glVertexAttrib4Nsv)(GLuint,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttrib4NsvARB)(GLuint,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttrib4Nub)(GLuint,GLubyte,GLubyte,GLubyte,GLubyte);
-        void       (WINE_GLAPI *p_glVertexAttrib4NubARB)(GLuint,GLubyte,GLubyte,GLubyte,GLubyte);
-        void       (WINE_GLAPI *p_glVertexAttrib4Nubv)(GLuint,const GLubyte*);
-        void       (WINE_GLAPI *p_glVertexAttrib4NubvARB)(GLuint,const GLubyte*);
-        void       (WINE_GLAPI *p_glVertexAttrib4Nuiv)(GLuint,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexAttrib4NuivARB)(GLuint,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexAttrib4Nusv)(GLuint,const GLushort*);
-        void       (WINE_GLAPI *p_glVertexAttrib4NusvARB)(GLuint,const GLushort*);
-        void       (WINE_GLAPI *p_glVertexAttrib4bv)(GLuint,const GLbyte*);
-        void       (WINE_GLAPI *p_glVertexAttrib4bvARB)(GLuint,const GLbyte*);
-        void       (WINE_GLAPI *p_glVertexAttrib4d)(GLuint,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttrib4dARB)(GLuint,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttrib4dNV)(GLuint,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttrib4dv)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttrib4dvARB)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttrib4dvNV)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttrib4f)(GLuint,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glVertexAttrib4fARB)(GLuint,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glVertexAttrib4fNV)(GLuint,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glVertexAttrib4fv)(GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexAttrib4fvARB)(GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexAttrib4fvNV)(GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexAttrib4hNV)(GLuint,GLhalfNV,GLhalfNV,GLhalfNV,GLhalfNV);
-        void       (WINE_GLAPI *p_glVertexAttrib4hvNV)(GLuint,const GLhalfNV*);
-        void       (WINE_GLAPI *p_glVertexAttrib4iv)(GLuint,const GLint*);
-        void       (WINE_GLAPI *p_glVertexAttrib4ivARB)(GLuint,const GLint*);
-        void       (WINE_GLAPI *p_glVertexAttrib4s)(GLuint,GLshort,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glVertexAttrib4sARB)(GLuint,GLshort,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glVertexAttrib4sNV)(GLuint,GLshort,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glVertexAttrib4sv)(GLuint,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttrib4svARB)(GLuint,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttrib4svNV)(GLuint,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttrib4ubNV)(GLuint,GLubyte,GLubyte,GLubyte,GLubyte);
-        void       (WINE_GLAPI *p_glVertexAttrib4ubv)(GLuint,const GLubyte*);
-        void       (WINE_GLAPI *p_glVertexAttrib4ubvARB)(GLuint,const GLubyte*);
-        void       (WINE_GLAPI *p_glVertexAttrib4ubvNV)(GLuint,const GLubyte*);
-        void       (WINE_GLAPI *p_glVertexAttrib4uiv)(GLuint,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexAttrib4uivARB)(GLuint,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexAttrib4usv)(GLuint,const GLushort*);
-        void       (WINE_GLAPI *p_glVertexAttrib4usvARB)(GLuint,const GLushort*);
-        void       (WINE_GLAPI *p_glVertexAttribArrayObjectATI)(GLuint,GLint,GLenum,GLboolean,GLsizei,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribBinding)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribDivisor)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribDivisorARB)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribFormat)(GLuint,GLint,GLenum,GLboolean,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribFormatNV)(GLuint,GLint,GLenum,GLboolean,GLsizei);
-        void       (WINE_GLAPI *p_glVertexAttribI1i)(GLuint,GLint);
-        void       (WINE_GLAPI *p_glVertexAttribI1iEXT)(GLuint,GLint);
-        void       (WINE_GLAPI *p_glVertexAttribI1iv)(GLuint,const GLint*);
-        void       (WINE_GLAPI *p_glVertexAttribI1ivEXT)(GLuint,const GLint*);
-        void       (WINE_GLAPI *p_glVertexAttribI1ui)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribI1uiEXT)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribI1uiv)(GLuint,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexAttribI1uivEXT)(GLuint,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexAttribI2i)(GLuint,GLint,GLint);
-        void       (WINE_GLAPI *p_glVertexAttribI2iEXT)(GLuint,GLint,GLint);
-        void       (WINE_GLAPI *p_glVertexAttribI2iv)(GLuint,const GLint*);
-        void       (WINE_GLAPI *p_glVertexAttribI2ivEXT)(GLuint,const GLint*);
-        void       (WINE_GLAPI *p_glVertexAttribI2ui)(GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribI2uiEXT)(GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribI2uiv)(GLuint,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexAttribI2uivEXT)(GLuint,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexAttribI3i)(GLuint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glVertexAttribI3iEXT)(GLuint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glVertexAttribI3iv)(GLuint,const GLint*);
-        void       (WINE_GLAPI *p_glVertexAttribI3ivEXT)(GLuint,const GLint*);
-        void       (WINE_GLAPI *p_glVertexAttribI3ui)(GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribI3uiEXT)(GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribI3uiv)(GLuint,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexAttribI3uivEXT)(GLuint,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexAttribI4bv)(GLuint,const GLbyte*);
-        void       (WINE_GLAPI *p_glVertexAttribI4bvEXT)(GLuint,const GLbyte*);
-        void       (WINE_GLAPI *p_glVertexAttribI4i)(GLuint,GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glVertexAttribI4iEXT)(GLuint,GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glVertexAttribI4iv)(GLuint,const GLint*);
-        void       (WINE_GLAPI *p_glVertexAttribI4ivEXT)(GLuint,const GLint*);
-        void       (WINE_GLAPI *p_glVertexAttribI4sv)(GLuint,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttribI4svEXT)(GLuint,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttribI4ubv)(GLuint,const GLubyte*);
-        void       (WINE_GLAPI *p_glVertexAttribI4ubvEXT)(GLuint,const GLubyte*);
-        void       (WINE_GLAPI *p_glVertexAttribI4ui)(GLuint,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribI4uiEXT)(GLuint,GLuint,GLuint,GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribI4uiv)(GLuint,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexAttribI4uivEXT)(GLuint,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexAttribI4usv)(GLuint,const GLushort*);
-        void       (WINE_GLAPI *p_glVertexAttribI4usvEXT)(GLuint,const GLushort*);
-        void       (WINE_GLAPI *p_glVertexAttribIFormat)(GLuint,GLint,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribIFormatNV)(GLuint,GLint,GLenum,GLsizei);
-        void       (WINE_GLAPI *p_glVertexAttribIPointer)(GLuint,GLint,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glVertexAttribIPointerEXT)(GLuint,GLint,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glVertexAttribL1d)(GLuint,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttribL1dEXT)(GLuint,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttribL1dv)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttribL1dvEXT)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttribL1i64NV)(GLuint,GLint64EXT);
-        void       (WINE_GLAPI *p_glVertexAttribL1i64vNV)(GLuint,const GLint64EXT*);
-        void       (WINE_GLAPI *p_glVertexAttribL1ui64ARB)(GLuint,GLuint64EXT);
-        void       (WINE_GLAPI *p_glVertexAttribL1ui64NV)(GLuint,GLuint64EXT);
-        void       (WINE_GLAPI *p_glVertexAttribL1ui64vARB)(GLuint,const GLuint64EXT*);
-        void       (WINE_GLAPI *p_glVertexAttribL1ui64vNV)(GLuint,const GLuint64EXT*);
-        void       (WINE_GLAPI *p_glVertexAttribL2d)(GLuint,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttribL2dEXT)(GLuint,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttribL2dv)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttribL2dvEXT)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttribL2i64NV)(GLuint,GLint64EXT,GLint64EXT);
-        void       (WINE_GLAPI *p_glVertexAttribL2i64vNV)(GLuint,const GLint64EXT*);
-        void       (WINE_GLAPI *p_glVertexAttribL2ui64NV)(GLuint,GLuint64EXT,GLuint64EXT);
-        void       (WINE_GLAPI *p_glVertexAttribL2ui64vNV)(GLuint,const GLuint64EXT*);
-        void       (WINE_GLAPI *p_glVertexAttribL3d)(GLuint,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttribL3dEXT)(GLuint,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttribL3dv)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttribL3dvEXT)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttribL3i64NV)(GLuint,GLint64EXT,GLint64EXT,GLint64EXT);
-        void       (WINE_GLAPI *p_glVertexAttribL3i64vNV)(GLuint,const GLint64EXT*);
-        void       (WINE_GLAPI *p_glVertexAttribL3ui64NV)(GLuint,GLuint64EXT,GLuint64EXT,GLuint64EXT);
-        void       (WINE_GLAPI *p_glVertexAttribL3ui64vNV)(GLuint,const GLuint64EXT*);
-        void       (WINE_GLAPI *p_glVertexAttribL4d)(GLuint,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttribL4dEXT)(GLuint,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexAttribL4dv)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttribL4dvEXT)(GLuint,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttribL4i64NV)(GLuint,GLint64EXT,GLint64EXT,GLint64EXT,GLint64EXT);
-        void       (WINE_GLAPI *p_glVertexAttribL4i64vNV)(GLuint,const GLint64EXT*);
-        void       (WINE_GLAPI *p_glVertexAttribL4ui64NV)(GLuint,GLuint64EXT,GLuint64EXT,GLuint64EXT,GLuint64EXT);
-        void       (WINE_GLAPI *p_glVertexAttribL4ui64vNV)(GLuint,const GLuint64EXT*);
-        void       (WINE_GLAPI *p_glVertexAttribLFormat)(GLuint,GLint,GLenum,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribLFormatNV)(GLuint,GLint,GLenum,GLsizei);
-        void       (WINE_GLAPI *p_glVertexAttribLPointer)(GLuint,GLint,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glVertexAttribLPointerEXT)(GLuint,GLint,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glVertexAttribP1ui)(GLuint,GLenum,GLboolean,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribP1uiv)(GLuint,GLenum,GLboolean,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexAttribP2ui)(GLuint,GLenum,GLboolean,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribP2uiv)(GLuint,GLenum,GLboolean,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexAttribP3ui)(GLuint,GLenum,GLboolean,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribP3uiv)(GLuint,GLenum,GLboolean,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexAttribP4ui)(GLuint,GLenum,GLboolean,GLuint);
-        void       (WINE_GLAPI *p_glVertexAttribP4uiv)(GLuint,GLenum,GLboolean,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexAttribParameteriAMD)(GLuint,GLenum,GLint);
-        void       (WINE_GLAPI *p_glVertexAttribPointer)(GLuint,GLint,GLenum,GLboolean,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glVertexAttribPointerARB)(GLuint,GLint,GLenum,GLboolean,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glVertexAttribPointerNV)(GLuint,GLint,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glVertexAttribs1dvNV)(GLuint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttribs1fvNV)(GLuint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexAttribs1hvNV)(GLuint,GLsizei,const GLhalfNV*);
-        void       (WINE_GLAPI *p_glVertexAttribs1svNV)(GLuint,GLsizei,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttribs2dvNV)(GLuint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttribs2fvNV)(GLuint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexAttribs2hvNV)(GLuint,GLsizei,const GLhalfNV*);
-        void       (WINE_GLAPI *p_glVertexAttribs2svNV)(GLuint,GLsizei,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttribs3dvNV)(GLuint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttribs3fvNV)(GLuint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexAttribs3hvNV)(GLuint,GLsizei,const GLhalfNV*);
-        void       (WINE_GLAPI *p_glVertexAttribs3svNV)(GLuint,GLsizei,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttribs4dvNV)(GLuint,GLsizei,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexAttribs4fvNV)(GLuint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexAttribs4hvNV)(GLuint,GLsizei,const GLhalfNV*);
-        void       (WINE_GLAPI *p_glVertexAttribs4svNV)(GLuint,GLsizei,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexAttribs4ubvNV)(GLuint,GLsizei,const GLubyte*);
-        void       (WINE_GLAPI *p_glVertexBindingDivisor)(GLuint,GLuint);
-        void       (WINE_GLAPI *p_glVertexBlendARB)(GLint);
-        void       (WINE_GLAPI *p_glVertexBlendEnvfATI)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glVertexBlendEnviATI)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glVertexFormatNV)(GLint,GLenum,GLsizei);
-        void       (WINE_GLAPI *p_glVertexP2ui)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glVertexP2uiv)(GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexP3ui)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glVertexP3uiv)(GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexP4ui)(GLenum,GLuint);
-        void       (WINE_GLAPI *p_glVertexP4uiv)(GLenum,const GLuint*);
-        void       (WINE_GLAPI *p_glVertexPointerEXT)(GLint,GLenum,GLsizei,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glVertexPointerListIBM)(GLint,GLenum,GLint,const void**,GLint);
-        void       (WINE_GLAPI *p_glVertexPointervINTEL)(GLint,GLenum,const void**);
-        void       (WINE_GLAPI *p_glVertexStream1dATI)(GLenum,GLdouble);
-        void       (WINE_GLAPI *p_glVertexStream1dvATI)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexStream1fATI)(GLenum,GLfloat);
-        void       (WINE_GLAPI *p_glVertexStream1fvATI)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexStream1iATI)(GLenum,GLint);
-        void       (WINE_GLAPI *p_glVertexStream1ivATI)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glVertexStream1sATI)(GLenum,GLshort);
-        void       (WINE_GLAPI *p_glVertexStream1svATI)(GLenum,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexStream2dATI)(GLenum,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexStream2dvATI)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexStream2fATI)(GLenum,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glVertexStream2fvATI)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexStream2iATI)(GLenum,GLint,GLint);
-        void       (WINE_GLAPI *p_glVertexStream2ivATI)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glVertexStream2sATI)(GLenum,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glVertexStream2svATI)(GLenum,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexStream3dATI)(GLenum,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexStream3dvATI)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexStream3fATI)(GLenum,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glVertexStream3fvATI)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexStream3iATI)(GLenum,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glVertexStream3ivATI)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glVertexStream3sATI)(GLenum,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glVertexStream3svATI)(GLenum,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexStream4dATI)(GLenum,GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glVertexStream4dvATI)(GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glVertexStream4fATI)(GLenum,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glVertexStream4fvATI)(GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexStream4iATI)(GLenum,GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glVertexStream4ivATI)(GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glVertexStream4sATI)(GLenum,GLshort,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glVertexStream4svATI)(GLenum,const GLshort*);
-        void       (WINE_GLAPI *p_glVertexWeightPointerEXT)(GLint,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glVertexWeightfEXT)(GLfloat);
-        void       (WINE_GLAPI *p_glVertexWeightfvEXT)(const GLfloat*);
-        void       (WINE_GLAPI *p_glVertexWeighthNV)(GLhalfNV);
-        void       (WINE_GLAPI *p_glVertexWeighthvNV)(const GLhalfNV*);
-        GLenum     (WINE_GLAPI *p_glVideoCaptureNV)(GLuint,GLuint*,GLuint64EXT*);
-        void       (WINE_GLAPI *p_glVideoCaptureStreamParameterdvNV)(GLuint,GLuint,GLenum,const GLdouble*);
-        void       (WINE_GLAPI *p_glVideoCaptureStreamParameterfvNV)(GLuint,GLuint,GLenum,const GLfloat*);
-        void       (WINE_GLAPI *p_glVideoCaptureStreamParameterivNV)(GLuint,GLuint,GLenum,const GLint*);
-        void       (WINE_GLAPI *p_glViewportArrayv)(GLuint,GLsizei,const GLfloat*);
-        void       (WINE_GLAPI *p_glViewportIndexedf)(GLuint,GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glViewportIndexedfv)(GLuint,const GLfloat*);
-        void       (WINE_GLAPI *p_glViewportPositionWScaleNV)(GLuint,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glViewportSwizzleNV)(GLuint,GLenum,GLenum,GLenum,GLenum);
-        void       (WINE_GLAPI *p_glWaitSemaphoreEXT)(GLuint,GLuint,const GLuint*,GLuint,const GLuint*,const GLenum*);
-        void       (WINE_GLAPI *p_glWaitSync)(GLsync,GLbitfield,GLuint64);
-        void       (WINE_GLAPI *p_glWaitVkSemaphoreNV)(GLuint64);
-        void       (WINE_GLAPI *p_glWeightPathsNV)(GLuint,GLsizei,const GLuint*,const GLfloat*);
-        void       (WINE_GLAPI *p_glWeightPointerARB)(GLint,GLenum,GLsizei,const void*);
-        void       (WINE_GLAPI *p_glWeightbvARB)(GLint,const GLbyte*);
-        void       (WINE_GLAPI *p_glWeightdvARB)(GLint,const GLdouble*);
-        void       (WINE_GLAPI *p_glWeightfvARB)(GLint,const GLfloat*);
-        void       (WINE_GLAPI *p_glWeightivARB)(GLint,const GLint*);
-        void       (WINE_GLAPI *p_glWeightsvARB)(GLint,const GLshort*);
-        void       (WINE_GLAPI *p_glWeightubvARB)(GLint,const GLubyte*);
-        void       (WINE_GLAPI *p_glWeightuivARB)(GLint,const GLuint*);
-        void       (WINE_GLAPI *p_glWeightusvARB)(GLint,const GLushort*);
-        void       (WINE_GLAPI *p_glWindowPos2d)(GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glWindowPos2dARB)(GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glWindowPos2dMESA)(GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glWindowPos2dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glWindowPos2dvARB)(const GLdouble*);
-        void       (WINE_GLAPI *p_glWindowPos2dvMESA)(const GLdouble*);
-        void       (WINE_GLAPI *p_glWindowPos2f)(GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glWindowPos2fARB)(GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glWindowPos2fMESA)(GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glWindowPos2fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glWindowPos2fvARB)(const GLfloat*);
-        void       (WINE_GLAPI *p_glWindowPos2fvMESA)(const GLfloat*);
-        void       (WINE_GLAPI *p_glWindowPos2i)(GLint,GLint);
-        void       (WINE_GLAPI *p_glWindowPos2iARB)(GLint,GLint);
-        void       (WINE_GLAPI *p_glWindowPos2iMESA)(GLint,GLint);
-        void       (WINE_GLAPI *p_glWindowPos2iv)(const GLint*);
-        void       (WINE_GLAPI *p_glWindowPos2ivARB)(const GLint*);
-        void       (WINE_GLAPI *p_glWindowPos2ivMESA)(const GLint*);
-        void       (WINE_GLAPI *p_glWindowPos2s)(GLshort,GLshort);
-        void       (WINE_GLAPI *p_glWindowPos2sARB)(GLshort,GLshort);
-        void       (WINE_GLAPI *p_glWindowPos2sMESA)(GLshort,GLshort);
-        void       (WINE_GLAPI *p_glWindowPos2sv)(const GLshort*);
-        void       (WINE_GLAPI *p_glWindowPos2svARB)(const GLshort*);
-        void       (WINE_GLAPI *p_glWindowPos2svMESA)(const GLshort*);
-        void       (WINE_GLAPI *p_glWindowPos3d)(GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glWindowPos3dARB)(GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glWindowPos3dMESA)(GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glWindowPos3dv)(const GLdouble*);
-        void       (WINE_GLAPI *p_glWindowPos3dvARB)(const GLdouble*);
-        void       (WINE_GLAPI *p_glWindowPos3dvMESA)(const GLdouble*);
-        void       (WINE_GLAPI *p_glWindowPos3f)(GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glWindowPos3fARB)(GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glWindowPos3fMESA)(GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glWindowPos3fv)(const GLfloat*);
-        void       (WINE_GLAPI *p_glWindowPos3fvARB)(const GLfloat*);
-        void       (WINE_GLAPI *p_glWindowPos3fvMESA)(const GLfloat*);
-        void       (WINE_GLAPI *p_glWindowPos3i)(GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glWindowPos3iARB)(GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glWindowPos3iMESA)(GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glWindowPos3iv)(const GLint*);
-        void       (WINE_GLAPI *p_glWindowPos3ivARB)(const GLint*);
-        void       (WINE_GLAPI *p_glWindowPos3ivMESA)(const GLint*);
-        void       (WINE_GLAPI *p_glWindowPos3s)(GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glWindowPos3sARB)(GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glWindowPos3sMESA)(GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glWindowPos3sv)(const GLshort*);
-        void       (WINE_GLAPI *p_glWindowPos3svARB)(const GLshort*);
-        void       (WINE_GLAPI *p_glWindowPos3svMESA)(const GLshort*);
-        void       (WINE_GLAPI *p_glWindowPos4dMESA)(GLdouble,GLdouble,GLdouble,GLdouble);
-        void       (WINE_GLAPI *p_glWindowPos4dvMESA)(const GLdouble*);
-        void       (WINE_GLAPI *p_glWindowPos4fMESA)(GLfloat,GLfloat,GLfloat,GLfloat);
-        void       (WINE_GLAPI *p_glWindowPos4fvMESA)(const GLfloat*);
-        void       (WINE_GLAPI *p_glWindowPos4iMESA)(GLint,GLint,GLint,GLint);
-        void       (WINE_GLAPI *p_glWindowPos4ivMESA)(const GLint*);
-        void       (WINE_GLAPI *p_glWindowPos4sMESA)(GLshort,GLshort,GLshort,GLshort);
-        void       (WINE_GLAPI *p_glWindowPos4svMESA)(const GLshort*);
-        void       (WINE_GLAPI *p_glWindowRectanglesEXT)(GLenum,GLsizei,const GLint*);
-        void       (WINE_GLAPI *p_glWriteMaskEXT)(GLuint,GLuint,GLenum,GLenum,GLenum,GLenum);
-        void*      (WINE_GLAPI *p_wglAllocateMemoryNV)(GLsizei,GLfloat,GLfloat,GLfloat);
-        BOOL       (WINE_GLAPI *p_wglBindTexImageARB)(struct wgl_pbuffer *,int);
-        BOOL       (WINE_GLAPI *p_wglChoosePixelFormatARB)(HDC,const int*,const FLOAT*,UINT,int*,UINT*);
-        struct wgl_context * (WINE_GLAPI *p_wglCreateContextAttribsARB)(HDC,struct wgl_context *,const int*);
-        struct wgl_pbuffer * (WINE_GLAPI *p_wglCreatePbufferARB)(HDC,int,int,int,const int*);
-        BOOL       (WINE_GLAPI *p_wglDestroyPbufferARB)(struct wgl_pbuffer *);
-        void       (WINE_GLAPI *p_wglFreeMemoryNV)(void*);
+        void       (WINE_GLAPI *p_glVDPAUGetSurfaceivNV)( GLvdpauSurfaceNV surface, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values );
+        void       (WINE_GLAPI *p_glVDPAUInitNV)( const void *vdpDevice, const void *getProcAddress );
+        GLboolean  (WINE_GLAPI *p_glVDPAUIsSurfaceNV)( GLvdpauSurfaceNV surface );
+        void       (WINE_GLAPI *p_glVDPAUMapSurfacesNV)( GLsizei numSurfaces, const GLvdpauSurfaceNV *surfaces );
+        GLvdpauSurfaceNV (WINE_GLAPI *p_glVDPAURegisterOutputSurfaceNV)( const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames );
+        GLvdpauSurfaceNV (WINE_GLAPI *p_glVDPAURegisterVideoSurfaceNV)( const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames );
+        void       (WINE_GLAPI *p_glVDPAUSurfaceAccessNV)( GLvdpauSurfaceNV surface, GLenum access );
+        void       (WINE_GLAPI *p_glVDPAUUnmapSurfacesNV)( GLsizei numSurface, const GLvdpauSurfaceNV *surfaces );
+        void       (WINE_GLAPI *p_glVDPAUUnregisterSurfaceNV)( GLvdpauSurfaceNV surface );
+        void       (WINE_GLAPI *p_glValidateProgram)( GLuint program );
+        void       (WINE_GLAPI *p_glValidateProgramARB)( GLhandleARB programObj );
+        void       (WINE_GLAPI *p_glValidateProgramPipeline)( GLuint pipeline );
+        void       (WINE_GLAPI *p_glVariantArrayObjectATI)( GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset );
+        void       (WINE_GLAPI *p_glVariantPointerEXT)( GLuint id, GLenum type, GLuint stride, const void *addr );
+        void       (WINE_GLAPI *p_glVariantbvEXT)( GLuint id, const GLbyte *addr );
+        void       (WINE_GLAPI *p_glVariantdvEXT)( GLuint id, const GLdouble *addr );
+        void       (WINE_GLAPI *p_glVariantfvEXT)( GLuint id, const GLfloat *addr );
+        void       (WINE_GLAPI *p_glVariantivEXT)( GLuint id, const GLint *addr );
+        void       (WINE_GLAPI *p_glVariantsvEXT)( GLuint id, const GLshort *addr );
+        void       (WINE_GLAPI *p_glVariantubvEXT)( GLuint id, const GLubyte *addr );
+        void       (WINE_GLAPI *p_glVariantuivEXT)( GLuint id, const GLuint *addr );
+        void       (WINE_GLAPI *p_glVariantusvEXT)( GLuint id, const GLushort *addr );
+        void       (WINE_GLAPI *p_glVertex2bOES)( GLbyte x, GLbyte y );
+        void       (WINE_GLAPI *p_glVertex2bvOES)( const GLbyte *coords );
+        void       (WINE_GLAPI *p_glVertex2hNV)( GLhalfNV x, GLhalfNV y );
+        void       (WINE_GLAPI *p_glVertex2hvNV)( const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glVertex2xOES)( GLfixed x );
+        void       (WINE_GLAPI *p_glVertex2xvOES)( const GLfixed *coords );
+        void       (WINE_GLAPI *p_glVertex3bOES)( GLbyte x, GLbyte y, GLbyte z );
+        void       (WINE_GLAPI *p_glVertex3bvOES)( const GLbyte *coords );
+        void       (WINE_GLAPI *p_glVertex3hNV)( GLhalfNV x, GLhalfNV y, GLhalfNV z );
+        void       (WINE_GLAPI *p_glVertex3hvNV)( const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glVertex3xOES)( GLfixed x, GLfixed y );
+        void       (WINE_GLAPI *p_glVertex3xvOES)( const GLfixed *coords );
+        void       (WINE_GLAPI *p_glVertex4bOES)( GLbyte x, GLbyte y, GLbyte z, GLbyte w );
+        void       (WINE_GLAPI *p_glVertex4bvOES)( const GLbyte *coords );
+        void       (WINE_GLAPI *p_glVertex4hNV)( GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w );
+        void       (WINE_GLAPI *p_glVertex4hvNV)( const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glVertex4xOES)( GLfixed x, GLfixed y, GLfixed z );
+        void       (WINE_GLAPI *p_glVertex4xvOES)( const GLfixed *coords );
+        void       (WINE_GLAPI *p_glVertexArrayAttribBinding)( GLuint vaobj, GLuint attribindex, GLuint bindingindex );
+        void       (WINE_GLAPI *p_glVertexArrayAttribFormat)( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset );
+        void       (WINE_GLAPI *p_glVertexArrayAttribIFormat)( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset );
+        void       (WINE_GLAPI *p_glVertexArrayAttribLFormat)( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset );
+        void       (WINE_GLAPI *p_glVertexArrayBindVertexBufferEXT)( GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride );
+        void       (WINE_GLAPI *p_glVertexArrayBindingDivisor)( GLuint vaobj, GLuint bindingindex, GLuint divisor );
+        void       (WINE_GLAPI *p_glVertexArrayColorOffsetEXT)( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset );
+        void       (WINE_GLAPI *p_glVertexArrayEdgeFlagOffsetEXT)( GLuint vaobj, GLuint buffer, GLsizei stride, GLintptr offset );
+        void       (WINE_GLAPI *p_glVertexArrayElementBuffer)( GLuint vaobj, GLuint buffer );
+        void       (WINE_GLAPI *p_glVertexArrayFogCoordOffsetEXT)( GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset );
+        void       (WINE_GLAPI *p_glVertexArrayIndexOffsetEXT)( GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset );
+        void       (WINE_GLAPI *p_glVertexArrayMultiTexCoordOffsetEXT)( GLuint vaobj, GLuint buffer, GLenum texunit, GLint size, GLenum type, GLsizei stride, GLintptr offset );
+        void       (WINE_GLAPI *p_glVertexArrayNormalOffsetEXT)( GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset );
+        void       (WINE_GLAPI *p_glVertexArrayParameteriAPPLE)( GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glVertexArrayRangeAPPLE)( GLsizei length, void *pointer );
+        void       (WINE_GLAPI *p_glVertexArrayRangeNV)( GLsizei length, const void *pointer );
+        void       (WINE_GLAPI *p_glVertexArraySecondaryColorOffsetEXT)( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset );
+        void       (WINE_GLAPI *p_glVertexArrayTexCoordOffsetEXT)( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset );
+        void       (WINE_GLAPI *p_glVertexArrayVertexAttribBindingEXT)( GLuint vaobj, GLuint attribindex, GLuint bindingindex );
+        void       (WINE_GLAPI *p_glVertexArrayVertexAttribDivisorEXT)( GLuint vaobj, GLuint index, GLuint divisor );
+        void       (WINE_GLAPI *p_glVertexArrayVertexAttribFormatEXT)( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset );
+        void       (WINE_GLAPI *p_glVertexArrayVertexAttribIFormatEXT)( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset );
+        void       (WINE_GLAPI *p_glVertexArrayVertexAttribIOffsetEXT)( GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset );
+        void       (WINE_GLAPI *p_glVertexArrayVertexAttribLFormatEXT)( GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset );
+        void       (WINE_GLAPI *p_glVertexArrayVertexAttribLOffsetEXT)( GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset );
+        void       (WINE_GLAPI *p_glVertexArrayVertexAttribOffsetEXT)( GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset );
+        void       (WINE_GLAPI *p_glVertexArrayVertexBindingDivisorEXT)( GLuint vaobj, GLuint bindingindex, GLuint divisor );
+        void       (WINE_GLAPI *p_glVertexArrayVertexBuffer)( GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride );
+        void       (WINE_GLAPI *p_glVertexArrayVertexBuffers)( GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides );
+        void       (WINE_GLAPI *p_glVertexArrayVertexOffsetEXT)( GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset );
+        void       (WINE_GLAPI *p_glVertexAttrib1d)( GLuint index, GLdouble x );
+        void       (WINE_GLAPI *p_glVertexAttrib1dARB)( GLuint index, GLdouble x );
+        void       (WINE_GLAPI *p_glVertexAttrib1dNV)( GLuint index, GLdouble x );
+        void       (WINE_GLAPI *p_glVertexAttrib1dv)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttrib1dvARB)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttrib1dvNV)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttrib1f)( GLuint index, GLfloat x );
+        void       (WINE_GLAPI *p_glVertexAttrib1fARB)( GLuint index, GLfloat x );
+        void       (WINE_GLAPI *p_glVertexAttrib1fNV)( GLuint index, GLfloat x );
+        void       (WINE_GLAPI *p_glVertexAttrib1fv)( GLuint index, const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertexAttrib1fvARB)( GLuint index, const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertexAttrib1fvNV)( GLuint index, const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertexAttrib1hNV)( GLuint index, GLhalfNV x );
+        void       (WINE_GLAPI *p_glVertexAttrib1hvNV)( GLuint index, const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glVertexAttrib1s)( GLuint index, GLshort x );
+        void       (WINE_GLAPI *p_glVertexAttrib1sARB)( GLuint index, GLshort x );
+        void       (WINE_GLAPI *p_glVertexAttrib1sNV)( GLuint index, GLshort x );
+        void       (WINE_GLAPI *p_glVertexAttrib1sv)( GLuint index, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttrib1svARB)( GLuint index, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttrib1svNV)( GLuint index, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttrib2d)( GLuint index, GLdouble x, GLdouble y );
+        void       (WINE_GLAPI *p_glVertexAttrib2dARB)( GLuint index, GLdouble x, GLdouble y );
+        void       (WINE_GLAPI *p_glVertexAttrib2dNV)( GLuint index, GLdouble x, GLdouble y );
+        void       (WINE_GLAPI *p_glVertexAttrib2dv)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttrib2dvARB)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttrib2dvNV)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttrib2f)( GLuint index, GLfloat x, GLfloat y );
+        void       (WINE_GLAPI *p_glVertexAttrib2fARB)( GLuint index, GLfloat x, GLfloat y );
+        void       (WINE_GLAPI *p_glVertexAttrib2fNV)( GLuint index, GLfloat x, GLfloat y );
+        void       (WINE_GLAPI *p_glVertexAttrib2fv)( GLuint index, const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertexAttrib2fvARB)( GLuint index, const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertexAttrib2fvNV)( GLuint index, const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertexAttrib2hNV)( GLuint index, GLhalfNV x, GLhalfNV y );
+        void       (WINE_GLAPI *p_glVertexAttrib2hvNV)( GLuint index, const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glVertexAttrib2s)( GLuint index, GLshort x, GLshort y );
+        void       (WINE_GLAPI *p_glVertexAttrib2sARB)( GLuint index, GLshort x, GLshort y );
+        void       (WINE_GLAPI *p_glVertexAttrib2sNV)( GLuint index, GLshort x, GLshort y );
+        void       (WINE_GLAPI *p_glVertexAttrib2sv)( GLuint index, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttrib2svARB)( GLuint index, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttrib2svNV)( GLuint index, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttrib3d)( GLuint index, GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glVertexAttrib3dARB)( GLuint index, GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glVertexAttrib3dNV)( GLuint index, GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glVertexAttrib3dv)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttrib3dvARB)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttrib3dvNV)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttrib3f)( GLuint index, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glVertexAttrib3fARB)( GLuint index, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glVertexAttrib3fNV)( GLuint index, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glVertexAttrib3fv)( GLuint index, const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertexAttrib3fvARB)( GLuint index, const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertexAttrib3fvNV)( GLuint index, const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertexAttrib3hNV)( GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z );
+        void       (WINE_GLAPI *p_glVertexAttrib3hvNV)( GLuint index, const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glVertexAttrib3s)( GLuint index, GLshort x, GLshort y, GLshort z );
+        void       (WINE_GLAPI *p_glVertexAttrib3sARB)( GLuint index, GLshort x, GLshort y, GLshort z );
+        void       (WINE_GLAPI *p_glVertexAttrib3sNV)( GLuint index, GLshort x, GLshort y, GLshort z );
+        void       (WINE_GLAPI *p_glVertexAttrib3sv)( GLuint index, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttrib3svARB)( GLuint index, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttrib3svNV)( GLuint index, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4Nbv)( GLuint index, const GLbyte *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4NbvARB)( GLuint index, const GLbyte *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4Niv)( GLuint index, const GLint *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4NivARB)( GLuint index, const GLint *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4Nsv)( GLuint index, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4NsvARB)( GLuint index, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4Nub)( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w );
+        void       (WINE_GLAPI *p_glVertexAttrib4NubARB)( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w );
+        void       (WINE_GLAPI *p_glVertexAttrib4Nubv)( GLuint index, const GLubyte *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4NubvARB)( GLuint index, const GLubyte *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4Nuiv)( GLuint index, const GLuint *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4NuivARB)( GLuint index, const GLuint *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4Nusv)( GLuint index, const GLushort *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4NusvARB)( GLuint index, const GLushort *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4bv)( GLuint index, const GLbyte *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4bvARB)( GLuint index, const GLbyte *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4d)( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+        void       (WINE_GLAPI *p_glVertexAttrib4dARB)( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+        void       (WINE_GLAPI *p_glVertexAttrib4dNV)( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+        void       (WINE_GLAPI *p_glVertexAttrib4dv)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4dvARB)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4dvNV)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4f)( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
+        void       (WINE_GLAPI *p_glVertexAttrib4fARB)( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
+        void       (WINE_GLAPI *p_glVertexAttrib4fNV)( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
+        void       (WINE_GLAPI *p_glVertexAttrib4fv)( GLuint index, const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4fvARB)( GLuint index, const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4fvNV)( GLuint index, const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4hNV)( GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w );
+        void       (WINE_GLAPI *p_glVertexAttrib4hvNV)( GLuint index, const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4iv)( GLuint index, const GLint *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4ivARB)( GLuint index, const GLint *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4s)( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w );
+        void       (WINE_GLAPI *p_glVertexAttrib4sARB)( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w );
+        void       (WINE_GLAPI *p_glVertexAttrib4sNV)( GLuint index, GLshort x, GLshort y, GLshort z, GLshort w );
+        void       (WINE_GLAPI *p_glVertexAttrib4sv)( GLuint index, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4svARB)( GLuint index, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4svNV)( GLuint index, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4ubNV)( GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w );
+        void       (WINE_GLAPI *p_glVertexAttrib4ubv)( GLuint index, const GLubyte *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4ubvARB)( GLuint index, const GLubyte *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4ubvNV)( GLuint index, const GLubyte *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4uiv)( GLuint index, const GLuint *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4uivARB)( GLuint index, const GLuint *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4usv)( GLuint index, const GLushort *v );
+        void       (WINE_GLAPI *p_glVertexAttrib4usvARB)( GLuint index, const GLushort *v );
+        void       (WINE_GLAPI *p_glVertexAttribArrayObjectATI)( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset );
+        void       (WINE_GLAPI *p_glVertexAttribBinding)( GLuint attribindex, GLuint bindingindex );
+        void       (WINE_GLAPI *p_glVertexAttribDivisor)( GLuint index, GLuint divisor );
+        void       (WINE_GLAPI *p_glVertexAttribDivisorARB)( GLuint index, GLuint divisor );
+        void       (WINE_GLAPI *p_glVertexAttribFormat)( GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset );
+        void       (WINE_GLAPI *p_glVertexAttribFormatNV)( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride );
+        void       (WINE_GLAPI *p_glVertexAttribI1i)( GLuint index, GLint x );
+        void       (WINE_GLAPI *p_glVertexAttribI1iEXT)( GLuint index, GLint x );
+        void       (WINE_GLAPI *p_glVertexAttribI1iv)( GLuint index, const GLint *v );
+        void       (WINE_GLAPI *p_glVertexAttribI1ivEXT)( GLuint index, const GLint *v );
+        void       (WINE_GLAPI *p_glVertexAttribI1ui)( GLuint index, GLuint x );
+        void       (WINE_GLAPI *p_glVertexAttribI1uiEXT)( GLuint index, GLuint x );
+        void       (WINE_GLAPI *p_glVertexAttribI1uiv)( GLuint index, const GLuint *v );
+        void       (WINE_GLAPI *p_glVertexAttribI1uivEXT)( GLuint index, const GLuint *v );
+        void       (WINE_GLAPI *p_glVertexAttribI2i)( GLuint index, GLint x, GLint y );
+        void       (WINE_GLAPI *p_glVertexAttribI2iEXT)( GLuint index, GLint x, GLint y );
+        void       (WINE_GLAPI *p_glVertexAttribI2iv)( GLuint index, const GLint *v );
+        void       (WINE_GLAPI *p_glVertexAttribI2ivEXT)( GLuint index, const GLint *v );
+        void       (WINE_GLAPI *p_glVertexAttribI2ui)( GLuint index, GLuint x, GLuint y );
+        void       (WINE_GLAPI *p_glVertexAttribI2uiEXT)( GLuint index, GLuint x, GLuint y );
+        void       (WINE_GLAPI *p_glVertexAttribI2uiv)( GLuint index, const GLuint *v );
+        void       (WINE_GLAPI *p_glVertexAttribI2uivEXT)( GLuint index, const GLuint *v );
+        void       (WINE_GLAPI *p_glVertexAttribI3i)( GLuint index, GLint x, GLint y, GLint z );
+        void       (WINE_GLAPI *p_glVertexAttribI3iEXT)( GLuint index, GLint x, GLint y, GLint z );
+        void       (WINE_GLAPI *p_glVertexAttribI3iv)( GLuint index, const GLint *v );
+        void       (WINE_GLAPI *p_glVertexAttribI3ivEXT)( GLuint index, const GLint *v );
+        void       (WINE_GLAPI *p_glVertexAttribI3ui)( GLuint index, GLuint x, GLuint y, GLuint z );
+        void       (WINE_GLAPI *p_glVertexAttribI3uiEXT)( GLuint index, GLuint x, GLuint y, GLuint z );
+        void       (WINE_GLAPI *p_glVertexAttribI3uiv)( GLuint index, const GLuint *v );
+        void       (WINE_GLAPI *p_glVertexAttribI3uivEXT)( GLuint index, const GLuint *v );
+        void       (WINE_GLAPI *p_glVertexAttribI4bv)( GLuint index, const GLbyte *v );
+        void       (WINE_GLAPI *p_glVertexAttribI4bvEXT)( GLuint index, const GLbyte *v );
+        void       (WINE_GLAPI *p_glVertexAttribI4i)( GLuint index, GLint x, GLint y, GLint z, GLint w );
+        void       (WINE_GLAPI *p_glVertexAttribI4iEXT)( GLuint index, GLint x, GLint y, GLint z, GLint w );
+        void       (WINE_GLAPI *p_glVertexAttribI4iv)( GLuint index, const GLint *v );
+        void       (WINE_GLAPI *p_glVertexAttribI4ivEXT)( GLuint index, const GLint *v );
+        void       (WINE_GLAPI *p_glVertexAttribI4sv)( GLuint index, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttribI4svEXT)( GLuint index, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttribI4ubv)( GLuint index, const GLubyte *v );
+        void       (WINE_GLAPI *p_glVertexAttribI4ubvEXT)( GLuint index, const GLubyte *v );
+        void       (WINE_GLAPI *p_glVertexAttribI4ui)( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w );
+        void       (WINE_GLAPI *p_glVertexAttribI4uiEXT)( GLuint index, GLuint x, GLuint y, GLuint z, GLuint w );
+        void       (WINE_GLAPI *p_glVertexAttribI4uiv)( GLuint index, const GLuint *v );
+        void       (WINE_GLAPI *p_glVertexAttribI4uivEXT)( GLuint index, const GLuint *v );
+        void       (WINE_GLAPI *p_glVertexAttribI4usv)( GLuint index, const GLushort *v );
+        void       (WINE_GLAPI *p_glVertexAttribI4usvEXT)( GLuint index, const GLushort *v );
+        void       (WINE_GLAPI *p_glVertexAttribIFormat)( GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset );
+        void       (WINE_GLAPI *p_glVertexAttribIFormatNV)( GLuint index, GLint size, GLenum type, GLsizei stride );
+        void       (WINE_GLAPI *p_glVertexAttribIPointer)( GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glVertexAttribIPointerEXT)( GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glVertexAttribL1d)( GLuint index, GLdouble x );
+        void       (WINE_GLAPI *p_glVertexAttribL1dEXT)( GLuint index, GLdouble x );
+        void       (WINE_GLAPI *p_glVertexAttribL1dv)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttribL1dvEXT)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttribL1i64NV)( GLuint index, GLint64EXT x );
+        void       (WINE_GLAPI *p_glVertexAttribL1i64vNV)( GLuint index, const GLint64EXT *v );
+        void       (WINE_GLAPI *p_glVertexAttribL1ui64ARB)( GLuint index, GLuint64EXT x );
+        void       (WINE_GLAPI *p_glVertexAttribL1ui64NV)( GLuint index, GLuint64EXT x );
+        void       (WINE_GLAPI *p_glVertexAttribL1ui64vARB)( GLuint index, const GLuint64EXT *v );
+        void       (WINE_GLAPI *p_glVertexAttribL1ui64vNV)( GLuint index, const GLuint64EXT *v );
+        void       (WINE_GLAPI *p_glVertexAttribL2d)( GLuint index, GLdouble x, GLdouble y );
+        void       (WINE_GLAPI *p_glVertexAttribL2dEXT)( GLuint index, GLdouble x, GLdouble y );
+        void       (WINE_GLAPI *p_glVertexAttribL2dv)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttribL2dvEXT)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttribL2i64NV)( GLuint index, GLint64EXT x, GLint64EXT y );
+        void       (WINE_GLAPI *p_glVertexAttribL2i64vNV)( GLuint index, const GLint64EXT *v );
+        void       (WINE_GLAPI *p_glVertexAttribL2ui64NV)( GLuint index, GLuint64EXT x, GLuint64EXT y );
+        void       (WINE_GLAPI *p_glVertexAttribL2ui64vNV)( GLuint index, const GLuint64EXT *v );
+        void       (WINE_GLAPI *p_glVertexAttribL3d)( GLuint index, GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glVertexAttribL3dEXT)( GLuint index, GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glVertexAttribL3dv)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttribL3dvEXT)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttribL3i64NV)( GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z );
+        void       (WINE_GLAPI *p_glVertexAttribL3i64vNV)( GLuint index, const GLint64EXT *v );
+        void       (WINE_GLAPI *p_glVertexAttribL3ui64NV)( GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z );
+        void       (WINE_GLAPI *p_glVertexAttribL3ui64vNV)( GLuint index, const GLuint64EXT *v );
+        void       (WINE_GLAPI *p_glVertexAttribL4d)( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+        void       (WINE_GLAPI *p_glVertexAttribL4dEXT)( GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+        void       (WINE_GLAPI *p_glVertexAttribL4dv)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttribL4dvEXT)( GLuint index, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttribL4i64NV)( GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w );
+        void       (WINE_GLAPI *p_glVertexAttribL4i64vNV)( GLuint index, const GLint64EXT *v );
+        void       (WINE_GLAPI *p_glVertexAttribL4ui64NV)( GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w );
+        void       (WINE_GLAPI *p_glVertexAttribL4ui64vNV)( GLuint index, const GLuint64EXT *v );
+        void       (WINE_GLAPI *p_glVertexAttribLFormat)( GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset );
+        void       (WINE_GLAPI *p_glVertexAttribLFormatNV)( GLuint index, GLint size, GLenum type, GLsizei stride );
+        void       (WINE_GLAPI *p_glVertexAttribLPointer)( GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glVertexAttribLPointerEXT)( GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glVertexAttribP1ui)( GLuint index, GLenum type, GLboolean normalized, GLuint value );
+        void       (WINE_GLAPI *p_glVertexAttribP1uiv)( GLuint index, GLenum type, GLboolean normalized, const GLuint *value );
+        void       (WINE_GLAPI *p_glVertexAttribP2ui)( GLuint index, GLenum type, GLboolean normalized, GLuint value );
+        void       (WINE_GLAPI *p_glVertexAttribP2uiv)( GLuint index, GLenum type, GLboolean normalized, const GLuint *value );
+        void       (WINE_GLAPI *p_glVertexAttribP3ui)( GLuint index, GLenum type, GLboolean normalized, GLuint value );
+        void       (WINE_GLAPI *p_glVertexAttribP3uiv)( GLuint index, GLenum type, GLboolean normalized, const GLuint *value );
+        void       (WINE_GLAPI *p_glVertexAttribP4ui)( GLuint index, GLenum type, GLboolean normalized, GLuint value );
+        void       (WINE_GLAPI *p_glVertexAttribP4uiv)( GLuint index, GLenum type, GLboolean normalized, const GLuint *value );
+        void       (WINE_GLAPI *p_glVertexAttribParameteriAMD)( GLuint index, GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glVertexAttribPointer)( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glVertexAttribPointerARB)( GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glVertexAttribPointerNV)( GLuint index, GLint fsize, GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glVertexAttribs1dvNV)( GLuint index, GLsizei count, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttribs1fvNV)( GLuint index, GLsizei count, const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertexAttribs1hvNV)( GLuint index, GLsizei n, const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glVertexAttribs1svNV)( GLuint index, GLsizei count, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttribs2dvNV)( GLuint index, GLsizei count, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttribs2fvNV)( GLuint index, GLsizei count, const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertexAttribs2hvNV)( GLuint index, GLsizei n, const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glVertexAttribs2svNV)( GLuint index, GLsizei count, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttribs3dvNV)( GLuint index, GLsizei count, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttribs3fvNV)( GLuint index, GLsizei count, const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertexAttribs3hvNV)( GLuint index, GLsizei n, const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glVertexAttribs3svNV)( GLuint index, GLsizei count, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttribs4dvNV)( GLuint index, GLsizei count, const GLdouble *v );
+        void       (WINE_GLAPI *p_glVertexAttribs4fvNV)( GLuint index, GLsizei count, const GLfloat *v );
+        void       (WINE_GLAPI *p_glVertexAttribs4hvNV)( GLuint index, GLsizei n, const GLhalfNV *v );
+        void       (WINE_GLAPI *p_glVertexAttribs4svNV)( GLuint index, GLsizei count, const GLshort *v );
+        void       (WINE_GLAPI *p_glVertexAttribs4ubvNV)( GLuint index, GLsizei count, const GLubyte *v );
+        void       (WINE_GLAPI *p_glVertexBindingDivisor)( GLuint bindingindex, GLuint divisor );
+        void       (WINE_GLAPI *p_glVertexBlendARB)( GLint count );
+        void       (WINE_GLAPI *p_glVertexBlendEnvfATI)( GLenum pname, GLfloat param );
+        void       (WINE_GLAPI *p_glVertexBlendEnviATI)( GLenum pname, GLint param );
+        void       (WINE_GLAPI *p_glVertexFormatNV)( GLint size, GLenum type, GLsizei stride );
+        void       (WINE_GLAPI *p_glVertexP2ui)( GLenum type, GLuint value );
+        void       (WINE_GLAPI *p_glVertexP2uiv)( GLenum type, const GLuint *value );
+        void       (WINE_GLAPI *p_glVertexP3ui)( GLenum type, GLuint value );
+        void       (WINE_GLAPI *p_glVertexP3uiv)( GLenum type, const GLuint *value );
+        void       (WINE_GLAPI *p_glVertexP4ui)( GLenum type, GLuint value );
+        void       (WINE_GLAPI *p_glVertexP4uiv)( GLenum type, const GLuint *value );
+        void       (WINE_GLAPI *p_glVertexPointerEXT)( GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer );
+        void       (WINE_GLAPI *p_glVertexPointerListIBM)( GLint size, GLenum type, GLint stride, const void **pointer, GLint ptrstride );
+        void       (WINE_GLAPI *p_glVertexPointervINTEL)( GLint size, GLenum type, const void **pointer );
+        void       (WINE_GLAPI *p_glVertexStream1dATI)( GLenum stream, GLdouble x );
+        void       (WINE_GLAPI *p_glVertexStream1dvATI)( GLenum stream, const GLdouble *coords );
+        void       (WINE_GLAPI *p_glVertexStream1fATI)( GLenum stream, GLfloat x );
+        void       (WINE_GLAPI *p_glVertexStream1fvATI)( GLenum stream, const GLfloat *coords );
+        void       (WINE_GLAPI *p_glVertexStream1iATI)( GLenum stream, GLint x );
+        void       (WINE_GLAPI *p_glVertexStream1ivATI)( GLenum stream, const GLint *coords );
+        void       (WINE_GLAPI *p_glVertexStream1sATI)( GLenum stream, GLshort x );
+        void       (WINE_GLAPI *p_glVertexStream1svATI)( GLenum stream, const GLshort *coords );
+        void       (WINE_GLAPI *p_glVertexStream2dATI)( GLenum stream, GLdouble x, GLdouble y );
+        void       (WINE_GLAPI *p_glVertexStream2dvATI)( GLenum stream, const GLdouble *coords );
+        void       (WINE_GLAPI *p_glVertexStream2fATI)( GLenum stream, GLfloat x, GLfloat y );
+        void       (WINE_GLAPI *p_glVertexStream2fvATI)( GLenum stream, const GLfloat *coords );
+        void       (WINE_GLAPI *p_glVertexStream2iATI)( GLenum stream, GLint x, GLint y );
+        void       (WINE_GLAPI *p_glVertexStream2ivATI)( GLenum stream, const GLint *coords );
+        void       (WINE_GLAPI *p_glVertexStream2sATI)( GLenum stream, GLshort x, GLshort y );
+        void       (WINE_GLAPI *p_glVertexStream2svATI)( GLenum stream, const GLshort *coords );
+        void       (WINE_GLAPI *p_glVertexStream3dATI)( GLenum stream, GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glVertexStream3dvATI)( GLenum stream, const GLdouble *coords );
+        void       (WINE_GLAPI *p_glVertexStream3fATI)( GLenum stream, GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glVertexStream3fvATI)( GLenum stream, const GLfloat *coords );
+        void       (WINE_GLAPI *p_glVertexStream3iATI)( GLenum stream, GLint x, GLint y, GLint z );
+        void       (WINE_GLAPI *p_glVertexStream3ivATI)( GLenum stream, const GLint *coords );
+        void       (WINE_GLAPI *p_glVertexStream3sATI)( GLenum stream, GLshort x, GLshort y, GLshort z );
+        void       (WINE_GLAPI *p_glVertexStream3svATI)( GLenum stream, const GLshort *coords );
+        void       (WINE_GLAPI *p_glVertexStream4dATI)( GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+        void       (WINE_GLAPI *p_glVertexStream4dvATI)( GLenum stream, const GLdouble *coords );
+        void       (WINE_GLAPI *p_glVertexStream4fATI)( GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w );
+        void       (WINE_GLAPI *p_glVertexStream4fvATI)( GLenum stream, const GLfloat *coords );
+        void       (WINE_GLAPI *p_glVertexStream4iATI)( GLenum stream, GLint x, GLint y, GLint z, GLint w );
+        void       (WINE_GLAPI *p_glVertexStream4ivATI)( GLenum stream, const GLint *coords );
+        void       (WINE_GLAPI *p_glVertexStream4sATI)( GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w );
+        void       (WINE_GLAPI *p_glVertexStream4svATI)( GLenum stream, const GLshort *coords );
+        void       (WINE_GLAPI *p_glVertexWeightPointerEXT)( GLint size, GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glVertexWeightfEXT)( GLfloat weight );
+        void       (WINE_GLAPI *p_glVertexWeightfvEXT)( const GLfloat *weight );
+        void       (WINE_GLAPI *p_glVertexWeighthNV)( GLhalfNV weight );
+        void       (WINE_GLAPI *p_glVertexWeighthvNV)( const GLhalfNV *weight );
+        GLenum     (WINE_GLAPI *p_glVideoCaptureNV)( GLuint video_capture_slot, GLuint *sequence_num, GLuint64EXT *capture_time );
+        void       (WINE_GLAPI *p_glVideoCaptureStreamParameterdvNV)( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLdouble *params );
+        void       (WINE_GLAPI *p_glVideoCaptureStreamParameterfvNV)( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLfloat *params );
+        void       (WINE_GLAPI *p_glVideoCaptureStreamParameterivNV)( GLuint video_capture_slot, GLuint stream, GLenum pname, const GLint *params );
+        void       (WINE_GLAPI *p_glViewportArrayv)( GLuint first, GLsizei count, const GLfloat *v );
+        void       (WINE_GLAPI *p_glViewportIndexedf)( GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h );
+        void       (WINE_GLAPI *p_glViewportIndexedfv)( GLuint index, const GLfloat *v );
+        void       (WINE_GLAPI *p_glViewportPositionWScaleNV)( GLuint index, GLfloat xcoeff, GLfloat ycoeff );
+        void       (WINE_GLAPI *p_glViewportSwizzleNV)( GLuint index, GLenum swizzlex, GLenum swizzley, GLenum swizzlez, GLenum swizzlew );
+        void       (WINE_GLAPI *p_glWaitSemaphoreEXT)( GLuint semaphore, GLuint numBufferBarriers, const GLuint *buffers, GLuint numTextureBarriers, const GLuint *textures, const GLenum *srcLayouts );
+        void       (WINE_GLAPI *p_glWaitSync)( GLsync sync, GLbitfield flags, GLuint64 timeout );
+        void       (WINE_GLAPI *p_glWaitVkSemaphoreNV)( GLuint64 vkSemaphore );
+        void       (WINE_GLAPI *p_glWeightPathsNV)( GLuint resultPath, GLsizei numPaths, const GLuint *paths, const GLfloat *weights );
+        void       (WINE_GLAPI *p_glWeightPointerARB)( GLint size, GLenum type, GLsizei stride, const void *pointer );
+        void       (WINE_GLAPI *p_glWeightbvARB)( GLint size, const GLbyte *weights );
+        void       (WINE_GLAPI *p_glWeightdvARB)( GLint size, const GLdouble *weights );
+        void       (WINE_GLAPI *p_glWeightfvARB)( GLint size, const GLfloat *weights );
+        void       (WINE_GLAPI *p_glWeightivARB)( GLint size, const GLint *weights );
+        void       (WINE_GLAPI *p_glWeightsvARB)( GLint size, const GLshort *weights );
+        void       (WINE_GLAPI *p_glWeightubvARB)( GLint size, const GLubyte *weights );
+        void       (WINE_GLAPI *p_glWeightuivARB)( GLint size, const GLuint *weights );
+        void       (WINE_GLAPI *p_glWeightusvARB)( GLint size, const GLushort *weights );
+        void       (WINE_GLAPI *p_glWindowPos2d)( GLdouble x, GLdouble y );
+        void       (WINE_GLAPI *p_glWindowPos2dARB)( GLdouble x, GLdouble y );
+        void       (WINE_GLAPI *p_glWindowPos2dMESA)( GLdouble x, GLdouble y );
+        void       (WINE_GLAPI *p_glWindowPos2dv)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glWindowPos2dvARB)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glWindowPos2dvMESA)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glWindowPos2f)( GLfloat x, GLfloat y );
+        void       (WINE_GLAPI *p_glWindowPos2fARB)( GLfloat x, GLfloat y );
+        void       (WINE_GLAPI *p_glWindowPos2fMESA)( GLfloat x, GLfloat y );
+        void       (WINE_GLAPI *p_glWindowPos2fv)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glWindowPos2fvARB)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glWindowPos2fvMESA)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glWindowPos2i)( GLint x, GLint y );
+        void       (WINE_GLAPI *p_glWindowPos2iARB)( GLint x, GLint y );
+        void       (WINE_GLAPI *p_glWindowPos2iMESA)( GLint x, GLint y );
+        void       (WINE_GLAPI *p_glWindowPos2iv)( const GLint *v );
+        void       (WINE_GLAPI *p_glWindowPos2ivARB)( const GLint *v );
+        void       (WINE_GLAPI *p_glWindowPos2ivMESA)( const GLint *v );
+        void       (WINE_GLAPI *p_glWindowPos2s)( GLshort x, GLshort y );
+        void       (WINE_GLAPI *p_glWindowPos2sARB)( GLshort x, GLshort y );
+        void       (WINE_GLAPI *p_glWindowPos2sMESA)( GLshort x, GLshort y );
+        void       (WINE_GLAPI *p_glWindowPos2sv)( const GLshort *v );
+        void       (WINE_GLAPI *p_glWindowPos2svARB)( const GLshort *v );
+        void       (WINE_GLAPI *p_glWindowPos2svMESA)( const GLshort *v );
+        void       (WINE_GLAPI *p_glWindowPos3d)( GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glWindowPos3dARB)( GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glWindowPos3dMESA)( GLdouble x, GLdouble y, GLdouble z );
+        void       (WINE_GLAPI *p_glWindowPos3dv)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glWindowPos3dvARB)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glWindowPos3dvMESA)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glWindowPos3f)( GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glWindowPos3fARB)( GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glWindowPos3fMESA)( GLfloat x, GLfloat y, GLfloat z );
+        void       (WINE_GLAPI *p_glWindowPos3fv)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glWindowPos3fvARB)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glWindowPos3fvMESA)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glWindowPos3i)( GLint x, GLint y, GLint z );
+        void       (WINE_GLAPI *p_glWindowPos3iARB)( GLint x, GLint y, GLint z );
+        void       (WINE_GLAPI *p_glWindowPos3iMESA)( GLint x, GLint y, GLint z );
+        void       (WINE_GLAPI *p_glWindowPos3iv)( const GLint *v );
+        void       (WINE_GLAPI *p_glWindowPos3ivARB)( const GLint *v );
+        void       (WINE_GLAPI *p_glWindowPos3ivMESA)( const GLint *v );
+        void       (WINE_GLAPI *p_glWindowPos3s)( GLshort x, GLshort y, GLshort z );
+        void       (WINE_GLAPI *p_glWindowPos3sARB)( GLshort x, GLshort y, GLshort z );
+        void       (WINE_GLAPI *p_glWindowPos3sMESA)( GLshort x, GLshort y, GLshort z );
+        void       (WINE_GLAPI *p_glWindowPos3sv)( const GLshort *v );
+        void       (WINE_GLAPI *p_glWindowPos3svARB)( const GLshort *v );
+        void       (WINE_GLAPI *p_glWindowPos3svMESA)( const GLshort *v );
+        void       (WINE_GLAPI *p_glWindowPos4dMESA)( GLdouble x, GLdouble y, GLdouble z, GLdouble w );
+        void       (WINE_GLAPI *p_glWindowPos4dvMESA)( const GLdouble *v );
+        void       (WINE_GLAPI *p_glWindowPos4fMESA)( GLfloat x, GLfloat y, GLfloat z, GLfloat w );
+        void       (WINE_GLAPI *p_glWindowPos4fvMESA)( const GLfloat *v );
+        void       (WINE_GLAPI *p_glWindowPos4iMESA)( GLint x, GLint y, GLint z, GLint w );
+        void       (WINE_GLAPI *p_glWindowPos4ivMESA)( const GLint *v );
+        void       (WINE_GLAPI *p_glWindowPos4sMESA)( GLshort x, GLshort y, GLshort z, GLshort w );
+        void       (WINE_GLAPI *p_glWindowPos4svMESA)( const GLshort *v );
+        void       (WINE_GLAPI *p_glWindowRectanglesEXT)( GLenum mode, GLsizei count, const GLint *box );
+        void       (WINE_GLAPI *p_glWriteMaskEXT)( GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW );
+        void *     (WINE_GLAPI *p_wglAllocateMemoryNV)( GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority );
+        BOOL       (WINE_GLAPI *p_wglBindTexImageARB)( struct wgl_pbuffer * hPbuffer, int iBuffer );
+        BOOL       (WINE_GLAPI *p_wglChoosePixelFormatARB)( HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats );
+        struct wgl_context * (WINE_GLAPI *p_wglCreateContextAttribsARB)( HDC hDC, struct wgl_context * hShareContext, const int *attribList );
+        struct wgl_pbuffer * (WINE_GLAPI *p_wglCreatePbufferARB)( HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList );
+        BOOL       (WINE_GLAPI *p_wglDestroyPbufferARB)( struct wgl_pbuffer * hPbuffer );
+        void       (WINE_GLAPI *p_wglFreeMemoryNV)( void *pointer );
         HDC        (WINE_GLAPI *p_wglGetCurrentReadDCARB)(void);
-        const char* (WINE_GLAPI *p_wglGetExtensionsStringARB)(HDC);
-        const char* (WINE_GLAPI *p_wglGetExtensionsStringEXT)(void);
-        HDC        (WINE_GLAPI *p_wglGetPbufferDCARB)(struct wgl_pbuffer *);
-        BOOL       (WINE_GLAPI *p_wglGetPixelFormatAttribfvARB)(HDC,int,int,UINT,const int*,FLOAT*);
-        BOOL       (WINE_GLAPI *p_wglGetPixelFormatAttribivARB)(HDC,int,int,UINT,const int*,int*);
+        const char * (WINE_GLAPI *p_wglGetExtensionsStringARB)( HDC hdc );
+        const char * (WINE_GLAPI *p_wglGetExtensionsStringEXT)(void);
+        HDC        (WINE_GLAPI *p_wglGetPbufferDCARB)( struct wgl_pbuffer * hPbuffer );
+        BOOL       (WINE_GLAPI *p_wglGetPixelFormatAttribfvARB)( HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues );
+        BOOL       (WINE_GLAPI *p_wglGetPixelFormatAttribivARB)( HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues );
         int        (WINE_GLAPI *p_wglGetSwapIntervalEXT)(void);
-        BOOL       (WINE_GLAPI *p_wglMakeContextCurrentARB)(HDC,HDC,struct wgl_context *);
-        BOOL       (WINE_GLAPI *p_wglQueryCurrentRendererIntegerWINE)(GLenum,GLuint*);
-        const GLchar* (WINE_GLAPI *p_wglQueryCurrentRendererStringWINE)(GLenum);
-        BOOL       (WINE_GLAPI *p_wglQueryPbufferARB)(struct wgl_pbuffer *,int,int*);
-        BOOL       (WINE_GLAPI *p_wglQueryRendererIntegerWINE)(HDC,GLint,GLenum,GLuint*);
-        const GLchar* (WINE_GLAPI *p_wglQueryRendererStringWINE)(HDC,GLint,GLenum);
-        int        (WINE_GLAPI *p_wglReleasePbufferDCARB)(struct wgl_pbuffer *,HDC);
-        BOOL       (WINE_GLAPI *p_wglReleaseTexImageARB)(struct wgl_pbuffer *,int);
-        BOOL       (WINE_GLAPI *p_wglSetPbufferAttribARB)(struct wgl_pbuffer *,const int*);
-        BOOL       (WINE_GLAPI *p_wglSetPixelFormatWINE)(HDC,int);
-        BOOL       (WINE_GLAPI *p_wglSwapIntervalEXT)(int);
+        BOOL       (WINE_GLAPI *p_wglMakeContextCurrentARB)( HDC hDrawDC, HDC hReadDC, struct wgl_context * hglrc );
+        BOOL       (WINE_GLAPI *p_wglQueryCurrentRendererIntegerWINE)( GLenum attribute, GLuint *value );
+        const GLchar * (WINE_GLAPI *p_wglQueryCurrentRendererStringWINE)( GLenum attribute );
+        BOOL       (WINE_GLAPI *p_wglQueryPbufferARB)( struct wgl_pbuffer * hPbuffer, int iAttribute, int *piValue );
+        BOOL       (WINE_GLAPI *p_wglQueryRendererIntegerWINE)( HDC dc, GLint renderer, GLenum attribute, GLuint *value );
+        const GLchar * (WINE_GLAPI *p_wglQueryRendererStringWINE)( HDC dc, GLint renderer, GLenum attribute );
+        int        (WINE_GLAPI *p_wglReleasePbufferDCARB)( struct wgl_pbuffer * hPbuffer, HDC hDC );
+        BOOL       (WINE_GLAPI *p_wglReleaseTexImageARB)( struct wgl_pbuffer * hPbuffer, int iBuffer );
+        BOOL       (WINE_GLAPI *p_wglSetPbufferAttribARB)( struct wgl_pbuffer * hPbuffer, const int *piAttribList );
+        BOOL       (WINE_GLAPI *p_wglSetPixelFormatWINE)( HDC hdc, int format );
+        BOOL       (WINE_GLAPI *p_wglSwapIntervalEXT)( int interval );
     } ext;
 };