Changes to generated code caused by the previous commits.

3 files changed, 5003 insertions, 3436 deletions

diff --git a/src/glx/x11/indirect.c b/src/glx/x11/indirect.c
index a3acf062878..4f615baa17f 100644
--- a/src/glx/x11/indirect.c
+++ b/src/glx/x11/indirect.c
@@ -63,24 +63,24 @@
          *((int *)(dest)) = temp.i; } while(0)
 
 NOINLINE CARD32
-__glXReadReply( Display *dpy, size_t size, void * dest, GLboolean reply_is_always_array )
+__glXReadReply(Display * dpy, size_t size, void *dest,
+               GLboolean reply_is_always_array)
 {
     xGLXSingleReply reply;
-    
+
     (void) _XReply(dpy, (xReply *) & reply, 0, False);
     if (size != 0) {
         if ((reply.length > 0) || reply_is_always_array) {
-            const GLint bytes = (reply_is_always_array) 
-              ? (4 * reply.length) : (reply.size * size);
+            const GLint bytes = (reply_is_always_array)
+                ? (4 * reply.length) : (reply.size * size);
             const GLint extra = 4 - (bytes & 3);
 
             _XRead(dpy, dest, bytes);
-            if ( extra < 4 ) {
+            if (extra < 4) {
                 _XEatData(dpy, extra);
             }
-        }
-        else {
-            (void) memcpy( dest, &(reply.pad3), size);
+        } else {
+            (void) memcpy(dest, &(reply.pad3), size);
         }
     }
 
@@ -88,37 +88,40 @@ __glXReadReply( Display *dpy, size_t size, void * dest, GLboolean reply_is_alway
 }
 
 NOINLINE void
-__glXReadPixelReply( Display *dpy, __GLXcontext * gc, unsigned max_dim,
-    GLint width, GLint height, GLint depth, GLenum format, GLenum type,
-    void * dest, GLboolean dimensions_in_reply )
+__glXReadPixelReply(Display * dpy, __GLXcontext * gc, unsigned max_dim,
+                    GLint width, GLint height, GLint depth, GLenum format,
+                    GLenum type, void *dest, GLboolean dimensions_in_reply)
 {
     xGLXSingleReply reply;
     GLint size;
-    
+
     (void) _XReply(dpy, (xReply *) & reply, 0, False);
 
-    if ( dimensions_in_reply ) {
-        width  = reply.pad3;
+    if (dimensions_in_reply) {
+        width = reply.pad3;
         height = reply.pad4;
-        depth  = reply.pad5;
-	
-	if ((height == 0) || (max_dim < 2)) { height = 1; }
-	if ((depth  == 0) || (max_dim < 3)) { depth  = 1; }
+        depth = reply.pad5;
+
+        if ((height == 0) || (max_dim < 2)) {
+            height = 1;
+        }
+        if ((depth == 0) || (max_dim < 3)) {
+            depth = 1;
+        }
     }
 
     size = reply.length * 4;
     if (size != 0) {
-        void * buf = Xmalloc( size );
+        void *buf = Xmalloc(size);
 
-        if ( buf == NULL ) {
+        if (buf == NULL) {
             _XEatData(dpy, size);
             __glXSetError(gc, GL_OUT_OF_MEMORY);
-        }
-        else {
+        } else {
             const GLint extra = 4 - (size & 3);
 
             _XRead(dpy, buf, size);
-            if ( extra < 4 ) {
+            if (extra < 4) {
                 _XEatData(dpy, extra);
             }
 
@@ -132,10 +135,10 @@ __glXReadPixelReply( Display *dpy, __GLXcontext * gc, unsigned max_dim,
 #define X_GLXSingle 0
 
 NOINLINE FASTCALL GLubyte *
-__glXSetupSingleRequest( __GLXcontext * gc, GLint sop, GLint cmdlen )
+__glXSetupSingleRequest(__GLXcontext * gc, GLint sop, GLint cmdlen)
 {
-    xGLXSingleReq * req;
-    Display * const dpy = gc->currentDpy;
+    xGLXSingleReq *req;
+    Display *const dpy = gc->currentDpy;
 
     (void) __glXFlushRenderBuffer(gc, gc->pc);
     LockDisplay(dpy);
@@ -143,14 +146,15 @@ __glXSetupSingleRequest( __GLXcontext * gc, GLint sop, GLint cmdlen )
     req->reqType = gc->majorOpcode;
     req->contextTag = gc->currentContextTag;
     req->glxCode = sop;
-    return (GLubyte *)(req) + sz_xGLXSingleReq;
+    return (GLubyte *) (req) + sz_xGLXSingleReq;
 }
 
 NOINLINE FASTCALL GLubyte *
-__glXSetupVendorRequest( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen )
+__glXSetupVendorRequest(__GLXcontext * gc, GLint code, GLint vop,
+                        GLint cmdlen)
 {
-    xGLXVendorPrivateReq * req;
-    Display * const dpy = gc->currentDpy;
+    xGLXVendorPrivateReq *req;
+    Display *const dpy = gc->currentDpy;
 
     (void) __glXFlushRenderBuffer(gc, gc->pc);
     LockDisplay(dpy);
@@ -159,7 +163,7 @@ __glXSetupVendorRequest( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen
     req->glxCode = code;
     req->vendorCode = vop;
     req->contextTag = gc->currentContextTag;
-    return (GLubyte *)(req) + sz_xGLXVendorPrivateReq;
+    return (GLubyte *) (req) + sz_xGLXVendorPrivateReq;
 }
 
 const GLuint __glXDefaultPixelStore[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
@@ -176,107 +180,123 @@ const GLuint __glXDefaultPixelStore[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
 #define default_pixel_store_4D_size 36
 
 static FASTCALL NOINLINE void
-generic_3_byte( GLint rop, const void * ptr )
+generic_3_byte(GLint rop, const void *ptr)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
 
     emit_header(gc->pc, rop, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), ptr, 4);
+    (void) memcpy((void *) (gc->pc + 4), ptr, 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 static FASTCALL NOINLINE void
-generic_4_byte( GLint rop, const void * ptr )
+generic_4_byte(GLint rop, const void *ptr)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
 
     emit_header(gc->pc, rop, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), ptr, 4);
+    (void) memcpy((void *) (gc->pc + 4), ptr, 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 static FASTCALL NOINLINE void
-generic_6_byte( GLint rop, const void * ptr )
+generic_6_byte(GLint rop, const void *ptr)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
 
     emit_header(gc->pc, rop, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), ptr, 8);
+    (void) memcpy((void *) (gc->pc + 4), ptr, 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 static FASTCALL NOINLINE void
-generic_8_byte( GLint rop, const void * ptr )
+generic_8_byte(GLint rop, const void *ptr)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
 
     emit_header(gc->pc, rop, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), ptr, 8);
+    (void) memcpy((void *) (gc->pc + 4), ptr, 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 static FASTCALL NOINLINE void
-generic_12_byte( GLint rop, const void * ptr )
+generic_12_byte(GLint rop, const void *ptr)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
 
     emit_header(gc->pc, rop, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), ptr, 12);
+    (void) memcpy((void *) (gc->pc + 4), ptr, 12);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 static FASTCALL NOINLINE void
-generic_16_byte( GLint rop, const void * ptr )
+generic_16_byte(GLint rop, const void *ptr)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
 
     emit_header(gc->pc, rop, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), ptr, 16);
+    (void) memcpy((void *) (gc->pc + 4), ptr, 16);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 static FASTCALL NOINLINE void
-generic_24_byte( GLint rop, const void * ptr )
+generic_24_byte(GLint rop, const void *ptr)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
 
     emit_header(gc->pc, rop, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), ptr, 24);
+    (void) memcpy((void *) (gc->pc + 4), ptr, 24);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 static FASTCALL NOINLINE void
-generic_32_byte( GLint rop, const void * ptr )
+generic_32_byte(GLint rop, const void *ptr)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 36;
 
     emit_header(gc->pc, rop, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), ptr, 32);
+    (void) memcpy((void *) (gc->pc + 4), ptr, 32);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLsop_NewList 101
 void
 __indirect_glNewList(GLuint list, GLenum mode)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
@@ -284,10 +304,12 @@ __indirect_glNewList(GLuint list, GLenum mode)
         (void) __glXFlushRenderBuffer(gc, gc->pc);
         xcb_glx_new_list(c, gc->currentContextTag, list, mode);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_NewList, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&mode), 4);
-        UnlockDisplay(dpy); SyncHandle();
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_NewList, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&list), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&mode), 4);
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -297,8 +319,8 @@ __indirect_glNewList(GLuint list, GLenum mode)
 void
 __indirect_glEndList(void)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 0;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
@@ -307,7 +329,8 @@ __indirect_glEndList(void)
         xcb_glx_end_list(c, gc->currentContextTag);
 #else
         (void) __glXSetupSingleRequest(gc, X_GLsop_EndList, cmdlen);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -317,41 +340,45 @@ __indirect_glEndList(void)
 void
 __indirect_glCallList(GLuint list)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_CallList, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&list), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&list), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_CallLists 2
 void
 __indirect_glCallLists(GLsizei n, GLenum type, const GLvoid * lists)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glCallLists_size(type);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * n));
     if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) {
         if (cmdlen <= gc->maxSmallRenderCommandSize) {
-            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+            if ((gc->pc + cmdlen) > gc->bufEnd) {
                 (void) __glXFlushRenderBuffer(gc, gc->pc);
             }
             emit_header(gc->pc, X_GLrop_CallLists, cmdlen);
-            (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
-            (void) memcpy((void *)(gc->pc + 8), (void *)(&type), 4);
-            (void) memcpy((void *)(gc->pc + 12), (void *)(lists), (compsize * n));
+            (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
+            (void) memcpy((void *) (gc->pc + 8), (void *) (&type), 4);
+            (void) memcpy((void *) (gc->pc + 12), (void *) (lists),
+                          (compsize * n));
             gc->pc += cmdlen;
-            if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
-        }
-        else {
+            if (__builtin_expect(gc->pc > gc->limit, 0)) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+        } else {
             const GLint op = X_GLrop_CallLists;
             const GLuint cmdlenLarge = cmdlen + 4;
-            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
-            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
-            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
-            (void) memcpy((void *)(pc + 8), (void *)(&n), 4);
-            (void) memcpy((void *)(pc + 12), (void *)(&type), 4);
+            GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
+            (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
+            (void) memcpy((void *) (pc + 8), (void *) (&n), 4);
+            (void) memcpy((void *) (pc + 12), (void *) (&type), 4);
             __glXSendLargeCommand(gc, pc, 16, lists, (compsize * n));
         }
     }
@@ -361,8 +388,8 @@ __indirect_glCallLists(GLsizei n, GLenum type, const GLvoid * lists)
 void
 __indirect_glDeleteLists(GLuint list, GLsizei range)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
@@ -370,10 +397,12 @@ __indirect_glDeleteLists(GLuint list, GLsizei range)
         (void) __glXFlushRenderBuffer(gc, gc->pc);
         xcb_glx_delete_lists(c, gc->currentContextTag, list, range);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteLists, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&range), 4);
-        UnlockDisplay(dpy); SyncHandle();
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_DeleteLists, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&list), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&range), 4);
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -383,22 +412,28 @@ __indirect_glDeleteLists(GLuint list, GLsizei range)
 GLuint
 __indirect_glGenLists(GLsizei range)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     GLuint retval = (GLuint) 0;
     const GLuint cmdlen = 4;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_gen_lists_reply_t *reply = xcb_glx_gen_lists_reply(c, xcb_glx_gen_lists(c, gc->currentContextTag, range), NULL);
+        xcb_glx_gen_lists_reply_t *reply =
+            xcb_glx_gen_lists_reply(c,
+                                    xcb_glx_gen_lists(c,
+                                                      gc->currentContextTag,
+                                                      range), NULL);
         retval = reply->ret_val;
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenLists, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&range), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GenLists, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&range), 4);
         retval = (GLuint) __glXReadReply(dpy, 0, NULL, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return retval;
@@ -408,67 +443,79 @@ __indirect_glGenLists(GLsizei range)
 void
 __indirect_glListBase(GLuint base)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_ListBase, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&base), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&base), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Begin 4
 void
 __indirect_glBegin(GLenum mode)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_Begin, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Bitmap 5
 void
-__indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap)
+__indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig,
+                    GLfloat yorig, GLfloat xmove, GLfloat ymove,
+                    const GLubyte * bitmap)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const GLuint compsize = (bitmap != NULL) ? __glImageSize(width, height, 1, GL_COLOR_INDEX, GL_BITMAP, 0) : 0;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const GLuint compsize =
+        (bitmap != NULL) ? __glImageSize(width, height, 1, GL_COLOR_INDEX,
+                                         GL_BITMAP, 0) : 0;
     const GLuint cmdlen = 48 + __GLX_PAD(compsize);
     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
         if (cmdlen <= gc->maxSmallRenderCommandSize) {
-            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+            if ((gc->pc + cmdlen) > gc->bufEnd) {
                 (void) __glXFlushRenderBuffer(gc, gc->pc);
             }
             emit_header(gc->pc, X_GLrop_Bitmap, cmdlen);
-            (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
-            (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
-            (void) memcpy((void *)(gc->pc + 32), (void *)(&xorig), 4);
-            (void) memcpy((void *)(gc->pc + 36), (void *)(&yorig), 4);
-            (void) memcpy((void *)(gc->pc + 40), (void *)(&xmove), 4);
-            (void) memcpy((void *)(gc->pc + 44), (void *)(&ymove), 4);
+            (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
+            (void) memcpy((void *) (gc->pc + 28), (void *) (&height), 4);
+            (void) memcpy((void *) (gc->pc + 32), (void *) (&xorig), 4);
+            (void) memcpy((void *) (gc->pc + 36), (void *) (&yorig), 4);
+            (void) memcpy((void *) (gc->pc + 40), (void *) (&xmove), 4);
+            (void) memcpy((void *) (gc->pc + 44), (void *) (&ymove), 4);
             if (compsize > 0) {
-                (*gc->fillImage)(gc, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP, bitmap, gc->pc + 48, gc->pc + 4);
-            }
-            else {
-                (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+                (*gc->fillImage) (gc, 2, width, height, 1, GL_COLOR_INDEX,
+                                  GL_BITMAP, bitmap, gc->pc + 48, gc->pc + 4);
+            } else {
+                (void) memcpy(gc->pc + 4, default_pixel_store_2D,
+                              default_pixel_store_2D_size);
             }
             gc->pc += cmdlen;
-            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
-        }
-        else {
+            if (gc->pc > gc->limit) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+        } else {
             const GLint op = X_GLrop_Bitmap;
             const GLuint cmdlenLarge = cmdlen + 4;
-            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
-            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
-            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
-            (void) memcpy((void *)(pc + 28), (void *)(&width), 4);
-            (void) memcpy((void *)(pc + 32), (void *)(&height), 4);
-            (void) memcpy((void *)(pc + 36), (void *)(&xorig), 4);
-            (void) memcpy((void *)(pc + 40), (void *)(&yorig), 4);
-            (void) memcpy((void *)(pc + 44), (void *)(&xmove), 4);
-            (void) memcpy((void *)(pc + 48), (void *)(&ymove), 4);
-            __glXSendLargeImage(gc, compsize, 2, width, height, 1, GL_COLOR_INDEX, GL_BITMAP, bitmap, pc + 52, pc + 8);
+            GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
+            (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
+            (void) memcpy((void *) (pc + 28), (void *) (&width), 4);
+            (void) memcpy((void *) (pc + 32), (void *) (&height), 4);
+            (void) memcpy((void *) (pc + 36), (void *) (&xorig), 4);
+            (void) memcpy((void *) (pc + 40), (void *) (&yorig), 4);
+            (void) memcpy((void *) (pc + 44), (void *) (&xmove), 4);
+            (void) memcpy((void *) (pc + 48), (void *) (&ymove), 4);
+            __glXSendLargeImage(gc, compsize, 2, width, height, 1,
+                                GL_COLOR_INDEX, GL_BITMAP, bitmap, pc + 52,
+                                pc + 8);
         }
     }
 }
@@ -477,2736 +524,3083 @@ __indirect_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig,
 void
 __indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_Color3bv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
-    (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
+    (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Color3bv 6
 void
 __indirect_glColor3bv(const GLbyte * v)
 {
-    generic_3_byte( X_GLrop_Color3bv, v );
+    generic_3_byte(X_GLrop_Color3bv, v);
 }
 
 #define X_GLrop_Color3dv 7
 void
 __indirect_glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_Color3dv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&green), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&blue), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Color3dv 7
 void
 __indirect_glColor3dv(const GLdouble * v)
 {
-    generic_24_byte( X_GLrop_Color3dv, v );
+    generic_24_byte(X_GLrop_Color3dv, v);
 }
 
 #define X_GLrop_Color3fv 8
 void
 __indirect_glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_Color3fv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Color3fv 8
 void
 __indirect_glColor3fv(const GLfloat * v)
 {
-    generic_12_byte( X_GLrop_Color3fv, v );
+    generic_12_byte(X_GLrop_Color3fv, v);
 }
 
 #define X_GLrop_Color3iv 9
 void
 __indirect_glColor3i(GLint red, GLint green, GLint blue)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_Color3iv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Color3iv 9
 void
 __indirect_glColor3iv(const GLint * v)
 {
-    generic_12_byte( X_GLrop_Color3iv, v );
+    generic_12_byte(X_GLrop_Color3iv, v);
 }
 
 #define X_GLrop_Color3sv 10
 void
 __indirect_glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_Color3sv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Color3sv 10
 void
 __indirect_glColor3sv(const GLshort * v)
 {
-    generic_6_byte( X_GLrop_Color3sv, v );
+    generic_6_byte(X_GLrop_Color3sv, v);
 }
 
 #define X_GLrop_Color3ubv 11
 void
 __indirect_glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_Color3ubv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
-    (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
+    (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Color3ubv 11
 void
 __indirect_glColor3ubv(const GLubyte * v)
 {
-    generic_3_byte( X_GLrop_Color3ubv, v );
+    generic_3_byte(X_GLrop_Color3ubv, v);
 }
 
 #define X_GLrop_Color3uiv 12
 void
 __indirect_glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_Color3uiv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Color3uiv 12
 void
 __indirect_glColor3uiv(const GLuint * v)
 {
-    generic_12_byte( X_GLrop_Color3uiv, v );
+    generic_12_byte(X_GLrop_Color3uiv, v);
 }
 
 #define X_GLrop_Color3usv 13
 void
 __indirect_glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_Color3usv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Color3usv 13
 void
 __indirect_glColor3usv(const GLushort * v)
 {
-    generic_6_byte( X_GLrop_Color3usv, v );
+    generic_6_byte(X_GLrop_Color3usv, v);
 }
 
 #define X_GLrop_Color4bv 14
 void
 __indirect_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_Color4bv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
-    (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
-    (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
+    (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
+    (void) memcpy((void *) (gc->pc + 7), (void *) (&alpha), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Color4bv 14
 void
 __indirect_glColor4bv(const GLbyte * v)
 {
-    generic_4_byte( X_GLrop_Color4bv, v );
+    generic_4_byte(X_GLrop_Color4bv, v);
 }
 
 #define X_GLrop_Color4dv 15
 void
-__indirect_glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
+__indirect_glColor4d(GLdouble red, GLdouble green, GLdouble blue,
+                     GLdouble alpha)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 36;
     emit_header(gc->pc, X_GLrop_Color4dv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&alpha), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&green), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&blue), 8);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&alpha), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Color4dv 15
 void
 __indirect_glColor4dv(const GLdouble * v)
 {
-    generic_32_byte( X_GLrop_Color4dv, v );
+    generic_32_byte(X_GLrop_Color4dv, v);
 }
 
 #define X_GLrop_Color4fv 16
 void
 __indirect_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_Color4fv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Color4fv 16
 void
 __indirect_glColor4fv(const GLfloat * v)
 {
-    generic_16_byte( X_GLrop_Color4fv, v );
+    generic_16_byte(X_GLrop_Color4fv, v);
 }
 
 #define X_GLrop_Color4iv 17
 void
 __indirect_glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_Color4iv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Color4iv 17
 void
 __indirect_glColor4iv(const GLint * v)
 {
-    generic_16_byte( X_GLrop_Color4iv, v );
+    generic_16_byte(X_GLrop_Color4iv, v);
 }
 
 #define X_GLrop_Color4sv 18
 void
 __indirect_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_Color4sv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
-    (void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
+    (void) memcpy((void *) (gc->pc + 10), (void *) (&alpha), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Color4sv 18
 void
 __indirect_glColor4sv(const GLshort * v)
 {
-    generic_8_byte( X_GLrop_Color4sv, v );
+    generic_8_byte(X_GLrop_Color4sv, v);
 }
 
 #define X_GLrop_Color4ubv 19
 void
 __indirect_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_Color4ubv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
-    (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
-    (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
+    (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
+    (void) memcpy((void *) (gc->pc + 7), (void *) (&alpha), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Color4ubv 19
 void
 __indirect_glColor4ubv(const GLubyte * v)
 {
-    generic_4_byte( X_GLrop_Color4ubv, v );
+    generic_4_byte(X_GLrop_Color4ubv, v);
 }
 
 #define X_GLrop_Color4uiv 20
 void
 __indirect_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_Color4uiv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Color4uiv 20
 void
 __indirect_glColor4uiv(const GLuint * v)
 {
-    generic_16_byte( X_GLrop_Color4uiv, v );
+    generic_16_byte(X_GLrop_Color4uiv, v);
 }
 
 #define X_GLrop_Color4usv 21
 void
-__indirect_glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
+__indirect_glColor4us(GLushort red, GLushort green, GLushort blue,
+                      GLushort alpha)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_Color4usv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
-    (void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
+    (void) memcpy((void *) (gc->pc + 10), (void *) (&alpha), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Color4usv 21
 void
 __indirect_glColor4usv(const GLushort * v)
 {
-    generic_8_byte( X_GLrop_Color4usv, v );
+    generic_8_byte(X_GLrop_Color4usv, v);
 }
 
 #define X_GLrop_EdgeFlagv 22
 void
 __indirect_glEdgeFlag(GLboolean flag)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&flag), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_EdgeFlagv 22
 void
 __indirect_glEdgeFlagv(const GLboolean * flag)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(flag), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (flag), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_End 23
 void
 __indirect_glEnd(void)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 4;
     emit_header(gc->pc, X_GLrop_End, cmdlen);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Indexdv 24
 void
 __indirect_glIndexd(GLdouble c)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_Indexdv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Indexdv 24
 void
 __indirect_glIndexdv(const GLdouble * c)
 {
-    generic_8_byte( X_GLrop_Indexdv, c );
+    generic_8_byte(X_GLrop_Indexdv, c);
 }
 
 #define X_GLrop_Indexfv 25
 void
 __indirect_glIndexf(GLfloat c)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_Indexfv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Indexfv 25
 void
 __indirect_glIndexfv(const GLfloat * c)
 {
-    generic_4_byte( X_GLrop_Indexfv, c );
+    generic_4_byte(X_GLrop_Indexfv, c);
 }
 
 #define X_GLrop_Indexiv 26
 void
 __indirect_glIndexi(GLint c)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_Indexiv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Indexiv 26
 void
 __indirect_glIndexiv(const GLint * c)
 {
-    generic_4_byte( X_GLrop_Indexiv, c );
+    generic_4_byte(X_GLrop_Indexiv, c);
 }
 
 #define X_GLrop_Indexsv 27
 void
 __indirect_glIndexs(GLshort c)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Indexsv 27
 void
 __indirect_glIndexsv(const GLshort * c)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(c), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (c), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Normal3bv 28
 void
 __indirect_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_Normal3bv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 1);
-    (void) memcpy((void *)(gc->pc + 5), (void *)(&ny), 1);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&nz), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 1);
+    (void) memcpy((void *) (gc->pc + 5), (void *) (&ny), 1);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&nz), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Normal3bv 28
 void
 __indirect_glNormal3bv(const GLbyte * v)
 {
-    generic_3_byte( X_GLrop_Normal3bv, v );
+    generic_3_byte(X_GLrop_Normal3bv, v);
 }
 
 #define X_GLrop_Normal3dv 29
 void
 __indirect_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_Normal3dv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&ny), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&nz), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&ny), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&nz), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Normal3dv 29
 void
 __indirect_glNormal3dv(const GLdouble * v)
 {
-    generic_24_byte( X_GLrop_Normal3dv, v );
+    generic_24_byte(X_GLrop_Normal3dv, v);
 }
 
 #define X_GLrop_Normal3fv 30
 void
 __indirect_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_Normal3fv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&ny), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&nz), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Normal3fv 30
 void
 __indirect_glNormal3fv(const GLfloat * v)
 {
-    generic_12_byte( X_GLrop_Normal3fv, v );
+    generic_12_byte(X_GLrop_Normal3fv, v);
 }
 
 #define X_GLrop_Normal3iv 31
 void
 __indirect_glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_Normal3iv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&ny), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&nz), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Normal3iv 31
 void
 __indirect_glNormal3iv(const GLint * v)
 {
-    generic_12_byte( X_GLrop_Normal3iv, v );
+    generic_12_byte(X_GLrop_Normal3iv, v);
 }
 
 #define X_GLrop_Normal3sv 32
 void
 __indirect_glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_Normal3sv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 2);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&ny), 2);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&nz), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&nx), 2);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&ny), 2);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&nz), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Normal3sv 32
 void
 __indirect_glNormal3sv(const GLshort * v)
 {
-    generic_6_byte( X_GLrop_Normal3sv, v );
+    generic_6_byte(X_GLrop_Normal3sv, v);
 }
 
 #define X_GLrop_RasterPos2dv 33
 void
 __indirect_glRasterPos2d(GLdouble x, GLdouble y)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_RasterPos2dv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_RasterPos2dv 33
 void
 __indirect_glRasterPos2dv(const GLdouble * v)
 {
-    generic_16_byte( X_GLrop_RasterPos2dv, v );
+    generic_16_byte(X_GLrop_RasterPos2dv, v);
 }
 
 #define X_GLrop_RasterPos2fv 34
 void
 __indirect_glRasterPos2f(GLfloat x, GLfloat y)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_RasterPos2fv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_RasterPos2fv 34
 void
 __indirect_glRasterPos2fv(const GLfloat * v)
 {
-    generic_8_byte( X_GLrop_RasterPos2fv, v );
+    generic_8_byte(X_GLrop_RasterPos2fv, v);
 }
 
 #define X_GLrop_RasterPos2iv 35
 void
 __indirect_glRasterPos2i(GLint x, GLint y)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_RasterPos2iv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_RasterPos2iv 35
 void
 __indirect_glRasterPos2iv(const GLint * v)
 {
-    generic_8_byte( X_GLrop_RasterPos2iv, v );
+    generic_8_byte(X_GLrop_RasterPos2iv, v);
 }
 
 #define X_GLrop_RasterPos2sv 36
 void
 __indirect_glRasterPos2s(GLshort x, GLshort y)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_RasterPos2sv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_RasterPos2sv 36
 void
 __indirect_glRasterPos2sv(const GLshort * v)
 {
-    generic_4_byte( X_GLrop_RasterPos2sv, v );
+    generic_4_byte(X_GLrop_RasterPos2sv, v);
 }
 
 #define X_GLrop_RasterPos3dv 37
 void
 __indirect_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_RasterPos3dv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_RasterPos3dv 37
 void
 __indirect_glRasterPos3dv(const GLdouble * v)
 {
-    generic_24_byte( X_GLrop_RasterPos3dv, v );
+    generic_24_byte(X_GLrop_RasterPos3dv, v);
 }
 
 #define X_GLrop_RasterPos3fv 38
 void
 __indirect_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_RasterPos3fv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_RasterPos3fv 38
 void
 __indirect_glRasterPos3fv(const GLfloat * v)
 {
-    generic_12_byte( X_GLrop_RasterPos3fv, v );
+    generic_12_byte(X_GLrop_RasterPos3fv, v);
 }
 
 #define X_GLrop_RasterPos3iv 39
 void
 __indirect_glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_RasterPos3iv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_RasterPos3iv 39
 void
 __indirect_glRasterPos3iv(const GLint * v)
 {
-    generic_12_byte( X_GLrop_RasterPos3iv, v );
+    generic_12_byte(X_GLrop_RasterPos3iv, v);
 }
 
 #define X_GLrop_RasterPos3sv 40
 void
 __indirect_glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_RasterPos3sv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_RasterPos3sv 40
 void
 __indirect_glRasterPos3sv(const GLshort * v)
 {
-    generic_6_byte( X_GLrop_RasterPos3sv, v );
+    generic_6_byte(X_GLrop_RasterPos3sv, v);
 }
 
 #define X_GLrop_RasterPos4dv 41
 void
 __indirect_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 36;
     emit_header(gc->pc, X_GLrop_RasterPos4dv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&w), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_RasterPos4dv 41
 void
 __indirect_glRasterPos4dv(const GLdouble * v)
 {
-    generic_32_byte( X_GLrop_RasterPos4dv, v );
+    generic_32_byte(X_GLrop_RasterPos4dv, v);
 }
 
 #define X_GLrop_RasterPos4fv 42
 void
 __indirect_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_RasterPos4fv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_RasterPos4fv 42
 void
 __indirect_glRasterPos4fv(const GLfloat * v)
 {
-    generic_16_byte( X_GLrop_RasterPos4fv, v );
+    generic_16_byte(X_GLrop_RasterPos4fv, v);
 }
 
 #define X_GLrop_RasterPos4iv 43
 void
 __indirect_glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_RasterPos4iv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_RasterPos4iv 43
 void
 __indirect_glRasterPos4iv(const GLint * v)
 {
-    generic_16_byte( X_GLrop_RasterPos4iv, v );
+    generic_16_byte(X_GLrop_RasterPos4iv, v);
 }
 
 #define X_GLrop_RasterPos4sv 44
 void
 __indirect_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_RasterPos4sv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
-    (void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2);
+    (void) memcpy((void *) (gc->pc + 10), (void *) (&w), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_RasterPos4sv 44
 void
 __indirect_glRasterPos4sv(const GLshort * v)
 {
-    generic_8_byte( X_GLrop_RasterPos4sv, v );
+    generic_8_byte(X_GLrop_RasterPos4sv, v);
 }
 
 #define X_GLrop_Rectdv 45
 void
 __indirect_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 36;
     emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&y1), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&x2), 8);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&y2), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&y1), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&x2), 8);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&y2), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Rectdv 45
 void
 __indirect_glRectdv(const GLdouble * v1, const GLdouble * v2)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 36;
     emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 16);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(v2), 16);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 16);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (v2), 16);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Rectfv 46
 void
 __indirect_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y1), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&x2), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&y2), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Rectfv 46
 void
 __indirect_glRectfv(const GLfloat * v1, const GLfloat * v2)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (v2), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Rectiv 47
 void
 __indirect_glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y1), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&x2), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&y2), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Rectiv 47
 void
 __indirect_glRectiv(const GLint * v1, const GLint * v2)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (v2), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Rectsv 48
 void
 __indirect_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 2);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&y1), 2);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x2), 2);
-    (void) memcpy((void *)(gc->pc + 10), (void *)(&y2), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x1), 2);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&y1), 2);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x2), 2);
+    (void) memcpy((void *) (gc->pc + 10), (void *) (&y2), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Rectsv 48
 void
 __indirect_glRectsv(const GLshort * v1, const GLshort * v2)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v2), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (v1), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v2), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord1dv 49
 void
 __indirect_glTexCoord1d(GLdouble s)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_TexCoord1dv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord1dv 49
 void
 __indirect_glTexCoord1dv(const GLdouble * v)
 {
-    generic_8_byte( X_GLrop_TexCoord1dv, v );
+    generic_8_byte(X_GLrop_TexCoord1dv, v);
 }
 
 #define X_GLrop_TexCoord1fv 50
 void
 __indirect_glTexCoord1f(GLfloat s)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_TexCoord1fv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord1fv 50
 void
 __indirect_glTexCoord1fv(const GLfloat * v)
 {
-    generic_4_byte( X_GLrop_TexCoord1fv, v );
+    generic_4_byte(X_GLrop_TexCoord1fv, v);
 }
 
 #define X_GLrop_TexCoord1iv 51
 void
 __indirect_glTexCoord1i(GLint s)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_TexCoord1iv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord1iv 51
 void
 __indirect_glTexCoord1iv(const GLint * v)
 {
-    generic_4_byte( X_GLrop_TexCoord1iv, v );
+    generic_4_byte(X_GLrop_TexCoord1iv, v);
 }
 
 #define X_GLrop_TexCoord1sv 52
 void
 __indirect_glTexCoord1s(GLshort s)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord1sv 52
 void
 __indirect_glTexCoord1sv(const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (v), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord2dv 53
 void
 __indirect_glTexCoord2d(GLdouble s, GLdouble t)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_TexCoord2dv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord2dv 53
 void
 __indirect_glTexCoord2dv(const GLdouble * v)
 {
-    generic_16_byte( X_GLrop_TexCoord2dv, v );
+    generic_16_byte(X_GLrop_TexCoord2dv, v);
 }
 
 #define X_GLrop_TexCoord2fv 54
 void
 __indirect_glTexCoord2f(GLfloat s, GLfloat t)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_TexCoord2fv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord2fv 54
 void
 __indirect_glTexCoord2fv(const GLfloat * v)
 {
-    generic_8_byte( X_GLrop_TexCoord2fv, v );
+    generic_8_byte(X_GLrop_TexCoord2fv, v);
 }
 
 #define X_GLrop_TexCoord2iv 55
 void
 __indirect_glTexCoord2i(GLint s, GLint t)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_TexCoord2iv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord2iv 55
 void
 __indirect_glTexCoord2iv(const GLint * v)
 {
-    generic_8_byte( X_GLrop_TexCoord2iv, v );
+    generic_8_byte(X_GLrop_TexCoord2iv, v);
 }
 
 #define X_GLrop_TexCoord2sv 56
 void
 __indirect_glTexCoord2s(GLshort s, GLshort t)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_TexCoord2sv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&t), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord2sv 56
 void
 __indirect_glTexCoord2sv(const GLshort * v)
 {
-    generic_4_byte( X_GLrop_TexCoord2sv, v );
+    generic_4_byte(X_GLrop_TexCoord2sv, v);
 }
 
 #define X_GLrop_TexCoord3dv 57
 void
 __indirect_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_TexCoord3dv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord3dv 57
 void
 __indirect_glTexCoord3dv(const GLdouble * v)
 {
-    generic_24_byte( X_GLrop_TexCoord3dv, v );
+    generic_24_byte(X_GLrop_TexCoord3dv, v);
 }
 
 #define X_GLrop_TexCoord3fv 58
 void
 __indirect_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_TexCoord3fv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord3fv 58
 void
 __indirect_glTexCoord3fv(const GLfloat * v)
 {
-    generic_12_byte( X_GLrop_TexCoord3fv, v );
+    generic_12_byte(X_GLrop_TexCoord3fv, v);
 }
 
 #define X_GLrop_TexCoord3iv 59
 void
 __indirect_glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_TexCoord3iv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord3iv 59
 void
 __indirect_glTexCoord3iv(const GLint * v)
 {
-    generic_12_byte( X_GLrop_TexCoord3iv, v );
+    generic_12_byte(X_GLrop_TexCoord3iv, v);
 }
 
 #define X_GLrop_TexCoord3sv 60
 void
 __indirect_glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_TexCoord3sv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&t), 2);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&r), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord3sv 60
 void
 __indirect_glTexCoord3sv(const GLshort * v)
 {
-    generic_6_byte( X_GLrop_TexCoord3sv, v );
+    generic_6_byte(X_GLrop_TexCoord3sv, v);
 }
 
 #define X_GLrop_TexCoord4dv 61
 void
 __indirect_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 36;
     emit_header(gc->pc, X_GLrop_TexCoord4dv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&q), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord4dv 61
 void
 __indirect_glTexCoord4dv(const GLdouble * v)
 {
-    generic_32_byte( X_GLrop_TexCoord4dv, v );
+    generic_32_byte(X_GLrop_TexCoord4dv, v);
 }
 
 #define X_GLrop_TexCoord4fv 62
 void
 __indirect_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_TexCoord4fv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&q), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord4fv 62
 void
 __indirect_glTexCoord4fv(const GLfloat * v)
 {
-    generic_16_byte( X_GLrop_TexCoord4fv, v );
+    generic_16_byte(X_GLrop_TexCoord4fv, v);
 }
 
 #define X_GLrop_TexCoord4iv 63
 void
 __indirect_glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_TexCoord4iv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&t), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&q), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord4iv 63
 void
 __indirect_glTexCoord4iv(const GLint * v)
 {
-    generic_16_byte( X_GLrop_TexCoord4iv, v );
+    generic_16_byte(X_GLrop_TexCoord4iv, v);
 }
 
 #define X_GLrop_TexCoord4sv 64
 void
 __indirect_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_TexCoord4sv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
-    (void) memcpy((void *)(gc->pc + 10), (void *)(&q), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 2);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&t), 2);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&r), 2);
+    (void) memcpy((void *) (gc->pc + 10), (void *) (&q), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexCoord4sv 64
 void
 __indirect_glTexCoord4sv(const GLshort * v)
 {
-    generic_8_byte( X_GLrop_TexCoord4sv, v );
+    generic_8_byte(X_GLrop_TexCoord4sv, v);
 }
 
 #define X_GLrop_Vertex2dv 65
 void
 __indirect_glVertex2d(GLdouble x, GLdouble y)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_Vertex2dv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Vertex2dv 65
 void
 __indirect_glVertex2dv(const GLdouble * v)
 {
-    generic_16_byte( X_GLrop_Vertex2dv, v );
+    generic_16_byte(X_GLrop_Vertex2dv, v);
 }
 
 #define X_GLrop_Vertex2fv 66
 void
 __indirect_glVertex2f(GLfloat x, GLfloat y)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_Vertex2fv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Vertex2fv 66
 void
 __indirect_glVertex2fv(const GLfloat * v)
 {
-    generic_8_byte( X_GLrop_Vertex2fv, v );
+    generic_8_byte(X_GLrop_Vertex2fv, v);
 }
 
 #define X_GLrop_Vertex2iv 67
 void
 __indirect_glVertex2i(GLint x, GLint y)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_Vertex2iv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Vertex2iv 67
 void
 __indirect_glVertex2iv(const GLint * v)
 {
-    generic_8_byte( X_GLrop_Vertex2iv, v );
+    generic_8_byte(X_GLrop_Vertex2iv, v);
 }
 
 #define X_GLrop_Vertex2sv 68
 void
 __indirect_glVertex2s(GLshort x, GLshort y)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_Vertex2sv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Vertex2sv 68
 void
 __indirect_glVertex2sv(const GLshort * v)
 {
-    generic_4_byte( X_GLrop_Vertex2sv, v );
+    generic_4_byte(X_GLrop_Vertex2sv, v);
 }
 
 #define X_GLrop_Vertex3dv 69
 void
 __indirect_glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_Vertex3dv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Vertex3dv 69
 void
 __indirect_glVertex3dv(const GLdouble * v)
 {
-    generic_24_byte( X_GLrop_Vertex3dv, v );
+    generic_24_byte(X_GLrop_Vertex3dv, v);
 }
 
 #define X_GLrop_Vertex3fv 70
 void
 __indirect_glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_Vertex3fv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Vertex3fv 70
 void
 __indirect_glVertex3fv(const GLfloat * v)
 {
-    generic_12_byte( X_GLrop_Vertex3fv, v );
+    generic_12_byte(X_GLrop_Vertex3fv, v);
 }
 
 #define X_GLrop_Vertex3iv 71
 void
 __indirect_glVertex3i(GLint x, GLint y, GLint z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_Vertex3iv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Vertex3iv 71
 void
 __indirect_glVertex3iv(const GLint * v)
 {
-    generic_12_byte( X_GLrop_Vertex3iv, v );
+    generic_12_byte(X_GLrop_Vertex3iv, v);
 }
 
 #define X_GLrop_Vertex3sv 72
 void
 __indirect_glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_Vertex3sv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Vertex3sv 72
 void
 __indirect_glVertex3sv(const GLshort * v)
 {
-    generic_6_byte( X_GLrop_Vertex3sv, v );
+    generic_6_byte(X_GLrop_Vertex3sv, v);
 }
 
 #define X_GLrop_Vertex4dv 73
 void
 __indirect_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 36;
     emit_header(gc->pc, X_GLrop_Vertex4dv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&w), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Vertex4dv 73
 void
 __indirect_glVertex4dv(const GLdouble * v)
 {
-    generic_32_byte( X_GLrop_Vertex4dv, v );
+    generic_32_byte(X_GLrop_Vertex4dv, v);
 }
 
 #define X_GLrop_Vertex4fv 74
 void
 __indirect_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_Vertex4fv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Vertex4fv 74
 void
 __indirect_glVertex4fv(const GLfloat * v)
 {
-    generic_16_byte( X_GLrop_Vertex4fv, v );
+    generic_16_byte(X_GLrop_Vertex4fv, v);
 }
 
 #define X_GLrop_Vertex4iv 75
 void
 __indirect_glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_Vertex4iv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&w), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Vertex4iv 75
 void
 __indirect_glVertex4iv(const GLint * v)
 {
-    generic_16_byte( X_GLrop_Vertex4iv, v );
+    generic_16_byte(X_GLrop_Vertex4iv, v);
 }
 
 #define X_GLrop_Vertex4sv 76
 void
 __indirect_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_Vertex4sv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
-    (void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 2);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&y), 2);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&z), 2);
+    (void) memcpy((void *) (gc->pc + 10), (void *) (&w), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Vertex4sv 76
 void
 __indirect_glVertex4sv(const GLshort * v)
 {
-    generic_8_byte( X_GLrop_Vertex4sv, v );
+    generic_8_byte(X_GLrop_Vertex4sv, v);
 }
 
 #define X_GLrop_ClipPlane 77
 void
 __indirect_glClipPlane(GLenum plane, const GLdouble * equation)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 40;
     emit_header(gc->pc, X_GLrop_ClipPlane, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(equation), 32);
-    (void) memcpy((void *)(gc->pc + 36), (void *)(&plane), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (equation), 32);
+    (void) memcpy((void *) (gc->pc + 36), (void *) (&plane), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ColorMaterial 78
 void
 __indirect_glColorMaterial(GLenum face, GLenum mode)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_ColorMaterial, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&mode), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_CullFace 79
 void
 __indirect_glCullFace(GLenum mode)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_CullFace, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Fogf 80
 void
 __indirect_glFogf(GLenum pname, GLfloat param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_Fogf, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Fogfv 81
 void
 __indirect_glFogfv(GLenum pname, const GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glFogfv_size(pname);
     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_Fogfv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Fogi 82
 void
 __indirect_glFogi(GLenum pname, GLint param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_Fogi, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Fogiv 83
 void
 __indirect_glFogiv(GLenum pname, const GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glFogiv_size(pname);
     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_Fogiv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_FrontFace 84
 void
 __indirect_glFrontFace(GLenum mode)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_FrontFace, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Hint 85
 void
 __indirect_glHint(GLenum target, GLenum mode)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_Hint, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&mode), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Lightf 86
 void
 __indirect_glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_Lightf, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Lightfv 87
 void
 __indirect_glLightfv(GLenum light, GLenum pname, const GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glLightfv_size(pname);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_Lightfv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Lighti 88
 void
 __indirect_glLighti(GLenum light, GLenum pname, GLint param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_Lighti, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Lightiv 89
 void
 __indirect_glLightiv(GLenum light, GLenum pname, const GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glLightiv_size(pname);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_Lightiv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&light), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_LightModelf 90
 void
 __indirect_glLightModelf(GLenum pname, GLfloat param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_LightModelf, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_LightModelfv 91
 void
 __indirect_glLightModelfv(GLenum pname, const GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glLightModelfv_size(pname);
     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_LightModelfv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_LightModeli 92
 void
 __indirect_glLightModeli(GLenum pname, GLint param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_LightModeli, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_LightModeliv 93
 void
 __indirect_glLightModeliv(GLenum pname, const GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glLightModeliv_size(pname);
     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_LightModeliv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_LineStipple 94
 void
 __indirect_glLineStipple(GLint factor, GLushort pattern)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_LineStipple, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pattern), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&factor), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pattern), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_LineWidth 95
 void
 __indirect_glLineWidth(GLfloat width)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_LineWidth, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&width), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&width), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Materialf 96
 void
 __indirect_glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_Materialf, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Materialfv 97
 void
 __indirect_glMaterialfv(GLenum face, GLenum pname, const GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glMaterialfv_size(pname);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_Materialfv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Materiali 98
 void
 __indirect_glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_Materiali, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Materialiv 99
 void
 __indirect_glMaterialiv(GLenum face, GLenum pname, const GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glMaterialiv_size(pname);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_Materialiv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PointSize 100
 void
 __indirect_glPointSize(GLfloat size)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_PointSize, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&size), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&size), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PolygonMode 101
 void
 __indirect_glPolygonMode(GLenum face, GLenum mode)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_PolygonMode, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&mode), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PolygonStipple 102
 void
 __indirect_glPolygonStipple(const GLubyte * mask)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const GLuint compsize = (mask != NULL) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, 0) : 0;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const GLuint compsize =
+        (mask != NULL) ? __glImageSize(32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,
+                                       0) : 0;
     const GLuint cmdlen = 24 + __GLX_PAD(compsize);
     emit_header(gc->pc, X_GLrop_PolygonStipple, cmdlen);
     if (compsize > 0) {
-        (*gc->fillImage)(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask, gc->pc + 24, gc->pc + 4);
-    }
-    else {
-        (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+        (*gc->fillImage) (gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask,
+                          gc->pc + 24, gc->pc + 4);
+    } else {
+        (void) memcpy(gc->pc + 4, default_pixel_store_2D,
+                      default_pixel_store_2D_size);
     }
     gc->pc += cmdlen;
-    if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (gc->pc > gc->limit) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Scissor 103
 void
 __indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_Scissor, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ShadeModel 104
 void
 __indirect_glShadeModel(GLenum mode)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_ShadeModel, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexParameterf 105
 void
 __indirect_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_TexParameterf, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexParameterfv 106
 void
-__indirect_glTexParameterfv(GLenum target, GLenum pname, const GLfloat * params)
+__indirect_glTexParameterfv(GLenum target, GLenum pname,
+                            const GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glTexParameterfv_size(pname);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_TexParameterfv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexParameteri 107
 void
 __indirect_glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_TexParameteri, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexParameteriv 108
 void
 __indirect_glTexParameteriv(GLenum target, GLenum pname, const GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glTexParameteriv_size(pname);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_TexParameteriv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 static void
-__glx_TexImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels )
-{
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const GLuint compsize = __glImageSize(width, height, 1, format, type, target);
+__glx_TexImage_1D2D(unsigned opcode, unsigned dim, GLenum target, GLint level,
+                    GLint internalformat, GLsizei width, GLsizei height,
+                    GLint border, GLenum format, GLenum type,
+                    const GLvoid * pixels)
+{
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const GLuint compsize =
+        __glImageSize(width, height, 1, format, type, target);
     const GLuint cmdlen = 56 + __GLX_PAD(compsize);
     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
         if (cmdlen <= gc->maxSmallRenderCommandSize) {
-            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+            if ((gc->pc + cmdlen) > gc->bufEnd) {
                 (void) __glXFlushRenderBuffer(gc, gc->pc);
             }
             emit_header(gc->pc, opcode, cmdlen);
-            (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
-            (void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4);
-            (void) memcpy((void *)(gc->pc + 32), (void *)(&internalformat), 4);
-            (void) memcpy((void *)(gc->pc + 36), (void *)(&width), 4);
-            (void) memcpy((void *)(gc->pc + 40), (void *)(&height), 4);
-            (void) memcpy((void *)(gc->pc + 44), (void *)(&border), 4);
-            (void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4);
-            (void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4);
+            (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
+            (void) memcpy((void *) (gc->pc + 28), (void *) (&level), 4);
+            (void) memcpy((void *) (gc->pc + 32), (void *) (&internalformat),
+                          4);
+            (void) memcpy((void *) (gc->pc + 36), (void *) (&width), 4);
+            (void) memcpy((void *) (gc->pc + 40), (void *) (&height), 4);
+            (void) memcpy((void *) (gc->pc + 44), (void *) (&border), 4);
+            (void) memcpy((void *) (gc->pc + 48), (void *) (&format), 4);
+            (void) memcpy((void *) (gc->pc + 52), (void *) (&type), 4);
             if ((compsize > 0) && (pixels != NULL)) {
-                (*gc->fillImage)(gc, dim, width, height, 1, format, type, pixels, gc->pc + 56, gc->pc + 4);
-            }
-            else {
-                (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+                (*gc->fillImage) (gc, dim, width, height, 1, format, type,
+                                  pixels, gc->pc + 56, gc->pc + 4);
+            } else {
+                (void) memcpy(gc->pc + 4, default_pixel_store_2D,
+                              default_pixel_store_2D_size);
             }
             gc->pc += cmdlen;
-            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
-        }
-        else {
+            if (gc->pc > gc->limit) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+        } else {
             const GLint op = opcode;
             const GLuint cmdlenLarge = cmdlen + 4;
-            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
-            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
-            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
-            (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
-            (void) memcpy((void *)(pc + 32), (void *)(&level), 4);
-            (void) memcpy((void *)(pc + 36), (void *)(&internalformat), 4);
-            (void) memcpy((void *)(pc + 40), (void *)(&width), 4);
-            (void) memcpy((void *)(pc + 44), (void *)(&height), 4);
-            (void) memcpy((void *)(pc + 48), (void *)(&border), 4);
-            (void) memcpy((void *)(pc + 52), (void *)(&format), 4);
-            (void) memcpy((void *)(pc + 56), (void *)(&type), 4);
-            __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, pc + 60, pc + 8);
+            GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
+            (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
+            (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
+            (void) memcpy((void *) (pc + 32), (void *) (&level), 4);
+            (void) memcpy((void *) (pc + 36), (void *) (&internalformat), 4);
+            (void) memcpy((void *) (pc + 40), (void *) (&width), 4);
+            (void) memcpy((void *) (pc + 44), (void *) (&height), 4);
+            (void) memcpy((void *) (pc + 48), (void *) (&border), 4);
+            (void) memcpy((void *) (pc + 52), (void *) (&format), 4);
+            (void) memcpy((void *) (pc + 56), (void *) (&type), 4);
+            __glXSendLargeImage(gc, compsize, dim, width, height, 1, format,
+                                type, pixels, pc + 60, pc + 8);
         }
     }
 }
 
 #define X_GLrop_TexImage1D 109
 void
-__indirect_glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
+__indirect_glTexImage1D(GLenum target, GLint level, GLint internalformat,
+                        GLsizei width, GLint border, GLenum format,
+                        GLenum type, const GLvoid * pixels)
 {
-    __glx_TexImage_1D2D(X_GLrop_TexImage1D, 1, target, level, internalformat, width, 1, border, format, type, pixels );
+    __glx_TexImage_1D2D(X_GLrop_TexImage1D, 1, target, level, internalformat,
+                        width, 1, border, format, type, pixels);
 }
 
 #define X_GLrop_TexImage2D 110
 void
-__indirect_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
+__indirect_glTexImage2D(GLenum target, GLint level, GLint internalformat,
+                        GLsizei width, GLsizei height, GLint border,
+                        GLenum format, GLenum type, const GLvoid * pixels)
 {
-    __glx_TexImage_1D2D(X_GLrop_TexImage2D, 2, target, level, internalformat, width, height, border, format, type, pixels );
+    __glx_TexImage_1D2D(X_GLrop_TexImage2D, 2, target, level, internalformat,
+                        width, height, border, format, type, pixels);
 }
 
 #define X_GLrop_TexEnvf 111
 void
 __indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_TexEnvf, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexEnvfv 112
 void
 __indirect_glTexEnvfv(GLenum target, GLenum pname, const GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glTexEnvfv_size(pname);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_TexEnvfv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexEnvi 113
 void
 __indirect_glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_TexEnvi, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexEnviv 114
 void
 __indirect_glTexEnviv(GLenum target, GLenum pname, const GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glTexEnviv_size(pname);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_TexEnviv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexGend 115
 void
 __indirect_glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_TexGend, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&param), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&coord), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&pname), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&param), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&coord), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&pname), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexGendv 116
 void
 __indirect_glTexGendv(GLenum coord, GLenum pname, const GLdouble * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glTexGendv_size(pname);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8));
     emit_header(gc->pc, X_GLrop_TexGendv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 8));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 8));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexGenf 117
 void
 __indirect_glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_TexGenf, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexGenfv 118
 void
 __indirect_glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glTexGenfv_size(pname);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_TexGenfv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexGeni 119
 void
 __indirect_glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_TexGeni, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_TexGeniv 120
 void
 __indirect_glTexGeniv(GLenum coord, GLenum pname, const GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glTexGeniv_size(pname);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_TexGeniv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_InitNames 121
 void
 __indirect_glInitNames(void)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 4;
     emit_header(gc->pc, X_GLrop_InitNames, cmdlen);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_LoadName 122
 void
 __indirect_glLoadName(GLuint name)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_LoadName, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&name), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PassThrough 123
 void
 __indirect_glPassThrough(GLfloat token)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_PassThrough, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&token), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&token), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PopName 124
 void
 __indirect_glPopName(void)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 4;
     emit_header(gc->pc, X_GLrop_PopName, cmdlen);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PushName 125
 void
 __indirect_glPushName(GLuint name)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_PushName, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&name), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_DrawBuffer 126
 void
 __indirect_glDrawBuffer(GLenum mode)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_DrawBuffer, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Clear 127
 void
 __indirect_glClear(GLbitfield mask)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_Clear, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ClearAccum 128
 void
-__indirect_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
+__indirect_glClearAccum(GLfloat red, GLfloat green, GLfloat blue,
+                        GLfloat alpha)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_ClearAccum, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ClearIndex 129
 void
 __indirect_glClearIndex(GLfloat c)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_ClearIndex, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ClearColor 130
 void
-__indirect_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+__indirect_glClearColor(GLclampf red, GLclampf green, GLclampf blue,
+                        GLclampf alpha)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_ClearColor, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ClearStencil 131
 void
 __indirect_glClearStencil(GLint s)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_ClearStencil, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ClearDepth 132
 void
 __indirect_glClearDepth(GLclampd depth)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_ClearDepth, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&depth), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&depth), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_StencilMask 133
 void
 __indirect_glStencilMask(GLuint mask)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_StencilMask, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ColorMask 134
 void
-__indirect_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+__indirect_glColorMask(GLboolean red, GLboolean green, GLboolean blue,
+                       GLboolean alpha)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_ColorMask, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
-    (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
-    (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
+    (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
+    (void) memcpy((void *) (gc->pc + 7), (void *) (&alpha), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_DepthMask 135
 void
 __indirect_glDepthMask(GLboolean flag)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_DepthMask, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&flag), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_IndexMask 136
 void
 __indirect_glIndexMask(GLuint mask)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_IndexMask, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Accum 137
 void
 __indirect_glAccum(GLenum op, GLfloat value)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_Accum, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&op), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&value), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&op), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&value), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PopAttrib 141
 void
 __indirect_glPopAttrib(void)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 4;
     emit_header(gc->pc, X_GLrop_PopAttrib, cmdlen);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PushAttrib 142
 void
 __indirect_glPushAttrib(GLbitfield mask)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_PushAttrib, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&mask), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MapGrid1d 147
 void
 __indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_MapGrid1d, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&un), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&u1), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&un), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MapGrid1f 148
 void
 __indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_MapGrid1f, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&un), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&u1), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MapGrid2d 149
 void
-__indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
+__indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn,
+                       GLdouble v1, GLdouble v2)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 44;
     emit_header(gc->pc, X_GLrop_MapGrid2d, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 8);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&v2), 8);
-    (void) memcpy((void *)(gc->pc + 36), (void *)(&un), 4);
-    (void) memcpy((void *)(gc->pc + 40), (void *)(&vn), 4);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&u1), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&v1), 8);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&v2), 8);
+    (void) memcpy((void *) (gc->pc + 36), (void *) (&un), 4);
+    (void) memcpy((void *) (gc->pc + 40), (void *) (&vn), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MapGrid2f 150
 void
-__indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
+__indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1,
+                       GLfloat v2)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_MapGrid2f, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&vn), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 4);
-    (void) memcpy((void *)(gc->pc + 24), (void *)(&v2), 4);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&un), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&u1), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&u2), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&vn), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&v1), 4);
+    (void) memcpy((void *) (gc->pc + 24), (void *) (&v2), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_EvalCoord1dv 151
 void
 __indirect_glEvalCoord1d(GLdouble u)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_EvalCoord1dv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_EvalCoord1dv 151
 void
 __indirect_glEvalCoord1dv(const GLdouble * u)
 {
-    generic_8_byte( X_GLrop_EvalCoord1dv, u );
+    generic_8_byte(X_GLrop_EvalCoord1dv, u);
 }
 
 #define X_GLrop_EvalCoord1fv 152
 void
 __indirect_glEvalCoord1f(GLfloat u)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_EvalCoord1fv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_EvalCoord1fv 152
 void
 __indirect_glEvalCoord1fv(const GLfloat * u)
 {
-    generic_4_byte( X_GLrop_EvalCoord1fv, u );
+    generic_4_byte(X_GLrop_EvalCoord1fv, u);
 }
 
 #define X_GLrop_EvalCoord2dv 153
 void
 __indirect_glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_EvalCoord2dv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&v), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&v), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_EvalCoord2dv 153
 void
 __indirect_glEvalCoord2dv(const GLdouble * u)
 {
-    generic_16_byte( X_GLrop_EvalCoord2dv, u );
+    generic_16_byte(X_GLrop_EvalCoord2dv, u);
 }
 
 #define X_GLrop_EvalCoord2fv 154
 void
 __indirect_glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_EvalCoord2fv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&v), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&u), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&v), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_EvalCoord2fv 154
 void
 __indirect_glEvalCoord2fv(const GLfloat * u)
 {
-    generic_8_byte( X_GLrop_EvalCoord2fv, u );
+    generic_8_byte(X_GLrop_EvalCoord2fv, u);
 }
 
 #define X_GLrop_EvalMesh1 155
 void
 __indirect_glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_EvalMesh1, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&i1), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&i2), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_EvalPoint1 156
 void
 __indirect_glEvalPoint1(GLint i)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_EvalPoint1, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&i), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_EvalMesh2 157
 void
 __indirect_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_EvalMesh2, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&j1), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&j2), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&i1), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&i2), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&j1), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&j2), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_EvalPoint2 158
 void
 __indirect_glEvalPoint2(GLint i, GLint j)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_EvalPoint2, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&j), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&i), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&j), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_AlphaFunc 159
 void
 __indirect_glAlphaFunc(GLenum func, GLclampf ref)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_AlphaFunc, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&func), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&ref), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_BlendFunc 160
 void
 __indirect_glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_BlendFunc, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&sfactor), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&dfactor), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&sfactor), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&dfactor), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_LogicOp 161
 void
 __indirect_glLogicOp(GLenum opcode)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_LogicOp, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&opcode), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&opcode), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_StencilFunc 162
 void
 __indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_StencilFunc, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&mask), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&func), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&ref), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&mask), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_StencilOp 163
 void
 __indirect_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_StencilOp, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&fail), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&zfail), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&zpass), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&fail), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&zfail), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&zpass), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_DepthFunc 164
 void
 __indirect_glDepthFunc(GLenum func)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_DepthFunc, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&func), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PixelZoom 165
 void
 __indirect_glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_PixelZoom, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&xfactor), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&yfactor), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&xfactor), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&yfactor), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PixelTransferf 166
 void
 __indirect_glPixelTransferf(GLenum pname, GLfloat param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_PixelTransferf, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PixelTransferi 167
 void
 __indirect_glPixelTransferi(GLenum pname, GLint param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_PixelTransferi, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PixelMapfv 168
 void
 __indirect_glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
     if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
         if (cmdlen <= gc->maxSmallRenderCommandSize) {
-            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+            if ((gc->pc + cmdlen) > gc->bufEnd) {
                 (void) __glXFlushRenderBuffer(gc, gc->pc);
             }
             emit_header(gc->pc, X_GLrop_PixelMapfv, cmdlen);
-            (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
-            (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
-            (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
+            (void) memcpy((void *) (gc->pc + 4), (void *) (&map), 4);
+            (void) memcpy((void *) (gc->pc + 8), (void *) (&mapsize), 4);
+            (void) memcpy((void *) (gc->pc + 12), (void *) (values),
+                          (mapsize * 4));
             gc->pc += cmdlen;
-            if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
-        }
-        else {
+            if (__builtin_expect(gc->pc > gc->limit, 0)) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+        } else {
             const GLint op = X_GLrop_PixelMapfv;
             const GLuint cmdlenLarge = cmdlen + 4;
-            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
-            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
-            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
-            (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
-            (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
+            GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
+            (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
+            (void) memcpy((void *) (pc + 8), (void *) (&map), 4);
+            (void) memcpy((void *) (pc + 12), (void *) (&mapsize), 4);
             __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
         }
     }
@@ -3216,28 +3610,30 @@ __indirect_glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values)
 void
 __indirect_glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
     if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
         if (cmdlen <= gc->maxSmallRenderCommandSize) {
-            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+            if ((gc->pc + cmdlen) > gc->bufEnd) {
                 (void) __glXFlushRenderBuffer(gc, gc->pc);
             }
             emit_header(gc->pc, X_GLrop_PixelMapuiv, cmdlen);
-            (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
-            (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
-            (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
+            (void) memcpy((void *) (gc->pc + 4), (void *) (&map), 4);
+            (void) memcpy((void *) (gc->pc + 8), (void *) (&mapsize), 4);
+            (void) memcpy((void *) (gc->pc + 12), (void *) (values),
+                          (mapsize * 4));
             gc->pc += cmdlen;
-            if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
-        }
-        else {
+            if (__builtin_expect(gc->pc > gc->limit, 0)) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+        } else {
             const GLint op = X_GLrop_PixelMapuiv;
             const GLuint cmdlenLarge = cmdlen + 4;
-            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
-            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
-            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
-            (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
-            (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
+            GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
+            (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
+            (void) memcpy((void *) (pc + 8), (void *) (&map), 4);
+            (void) memcpy((void *) (pc + 12), (void *) (&mapsize), 4);
             __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
         }
     }
@@ -3247,28 +3643,30 @@ __indirect_glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values)
 void
 __indirect_glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort * values)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 2));
     if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
         if (cmdlen <= gc->maxSmallRenderCommandSize) {
-            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+            if ((gc->pc + cmdlen) > gc->bufEnd) {
                 (void) __glXFlushRenderBuffer(gc, gc->pc);
             }
             emit_header(gc->pc, X_GLrop_PixelMapusv, cmdlen);
-            (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
-            (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
-            (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 2));
+            (void) memcpy((void *) (gc->pc + 4), (void *) (&map), 4);
+            (void) memcpy((void *) (gc->pc + 8), (void *) (&mapsize), 4);
+            (void) memcpy((void *) (gc->pc + 12), (void *) (values),
+                          (mapsize * 2));
             gc->pc += cmdlen;
-            if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
-        }
-        else {
+            if (__builtin_expect(gc->pc > gc->limit, 0)) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+        } else {
             const GLint op = X_GLrop_PixelMapusv;
             const GLuint cmdlenLarge = cmdlen + 4;
-            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
-            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
-            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
-            (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
-            (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
+            GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
+            (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
+            (void) memcpy((void *) (pc + 8), (void *) (&map), 4);
+            (void) memcpy((void *) (pc + 12), (void *) (&mapsize), 4);
             __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 2));
         }
     }
@@ -3278,57 +3676,77 @@ __indirect_glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort * values)
 void
 __indirect_glReadBuffer(GLenum mode)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_ReadBuffer, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_CopyPixels 172
 void
-__indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
+__indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height,
+                        GLenum type)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_CopyPixels, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&type), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&type), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLsop_ReadPixels 111
 void
-__indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels)
+__indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
+                        GLenum format, GLenum type, GLvoid * pixels)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const __GLXattribute * const state = gc->client_state_private;
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const __GLXattribute *const state = gc->client_state_private;
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 28;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_read_pixels_reply_t *reply = xcb_glx_read_pixels_reply(c, xcb_glx_read_pixels(c, gc->currentContextTag, x, y, width, height, format, type, state->storePack.swapEndian, 0), NULL);
-        (void)memcpy(pixels, xcb_glx_read_pixels_data(reply), xcb_glx_read_pixels_data_length(reply) * sizeof(GLvoid));
+        xcb_glx_read_pixels_reply_t *reply =
+            xcb_glx_read_pixels_reply(c,
+                                      xcb_glx_read_pixels(c,
+                                                          gc->
+                                                          currentContextTag,
+                                                          x, y, width, height,
+                                                          format, type,
+                                                          state->storePack.
+                                                          swapEndian, 0),
+                                      NULL);
+        (void) memcpy(pixels, xcb_glx_read_pixels_data(reply),
+                      xcb_glx_read_pixels_data_length(reply) *
+                      sizeof(GLvoid));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_ReadPixels, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&x), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&y), 4);
-        (void) memcpy((void *)(pc + 8), (void *)(&width), 4);
-        (void) memcpy((void *)(pc + 12), (void *)(&height), 4);
-        (void) memcpy((void *)(pc + 16), (void *)(&format), 4);
-        (void) memcpy((void *)(pc + 20), (void *)(&type), 4);
-        *(int32_t *)(pc + 24) = 0;
-        * (int8_t *)(pc + 24) = state->storePack.swapEndian;
-        __glXReadPixelReply(dpy, gc, 2, width, height, 1, format, type, pixels, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_ReadPixels, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&x), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&y), 4);
+        (void) memcpy((void *) (pc + 8), (void *) (&width), 4);
+        (void) memcpy((void *) (pc + 12), (void *) (&height), 4);
+        (void) memcpy((void *) (pc + 16), (void *) (&format), 4);
+        (void) memcpy((void *) (pc + 20), (void *) (&type), 4);
+        *(int32_t *) (pc + 24) = 0;
+        *(int8_t *) (pc + 24) = state->storePack.swapEndian;
+        __glXReadPixelReply(dpy, gc, 2, width, height, 1, format, type,
+                            pixels, GL_FALSE);
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3336,41 +3754,47 @@ __indirect_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum
 
 #define X_GLrop_DrawPixels 173
 void
-__indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
+__indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format,
+                        GLenum type, const GLvoid * pixels)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, format, type, 0) : 0;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const GLuint compsize =
+        (pixels != NULL) ? __glImageSize(width, height, 1, format, type,
+                                         0) : 0;
     const GLuint cmdlen = 40 + __GLX_PAD(compsize);
     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
         if (cmdlen <= gc->maxSmallRenderCommandSize) {
-            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+            if ((gc->pc + cmdlen) > gc->bufEnd) {
                 (void) __glXFlushRenderBuffer(gc, gc->pc);
             }
             emit_header(gc->pc, X_GLrop_DrawPixels, cmdlen);
-            (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
-            (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
-            (void) memcpy((void *)(gc->pc + 32), (void *)(&format), 4);
-            (void) memcpy((void *)(gc->pc + 36), (void *)(&type), 4);
+            (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
+            (void) memcpy((void *) (gc->pc + 28), (void *) (&height), 4);
+            (void) memcpy((void *) (gc->pc + 32), (void *) (&format), 4);
+            (void) memcpy((void *) (gc->pc + 36), (void *) (&type), 4);
             if (compsize > 0) {
-                (*gc->fillImage)(gc, 2, width, height, 1, format, type, pixels, gc->pc + 40, gc->pc + 4);
-            }
-            else {
-                (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+                (*gc->fillImage) (gc, 2, width, height, 1, format, type,
+                                  pixels, gc->pc + 40, gc->pc + 4);
+            } else {
+                (void) memcpy(gc->pc + 4, default_pixel_store_2D,
+                              default_pixel_store_2D_size);
             }
             gc->pc += cmdlen;
-            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
-        }
-        else {
+            if (gc->pc > gc->limit) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+        } else {
             const GLint op = X_GLrop_DrawPixels;
             const GLuint cmdlenLarge = cmdlen + 4;
-            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
-            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
-            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
-            (void) memcpy((void *)(pc + 28), (void *)(&width), 4);
-            (void) memcpy((void *)(pc + 32), (void *)(&height), 4);
-            (void) memcpy((void *)(pc + 36), (void *)(&format), 4);
-            (void) memcpy((void *)(pc + 40), (void *)(&type), 4);
-            __glXSendLargeImage(gc, compsize, 2, width, height, 1, format, type, pixels, pc + 44, pc + 8);
+            GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
+            (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
+            (void) memcpy((void *) (pc + 28), (void *) (&width), 4);
+            (void) memcpy((void *) (pc + 32), (void *) (&height), 4);
+            (void) memcpy((void *) (pc + 36), (void *) (&format), 4);
+            (void) memcpy((void *) (pc + 40), (void *) (&type), 4);
+            __glXSendLargeImage(gc, compsize, 2, width, height, 1, format,
+                                type, pixels, pc + 44, pc + 8);
         }
     }
 }
@@ -3379,21 +3803,30 @@ __indirect_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum typ
 void
 __indirect_glGetClipPlane(GLenum plane, GLdouble * equation)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 4;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_clip_plane_reply_t *reply = xcb_glx_get_clip_plane_reply(c, xcb_glx_get_clip_plane(c, gc->currentContextTag, plane), NULL);
-        (void)memcpy(equation, xcb_glx_get_clip_plane_data(reply), xcb_glx_get_clip_plane_data_length(reply) * sizeof(GLdouble));
+        xcb_glx_get_clip_plane_reply_t *reply =
+            xcb_glx_get_clip_plane_reply(c,
+                                         xcb_glx_get_clip_plane(c,
+                                                                gc->
+                                                                currentContextTag,
+                                                                plane), NULL);
+        (void) memcpy(equation, xcb_glx_get_clip_plane_data(reply),
+                      xcb_glx_get_clip_plane_data_length(reply) *
+                      sizeof(GLdouble));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetClipPlane, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&plane), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetClipPlane, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&plane), 4);
         (void) __glXReadReply(dpy, 8, equation, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3403,25 +3836,35 @@ __indirect_glGetClipPlane(GLenum plane, GLdouble * equation)
 void
 __indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_lightfv_reply_t *reply = xcb_glx_get_lightfv_reply(c, xcb_glx_get_lightfv(c, gc->currentContextTag, light, pname), NULL);
+        xcb_glx_get_lightfv_reply_t *reply =
+            xcb_glx_get_lightfv_reply(c,
+                                      xcb_glx_get_lightfv(c,
+                                                          gc->
+                                                          currentContextTag,
+                                                          light, pname),
+                                      NULL);
         if (xcb_glx_get_lightfv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_lightfv_data(reply), xcb_glx_get_lightfv_data_length(reply) * sizeof(GLfloat));
+            (void) memcpy(params, xcb_glx_get_lightfv_data(reply),
+                          xcb_glx_get_lightfv_data_length(reply) *
+                          sizeof(GLfloat));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetLightfv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&light), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetLightfv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&light), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3431,25 +3874,35 @@ __indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat * params)
 void
 __indirect_glGetLightiv(GLenum light, GLenum pname, GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_lightiv_reply_t *reply = xcb_glx_get_lightiv_reply(c, xcb_glx_get_lightiv(c, gc->currentContextTag, light, pname), NULL);
+        xcb_glx_get_lightiv_reply_t *reply =
+            xcb_glx_get_lightiv_reply(c,
+                                      xcb_glx_get_lightiv(c,
+                                                          gc->
+                                                          currentContextTag,
+                                                          light, pname),
+                                      NULL);
         if (xcb_glx_get_lightiv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_lightiv_data(reply), xcb_glx_get_lightiv_data_length(reply) * sizeof(GLint));
+            (void) memcpy(params, xcb_glx_get_lightiv_data(reply),
+                          xcb_glx_get_lightiv_data_length(reply) *
+                          sizeof(GLint));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetLightiv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&light), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetLightiv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&light), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3459,25 +3912,33 @@ __indirect_glGetLightiv(GLenum light, GLenum pname, GLint * params)
 void
 __indirect_glGetMapdv(GLenum target, GLenum query, GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_mapdv_reply_t *reply = xcb_glx_get_mapdv_reply(c, xcb_glx_get_mapdv(c, gc->currentContextTag, target, query), NULL);
+        xcb_glx_get_mapdv_reply_t *reply =
+            xcb_glx_get_mapdv_reply(c,
+                                    xcb_glx_get_mapdv(c,
+                                                      gc->currentContextTag,
+                                                      target, query), NULL);
         if (xcb_glx_get_mapdv_data_length(reply) == 0)
-            (void)memcpy(v, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(v, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(v, xcb_glx_get_mapdv_data(reply), xcb_glx_get_mapdv_data_length(reply) * sizeof(GLdouble));
+            (void) memcpy(v, xcb_glx_get_mapdv_data(reply),
+                          xcb_glx_get_mapdv_data_length(reply) *
+                          sizeof(GLdouble));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapdv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetMapdv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&query), 4);
         (void) __glXReadReply(dpy, 8, v, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3487,25 +3948,33 @@ __indirect_glGetMapdv(GLenum target, GLenum query, GLdouble * v)
 void
 __indirect_glGetMapfv(GLenum target, GLenum query, GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_mapfv_reply_t *reply = xcb_glx_get_mapfv_reply(c, xcb_glx_get_mapfv(c, gc->currentContextTag, target, query), NULL);
+        xcb_glx_get_mapfv_reply_t *reply =
+            xcb_glx_get_mapfv_reply(c,
+                                    xcb_glx_get_mapfv(c,
+                                                      gc->currentContextTag,
+                                                      target, query), NULL);
         if (xcb_glx_get_mapfv_data_length(reply) == 0)
-            (void)memcpy(v, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(v, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(v, xcb_glx_get_mapfv_data(reply), xcb_glx_get_mapfv_data_length(reply) * sizeof(GLfloat));
+            (void) memcpy(v, xcb_glx_get_mapfv_data(reply),
+                          xcb_glx_get_mapfv_data_length(reply) *
+                          sizeof(GLfloat));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapfv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetMapfv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&query), 4);
         (void) __glXReadReply(dpy, 4, v, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3515,25 +3984,33 @@ __indirect_glGetMapfv(GLenum target, GLenum query, GLfloat * v)
 void
 __indirect_glGetMapiv(GLenum target, GLenum query, GLint * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_mapiv_reply_t *reply = xcb_glx_get_mapiv_reply(c, xcb_glx_get_mapiv(c, gc->currentContextTag, target, query), NULL);
+        xcb_glx_get_mapiv_reply_t *reply =
+            xcb_glx_get_mapiv_reply(c,
+                                    xcb_glx_get_mapiv(c,
+                                                      gc->currentContextTag,
+                                                      target, query), NULL);
         if (xcb_glx_get_mapiv_data_length(reply) == 0)
-            (void)memcpy(v, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(v, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(v, xcb_glx_get_mapiv_data(reply), xcb_glx_get_mapiv_data_length(reply) * sizeof(GLint));
+            (void) memcpy(v, xcb_glx_get_mapiv_data(reply),
+                          xcb_glx_get_mapiv_data_length(reply) *
+                          sizeof(GLint));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMapiv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetMapiv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&query), 4);
         (void) __glXReadReply(dpy, 4, v, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3543,25 +4020,35 @@ __indirect_glGetMapiv(GLenum target, GLenum query, GLint * v)
 void
 __indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_materialfv_reply_t *reply = xcb_glx_get_materialfv_reply(c, xcb_glx_get_materialfv(c, gc->currentContextTag, face, pname), NULL);
+        xcb_glx_get_materialfv_reply_t *reply =
+            xcb_glx_get_materialfv_reply(c,
+                                         xcb_glx_get_materialfv(c,
+                                                                gc->
+                                                                currentContextTag,
+                                                                face, pname),
+                                         NULL);
         if (xcb_glx_get_materialfv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_materialfv_data(reply), xcb_glx_get_materialfv_data_length(reply) * sizeof(GLfloat));
+            (void) memcpy(params, xcb_glx_get_materialfv_data(reply),
+                          xcb_glx_get_materialfv_data_length(reply) *
+                          sizeof(GLfloat));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMaterialfv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&face), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetMaterialfv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&face), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3571,25 +4058,35 @@ __indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params)
 void
 __indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_materialiv_reply_t *reply = xcb_glx_get_materialiv_reply(c, xcb_glx_get_materialiv(c, gc->currentContextTag, face, pname), NULL);
+        xcb_glx_get_materialiv_reply_t *reply =
+            xcb_glx_get_materialiv_reply(c,
+                                         xcb_glx_get_materialiv(c,
+                                                                gc->
+                                                                currentContextTag,
+                                                                face, pname),
+                                         NULL);
         if (xcb_glx_get_materialiv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_materialiv_data(reply), xcb_glx_get_materialiv_data_length(reply) * sizeof(GLint));
+            (void) memcpy(params, xcb_glx_get_materialiv_data(reply),
+                          xcb_glx_get_materialiv_data_length(reply) *
+                          sizeof(GLint));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMaterialiv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&face), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetMaterialiv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&face), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3599,24 +4096,33 @@ __indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint * params)
 void
 __indirect_glGetPixelMapfv(GLenum map, GLfloat * values)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 4;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_pixel_mapfv_reply_t *reply = xcb_glx_get_pixel_mapfv_reply(c, xcb_glx_get_pixel_mapfv(c, gc->currentContextTag, map), NULL);
+        xcb_glx_get_pixel_mapfv_reply_t *reply =
+            xcb_glx_get_pixel_mapfv_reply(c,
+                                          xcb_glx_get_pixel_mapfv(c,
+                                                                  gc->
+                                                                  currentContextTag,
+                                                                  map), NULL);
         if (xcb_glx_get_pixel_mapfv_data_length(reply) == 0)
-            (void)memcpy(values, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(values, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(values, xcb_glx_get_pixel_mapfv_data(reply), xcb_glx_get_pixel_mapfv_data_length(reply) * sizeof(GLfloat));
+            (void) memcpy(values, xcb_glx_get_pixel_mapfv_data(reply),
+                          xcb_glx_get_pixel_mapfv_data_length(reply) *
+                          sizeof(GLfloat));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapfv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapfv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&map), 4);
         (void) __glXReadReply(dpy, 4, values, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3626,24 +4132,34 @@ __indirect_glGetPixelMapfv(GLenum map, GLfloat * values)
 void
 __indirect_glGetPixelMapuiv(GLenum map, GLuint * values)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 4;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_pixel_mapuiv_reply_t *reply = xcb_glx_get_pixel_mapuiv_reply(c, xcb_glx_get_pixel_mapuiv(c, gc->currentContextTag, map), NULL);
+        xcb_glx_get_pixel_mapuiv_reply_t *reply =
+            xcb_glx_get_pixel_mapuiv_reply(c,
+                                           xcb_glx_get_pixel_mapuiv(c,
+                                                                    gc->
+                                                                    currentContextTag,
+                                                                    map),
+                                           NULL);
         if (xcb_glx_get_pixel_mapuiv_data_length(reply) == 0)
-            (void)memcpy(values, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(values, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(values, xcb_glx_get_pixel_mapuiv_data(reply), xcb_glx_get_pixel_mapuiv_data_length(reply) * sizeof(GLuint));
+            (void) memcpy(values, xcb_glx_get_pixel_mapuiv_data(reply),
+                          xcb_glx_get_pixel_mapuiv_data_length(reply) *
+                          sizeof(GLuint));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapuiv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapuiv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&map), 4);
         (void) __glXReadReply(dpy, 4, values, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3653,24 +4169,34 @@ __indirect_glGetPixelMapuiv(GLenum map, GLuint * values)
 void
 __indirect_glGetPixelMapusv(GLenum map, GLushort * values)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 4;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_pixel_mapusv_reply_t *reply = xcb_glx_get_pixel_mapusv_reply(c, xcb_glx_get_pixel_mapusv(c, gc->currentContextTag, map), NULL);
+        xcb_glx_get_pixel_mapusv_reply_t *reply =
+            xcb_glx_get_pixel_mapusv_reply(c,
+                                           xcb_glx_get_pixel_mapusv(c,
+                                                                    gc->
+                                                                    currentContextTag,
+                                                                    map),
+                                           NULL);
         if (xcb_glx_get_pixel_mapusv_data_length(reply) == 0)
-            (void)memcpy(values, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(values, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(values, xcb_glx_get_pixel_mapusv_data(reply), xcb_glx_get_pixel_mapusv_data_length(reply) * sizeof(GLushort));
+            (void) memcpy(values, xcb_glx_get_pixel_mapusv_data(reply),
+                          xcb_glx_get_pixel_mapusv_data_length(reply) *
+                          sizeof(GLushort));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapusv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetPixelMapusv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&map), 4);
         (void) __glXReadReply(dpy, 2, values, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3680,22 +4206,33 @@ __indirect_glGetPixelMapusv(GLenum map, GLushort * values)
 void
 __indirect_glGetPolygonStipple(GLubyte * mask)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const __GLXattribute * const state = gc->client_state_private;
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const __GLXattribute *const state = gc->client_state_private;
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 4;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_polygon_stipple_reply_t *reply = xcb_glx_get_polygon_stipple_reply(c, xcb_glx_get_polygon_stipple(c, gc->currentContextTag, 0), NULL);
-        (void)memcpy(mask, xcb_glx_get_polygon_stipple_data(reply), xcb_glx_get_polygon_stipple_data_length(reply) * sizeof(GLubyte));
+        xcb_glx_get_polygon_stipple_reply_t *reply =
+            xcb_glx_get_polygon_stipple_reply(c,
+                                              xcb_glx_get_polygon_stipple(c,
+                                                                          gc->
+                                                                          currentContextTag,
+                                                                          0),
+                                              NULL);
+        (void) memcpy(mask, xcb_glx_get_polygon_stipple_data(reply),
+                      xcb_glx_get_polygon_stipple_data_length(reply) *
+                      sizeof(GLubyte));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetPolygonStipple, cmdlen);
-        *(int32_t *)(pc + 0) = 0;
-        __glXReadPixelReply(dpy, gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, mask, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetPolygonStipple, cmdlen);
+        *(int32_t *) (pc + 0) = 0;
+        __glXReadPixelReply(dpy, gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP,
+                            mask, GL_FALSE);
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3705,25 +4242,35 @@ __indirect_glGetPolygonStipple(GLubyte * mask)
 void
 __indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_tex_envfv_reply_t *reply = xcb_glx_get_tex_envfv_reply(c, xcb_glx_get_tex_envfv(c, gc->currentContextTag, target, pname), NULL);
+        xcb_glx_get_tex_envfv_reply_t *reply =
+            xcb_glx_get_tex_envfv_reply(c,
+                                        xcb_glx_get_tex_envfv(c,
+                                                              gc->
+                                                              currentContextTag,
+                                                              target, pname),
+                                        NULL);
         if (xcb_glx_get_tex_envfv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_tex_envfv_data(reply), xcb_glx_get_tex_envfv_data_length(reply) * sizeof(GLfloat));
+            (void) memcpy(params, xcb_glx_get_tex_envfv_data(reply),
+                          xcb_glx_get_tex_envfv_data_length(reply) *
+                          sizeof(GLfloat));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexEnvfv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetTexEnvfv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3733,25 +4280,35 @@ __indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params)
 void
 __indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_tex_enviv_reply_t *reply = xcb_glx_get_tex_enviv_reply(c, xcb_glx_get_tex_enviv(c, gc->currentContextTag, target, pname), NULL);
+        xcb_glx_get_tex_enviv_reply_t *reply =
+            xcb_glx_get_tex_enviv_reply(c,
+                                        xcb_glx_get_tex_enviv(c,
+                                                              gc->
+                                                              currentContextTag,
+                                                              target, pname),
+                                        NULL);
         if (xcb_glx_get_tex_enviv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_tex_enviv_data(reply), xcb_glx_get_tex_enviv_data_length(reply) * sizeof(GLint));
+            (void) memcpy(params, xcb_glx_get_tex_enviv_data(reply),
+                          xcb_glx_get_tex_enviv_data_length(reply) *
+                          sizeof(GLint));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexEnviv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetTexEnviv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3761,25 +4318,35 @@ __indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint * params)
 void
 __indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_tex_gendv_reply_t *reply = xcb_glx_get_tex_gendv_reply(c, xcb_glx_get_tex_gendv(c, gc->currentContextTag, coord, pname), NULL);
+        xcb_glx_get_tex_gendv_reply_t *reply =
+            xcb_glx_get_tex_gendv_reply(c,
+                                        xcb_glx_get_tex_gendv(c,
+                                                              gc->
+                                                              currentContextTag,
+                                                              coord, pname),
+                                        NULL);
         if (xcb_glx_get_tex_gendv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_tex_gendv_data(reply), xcb_glx_get_tex_gendv_data_length(reply) * sizeof(GLdouble));
+            (void) memcpy(params, xcb_glx_get_tex_gendv_data(reply),
+                          xcb_glx_get_tex_gendv_data_length(reply) *
+                          sizeof(GLdouble));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGendv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetTexGendv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&coord), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 8, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3789,25 +4356,35 @@ __indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params)
 void
 __indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_tex_genfv_reply_t *reply = xcb_glx_get_tex_genfv_reply(c, xcb_glx_get_tex_genfv(c, gc->currentContextTag, coord, pname), NULL);
+        xcb_glx_get_tex_genfv_reply_t *reply =
+            xcb_glx_get_tex_genfv_reply(c,
+                                        xcb_glx_get_tex_genfv(c,
+                                                              gc->
+                                                              currentContextTag,
+                                                              coord, pname),
+                                        NULL);
         if (xcb_glx_get_tex_genfv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_tex_genfv_data(reply), xcb_glx_get_tex_genfv_data_length(reply) * sizeof(GLfloat));
+            (void) memcpy(params, xcb_glx_get_tex_genfv_data(reply),
+                          xcb_glx_get_tex_genfv_data_length(reply) *
+                          sizeof(GLfloat));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGenfv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetTexGenfv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&coord), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3817,25 +4394,35 @@ __indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params)
 void
 __indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_tex_geniv_reply_t *reply = xcb_glx_get_tex_geniv_reply(c, xcb_glx_get_tex_geniv(c, gc->currentContextTag, coord, pname), NULL);
+        xcb_glx_get_tex_geniv_reply_t *reply =
+            xcb_glx_get_tex_geniv_reply(c,
+                                        xcb_glx_get_tex_geniv(c,
+                                                              gc->
+                                                              currentContextTag,
+                                                              coord, pname),
+                                        NULL);
         if (xcb_glx_get_tex_geniv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_tex_geniv_data(reply), xcb_glx_get_tex_geniv_data_length(reply) * sizeof(GLint));
+            (void) memcpy(params, xcb_glx_get_tex_geniv_data(reply),
+                          xcb_glx_get_tex_geniv_data_length(reply) *
+                          sizeof(GLint));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexGeniv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetTexGeniv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&coord), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3843,29 +4430,45 @@ __indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint * params)
 
 #define X_GLsop_GetTexImage 135
 void
-__indirect_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels)
+__indirect_glGetTexImage(GLenum target, GLint level, GLenum format,
+                         GLenum type, GLvoid * pixels)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const __GLXattribute * const state = gc->client_state_private;
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const __GLXattribute *const state = gc->client_state_private;
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 20;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_tex_image_reply_t *reply = xcb_glx_get_tex_image_reply(c, xcb_glx_get_tex_image(c, gc->currentContextTag, target, level, format, type, state->storePack.swapEndian), NULL);
-        (void)memcpy(pixels, xcb_glx_get_tex_image_data(reply), xcb_glx_get_tex_image_data_length(reply) * sizeof(GLvoid));
+        xcb_glx_get_tex_image_reply_t *reply =
+            xcb_glx_get_tex_image_reply(c,
+                                        xcb_glx_get_tex_image(c,
+                                                              gc->
+                                                              currentContextTag,
+                                                              target, level,
+                                                              format, type,
+                                                              state->
+                                                              storePack.
+                                                              swapEndian),
+                                        NULL);
+        (void) memcpy(pixels, xcb_glx_get_tex_image_data(reply),
+                      xcb_glx_get_tex_image_data_length(reply) *
+                      sizeof(GLvoid));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexImage, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
-        (void) memcpy((void *)(pc + 8), (void *)(&format), 4);
-        (void) memcpy((void *)(pc + 12), (void *)(&type), 4);
-        *(int32_t *)(pc + 16) = 0;
-        * (int8_t *)(pc + 16) = state->storePack.swapEndian;
-        __glXReadPixelReply(dpy, gc, 3, 0, 0, 0, format, type, pixels, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetTexImage, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&level), 4);
+        (void) memcpy((void *) (pc + 8), (void *) (&format), 4);
+        (void) memcpy((void *) (pc + 12), (void *) (&type), 4);
+        *(int32_t *) (pc + 16) = 0;
+        *(int8_t *) (pc + 16) = state->storePack.swapEndian;
+        __glXReadPixelReply(dpy, gc, 3, 0, 0, 0, format, type, pixels,
+                            GL_TRUE);
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3875,25 +4478,36 @@ __indirect_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type,
 void
 __indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_tex_parameterfv_reply_t *reply = xcb_glx_get_tex_parameterfv_reply(c, xcb_glx_get_tex_parameterfv(c, gc->currentContextTag, target, pname), NULL);
+        xcb_glx_get_tex_parameterfv_reply_t *reply =
+            xcb_glx_get_tex_parameterfv_reply(c,
+                                              xcb_glx_get_tex_parameterfv(c,
+                                                                          gc->
+                                                                          currentContextTag,
+                                                                          target,
+                                                                          pname),
+                                              NULL);
         if (xcb_glx_get_tex_parameterfv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_tex_parameterfv_data(reply), xcb_glx_get_tex_parameterfv_data_length(reply) * sizeof(GLfloat));
+            (void) memcpy(params, xcb_glx_get_tex_parameterfv_data(reply),
+                          xcb_glx_get_tex_parameterfv_data_length(reply) *
+                          sizeof(GLfloat));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexParameterfv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetTexParameterfv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3903,25 +4517,36 @@ __indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params)
 void
 __indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_tex_parameteriv_reply_t *reply = xcb_glx_get_tex_parameteriv_reply(c, xcb_glx_get_tex_parameteriv(c, gc->currentContextTag, target, pname), NULL);
+        xcb_glx_get_tex_parameteriv_reply_t *reply =
+            xcb_glx_get_tex_parameteriv_reply(c,
+                                              xcb_glx_get_tex_parameteriv(c,
+                                                                          gc->
+                                                                          currentContextTag,
+                                                                          target,
+                                                                          pname),
+                                              NULL);
         if (xcb_glx_get_tex_parameteriv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_tex_parameteriv_data(reply), xcb_glx_get_tex_parameteriv_data_length(reply) * sizeof(GLint));
+            (void) memcpy(params, xcb_glx_get_tex_parameteriv_data(reply),
+                          xcb_glx_get_tex_parameteriv_data_length(reply) *
+                          sizeof(GLint));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexParameteriv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetTexParameteriv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3929,28 +4554,40 @@ __indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint * params)
 
 #define X_GLsop_GetTexLevelParameterfv 138
 void
-__indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat * params)
+__indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname,
+                                    GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 12;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_tex_level_parameterfv_reply_t *reply = xcb_glx_get_tex_level_parameterfv_reply(c, xcb_glx_get_tex_level_parameterfv(c, gc->currentContextTag, target, level, pname), NULL);
+        xcb_glx_get_tex_level_parameterfv_reply_t *reply =
+            xcb_glx_get_tex_level_parameterfv_reply(c,
+                                                    xcb_glx_get_tex_level_parameterfv
+                                                    (c, gc->currentContextTag,
+                                                     target, level, pname),
+                                                    NULL);
         if (xcb_glx_get_tex_level_parameterfv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_tex_level_parameterfv_data(reply), xcb_glx_get_tex_level_parameterfv_data_length(reply) * sizeof(GLfloat));
+            (void) memcpy(params,
+                          xcb_glx_get_tex_level_parameterfv_data(reply),
+                          xcb_glx_get_tex_level_parameterfv_data_length(reply)
+                          * sizeof(GLfloat));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameterfv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
-        (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameterfv,
+                                    cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&level), 4);
+        (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3958,28 +4595,40 @@ __indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GL
 
 #define X_GLsop_GetTexLevelParameteriv 139
 void
-__indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint * params)
+__indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname,
+                                    GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 12;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_tex_level_parameteriv_reply_t *reply = xcb_glx_get_tex_level_parameteriv_reply(c, xcb_glx_get_tex_level_parameteriv(c, gc->currentContextTag, target, level, pname), NULL);
+        xcb_glx_get_tex_level_parameteriv_reply_t *reply =
+            xcb_glx_get_tex_level_parameteriv_reply(c,
+                                                    xcb_glx_get_tex_level_parameteriv
+                                                    (c, gc->currentContextTag,
+                                                     target, level, pname),
+                                                    NULL);
         if (xcb_glx_get_tex_level_parameteriv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_tex_level_parameteriv_data(reply), xcb_glx_get_tex_level_parameteriv_data_length(reply) * sizeof(GLint));
+            (void) memcpy(params,
+                          xcb_glx_get_tex_level_parameteriv_data(reply),
+                          xcb_glx_get_tex_level_parameteriv_data_length(reply)
+                          * sizeof(GLint));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameteriv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
-        (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetTexLevelParameteriv,
+                                    cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&level), 4);
+        (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -3989,22 +4638,27 @@ __indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GL
 GLboolean
 __indirect_glIsList(GLuint list)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     GLboolean retval = (GLboolean) 0;
     const GLuint cmdlen = 4;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_is_list_reply_t *reply = xcb_glx_is_list_reply(c, xcb_glx_is_list(c, gc->currentContextTag, list), NULL);
+        xcb_glx_is_list_reply_t *reply =
+            xcb_glx_is_list_reply(c,
+                                  xcb_glx_is_list(c, gc->currentContextTag,
+                                                  list), NULL);
         retval = reply->ret_val;
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsList, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_IsList, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&list), 4);
         retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return retval;
@@ -4014,315 +4668,370 @@ __indirect_glIsList(GLuint list)
 void
 __indirect_glDepthRange(GLclampd zNear, GLclampd zFar)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_DepthRange, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&zNear), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&zFar), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&zNear), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&zFar), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Frustum 175
 void
-__indirect_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+__indirect_glFrustum(GLdouble left, GLdouble right, GLdouble bottom,
+                     GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 52;
     emit_header(gc->pc, X_GLrop_Frustum, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8);
-    (void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8);
-    (void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&left), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&right), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&bottom), 8);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&top), 8);
+    (void) memcpy((void *) (gc->pc + 36), (void *) (&zNear), 8);
+    (void) memcpy((void *) (gc->pc + 44), (void *) (&zFar), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_LoadIdentity 176
 void
 __indirect_glLoadIdentity(void)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 4;
     emit_header(gc->pc, X_GLrop_LoadIdentity, cmdlen);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_LoadMatrixf 177
 void
 __indirect_glLoadMatrixf(const GLfloat * m)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 68;
     emit_header(gc->pc, X_GLrop_LoadMatrixf, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(m), 64);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (m), 64);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_LoadMatrixd 178
 void
 __indirect_glLoadMatrixd(const GLdouble * m)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 132;
     emit_header(gc->pc, X_GLrop_LoadMatrixd, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(m), 128);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (m), 128);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MatrixMode 179
 void
 __indirect_glMatrixMode(GLenum mode)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_MatrixMode, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultMatrixf 180
 void
 __indirect_glMultMatrixf(const GLfloat * m)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 68;
     emit_header(gc->pc, X_GLrop_MultMatrixf, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(m), 64);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (m), 64);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultMatrixd 181
 void
 __indirect_glMultMatrixd(const GLdouble * m)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 132;
     emit_header(gc->pc, X_GLrop_MultMatrixd, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(m), 128);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (m), 128);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Ortho 182
 void
-__indirect_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
+__indirect_glOrtho(GLdouble left, GLdouble right, GLdouble bottom,
+                   GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 52;
     emit_header(gc->pc, X_GLrop_Ortho, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8);
-    (void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8);
-    (void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&left), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&right), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&bottom), 8);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&top), 8);
+    (void) memcpy((void *) (gc->pc + 36), (void *) (&zNear), 8);
+    (void) memcpy((void *) (gc->pc + 44), (void *) (&zFar), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PopMatrix 183
 void
 __indirect_glPopMatrix(void)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 4;
     emit_header(gc->pc, X_GLrop_PopMatrix, cmdlen);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PushMatrix 184
 void
 __indirect_glPushMatrix(void)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 4;
     emit_header(gc->pc, X_GLrop_PushMatrix, cmdlen);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Rotated 185
 void
 __indirect_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 36;
     emit_header(gc->pc, X_GLrop_Rotated, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&angle), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 8);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&z), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Rotatef 186
 void
 __indirect_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_Rotatef, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&angle), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Scaled 187
 void
 __indirect_glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_Scaled, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Scalef 188
 void
 __indirect_glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_Scalef, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Translated 189
 void
 __indirect_glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_Translated, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Translatef 190
 void
 __indirect_glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_Translatef, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Viewport 191
 void
 __indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_Viewport, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_BindTexture 4117
 void
 __indirect_glBindTexture(GLenum target, GLuint texture)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_BindTexture, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&texture), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&texture), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Indexubv 194
 void
 __indirect_glIndexub(GLubyte c)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&c), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Indexubv 194
 void
 __indirect_glIndexubv(const GLubyte * c)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(c), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (c), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PolygonOffset 192
 void
 __indirect_glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_PolygonOffset, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&units), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&factor), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&units), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLsop_AreTexturesResident 143
 GLboolean
-__indirect_glAreTexturesResident(GLsizei n, const GLuint * textures, GLboolean * residences)
+__indirect_glAreTexturesResident(GLsizei n, const GLuint * textures,
+                                 GLboolean * residences)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     GLboolean retval = (GLboolean) 0;
     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_are_textures_resident_reply_t *reply = xcb_glx_are_textures_resident_reply(c, xcb_glx_are_textures_resident(c, gc->currentContextTag, n, textures), NULL);
-        (void)memcpy(residences, xcb_glx_are_textures_resident_data(reply), xcb_glx_are_textures_resident_data_length(reply) * sizeof(GLboolean));
+        xcb_glx_are_textures_resident_reply_t *reply =
+            xcb_glx_are_textures_resident_reply(c,
+                                                xcb_glx_are_textures_resident
+                                                (c, gc->currentContextTag, n,
+                                                 textures), NULL);
+        (void) memcpy(residences, xcb_glx_are_textures_resident_data(reply),
+                      xcb_glx_are_textures_resident_data_length(reply) *
+                      sizeof(GLboolean));
         retval = reply->ret_val;
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_AreTexturesResident, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_AreTexturesResident, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (textures), (n * 4));
         retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return retval;
@@ -4330,89 +5039,106 @@ __indirect_glAreTexturesResident(GLsizei n, const GLuint * textures, GLboolean *
 
 #define X_GLrop_CopyTexImage1D 4119
 void
-__indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
+__indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat,
+                            GLint x, GLint y, GLsizei width, GLint border)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 32;
     emit_header(gc->pc, X_GLrop_CopyTexImage1D, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&border), 4);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&internalformat), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&border), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_CopyTexImage2D 4120
 void
-__indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+__indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat,
+                            GLint x, GLint y, GLsizei width, GLsizei height,
+                            GLint border)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 36;
     emit_header(gc->pc, X_GLrop_CopyTexImage2D, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
-    (void) memcpy((void *)(gc->pc + 32), (void *)(&border), 4);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&internalformat), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&height), 4);
+    (void) memcpy((void *) (gc->pc + 32), (void *) (&border), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_CopyTexSubImage1D 4121
 void
-__indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
+__indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset,
+                               GLint x, GLint y, GLsizei width)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_CopyTexSubImage1D, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&xoffset), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 24), (void *) (&width), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_CopyTexSubImage2D 4122
 void
-__indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+__indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset,
+                               GLint yoffset, GLint x, GLint y, GLsizei width,
+                               GLsizei height)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 36;
     emit_header(gc->pc, X_GLrop_CopyTexSubImage2D, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 24), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&width), 4);
-    (void) memcpy((void *)(gc->pc + 32), (void *)(&height), 4);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&xoffset), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&yoffset), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 24), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&width), 4);
+    (void) memcpy((void *) (gc->pc + 32), (void *) (&height), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLvop_DeleteTextures 12
 void
 __indirect_glDeleteTextures(GLsizei n, const GLuint * textures)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivate, X_GLvop_DeleteTextures, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
-        UnlockDisplay(dpy); SyncHandle();
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivate,
+                                    X_GLvop_DeleteTextures, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (textures), (n * 4));
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
@@ -4421,21 +5147,30 @@ __indirect_glDeleteTextures(GLsizei n, const GLuint * textures)
 void
 __indirect_glGenTextures(GLsizei n, GLuint * textures)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 4;
     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_gen_textures_reply_t *reply = xcb_glx_gen_textures_reply(c, xcb_glx_gen_textures(c, gc->currentContextTag, n), NULL);
-        (void)memcpy(textures, xcb_glx_gen_textures_data(reply), xcb_glx_gen_textures_data_length(reply) * sizeof(GLuint));
+        xcb_glx_gen_textures_reply_t *reply =
+            xcb_glx_gen_textures_reply(c,
+                                       xcb_glx_gen_textures(c,
+                                                            gc->
+                                                            currentContextTag,
+                                                            n), NULL);
+        (void) memcpy(textures, xcb_glx_gen_textures_data(reply),
+                      xcb_glx_gen_textures_data_length(reply) *
+                      sizeof(GLuint));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenTextures, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GenTextures, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
         (void) __glXReadReply(dpy, 4, textures, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -4445,22 +5180,28 @@ __indirect_glGenTextures(GLsizei n, GLuint * textures)
 GLboolean
 __indirect_glIsTexture(GLuint texture)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     GLboolean retval = (GLboolean) 0;
     const GLuint cmdlen = 4;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_is_texture_reply_t *reply = xcb_glx_is_texture_reply(c, xcb_glx_is_texture(c, gc->currentContextTag, texture), NULL);
+        xcb_glx_is_texture_reply_t *reply =
+            xcb_glx_is_texture_reply(c,
+                                     xcb_glx_is_texture(c,
+                                                        gc->currentContextTag,
+                                                        texture), NULL);
         retval = reply->ret_val;
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsTexture, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_IsTexture, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&texture), 4);
         retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return retval;
@@ -4468,224 +5209,281 @@ __indirect_glIsTexture(GLuint texture)
 
 #define X_GLrop_PrioritizeTextures 4118
 void
-__indirect_glPrioritizeTextures(GLsizei n, const GLuint * textures, const GLclampf * priorities)
+__indirect_glPrioritizeTextures(GLsizei n, const GLuint * textures,
+                                const GLclampf * priorities)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8 + __GLX_PAD((n * 4)) + __GLX_PAD((n * 4));
     if (__builtin_expect(n >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_PrioritizeTextures, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(textures), (n * 4));
-        (void) memcpy((void *)(gc->pc + 8 + (n * 4)), (void *)(priorities), (n * 4));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (textures), (n * 4));
+        (void) memcpy((void *) (gc->pc + 8 + (n * 4)), (void *) (priorities),
+                      (n * 4));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
 static void
-__glx_TexSubImage_1D2D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels )
-{
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, 1, format, type, target) : 0;
+__glx_TexSubImage_1D2D(unsigned opcode, unsigned dim, GLenum target,
+                       GLint level, GLint xoffset, GLint yoffset,
+                       GLsizei width, GLsizei height, GLenum format,
+                       GLenum type, const GLvoid * pixels)
+{
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const GLuint compsize =
+        (pixels != NULL) ? __glImageSize(width, height, 1, format, type,
+                                         target) : 0;
     const GLuint cmdlen = 60 + __GLX_PAD(compsize);
     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
         if (cmdlen <= gc->maxSmallRenderCommandSize) {
-            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+            if ((gc->pc + cmdlen) > gc->bufEnd) {
                 (void) __glXFlushRenderBuffer(gc, gc->pc);
             }
             emit_header(gc->pc, opcode, cmdlen);
-            (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
-            (void) memcpy((void *)(gc->pc + 28), (void *)(&level), 4);
-            (void) memcpy((void *)(gc->pc + 32), (void *)(&xoffset), 4);
-            (void) memcpy((void *)(gc->pc + 36), (void *)(&yoffset), 4);
-            (void) memcpy((void *)(gc->pc + 40), (void *)(&width), 4);
-            (void) memcpy((void *)(gc->pc + 44), (void *)(&height), 4);
-            (void) memcpy((void *)(gc->pc + 48), (void *)(&format), 4);
-            (void) memcpy((void *)(gc->pc + 52), (void *)(&type), 4);
-            (void) memcpy((void *)(gc->pc + 56), (void *)((pixels == NULL) ? one : zero), 4);
+            (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
+            (void) memcpy((void *) (gc->pc + 28), (void *) (&level), 4);
+            (void) memcpy((void *) (gc->pc + 32), (void *) (&xoffset), 4);
+            (void) memcpy((void *) (gc->pc + 36), (void *) (&yoffset), 4);
+            (void) memcpy((void *) (gc->pc + 40), (void *) (&width), 4);
+            (void) memcpy((void *) (gc->pc + 44), (void *) (&height), 4);
+            (void) memcpy((void *) (gc->pc + 48), (void *) (&format), 4);
+            (void) memcpy((void *) (gc->pc + 52), (void *) (&type), 4);
+            (void) memcpy((void *) (gc->pc + 56),
+                          (void *) ((pixels == NULL) ? one : zero), 4);
             if (compsize > 0) {
-                (*gc->fillImage)(gc, dim, width, height, 1, format, type, pixels, gc->pc + 60, gc->pc + 4);
-            }
-            else {
-                (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+                (*gc->fillImage) (gc, dim, width, height, 1, format, type,
+                                  pixels, gc->pc + 60, gc->pc + 4);
+            } else {
+                (void) memcpy(gc->pc + 4, default_pixel_store_2D,
+                              default_pixel_store_2D_size);
             }
             gc->pc += cmdlen;
-            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
-        }
-        else {
+            if (gc->pc > gc->limit) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+        } else {
             const GLint op = opcode;
             const GLuint cmdlenLarge = cmdlen + 4;
-            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
-            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
-            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
-            (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
-            (void) memcpy((void *)(pc + 32), (void *)(&level), 4);
-            (void) memcpy((void *)(pc + 36), (void *)(&xoffset), 4);
-            (void) memcpy((void *)(pc + 40), (void *)(&yoffset), 4);
-            (void) memcpy((void *)(pc + 44), (void *)(&width), 4);
-            (void) memcpy((void *)(pc + 48), (void *)(&height), 4);
-            (void) memcpy((void *)(pc + 52), (void *)(&format), 4);
-            (void) memcpy((void *)(pc + 56), (void *)(&type), 4);
-            (void) memcpy((void *)(pc + 60), zero, 4);
-            __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, pixels, pc + 64, pc + 8);
+            GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
+            (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
+            (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
+            (void) memcpy((void *) (pc + 32), (void *) (&level), 4);
+            (void) memcpy((void *) (pc + 36), (void *) (&xoffset), 4);
+            (void) memcpy((void *) (pc + 40), (void *) (&yoffset), 4);
+            (void) memcpy((void *) (pc + 44), (void *) (&width), 4);
+            (void) memcpy((void *) (pc + 48), (void *) (&height), 4);
+            (void) memcpy((void *) (pc + 52), (void *) (&format), 4);
+            (void) memcpy((void *) (pc + 56), (void *) (&type), 4);
+            (void) memcpy((void *) (pc + 60), zero, 4);
+            __glXSendLargeImage(gc, compsize, dim, width, height, 1, format,
+                                type, pixels, pc + 64, pc + 8);
         }
     }
 }
 
 #define X_GLrop_TexSubImage1D 4099
 void
-__indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)
+__indirect_glTexSubImage1D(GLenum target, GLint level, GLint xoffset,
+                           GLsizei width, GLenum format, GLenum type,
+                           const GLvoid * pixels)
 {
-    __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D, 1, target, level, xoffset, 1, width, 1, format, type, pixels );
+    __glx_TexSubImage_1D2D(X_GLrop_TexSubImage1D, 1, target, level, xoffset,
+                           1, width, 1, format, type, pixels);
 }
 
 #define X_GLrop_TexSubImage2D 4100
 void
-__indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
+__indirect_glTexSubImage2D(GLenum target, GLint level, GLint xoffset,
+                           GLint yoffset, GLsizei width, GLsizei height,
+                           GLenum format, GLenum type, const GLvoid * pixels)
 {
-    __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D, 2, target, level, xoffset, yoffset, width, height, format, type, pixels );
+    __glx_TexSubImage_1D2D(X_GLrop_TexSubImage2D, 2, target, level, xoffset,
+                           yoffset, width, height, format, type, pixels);
 }
 
 #define X_GLrop_BlendColor 4096
 void
-__indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+__indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue,
+                        GLclampf alpha)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_BlendColor, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&alpha), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_BlendEquation 4097
 void
 __indirect_glBlendEquation(GLenum mode)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_BlendEquation, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&mode), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ColorTable 2053
 void
-__indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)
+__indirect_glColorTable(GLenum target, GLenum internalformat, GLsizei width,
+                        GLenum format, GLenum type, const GLvoid * table)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const GLuint compsize = (table != NULL) ? __glImageSize(width, 1, 1, format, type, target) : 0;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const GLuint compsize =
+        (table != NULL) ? __glImageSize(width, 1, 1, format, type,
+                                        target) : 0;
     const GLuint cmdlen = 44 + __GLX_PAD(compsize);
     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
         if (cmdlen <= gc->maxSmallRenderCommandSize) {
-            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+            if ((gc->pc + cmdlen) > gc->bufEnd) {
                 (void) __glXFlushRenderBuffer(gc, gc->pc);
             }
             emit_header(gc->pc, X_GLrop_ColorTable, cmdlen);
-            (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
-            (void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4);
-            (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
-            (void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4);
-            (void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4);
+            (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
+            (void) memcpy((void *) (gc->pc + 28), (void *) (&internalformat),
+                          4);
+            (void) memcpy((void *) (gc->pc + 32), (void *) (&width), 4);
+            (void) memcpy((void *) (gc->pc + 36), (void *) (&format), 4);
+            (void) memcpy((void *) (gc->pc + 40), (void *) (&type), 4);
             if (compsize > 0) {
-                (*gc->fillImage)(gc, 1, width, 1, 1, format, type, table, gc->pc + 44, gc->pc + 4);
-            }
-            else {
-                (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_size );
+                (*gc->fillImage) (gc, 1, width, 1, 1, format, type, table,
+                                  gc->pc + 44, gc->pc + 4);
+            } else {
+                (void) memcpy(gc->pc + 4, default_pixel_store_1D,
+                              default_pixel_store_1D_size);
             }
             gc->pc += cmdlen;
-            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
-        }
-        else {
+            if (gc->pc > gc->limit) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+        } else {
             const GLint op = X_GLrop_ColorTable;
             const GLuint cmdlenLarge = cmdlen + 4;
-            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
-            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
-            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
-            (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
-            (void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4);
-            (void) memcpy((void *)(pc + 36), (void *)(&width), 4);
-            (void) memcpy((void *)(pc + 40), (void *)(&format), 4);
-            (void) memcpy((void *)(pc + 44), (void *)(&type), 4);
-            __glXSendLargeImage(gc, compsize, 1, width, 1, 1, format, type, table, pc + 48, pc + 8);
+            GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
+            (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
+            (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
+            (void) memcpy((void *) (pc + 32), (void *) (&internalformat), 4);
+            (void) memcpy((void *) (pc + 36), (void *) (&width), 4);
+            (void) memcpy((void *) (pc + 40), (void *) (&format), 4);
+            (void) memcpy((void *) (pc + 44), (void *) (&type), 4);
+            __glXSendLargeImage(gc, compsize, 1, width, 1, 1, format, type,
+                                table, pc + 48, pc + 8);
         }
     }
 }
 
 #define X_GLrop_ColorTableParameterfv 2054
 void
-__indirect_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat * params)
+__indirect_glColorTableParameterfv(GLenum target, GLenum pname,
+                                   const GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glColorTableParameterfv_size(pname);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_ColorTableParameterfv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ColorTableParameteriv 2055
 void
-__indirect_glColorTableParameteriv(GLenum target, GLenum pname, const GLint * params)
+__indirect_glColorTableParameteriv(GLenum target, GLenum pname,
+                                   const GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glColorTableParameteriv_size(pname);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_ColorTableParameteriv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_CopyColorTable 2056
 void
-__indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
+__indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x,
+                            GLint y, GLsizei width)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_CopyColorTable, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLsop_GetColorTable 147
 void
-__indirect_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid * table)
+__indirect_glGetColorTable(GLenum target, GLenum format, GLenum type,
+                           GLvoid * table)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const __GLXattribute * const state = gc->client_state_private;
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const __GLXattribute *const state = gc->client_state_private;
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 16;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_color_table_reply_t *reply = xcb_glx_get_color_table_reply(c, xcb_glx_get_color_table(c, gc->currentContextTag, target, format, type, state->storePack.swapEndian), NULL);
-        (void)memcpy(table, xcb_glx_get_color_table_data(reply), xcb_glx_get_color_table_data_length(reply) * sizeof(GLvoid));
+        xcb_glx_get_color_table_reply_t *reply =
+            xcb_glx_get_color_table_reply(c,
+                                          xcb_glx_get_color_table(c,
+                                                                  gc->
+                                                                  currentContextTag,
+                                                                  target,
+                                                                  format,
+                                                                  type,
+                                                                  state->
+                                                                  storePack.
+                                                                  swapEndian),
+                                          NULL);
+        (void) memcpy(table, xcb_glx_get_color_table_data(reply),
+                      xcb_glx_get_color_table_data_length(reply) *
+                      sizeof(GLvoid));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTable, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
-        (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
-        *(int32_t *)(pc + 12) = 0;
-        * (int8_t *)(pc + 12) = state->storePack.swapEndian;
-        __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetColorTable, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
+        (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
+        *(int32_t *) (pc + 12) = 0;
+        *(int8_t *) (pc + 12) = state->storePack.swapEndian;
+        __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table,
+                            GL_TRUE);
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -4693,27 +5491,39 @@ __indirect_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid * t
 
 #define X_GLsop_GetColorTableParameterfv 148
 void
-__indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params)
+__indirect_glGetColorTableParameterfv(GLenum target, GLenum pname,
+                                      GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_color_table_parameterfv_reply_t *reply = xcb_glx_get_color_table_parameterfv_reply(c, xcb_glx_get_color_table_parameterfv(c, gc->currentContextTag, target, pname), NULL);
+        xcb_glx_get_color_table_parameterfv_reply_t *reply =
+            xcb_glx_get_color_table_parameterfv_reply(c,
+                                                      xcb_glx_get_color_table_parameterfv
+                                                      (c,
+                                                       gc->currentContextTag,
+                                                       target, pname), NULL);
         if (xcb_glx_get_color_table_parameterfv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_color_table_parameterfv_data(reply), xcb_glx_get_color_table_parameterfv_data_length(reply) * sizeof(GLfloat));
+            (void) memcpy(params,
+                          xcb_glx_get_color_table_parameterfv_data(reply),
+                          xcb_glx_get_color_table_parameterfv_data_length
+                          (reply) * sizeof(GLfloat));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameterfv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameterfv,
+                                    cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -4721,27 +5531,39 @@ __indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * par
 
 #define X_GLsop_GetColorTableParameteriv 149
 void
-__indirect_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint * params)
+__indirect_glGetColorTableParameteriv(GLenum target, GLenum pname,
+                                      GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_color_table_parameteriv_reply_t *reply = xcb_glx_get_color_table_parameteriv_reply(c, xcb_glx_get_color_table_parameteriv(c, gc->currentContextTag, target, pname), NULL);
+        xcb_glx_get_color_table_parameteriv_reply_t *reply =
+            xcb_glx_get_color_table_parameteriv_reply(c,
+                                                      xcb_glx_get_color_table_parameteriv
+                                                      (c,
+                                                       gc->currentContextTag,
+                                                       target, pname), NULL);
         if (xcb_glx_get_color_table_parameteriv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_color_table_parameteriv_data(reply), xcb_glx_get_color_table_parameteriv_data_length(reply) * sizeof(GLint));
+            (void) memcpy(params,
+                          xcb_glx_get_color_table_parameteriv_data(reply),
+                          xcb_glx_get_color_table_parameteriv_data_length
+                          (reply) * sizeof(GLint));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameteriv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetColorTableParameteriv,
+                                    cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -4749,236 +5571,291 @@ __indirect_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint * param
 
 #define X_GLrop_ColorSubTable 195
 void
-__indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data)
+__indirect_glColorSubTable(GLenum target, GLsizei start, GLsizei count,
+                           GLenum format, GLenum type, const GLvoid * data)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const GLuint compsize = (data != NULL) ? __glImageSize(count, 1, 1, format, type, target) : 0;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const GLuint compsize =
+        (data != NULL) ? __glImageSize(count, 1, 1, format, type, target) : 0;
     const GLuint cmdlen = 44 + __GLX_PAD(compsize);
     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
         if (cmdlen <= gc->maxSmallRenderCommandSize) {
-            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+            if ((gc->pc + cmdlen) > gc->bufEnd) {
                 (void) __glXFlushRenderBuffer(gc, gc->pc);
             }
             emit_header(gc->pc, X_GLrop_ColorSubTable, cmdlen);
-            (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
-            (void) memcpy((void *)(gc->pc + 28), (void *)(&start), 4);
-            (void) memcpy((void *)(gc->pc + 32), (void *)(&count), 4);
-            (void) memcpy((void *)(gc->pc + 36), (void *)(&format), 4);
-            (void) memcpy((void *)(gc->pc + 40), (void *)(&type), 4);
+            (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
+            (void) memcpy((void *) (gc->pc + 28), (void *) (&start), 4);
+            (void) memcpy((void *) (gc->pc + 32), (void *) (&count), 4);
+            (void) memcpy((void *) (gc->pc + 36), (void *) (&format), 4);
+            (void) memcpy((void *) (gc->pc + 40), (void *) (&type), 4);
             if (compsize > 0) {
-                (*gc->fillImage)(gc, 1, count, 1, 1, format, type, data, gc->pc + 44, gc->pc + 4);
-            }
-            else {
-                (void) memcpy( gc->pc + 4, default_pixel_store_1D, default_pixel_store_1D_size );
+                (*gc->fillImage) (gc, 1, count, 1, 1, format, type, data,
+                                  gc->pc + 44, gc->pc + 4);
+            } else {
+                (void) memcpy(gc->pc + 4, default_pixel_store_1D,
+                              default_pixel_store_1D_size);
             }
             gc->pc += cmdlen;
-            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
-        }
-        else {
+            if (gc->pc > gc->limit) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+        } else {
             const GLint op = X_GLrop_ColorSubTable;
             const GLuint cmdlenLarge = cmdlen + 4;
-            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
-            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
-            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
-            (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
-            (void) memcpy((void *)(pc + 32), (void *)(&start), 4);
-            (void) memcpy((void *)(pc + 36), (void *)(&count), 4);
-            (void) memcpy((void *)(pc + 40), (void *)(&format), 4);
-            (void) memcpy((void *)(pc + 44), (void *)(&type), 4);
-            __glXSendLargeImage(gc, compsize, 1, count, 1, 1, format, type, data, pc + 48, pc + 8);
+            GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
+            (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
+            (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
+            (void) memcpy((void *) (pc + 32), (void *) (&start), 4);
+            (void) memcpy((void *) (pc + 36), (void *) (&count), 4);
+            (void) memcpy((void *) (pc + 40), (void *) (&format), 4);
+            (void) memcpy((void *) (pc + 44), (void *) (&type), 4);
+            __glXSendLargeImage(gc, compsize, 1, count, 1, 1, format, type,
+                                data, pc + 48, pc + 8);
         }
     }
 }
 
 #define X_GLrop_CopyColorSubTable 196
 void
-__indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
+__indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y,
+                               GLsizei width)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_CopyColorSubTable, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&start), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&start), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 static void
-__glx_ConvolutionFilter_1D2D( unsigned opcode, unsigned dim, GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image )
-{
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const GLuint compsize = (image != NULL) ? __glImageSize(width, height, 1, format, type, target) : 0;
+__glx_ConvolutionFilter_1D2D(unsigned opcode, unsigned dim, GLenum target,
+                             GLenum internalformat, GLsizei width,
+                             GLsizei height, GLenum format, GLenum type,
+                             const GLvoid * image)
+{
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const GLuint compsize =
+        (image != NULL) ? __glImageSize(width, height, 1, format, type,
+                                        target) : 0;
     const GLuint cmdlen = 48 + __GLX_PAD(compsize);
     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
         if (cmdlen <= gc->maxSmallRenderCommandSize) {
-            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+            if ((gc->pc + cmdlen) > gc->bufEnd) {
                 (void) __glXFlushRenderBuffer(gc, gc->pc);
             }
             emit_header(gc->pc, opcode, cmdlen);
-            (void) memcpy((void *)(gc->pc + 24), (void *)(&target), 4);
-            (void) memcpy((void *)(gc->pc + 28), (void *)(&internalformat), 4);
-            (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
-            (void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4);
-            (void) memcpy((void *)(gc->pc + 40), (void *)(&format), 4);
-            (void) memcpy((void *)(gc->pc + 44), (void *)(&type), 4);
+            (void) memcpy((void *) (gc->pc + 24), (void *) (&target), 4);
+            (void) memcpy((void *) (gc->pc + 28), (void *) (&internalformat),
+                          4);
+            (void) memcpy((void *) (gc->pc + 32), (void *) (&width), 4);
+            (void) memcpy((void *) (gc->pc + 36), (void *) (&height), 4);
+            (void) memcpy((void *) (gc->pc + 40), (void *) (&format), 4);
+            (void) memcpy((void *) (gc->pc + 44), (void *) (&type), 4);
             if (compsize > 0) {
-                (*gc->fillImage)(gc, dim, width, height, 1, format, type, image, gc->pc + 48, gc->pc + 4);
-            }
-            else {
-                (void) memcpy( gc->pc + 4, default_pixel_store_2D, default_pixel_store_2D_size );
+                (*gc->fillImage) (gc, dim, width, height, 1, format, type,
+                                  image, gc->pc + 48, gc->pc + 4);
+            } else {
+                (void) memcpy(gc->pc + 4, default_pixel_store_2D,
+                              default_pixel_store_2D_size);
             }
             gc->pc += cmdlen;
-            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
-        }
-        else {
+            if (gc->pc > gc->limit) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+        } else {
             const GLint op = opcode;
             const GLuint cmdlenLarge = cmdlen + 4;
-            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
-            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
-            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
-            (void) memcpy((void *)(pc + 28), (void *)(&target), 4);
-            (void) memcpy((void *)(pc + 32), (void *)(&internalformat), 4);
-            (void) memcpy((void *)(pc + 36), (void *)(&width), 4);
-            (void) memcpy((void *)(pc + 40), (void *)(&height), 4);
-            (void) memcpy((void *)(pc + 44), (void *)(&format), 4);
-            (void) memcpy((void *)(pc + 48), (void *)(&type), 4);
-            __glXSendLargeImage(gc, compsize, dim, width, height, 1, format, type, image, pc + 52, pc + 8);
+            GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
+            (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
+            (void) memcpy((void *) (pc + 28), (void *) (&target), 4);
+            (void) memcpy((void *) (pc + 32), (void *) (&internalformat), 4);
+            (void) memcpy((void *) (pc + 36), (void *) (&width), 4);
+            (void) memcpy((void *) (pc + 40), (void *) (&height), 4);
+            (void) memcpy((void *) (pc + 44), (void *) (&format), 4);
+            (void) memcpy((void *) (pc + 48), (void *) (&type), 4);
+            __glXSendLargeImage(gc, compsize, dim, width, height, 1, format,
+                                type, image, pc + 52, pc + 8);
         }
     }
 }
 
 #define X_GLrop_ConvolutionFilter1D 4101
 void
-__indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image)
+__indirect_glConvolutionFilter1D(GLenum target, GLenum internalformat,
+                                 GLsizei width, GLenum format, GLenum type,
+                                 const GLvoid * image)
 {
-    __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D, 1, target, internalformat, width, 1, format, type, image );
+    __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter1D, 1, target,
+                                 internalformat, width, 1, format, type,
+                                 image);
 }
 
 #define X_GLrop_ConvolutionFilter2D 4102
 void
-__indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)
+__indirect_glConvolutionFilter2D(GLenum target, GLenum internalformat,
+                                 GLsizei width, GLsizei height, GLenum format,
+                                 GLenum type, const GLvoid * image)
 {
-    __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D, 2, target, internalformat, width, height, format, type, image );
+    __glx_ConvolutionFilter_1D2D(X_GLrop_ConvolutionFilter2D, 2, target,
+                                 internalformat, width, height, format, type,
+                                 image);
 }
 
 #define X_GLrop_ConvolutionParameterf 4103
 void
-__indirect_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
+__indirect_glConvolutionParameterf(GLenum target, GLenum pname,
+                                   GLfloat params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_ConvolutionParameterf, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&params), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&params), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ConvolutionParameterfv 4104
 void
-__indirect_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat * params)
+__indirect_glConvolutionParameterfv(GLenum target, GLenum pname,
+                                    const GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glConvolutionParameterfv_size(pname);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_ConvolutionParameterfv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ConvolutionParameteri 4105
 void
 __indirect_glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_ConvolutionParameteri, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&params), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&params), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ConvolutionParameteriv 4106
 void
-__indirect_glConvolutionParameteriv(GLenum target, GLenum pname, const GLint * params)
+__indirect_glConvolutionParameteriv(GLenum target, GLenum pname,
+                                    const GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glConvolutionParameteriv_size(pname);
     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_ConvolutionParameteriv, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_CopyConvolutionFilter1D 4107
 void
-__indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
+__indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat,
+                                     GLint x, GLint y, GLsizei width)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_CopyConvolutionFilter1D, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_CopyConvolutionFilter2D 4108
 void
-__indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
+__indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat,
+                                     GLint x, GLint y, GLsizei width,
+                                     GLsizei height)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_CopyConvolutionFilter2D, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
-    (void) memcpy((void *)(gc->pc + 24), (void *)(&height), 4);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&width), 4);
+    (void) memcpy((void *) (gc->pc + 24), (void *) (&height), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLsop_GetConvolutionFilter 150
 void
-__indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid * image)
+__indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type,
+                                  GLvoid * image)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const __GLXattribute * const state = gc->client_state_private;
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const __GLXattribute *const state = gc->client_state_private;
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 16;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_convolution_filter_reply_t *reply = xcb_glx_get_convolution_filter_reply(c, xcb_glx_get_convolution_filter(c, gc->currentContextTag, target, format, type, state->storePack.swapEndian), NULL);
-        (void)memcpy(image, xcb_glx_get_convolution_filter_data(reply), xcb_glx_get_convolution_filter_data_length(reply) * sizeof(GLvoid));
+        xcb_glx_get_convolution_filter_reply_t *reply =
+            xcb_glx_get_convolution_filter_reply(c,
+                                                 xcb_glx_get_convolution_filter
+                                                 (c, gc->currentContextTag,
+                                                  target, format, type,
+                                                  state->storePack.
+                                                  swapEndian), NULL);
+        (void) memcpy(image, xcb_glx_get_convolution_filter_data(reply),
+                      xcb_glx_get_convolution_filter_data_length(reply) *
+                      sizeof(GLvoid));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionFilter, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
-        (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
-        *(int32_t *)(pc + 12) = 0;
-        * (int8_t *)(pc + 12) = state->storePack.swapEndian;
-        __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionFilter, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
+        (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
+        *(int32_t *) (pc + 12) = 0;
+        *(int8_t *) (pc + 12) = state->storePack.swapEndian;
+        __glXReadPixelReply(dpy, gc, 2, 0, 0, 0, format, type, image,
+                            GL_TRUE);
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -4986,27 +5863,39 @@ __indirect_glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLv
 
 #define X_GLsop_GetConvolutionParameterfv 151
 void
-__indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params)
+__indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname,
+                                       GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_convolution_parameterfv_reply_t *reply = xcb_glx_get_convolution_parameterfv_reply(c, xcb_glx_get_convolution_parameterfv(c, gc->currentContextTag, target, pname), NULL);
+        xcb_glx_get_convolution_parameterfv_reply_t *reply =
+            xcb_glx_get_convolution_parameterfv_reply(c,
+                                                      xcb_glx_get_convolution_parameterfv
+                                                      (c,
+                                                       gc->currentContextTag,
+                                                       target, pname), NULL);
         if (xcb_glx_get_convolution_parameterfv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_convolution_parameterfv_data(reply), xcb_glx_get_convolution_parameterfv_data_length(reply) * sizeof(GLfloat));
+            (void) memcpy(params,
+                          xcb_glx_get_convolution_parameterfv_data(reply),
+                          xcb_glx_get_convolution_parameterfv_data_length
+                          (reply) * sizeof(GLfloat));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameterfv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameterfv,
+                                    cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -5014,27 +5903,39 @@ __indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * pa
 
 #define X_GLsop_GetConvolutionParameteriv 152
 void
-__indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * params)
+__indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname,
+                                       GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_convolution_parameteriv_reply_t *reply = xcb_glx_get_convolution_parameteriv_reply(c, xcb_glx_get_convolution_parameteriv(c, gc->currentContextTag, target, pname), NULL);
+        xcb_glx_get_convolution_parameteriv_reply_t *reply =
+            xcb_glx_get_convolution_parameteriv_reply(c,
+                                                      xcb_glx_get_convolution_parameteriv
+                                                      (c,
+                                                       gc->currentContextTag,
+                                                       target, pname), NULL);
         if (xcb_glx_get_convolution_parameteriv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_convolution_parameteriv_data(reply), xcb_glx_get_convolution_parameteriv_data_length(reply) * sizeof(GLint));
+            (void) memcpy(params,
+                          xcb_glx_get_convolution_parameteriv_data(reply),
+                          xcb_glx_get_convolution_parameteriv_data_length
+                          (reply) * sizeof(GLint));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameteriv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetConvolutionParameteriv,
+                                    cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -5042,29 +5943,45 @@ __indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * para
 
 #define X_GLsop_GetHistogram 154
 void
-__indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
+__indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format,
+                          GLenum type, GLvoid * values)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const __GLXattribute * const state = gc->client_state_private;
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const __GLXattribute *const state = gc->client_state_private;
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 16;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_histogram_reply_t *reply = xcb_glx_get_histogram_reply(c, xcb_glx_get_histogram(c, gc->currentContextTag, target, reset, format, type, state->storePack.swapEndian), NULL);
-        (void)memcpy(values, xcb_glx_get_histogram_data(reply), xcb_glx_get_histogram_data_length(reply) * sizeof(GLvoid));
+        xcb_glx_get_histogram_reply_t *reply =
+            xcb_glx_get_histogram_reply(c,
+                                        xcb_glx_get_histogram(c,
+                                                              gc->
+                                                              currentContextTag,
+                                                              target, reset,
+                                                              format, type,
+                                                              state->
+                                                              storePack.
+                                                              swapEndian),
+                                        NULL);
+        (void) memcpy(values, xcb_glx_get_histogram_data(reply),
+                      xcb_glx_get_histogram_data_length(reply) *
+                      sizeof(GLvoid));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogram, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
-        (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
-        *(int32_t *)(pc + 12) = 0;
-        * (int8_t *)(pc + 12) = state->storePack.swapEndian;
-        * (int8_t *)(pc + 13) = reset;
-        __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetHistogram, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
+        (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
+        *(int32_t *) (pc + 12) = 0;
+        *(int8_t *) (pc + 12) = state->storePack.swapEndian;
+        *(int8_t *) (pc + 13) = reset;
+        __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, values,
+                            GL_TRUE);
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -5072,27 +5989,38 @@ __indirect_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum
 
 #define X_GLsop_GetHistogramParameterfv 155
 void
-__indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params)
+__indirect_glGetHistogramParameterfv(GLenum target, GLenum pname,
+                                     GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_histogram_parameterfv_reply_t *reply = xcb_glx_get_histogram_parameterfv_reply(c, xcb_glx_get_histogram_parameterfv(c, gc->currentContextTag, target, pname), NULL);
+        xcb_glx_get_histogram_parameterfv_reply_t *reply =
+            xcb_glx_get_histogram_parameterfv_reply(c,
+                                                    xcb_glx_get_histogram_parameterfv
+                                                    (c, gc->currentContextTag,
+                                                     target, pname), NULL);
         if (xcb_glx_get_histogram_parameterfv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_histogram_parameterfv_data(reply), xcb_glx_get_histogram_parameterfv_data_length(reply) * sizeof(GLfloat));
+            (void) memcpy(params,
+                          xcb_glx_get_histogram_parameterfv_data(reply),
+                          xcb_glx_get_histogram_parameterfv_data_length(reply)
+                          * sizeof(GLfloat));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameterfv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameterfv,
+                                    cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -5100,27 +6028,38 @@ __indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * para
 
 #define X_GLsop_GetHistogramParameteriv 156
 void
-__indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * params)
+__indirect_glGetHistogramParameteriv(GLenum target, GLenum pname,
+                                     GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_histogram_parameteriv_reply_t *reply = xcb_glx_get_histogram_parameteriv_reply(c, xcb_glx_get_histogram_parameteriv(c, gc->currentContextTag, target, pname), NULL);
+        xcb_glx_get_histogram_parameteriv_reply_t *reply =
+            xcb_glx_get_histogram_parameteriv_reply(c,
+                                                    xcb_glx_get_histogram_parameteriv
+                                                    (c, gc->currentContextTag,
+                                                     target, pname), NULL);
         if (xcb_glx_get_histogram_parameteriv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_histogram_parameteriv_data(reply), xcb_glx_get_histogram_parameteriv_data_length(reply) * sizeof(GLint));
+            (void) memcpy(params,
+                          xcb_glx_get_histogram_parameteriv_data(reply),
+                          xcb_glx_get_histogram_parameteriv_data_length(reply)
+                          * sizeof(GLint));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameteriv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetHistogramParameteriv,
+                                    cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -5128,29 +6067,41 @@ __indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * params
 
 #define X_GLsop_GetMinmax 157
 void
-__indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
+__indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format,
+                       GLenum type, GLvoid * values)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const __GLXattribute * const state = gc->client_state_private;
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const __GLXattribute *const state = gc->client_state_private;
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 16;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_minmax_reply_t *reply = xcb_glx_get_minmax_reply(c, xcb_glx_get_minmax(c, gc->currentContextTag, target, reset, format, type, state->storePack.swapEndian), NULL);
-        (void)memcpy(values, xcb_glx_get_minmax_data(reply), xcb_glx_get_minmax_data_length(reply) * sizeof(GLvoid));
+        xcb_glx_get_minmax_reply_t *reply =
+            xcb_glx_get_minmax_reply(c,
+                                     xcb_glx_get_minmax(c,
+                                                        gc->currentContextTag,
+                                                        target, reset, format,
+                                                        type,
+                                                        state->storePack.
+                                                        swapEndian), NULL);
+        (void) memcpy(values, xcb_glx_get_minmax_data(reply),
+                      xcb_glx_get_minmax_data_length(reply) * sizeof(GLvoid));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmax, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
-        (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
-        *(int32_t *)(pc + 12) = 0;
-        * (int8_t *)(pc + 12) = state->storePack.swapEndian;
-        * (int8_t *)(pc + 13) = reset;
-        __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetMinmax, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
+        (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
+        *(int32_t *) (pc + 12) = 0;
+        *(int8_t *) (pc + 12) = state->storePack.swapEndian;
+        *(int8_t *) (pc + 13) = reset;
+        __glXReadPixelReply(dpy, gc, 1, 2, 1, 1, format, type, values,
+                            GL_FALSE);
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -5158,27 +6109,36 @@ __indirect_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum typ
 
 #define X_GLsop_GetMinmaxParameterfv 158
 void
-__indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * params)
+__indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname,
+                                  GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_minmax_parameterfv_reply_t *reply = xcb_glx_get_minmax_parameterfv_reply(c, xcb_glx_get_minmax_parameterfv(c, gc->currentContextTag, target, pname), NULL);
+        xcb_glx_get_minmax_parameterfv_reply_t *reply =
+            xcb_glx_get_minmax_parameterfv_reply(c,
+                                                 xcb_glx_get_minmax_parameterfv
+                                                 (c, gc->currentContextTag,
+                                                  target, pname), NULL);
         if (xcb_glx_get_minmax_parameterfv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_minmax_parameterfv_data(reply), xcb_glx_get_minmax_parameterfv_data_length(reply) * sizeof(GLfloat));
+            (void) memcpy(params, xcb_glx_get_minmax_parameterfv_data(reply),
+                          xcb_glx_get_minmax_parameterfv_data_length(reply) *
+                          sizeof(GLfloat));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameterfv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameterfv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -5188,25 +6148,33 @@ __indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * params)
 void
 __indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_minmax_parameteriv_reply_t *reply = xcb_glx_get_minmax_parameteriv_reply(c, xcb_glx_get_minmax_parameteriv(c, gc->currentContextTag, target, pname), NULL);
+        xcb_glx_get_minmax_parameteriv_reply_t *reply =
+            xcb_glx_get_minmax_parameteriv_reply(c,
+                                                 xcb_glx_get_minmax_parameteriv
+                                                 (c, gc->currentContextTag,
+                                                  target, pname), NULL);
         if (xcb_glx_get_minmax_parameteriv_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_minmax_parameteriv_data(reply), xcb_glx_get_minmax_parameteriv_data_length(reply) * sizeof(GLint));
+            (void) memcpy(params, xcb_glx_get_minmax_parameteriv_data(reply),
+                          xcb_glx_get_minmax_parameteriv_data_length(reply) *
+                          sizeof(GLint));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameteriv, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetMinmaxParameteriv, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -5214,681 +6182,802 @@ __indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params)
 
 #define X_GLrop_Histogram 4110
 void
-__indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
+__indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat,
+                       GLboolean sink)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_Histogram, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&width), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&sink), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&width), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&internalformat), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&sink), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_Minmax 4111
 void
 __indirect_glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_Minmax, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&sink), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&sink), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ResetHistogram 4112
 void
 __indirect_glResetHistogram(GLenum target)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_ResetHistogram, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ResetMinmax 4113
 void
 __indirect_glResetMinmax(GLenum target)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_ResetMinmax, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 static void
-__glx_TexImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLint border, GLenum format, GLenum type, const GLvoid * pixels )
-{
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, depth, format, type, target) : 0;
+__glx_TexImage_3D4D(unsigned opcode, unsigned dim, GLenum target, GLint level,
+                    GLint internalformat, GLsizei width, GLsizei height,
+                    GLsizei depth, GLsizei extent, GLint border,
+                    GLenum format, GLenum type, const GLvoid * pixels)
+{
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const GLuint compsize =
+        (pixels != NULL) ? __glImageSize(width, height, depth, format, type,
+                                         target) : 0;
     const GLuint cmdlen = 84 + __GLX_PAD(compsize);
     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
         if (cmdlen <= gc->maxSmallRenderCommandSize) {
-            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+            if ((gc->pc + cmdlen) > gc->bufEnd) {
                 (void) __glXFlushRenderBuffer(gc, gc->pc);
             }
             emit_header(gc->pc, opcode, cmdlen);
-            (void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4);
-            (void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4);
-            (void) memcpy((void *)(gc->pc + 48), (void *)(&internalformat), 4);
-            (void) memcpy((void *)(gc->pc + 52), (void *)(&width), 4);
-            (void) memcpy((void *)(gc->pc + 56), (void *)(&height), 4);
-            (void) memcpy((void *)(gc->pc + 60), (void *)(&depth), 4);
-            (void) memcpy((void *)(gc->pc + 64), (void *)(&extent), 4);
-            (void) memcpy((void *)(gc->pc + 68), (void *)(&border), 4);
-            (void) memcpy((void *)(gc->pc + 72), (void *)(&format), 4);
-            (void) memcpy((void *)(gc->pc + 76), (void *)(&type), 4);
-            (void) memcpy((void *)(gc->pc + 80), (void *)((pixels == NULL) ? one : zero), 4);
+            (void) memcpy((void *) (gc->pc + 40), (void *) (&target), 4);
+            (void) memcpy((void *) (gc->pc + 44), (void *) (&level), 4);
+            (void) memcpy((void *) (gc->pc + 48), (void *) (&internalformat),
+                          4);
+            (void) memcpy((void *) (gc->pc + 52), (void *) (&width), 4);
+            (void) memcpy((void *) (gc->pc + 56), (void *) (&height), 4);
+            (void) memcpy((void *) (gc->pc + 60), (void *) (&depth), 4);
+            (void) memcpy((void *) (gc->pc + 64), (void *) (&extent), 4);
+            (void) memcpy((void *) (gc->pc + 68), (void *) (&border), 4);
+            (void) memcpy((void *) (gc->pc + 72), (void *) (&format), 4);
+            (void) memcpy((void *) (gc->pc + 76), (void *) (&type), 4);
+            (void) memcpy((void *) (gc->pc + 80),
+                          (void *) ((pixels == NULL) ? one : zero), 4);
             if (compsize > 0) {
-                (*gc->fillImage)(gc, dim, width, height, depth, format, type, pixels, gc->pc + 84, gc->pc + 4);
-            }
-            else {
-                (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_size );
+                (*gc->fillImage) (gc, dim, width, height, depth, format, type,
+                                  pixels, gc->pc + 84, gc->pc + 4);
+            } else {
+                (void) memcpy(gc->pc + 4, default_pixel_store_4D,
+                              default_pixel_store_4D_size);
             }
             gc->pc += cmdlen;
-            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
-        }
-        else {
+            if (gc->pc > gc->limit) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+        } else {
             const GLint op = opcode;
             const GLuint cmdlenLarge = cmdlen + 4;
-            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
-            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
-            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
-            (void) memcpy((void *)(pc + 44), (void *)(&target), 4);
-            (void) memcpy((void *)(pc + 48), (void *)(&level), 4);
-            (void) memcpy((void *)(pc + 52), (void *)(&internalformat), 4);
-            (void) memcpy((void *)(pc + 56), (void *)(&width), 4);
-            (void) memcpy((void *)(pc + 60), (void *)(&height), 4);
-            (void) memcpy((void *)(pc + 64), (void *)(&depth), 4);
-            (void) memcpy((void *)(pc + 68), (void *)(&extent), 4);
-            (void) memcpy((void *)(pc + 72), (void *)(&border), 4);
-            (void) memcpy((void *)(pc + 76), (void *)(&format), 4);
-            (void) memcpy((void *)(pc + 80), (void *)(&type), 4);
-            (void) memcpy((void *)(pc + 84), zero, 4);
-            __glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixels, pc + 88, pc + 8);
+            GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
+            (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
+            (void) memcpy((void *) (pc + 44), (void *) (&target), 4);
+            (void) memcpy((void *) (pc + 48), (void *) (&level), 4);
+            (void) memcpy((void *) (pc + 52), (void *) (&internalformat), 4);
+            (void) memcpy((void *) (pc + 56), (void *) (&width), 4);
+            (void) memcpy((void *) (pc + 60), (void *) (&height), 4);
+            (void) memcpy((void *) (pc + 64), (void *) (&depth), 4);
+            (void) memcpy((void *) (pc + 68), (void *) (&extent), 4);
+            (void) memcpy((void *) (pc + 72), (void *) (&border), 4);
+            (void) memcpy((void *) (pc + 76), (void *) (&format), 4);
+            (void) memcpy((void *) (pc + 80), (void *) (&type), 4);
+            (void) memcpy((void *) (pc + 84), zero, 4);
+            __glXSendLargeImage(gc, compsize, dim, width, height, depth,
+                                format, type, pixels, pc + 88, pc + 8);
         }
     }
 }
 
 #define X_GLrop_TexImage3D 4114
 void
-__indirect_glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
+__indirect_glTexImage3D(GLenum target, GLint level, GLint internalformat,
+                        GLsizei width, GLsizei height, GLsizei depth,
+                        GLint border, GLenum format, GLenum type,
+                        const GLvoid * pixels)
 {
-    __glx_TexImage_3D4D(X_GLrop_TexImage3D, 3, target, level, internalformat, width, height, depth, 1, border, format, type, pixels );
+    __glx_TexImage_3D4D(X_GLrop_TexImage3D, 3, target, level, internalformat,
+                        width, height, depth, 1, border, format, type,
+                        pixels);
 }
 
 static void
-__glx_TexSubImage_3D4D( unsigned opcode, unsigned dim, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLenum format, GLenum type, const GLvoid * pixels )
-{
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const GLuint compsize = (pixels != NULL) ? __glImageSize(width, height, depth, format, type, target) : 0;
+__glx_TexSubImage_3D4D(unsigned opcode, unsigned dim, GLenum target,
+                       GLint level, GLint xoffset, GLint yoffset,
+                       GLint zoffset, GLint woffset, GLsizei width,
+                       GLsizei height, GLsizei depth, GLsizei extent,
+                       GLenum format, GLenum type, const GLvoid * pixels)
+{
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const GLuint compsize =
+        (pixels != NULL) ? __glImageSize(width, height, depth, format, type,
+                                         target) : 0;
     const GLuint cmdlen = 92 + __GLX_PAD(compsize);
     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
         if (cmdlen <= gc->maxSmallRenderCommandSize) {
-            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+            if ((gc->pc + cmdlen) > gc->bufEnd) {
                 (void) __glXFlushRenderBuffer(gc, gc->pc);
             }
             emit_header(gc->pc, opcode, cmdlen);
-            (void) memcpy((void *)(gc->pc + 40), (void *)(&target), 4);
-            (void) memcpy((void *)(gc->pc + 44), (void *)(&level), 4);
-            (void) memcpy((void *)(gc->pc + 48), (void *)(&xoffset), 4);
-            (void) memcpy((void *)(gc->pc + 52), (void *)(&yoffset), 4);
-            (void) memcpy((void *)(gc->pc + 56), (void *)(&zoffset), 4);
-            (void) memcpy((void *)(gc->pc + 60), (void *)(&woffset), 4);
-            (void) memcpy((void *)(gc->pc + 64), (void *)(&width), 4);
-            (void) memcpy((void *)(gc->pc + 68), (void *)(&height), 4);
-            (void) memcpy((void *)(gc->pc + 72), (void *)(&depth), 4);
-            (void) memcpy((void *)(gc->pc + 76), (void *)(&extent), 4);
-            (void) memcpy((void *)(gc->pc + 80), (void *)(&format), 4);
-            (void) memcpy((void *)(gc->pc + 84), (void *)(&type), 4);
-            (void) memcpy((void *)(gc->pc + 88), (void *)((pixels == NULL) ? one : zero), 4);
+            (void) memcpy((void *) (gc->pc + 40), (void *) (&target), 4);
+            (void) memcpy((void *) (gc->pc + 44), (void *) (&level), 4);
+            (void) memcpy((void *) (gc->pc + 48), (void *) (&xoffset), 4);
+            (void) memcpy((void *) (gc->pc + 52), (void *) (&yoffset), 4);
+            (void) memcpy((void *) (gc->pc + 56), (void *) (&zoffset), 4);
+            (void) memcpy((void *) (gc->pc + 60), (void *) (&woffset), 4);
+            (void) memcpy((void *) (gc->pc + 64), (void *) (&width), 4);
+            (void) memcpy((void *) (gc->pc + 68), (void *) (&height), 4);
+            (void) memcpy((void *) (gc->pc + 72), (void *) (&depth), 4);
+            (void) memcpy((void *) (gc->pc + 76), (void *) (&extent), 4);
+            (void) memcpy((void *) (gc->pc + 80), (void *) (&format), 4);
+            (void) memcpy((void *) (gc->pc + 84), (void *) (&type), 4);
+            (void) memcpy((void *) (gc->pc + 88),
+                          (void *) ((pixels == NULL) ? one : zero), 4);
             if (compsize > 0) {
-                (*gc->fillImage)(gc, dim, width, height, depth, format, type, pixels, gc->pc + 92, gc->pc + 4);
-            }
-            else {
-                (void) memcpy( gc->pc + 4, default_pixel_store_4D, default_pixel_store_4D_size );
+                (*gc->fillImage) (gc, dim, width, height, depth, format, type,
+                                  pixels, gc->pc + 92, gc->pc + 4);
+            } else {
+                (void) memcpy(gc->pc + 4, default_pixel_store_4D,
+                              default_pixel_store_4D_size);
             }
             gc->pc += cmdlen;
-            if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
-        }
-        else {
+            if (gc->pc > gc->limit) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+        } else {
             const GLint op = opcode;
             const GLuint cmdlenLarge = cmdlen + 4;
-            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
-            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
-            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
-            (void) memcpy((void *)(pc + 44), (void *)(&target), 4);
-            (void) memcpy((void *)(pc + 48), (void *)(&level), 4);
-            (void) memcpy((void *)(pc + 52), (void *)(&xoffset), 4);
-            (void) memcpy((void *)(pc + 56), (void *)(&yoffset), 4);
-            (void) memcpy((void *)(pc + 60), (void *)(&zoffset), 4);
-            (void) memcpy((void *)(pc + 64), (void *)(&woffset), 4);
-            (void) memcpy((void *)(pc + 68), (void *)(&width), 4);
-            (void) memcpy((void *)(pc + 72), (void *)(&height), 4);
-            (void) memcpy((void *)(pc + 76), (void *)(&depth), 4);
-            (void) memcpy((void *)(pc + 80), (void *)(&extent), 4);
-            (void) memcpy((void *)(pc + 84), (void *)(&format), 4);
-            (void) memcpy((void *)(pc + 88), (void *)(&type), 4);
-            (void) memcpy((void *)(pc + 92), zero, 4);
-            __glXSendLargeImage(gc, compsize, dim, width, height, depth, format, type, pixels, pc + 96, pc + 8);
+            GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
+            (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
+            (void) memcpy((void *) (pc + 44), (void *) (&target), 4);
+            (void) memcpy((void *) (pc + 48), (void *) (&level), 4);
+            (void) memcpy((void *) (pc + 52), (void *) (&xoffset), 4);
+            (void) memcpy((void *) (pc + 56), (void *) (&yoffset), 4);
+            (void) memcpy((void *) (pc + 60), (void *) (&zoffset), 4);
+            (void) memcpy((void *) (pc + 64), (void *) (&woffset), 4);
+            (void) memcpy((void *) (pc + 68), (void *) (&width), 4);
+            (void) memcpy((void *) (pc + 72), (void *) (&height), 4);
+            (void) memcpy((void *) (pc + 76), (void *) (&depth), 4);
+            (void) memcpy((void *) (pc + 80), (void *) (&extent), 4);
+            (void) memcpy((void *) (pc + 84), (void *) (&format), 4);
+            (void) memcpy((void *) (pc + 88), (void *) (&type), 4);
+            (void) memcpy((void *) (pc + 92), zero, 4);
+            __glXSendLargeImage(gc, compsize, dim, width, height, depth,
+                                format, type, pixels, pc + 96, pc + 8);
         }
     }
 }
 
 #define X_GLrop_TexSubImage3D 4115
 void
-__indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)
+__indirect_glTexSubImage3D(GLenum target, GLint level, GLint xoffset,
+                           GLint yoffset, GLint zoffset, GLsizei width,
+                           GLsizei height, GLsizei depth, GLenum format,
+                           GLenum type, const GLvoid * pixels)
 {
-    __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D, 3, target, level, xoffset, yoffset, zoffset, 1, width, height, depth, 1, format, type, pixels );
+    __glx_TexSubImage_3D4D(X_GLrop_TexSubImage3D, 3, target, level, xoffset,
+                           yoffset, zoffset, 1, width, height, depth, 1,
+                           format, type, pixels);
 }
 
 #define X_GLrop_CopyTexSubImage3D 4123
 void
-__indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+__indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset,
+                               GLint yoffset, GLint zoffset, GLint x, GLint y,
+                               GLsizei width, GLsizei height)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 40;
     emit_header(gc->pc, X_GLrop_CopyTexSubImage3D, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&zoffset), 4);
-    (void) memcpy((void *)(gc->pc + 24), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
-    (void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&level), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&xoffset), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&yoffset), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&zoffset), 4);
+    (void) memcpy((void *) (gc->pc + 24), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 32), (void *) (&width), 4);
+    (void) memcpy((void *) (gc->pc + 36), (void *) (&height), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ActiveTextureARB 197
 void
 __indirect_glActiveTextureARB(GLenum texture)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_ActiveTextureARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&texture), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&texture), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord1dvARB 198
 void
 __indirect_glMultiTexCoord1dARB(GLenum target, GLdouble s)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&target), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord1dvARB 198
 void
 __indirect_glMultiTexCoord1dvARB(GLenum target, const GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (v), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&target), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord1fvARB 199
 void
 __indirect_glMultiTexCoord1fARB(GLenum target, GLfloat s)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord1fvARB 199
 void
 __indirect_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord1ivARB 200
 void
 __indirect_glMultiTexCoord1iARB(GLenum target, GLint s)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord1ivARB 200
 void
 __indirect_glMultiTexCoord1ivARB(GLenum target, const GLint * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord1svARB 201
 void
 __indirect_glMultiTexCoord1sARB(GLenum target, GLshort s)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord1svARB 201
 void
 __indirect_glMultiTexCoord1svARB(GLenum target, const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord2dvARB 202
 void
 __indirect_glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&target), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord2dvARB 202
 void
 __indirect_glMultiTexCoord2dvARB(GLenum target, const GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (v), 16);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&target), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord2fvARB 203
 void
 __indirect_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord2fvARB 203
 void
 __indirect_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord2ivARB 204
 void
 __indirect_glMultiTexCoord2iARB(GLenum target, GLint s, GLint t)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord2ivARB 204
 void
 __indirect_glMultiTexCoord2ivARB(GLenum target, const GLint * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord2svARB 205
 void
 __indirect_glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
-    (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2);
+    (void) memcpy((void *) (gc->pc + 10), (void *) (&t), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord2svARB 205
 void
 __indirect_glMultiTexCoord2svARB(GLenum target, const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord3dvARB 206
 void
-__indirect_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r)
+__indirect_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t,
+                                GLdouble r)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 32;
     emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&target), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord3dvARB 206
 void
 __indirect_glMultiTexCoord3dvARB(GLenum target, const GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 32;
     emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (v), 24);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&target), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord3fvARB 207
 void
-__indirect_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)
+__indirect_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t,
+                                GLfloat r)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord3fvARB 207
 void
 __indirect_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord3ivARB 208
 void
 __indirect_glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord3ivARB 208
 void
 __indirect_glMultiTexCoord3ivARB(GLenum target, const GLint * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord3svARB 209
 void
-__indirect_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r)
+__indirect_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t,
+                                GLshort r)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
-    (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2);
+    (void) memcpy((void *) (gc->pc + 10), (void *) (&t), 2);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord3svARB 209
 void
 __indirect_glMultiTexCoord3svARB(GLenum target, const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 6);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord4dvARB 210
 void
-__indirect_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
+__indirect_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t,
+                                GLdouble r, GLdouble q)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 40;
     emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8);
-    (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&s), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&r), 8);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&q), 8);
+    (void) memcpy((void *) (gc->pc + 36), (void *) (&target), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord4dvARB 210
 void
 __indirect_glMultiTexCoord4dvARB(GLenum target, const GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 40;
     emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
-    (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (v), 32);
+    (void) memcpy((void *) (gc->pc + 36), (void *) (&target), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord4fvARB 211
 void
-__indirect_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+__indirect_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t,
+                                GLfloat r, GLfloat q)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&q), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord4fvARB 211
 void
 __indirect_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord4ivARB 212
 void
-__indirect_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q)
+__indirect_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r,
+                                GLint q)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&t), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&r), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&q), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord4ivARB 212
 void
 __indirect_glMultiTexCoord4ivARB(GLenum target, const GLint * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord4svARB 213
 void
-__indirect_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
+__indirect_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t,
+                                GLshort r, GLshort q)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
-    (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2);
-    (void) memcpy((void *)(gc->pc + 14), (void *)(&q), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&s), 2);
+    (void) memcpy((void *) (gc->pc + 10), (void *) (&t), 2);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&r), 2);
+    (void) memcpy((void *) (gc->pc + 14), (void *) (&q), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_MultiTexCoord4svARB 213
 void
 __indirect_glMultiTexCoord4svARB(GLenum target, const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_SampleCoverageARB 229
 void
 __indirect_glSampleCoverageARB(GLclampf value, GLboolean invert)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_SampleCoverageARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&value), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&invert), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLvop_GetProgramStringARB 1308
 void
 __indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramStringARB, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GetProgramStringARB, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 1, string, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
@@ -5897,171 +6986,202 @@ __indirect_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid * string)
 void
 __indirect_glGetProgramivARB(GLenum target, GLenum pname, GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramivARB, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GetProgramivARB, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
 
 #define X_GLrop_ProgramEnvParameter4dvARB 4185
 void
-__indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+__indirect_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x,
+                                      GLdouble y, GLdouble z, GLdouble w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 44;
     emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
-    (void) memcpy((void *)(gc->pc + 36), (void *)(&w), 8);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 8);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&z), 8);
+    (void) memcpy((void *) (gc->pc + 36), (void *) (&w), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ProgramEnvParameter4dvARB 4185
 void
-__indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
+__indirect_glProgramEnvParameter4dvARB(GLenum target, GLuint index,
+                                       const GLdouble * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 44;
     emit_header(gc->pc, X_GLrop_ProgramEnvParameter4dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 32);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), 32);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ProgramEnvParameter4fvARB 4184
 void
-__indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+__indirect_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x,
+                                      GLfloat y, GLfloat z, GLfloat w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
-    (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 4);
+    (void) memcpy((void *) (gc->pc + 24), (void *) (&w), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ProgramEnvParameter4fvARB 4184
 void
-__indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
+__indirect_glProgramEnvParameter4fvARB(GLenum target, GLuint index,
+                                       const GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_ProgramEnvParameter4fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), 16);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ProgramLocalParameter4dvARB 4216
 void
-__indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+__indirect_glProgramLocalParameter4dARB(GLenum target, GLuint index,
+                                        GLdouble x, GLdouble y, GLdouble z,
+                                        GLdouble w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 44;
     emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
-    (void) memcpy((void *)(gc->pc + 36), (void *)(&w), 8);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 8);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&z), 8);
+    (void) memcpy((void *) (gc->pc + 36), (void *) (&w), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ProgramLocalParameter4dvARB 4216
 void
-__indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
+__indirect_glProgramLocalParameter4dvARB(GLenum target, GLuint index,
+                                         const GLdouble * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 44;
     emit_header(gc->pc, X_GLrop_ProgramLocalParameter4dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 32);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), 32);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ProgramLocalParameter4fvARB 4215
 void
-__indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+__indirect_glProgramLocalParameter4fARB(GLenum target, GLuint index,
+                                        GLfloat x, GLfloat y, GLfloat z,
+                                        GLfloat w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
-    (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 4);
+    (void) memcpy((void *) (gc->pc + 24), (void *) (&w), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ProgramLocalParameter4fvARB 4215
 void
-__indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
+__indirect_glProgramLocalParameter4fvARB(GLenum target, GLuint index,
+                                         const GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_ProgramLocalParameter4fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), 16);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ProgramStringARB 4217
 void
-__indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len, const GLvoid * string)
+__indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len,
+                              const GLvoid * string)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16 + __GLX_PAD(len);
     if (__builtin_expect((len >= 0) && (gc->currentDpy != NULL), 1)) {
         if (cmdlen <= gc->maxSmallRenderCommandSize) {
-            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+            if ((gc->pc + cmdlen) > gc->bufEnd) {
                 (void) __glXFlushRenderBuffer(gc, gc->pc);
             }
             emit_header(gc->pc, X_GLrop_ProgramStringARB, cmdlen);
-            (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-            (void) memcpy((void *)(gc->pc + 8), (void *)(&format), 4);
-            (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4);
-            (void) memcpy((void *)(gc->pc + 16), (void *)(string), len);
+            (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+            (void) memcpy((void *) (gc->pc + 8), (void *) (&format), 4);
+            (void) memcpy((void *) (gc->pc + 12), (void *) (&len), 4);
+            (void) memcpy((void *) (gc->pc + 16), (void *) (string), len);
             gc->pc += cmdlen;
-            if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
-        }
-        else {
+            if (__builtin_expect(gc->pc > gc->limit, 0)) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+        } else {
             const GLint op = X_GLrop_ProgramStringARB;
             const GLuint cmdlenLarge = cmdlen + 4;
-            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
-            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
-            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
-            (void) memcpy((void *)(pc + 8), (void *)(&target), 4);
-            (void) memcpy((void *)(pc + 12), (void *)(&format), 4);
-            (void) memcpy((void *)(pc + 16), (void *)(&len), 4);
+            GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
+            (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
+            (void) memcpy((void *) (pc + 8), (void *) (&target), 4);
+            (void) memcpy((void *) (pc + 12), (void *) (&format), 4);
+            (void) memcpy((void *) (pc + 16), (void *) (&len), 4);
             __glXSendLargeCommand(gc, pc, 20, string, len);
         }
     }
@@ -6071,510 +7191,589 @@ __indirect_glProgramStringARB(GLenum target, GLenum format, GLsizei len, const G
 void
 __indirect_glVertexAttrib1dARB(GLuint index, GLdouble x)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib1dvARB 4197
 void
 __indirect_glVertexAttrib1dvARB(GLuint index, const GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib1dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib1fvARB 4193
 void
 __indirect_glVertexAttrib1fARB(GLuint index, GLfloat x)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib1fvARB 4193
 void
 __indirect_glVertexAttrib1fvARB(GLuint index, const GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib1fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib1svARB 4189
 void
 __indirect_glVertexAttrib1sARB(GLuint index, GLshort x)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib1svARB 4189
 void
 __indirect_glVertexAttrib1svARB(GLuint index, const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib1svARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib2dvARB 4198
 void
 __indirect_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib2dvARB 4198
 void
 __indirect_glVertexAttrib2dvARB(GLuint index, const GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_VertexAttrib2dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib2fvARB 4194
 void
 __indirect_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib2fvARB 4194
 void
 __indirect_glVertexAttrib2fvARB(GLuint index, const GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib2fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib2svARB 4190
 void
 __indirect_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
-    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
+    (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib2svARB 4190
 void
 __indirect_glVertexAttrib2svARB(GLuint index, const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib2svARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib3dvARB 4199
 void
-__indirect_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z)
+__indirect_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y,
+                               GLdouble z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 32;
     emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
-    (void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
+    (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib3dvARB 4199
 void
 __indirect_glVertexAttrib3dvARB(GLuint index, const GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 32;
     emit_header(gc->pc, X_GLrop_VertexAttrib3dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 24);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 24);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib3fvARB 4195
 void
 __indirect_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib3fvARB 4195
 void
 __indirect_glVertexAttrib3fvARB(GLuint index, const GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_VertexAttrib3fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib3svARB 4191
 void
 __indirect_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
-    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
+    (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib3svARB 4191
 void
 __indirect_glVertexAttrib3svARB(GLuint index, const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib3svARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 6);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4NbvARB 4235
 void
 __indirect_glVertexAttrib4NbvARB(GLuint index, const GLbyte * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib4NbvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4NivARB 4237
 void
 __indirect_glVertexAttrib4NivARB(GLuint index, const GLint * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_VertexAttrib4NivARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4NsvARB 4236
 void
 __indirect_glVertexAttrib4NsvARB(GLuint index, const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib4NsvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4NubvARB 4201
 void
-__indirect_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
+__indirect_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y,
+                                 GLubyte z, GLubyte w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1);
-    (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1);
-    (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1);
-    (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 1);
+    (void) memcpy((void *) (gc->pc + 9), (void *) (&y), 1);
+    (void) memcpy((void *) (gc->pc + 10), (void *) (&z), 1);
+    (void) memcpy((void *) (gc->pc + 11), (void *) (&w), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4NubvARB 4201
 void
 __indirect_glVertexAttrib4NubvARB(GLuint index, const GLubyte * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib4NubvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4NuivARB 4239
 void
 __indirect_glVertexAttrib4NuivARB(GLuint index, const GLuint * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_VertexAttrib4NuivARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4NusvARB 4238
 void
 __indirect_glVertexAttrib4NusvARB(GLuint index, const GLushort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib4NusvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4bvARB 4230
 void
 __indirect_glVertexAttrib4bvARB(GLuint index, const GLbyte * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib4bvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4dvARB 4200
 void
-__indirect_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+__indirect_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y,
+                               GLdouble z, GLdouble w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 40;
     emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
-    (void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8);
-    (void) memcpy((void *)(gc->pc + 32), (void *)(&w), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
+    (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8);
+    (void) memcpy((void *) (gc->pc + 32), (void *) (&w), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4dvARB 4200
 void
 __indirect_glVertexAttrib4dvARB(GLuint index, const GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 40;
     emit_header(gc->pc, X_GLrop_VertexAttrib4dvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 32);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 32);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4fvARB 4196
 void
-__indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+__indirect_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z,
+                               GLfloat w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&w), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4fvARB 4196
 void
 __indirect_glVertexAttrib4fvARB(GLuint index, const GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_VertexAttrib4fvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4ivARB 4231
 void
 __indirect_glVertexAttrib4ivARB(GLuint index, const GLint * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_VertexAttrib4ivARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4svARB 4192
 void
-__indirect_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
+__indirect_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z,
+                               GLshort w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
-    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
-    (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
+    (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2);
+    (void) memcpy((void *) (gc->pc + 14), (void *) (&w), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4svARB 4192
 void
 __indirect_glVertexAttrib4svARB(GLuint index, const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib4svARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4ubvARB 4232
 void
 __indirect_glVertexAttrib4ubvARB(GLuint index, const GLubyte * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib4ubvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4uivARB 4234
 void
 __indirect_glVertexAttrib4uivARB(GLuint index, const GLuint * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_VertexAttrib4uivARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4usvARB 4233
 void
 __indirect_glVertexAttrib4usvARB(GLuint index, const GLushort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib4usvARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_BeginQueryARB 231
 void
 __indirect_glBeginQueryARB(GLenum target, GLuint id)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_BeginQueryARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&id), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLsop_DeleteQueriesARB 161
 void
 __indirect_glDeleteQueriesARB(GLsizei n, const GLuint * ids)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
 #ifdef USE_XCB
@@ -6582,10 +7781,12 @@ __indirect_glDeleteQueriesARB(GLsizei n, const GLuint * ids)
         (void) __glXFlushRenderBuffer(gc, gc->pc);
         xcb_glx_delete_queries_arb(c, gc->currentContextTag, n, ids);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_DeleteQueriesARB, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4));
-        UnlockDisplay(dpy); SyncHandle();
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_DeleteQueriesARB, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (ids), (n * 4));
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -6595,33 +7796,44 @@ __indirect_glDeleteQueriesARB(GLsizei n, const GLuint * ids)
 void
 __indirect_glEndQueryARB(GLenum target)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_EndQueryARB, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLsop_GenQueriesARB 162
 void
 __indirect_glGenQueriesARB(GLsizei n, GLuint * ids)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 4;
     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_gen_queries_arb_reply_t *reply = xcb_glx_gen_queries_arb_reply(c, xcb_glx_gen_queries_arb(c, gc->currentContextTag, n), NULL);
-        (void)memcpy(ids, xcb_glx_gen_queries_arb_data(reply), xcb_glx_gen_queries_arb_data_length(reply) * sizeof(GLuint));
+        xcb_glx_gen_queries_arb_reply_t *reply =
+            xcb_glx_gen_queries_arb_reply(c,
+                                          xcb_glx_gen_queries_arb(c,
+                                                                  gc->
+                                                                  currentContextTag,
+                                                                  n), NULL);
+        (void) memcpy(ids, xcb_glx_gen_queries_arb_data(reply),
+                      xcb_glx_gen_queries_arb_data_length(reply) *
+                      sizeof(GLuint));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GenQueriesARB, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GenQueriesARB, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
         (void) __glXReadReply(dpy, 4, ids, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -6631,25 +7843,33 @@ __indirect_glGenQueriesARB(GLsizei n, GLuint * ids)
 void
 __indirect_glGetQueryObjectivARB(GLuint id, GLenum pname, GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_query_objectiv_arb_reply_t *reply = xcb_glx_get_query_objectiv_arb_reply(c, xcb_glx_get_query_objectiv_arb(c, gc->currentContextTag, id, pname), NULL);
+        xcb_glx_get_query_objectiv_arb_reply_t *reply =
+            xcb_glx_get_query_objectiv_arb_reply(c,
+                                                 xcb_glx_get_query_objectiv_arb
+                                                 (c, gc->currentContextTag,
+                                                  id, pname), NULL);
         if (xcb_glx_get_query_objectiv_arb_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_query_objectiv_arb_data(reply), xcb_glx_get_query_objectiv_arb_data_length(reply) * sizeof(GLint));
+            (void) memcpy(params, xcb_glx_get_query_objectiv_arb_data(reply),
+                          xcb_glx_get_query_objectiv_arb_data_length(reply) *
+                          sizeof(GLint));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectivARB, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectivARB, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -6659,25 +7879,33 @@ __indirect_glGetQueryObjectivARB(GLuint id, GLenum pname, GLint * params)
 void
 __indirect_glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_query_objectuiv_arb_reply_t *reply = xcb_glx_get_query_objectuiv_arb_reply(c, xcb_glx_get_query_objectuiv_arb(c, gc->currentContextTag, id, pname), NULL);
+        xcb_glx_get_query_objectuiv_arb_reply_t *reply =
+            xcb_glx_get_query_objectuiv_arb_reply(c,
+                                                  xcb_glx_get_query_objectuiv_arb
+                                                  (c, gc->currentContextTag,
+                                                   id, pname), NULL);
         if (xcb_glx_get_query_objectuiv_arb_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_query_objectuiv_arb_data(reply), xcb_glx_get_query_objectuiv_arb_data_length(reply) * sizeof(GLuint));
+            (void) memcpy(params, xcb_glx_get_query_objectuiv_arb_data(reply),
+                          xcb_glx_get_query_objectuiv_arb_data_length(reply) *
+                          sizeof(GLuint));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectuivARB, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetQueryObjectuivARB, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -6687,25 +7915,36 @@ __indirect_glGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint * params)
 void
 __indirect_glGetQueryivARB(GLenum target, GLenum pname, GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_get_queryiv_arb_reply_t *reply = xcb_glx_get_queryiv_arb_reply(c, xcb_glx_get_queryiv_arb(c, gc->currentContextTag, target, pname), NULL);
+        xcb_glx_get_queryiv_arb_reply_t *reply =
+            xcb_glx_get_queryiv_arb_reply(c,
+                                          xcb_glx_get_queryiv_arb(c,
+                                                                  gc->
+                                                                  currentContextTag,
+                                                                  target,
+                                                                  pname),
+                                          NULL);
         if (xcb_glx_get_queryiv_arb_data_length(reply) == 0)
-            (void)memcpy(params, &reply->datum, sizeof(reply->datum));
+            (void) memcpy(params, &reply->datum, sizeof(reply->datum));
         else
-        (void)memcpy(params, xcb_glx_get_queryiv_arb_data(reply), xcb_glx_get_queryiv_arb_data_length(reply) * sizeof(GLint));
+            (void) memcpy(params, xcb_glx_get_queryiv_arb_data(reply),
+                          xcb_glx_get_queryiv_arb_data_length(reply) *
+                          sizeof(GLint));
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_GetQueryivARB, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_GetQueryivARB, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return;
@@ -6715,22 +7954,29 @@ __indirect_glGetQueryivARB(GLenum target, GLenum pname, GLint * params)
 GLboolean
 __indirect_glIsQueryARB(GLuint id)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     GLboolean retval = (GLboolean) 0;
     const GLuint cmdlen = 4;
     if (__builtin_expect(dpy != NULL, 1)) {
 #ifdef USE_XCB
         xcb_connection_t *c = XGetXCBConnection(dpy);
         (void) __glXFlushRenderBuffer(gc, gc->pc);
-        xcb_glx_is_query_arb_reply_t *reply = xcb_glx_is_query_arb_reply(c, xcb_glx_is_query_arb(c, gc->currentContextTag, id), NULL);
+        xcb_glx_is_query_arb_reply_t *reply =
+            xcb_glx_is_query_arb_reply(c,
+                                       xcb_glx_is_query_arb(c,
+                                                            gc->
+                                                            currentContextTag,
+                                                            id), NULL);
         retval = reply->ret_val;
         free(reply);
 #else
-        GLubyte const * pc = __glXSetupSingleRequest(gc, X_GLsop_IsQueryARB, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
+        GLubyte const *pc =
+            __glXSetupSingleRequest(gc, X_GLsop_IsQueryARB, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
         retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
 #endif /* USE_XCB */
     }
     return retval;
@@ -6740,26 +7986,27 @@ __indirect_glIsQueryARB(GLuint id)
 void
 __indirect_glDrawBuffersARB(GLsizei n, const GLenum * bufs)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
     if (__builtin_expect((n >= 0) && (gc->currentDpy != NULL), 1)) {
         if (cmdlen <= gc->maxSmallRenderCommandSize) {
-            if ( (gc->pc + cmdlen) > gc->bufEnd ) {
+            if ((gc->pc + cmdlen) > gc->bufEnd) {
                 (void) __glXFlushRenderBuffer(gc, gc->pc);
             }
             emit_header(gc->pc, X_GLrop_DrawBuffersARB, cmdlen);
-            (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
-            (void) memcpy((void *)(gc->pc + 8), (void *)(bufs), (n * 4));
+            (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
+            (void) memcpy((void *) (gc->pc + 8), (void *) (bufs), (n * 4));
             gc->pc += cmdlen;
-            if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
-        }
-        else {
+            if (__builtin_expect(gc->pc > gc->limit, 0)) {
+                (void) __glXFlushRenderBuffer(gc, gc->pc);
+            }
+        } else {
             const GLint op = X_GLrop_DrawBuffersARB;
             const GLuint cmdlenLarge = cmdlen + 4;
-            GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
-            (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
-            (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
-            (void) memcpy((void *)(pc + 8), (void *)(&n), 4);
+            GLubyte *const pc = __glXFlushRenderBuffer(gc, gc->pc);
+            (void) memcpy((void *) (pc + 0), (void *) (&cmdlenLarge), 4);
+            (void) memcpy((void *) (pc + 4), (void *) (&op), 4);
+            (void) memcpy((void *) (pc + 8), (void *) (&n), 4);
             __glXSendLargeCommand(gc, pc, 12, bufs, (n * 4));
         }
     }
@@ -6767,73 +8014,92 @@ __indirect_glDrawBuffersARB(GLsizei n, const GLenum * bufs)
 
 #define X_GLvop_GetColorTableParameterfvSGI 4099
 void
-__indirect_glGetColorTableParameterfvSGI(GLenum target, GLenum pname, GLfloat * params)
+__indirect_glGetColorTableParameterfvSGI(GLenum target, GLenum pname,
+                                         GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetColorTableParameterfvSGI, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GetColorTableParameterfvSGI,
+                                    cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
 
 #define X_GLvop_GetColorTableParameterivSGI 4100
 void
-__indirect_glGetColorTableParameterivSGI(GLenum target, GLenum pname, GLint * params)
+__indirect_glGetColorTableParameterivSGI(GLenum target, GLenum pname,
+                                         GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetColorTableParameterivSGI, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GetColorTableParameterivSGI,
+                                    cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
 
 #define X_GLvop_GetColorTableSGI 4098
 void
-__indirect_glGetColorTableSGI(GLenum target, GLenum format, GLenum type, GLvoid * table)
+__indirect_glGetColorTableSGI(GLenum target, GLenum format, GLenum type,
+                              GLvoid * table)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    const __GLXattribute * const state = gc->client_state_private;
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    const __GLXattribute *const state = gc->client_state_private;
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 16;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetColorTableSGI, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&format), 4);
-        (void) memcpy((void *)(pc + 8), (void *)(&type), 4);
-        *(int32_t *)(pc + 12) = 0;
-        * (int8_t *)(pc + 12) = state->storePack.swapEndian;
-        __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GetColorTableSGI, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&format), 4);
+        (void) memcpy((void *) (pc + 8), (void *) (&type), 4);
+        *(int32_t *) (pc + 12) = 0;
+        *(int8_t *) (pc + 12) = state->storePack.swapEndian;
+        __glXReadPixelReply(dpy, gc, 1, 0, 0, 0, format, type, table,
+                            GL_TRUE);
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
 
 #define X_GLvop_AreTexturesResidentEXT 11
 GLboolean
-__indirect_glAreTexturesResidentEXT(GLsizei n, const GLuint * textures, GLboolean * residences)
+__indirect_glAreTexturesResidentEXT(GLsizei n, const GLuint * textures,
+                                    GLboolean * residences)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     GLboolean retval = (GLboolean) 0;
     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreTexturesResidentEXT, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_AreTexturesResidentEXT, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (textures), (n * 4));
         retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return retval;
 }
@@ -6842,14 +8108,17 @@ __indirect_glAreTexturesResidentEXT(GLsizei n, const GLuint * textures, GLboolea
 void
 __indirect_glGenTexturesEXT(GLsizei n, GLuint * textures)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 4;
     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenTexturesEXT, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GenTexturesEXT, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
         (void) __glXReadReply(dpy, 4, textures, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
@@ -6858,15 +8127,18 @@ __indirect_glGenTexturesEXT(GLsizei n, GLuint * textures)
 GLboolean
 __indirect_glIsTextureEXT(GLuint texture)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     GLboolean retval = (GLboolean) 0;
     const GLuint cmdlen = 4;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsTextureEXT, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_IsTextureEXT, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&texture), 4);
         retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return retval;
 }
@@ -6875,310 +8147,347 @@ __indirect_glIsTextureEXT(GLuint texture)
 void
 __indirect_glSampleMaskSGIS(GLclampf value, GLboolean invert)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_SampleMaskSGIS, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&value), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&invert), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_SamplePatternSGIS 2049
 void
 __indirect_glSamplePatternSGIS(GLenum pattern)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_SamplePatternSGIS, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&pattern), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&pattern), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PointParameterfEXT 2065
 void
 __indirect_glPointParameterfEXT(GLenum pname, GLfloat param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_PointParameterfEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PointParameterfvEXT 2066
 void
 __indirect_glPointParameterfvEXT(GLenum pname, const GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glPointParameterfvEXT_size(pname);
     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_PointParameterfvEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_SecondaryColor3bvEXT 4126
 void
 __indirect_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_SecondaryColor3bvEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
-    (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
+    (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_SecondaryColor3bvEXT 4126
 void
 __indirect_glSecondaryColor3bvEXT(const GLbyte * v)
 {
-    generic_3_byte( X_GLrop_SecondaryColor3bvEXT, v );
+    generic_3_byte(X_GLrop_SecondaryColor3bvEXT, v);
 }
 
 #define X_GLrop_SecondaryColor3dvEXT 4130
 void
 __indirect_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_SecondaryColor3dvEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 8);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&green), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&blue), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_SecondaryColor3dvEXT 4130
 void
 __indirect_glSecondaryColor3dvEXT(const GLdouble * v)
 {
-    generic_24_byte( X_GLrop_SecondaryColor3dvEXT, v );
+    generic_24_byte(X_GLrop_SecondaryColor3dvEXT, v);
 }
 
 #define X_GLrop_SecondaryColor3fvEXT 4129
 void
 __indirect_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_SecondaryColor3fvEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_SecondaryColor3fvEXT 4129
 void
 __indirect_glSecondaryColor3fvEXT(const GLfloat * v)
 {
-    generic_12_byte( X_GLrop_SecondaryColor3fvEXT, v );
+    generic_12_byte(X_GLrop_SecondaryColor3fvEXT, v);
 }
 
 #define X_GLrop_SecondaryColor3ivEXT 4128
 void
 __indirect_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_SecondaryColor3ivEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_SecondaryColor3ivEXT 4128
 void
 __indirect_glSecondaryColor3ivEXT(const GLint * v)
 {
-    generic_12_byte( X_GLrop_SecondaryColor3ivEXT, v );
+    generic_12_byte(X_GLrop_SecondaryColor3ivEXT, v);
 }
 
 #define X_GLrop_SecondaryColor3svEXT 4127
 void
 __indirect_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_SecondaryColor3svEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_SecondaryColor3svEXT 4127
 void
 __indirect_glSecondaryColor3svEXT(const GLshort * v)
 {
-    generic_6_byte( X_GLrop_SecondaryColor3svEXT, v );
+    generic_6_byte(X_GLrop_SecondaryColor3svEXT, v);
 }
 
 #define X_GLrop_SecondaryColor3ubvEXT 4131
 void
 __indirect_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_SecondaryColor3ubvEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
-    (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 1);
+    (void) memcpy((void *) (gc->pc + 5), (void *) (&green), 1);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&blue), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_SecondaryColor3ubvEXT 4131
 void
 __indirect_glSecondaryColor3ubvEXT(const GLubyte * v)
 {
-    generic_3_byte( X_GLrop_SecondaryColor3ubvEXT, v );
+    generic_3_byte(X_GLrop_SecondaryColor3ubvEXT, v);
 }
 
 #define X_GLrop_SecondaryColor3uivEXT 4133
 void
 __indirect_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_SecondaryColor3uivEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&green), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&blue), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_SecondaryColor3uivEXT 4133
 void
 __indirect_glSecondaryColor3uivEXT(const GLuint * v)
 {
-    generic_12_byte( X_GLrop_SecondaryColor3uivEXT, v );
+    generic_12_byte(X_GLrop_SecondaryColor3uivEXT, v);
 }
 
 #define X_GLrop_SecondaryColor3usvEXT 4132
 void
 __indirect_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_SecondaryColor3usvEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
-    (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&red), 2);
+    (void) memcpy((void *) (gc->pc + 6), (void *) (&green), 2);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&blue), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_SecondaryColor3usvEXT 4132
 void
 __indirect_glSecondaryColor3usvEXT(const GLushort * v)
 {
-    generic_6_byte( X_GLrop_SecondaryColor3usvEXT, v );
+    generic_6_byte(X_GLrop_SecondaryColor3usvEXT, v);
 }
 
 #define X_GLrop_FogCoorddvEXT 4125
 void
 __indirect_glFogCoorddEXT(GLdouble coord)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_FogCoorddvEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_FogCoorddvEXT 4125
 void
 __indirect_glFogCoorddvEXT(const GLdouble * coord)
 {
-    generic_8_byte( X_GLrop_FogCoorddvEXT, coord );
+    generic_8_byte(X_GLrop_FogCoorddvEXT, coord);
 }
 
 #define X_GLrop_FogCoordfvEXT 4124
 void
 __indirect_glFogCoordfEXT(GLfloat coord)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_FogCoordfvEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&coord), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_FogCoordfvEXT 4124
 void
 __indirect_glFogCoordfvEXT(const GLfloat * coord)
 {
-    generic_4_byte( X_GLrop_FogCoordfvEXT, coord );
+    generic_4_byte(X_GLrop_FogCoordfvEXT, coord);
 }
 
 #define X_GLrop_BlendFuncSeparateEXT 4134
 void
-__indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
+__indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB,
+                                  GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_BlendFuncSeparateEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&sfactorRGB), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&dfactorRGB), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&sfactorAlpha), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&dfactorAlpha), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&sfactorRGB), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&dfactorRGB), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&sfactorAlpha), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&dfactorAlpha), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_WindowPos3fvMESA 230
 void
 __indirect_glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_WindowPos3fvMESA, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_WindowPos3fvMESA 230
 void
 __indirect_glWindowPos3fvMESA(const GLfloat * v)
 {
-    generic_12_byte( X_GLrop_WindowPos3fvMESA, v );
+    generic_12_byte(X_GLrop_WindowPos3fvMESA, v);
 }
 
 #define X_GLvop_AreProgramsResidentNV 1293
 GLboolean
-__indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids, GLboolean * residences)
+__indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids,
+                                   GLboolean * residences)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     GLboolean retval = (GLboolean) 0;
     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreProgramsResidentNV, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(ids), (n * 4));
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_AreProgramsResidentNV, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (ids), (n * 4));
         retval = (GLboolean) __glXReadReply(dpy, 1, residences, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return retval;
 }
@@ -7187,93 +8496,112 @@ __indirect_glAreProgramsResidentNV(GLsizei n, const GLuint * ids, GLboolean * re
 void
 __indirect_glBindProgramNV(GLenum target, GLuint program)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_BindProgramNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&program), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&program), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLvop_DeleteProgramsNV 1294
 void
 __indirect_glDeleteProgramsNV(GLsizei n, const GLuint * programs)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivate, X_GLvop_DeleteProgramsNV, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(programs), (n * 4));
-        UnlockDisplay(dpy); SyncHandle();
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivate,
+                                    X_GLvop_DeleteProgramsNV, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (programs), (n * 4));
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
 
 #define X_GLrop_ExecuteProgramNV 4181
 void
-__indirect_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat * params)
+__indirect_glExecuteProgramNV(GLenum target, GLuint id,
+                              const GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_ExecuteProgramNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&id), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), 16);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLvop_GenProgramsNV 1295
 void
 __indirect_glGenProgramsNV(GLsizei n, GLuint * programs)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 4;
     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenProgramsNV, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GenProgramsNV, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
         (void) __glXReadReply(dpy, 4, programs, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
 
 #define X_GLvop_GetProgramParameterdvNV 1297
 void
-__indirect_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble * params)
+__indirect_glGetProgramParameterdvNV(GLenum target, GLuint index,
+                                     GLenum pname, GLdouble * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 12;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramParameterdvNV, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&index), 4);
-        (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GetProgramParameterdvNV, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&index), 4);
+        (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 8, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
 
 #define X_GLvop_GetProgramParameterfvNV 1296
 void
-__indirect_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat * params)
+__indirect_glGetProgramParameterfvNV(GLenum target, GLuint index,
+                                     GLenum pname, GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 12;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramParameterfvNV, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&index), 4);
-        (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GetProgramParameterfvNV, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&index), 4);
+        (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
@@ -7282,15 +8610,18 @@ __indirect_glGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname,
 void
 __indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramStringNV, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GetProgramStringNV, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 1, program, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
@@ -7299,50 +8630,61 @@ __indirect_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte * program)
 void
 __indirect_glGetProgramivNV(GLuint id, GLenum pname, GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramivNV, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GetProgramivNV, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
 
 #define X_GLvop_GetTrackMatrixivNV 1300
 void
-__indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint * params)
+__indirect_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname,
+                                GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 12;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetTrackMatrixivNV, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&address), 4);
-        (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GetTrackMatrixivNV, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&address), 4);
+        (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
 
 #define X_GLvop_GetVertexAttribdvNV 1301
 void
-__indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * params)
+__indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname,
+                                 GLdouble * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribdvNV, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GetVertexAttribdvNV, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&index), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 8, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
@@ -7351,15 +8693,18 @@ __indirect_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble * params)
 void
 __indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribfvNV, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GetVertexAttribfvNV, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&index), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
@@ -7368,15 +8713,18 @@ __indirect_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat * params)
 void
 __indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetVertexAttribivNV, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&index), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GetVertexAttribivNV, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&index), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
@@ -7385,129 +8733,153 @@ __indirect_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint * params)
 GLboolean
 __indirect_glIsProgramNV(GLuint program)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     GLboolean retval = (GLboolean) 0;
     const GLuint cmdlen = 4;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsProgramNV, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&program), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_IsProgramNV, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&program), 4);
         retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return retval;
 }
 
 #define X_GLrop_LoadProgramNV 4183
 void
-__indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte * program)
+__indirect_glLoadProgramNV(GLenum target, GLuint id, GLsizei len,
+                           const GLubyte * program)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16 + __GLX_PAD(len);
     if (__builtin_expect(len >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_LoadProgramNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&id), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(&len), 4);
-        (void) memcpy((void *)(gc->pc + 16), (void *)(program), len);
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&id), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (&len), 4);
+        (void) memcpy((void *) (gc->pc + 16), (void *) (program), len);
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
 #define X_GLrop_ProgramParameter4dvNV 4185
 void
-__indirect_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+__indirect_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x,
+                                  GLdouble y, GLdouble z, GLdouble w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 44;
     emit_header(gc->pc, X_GLrop_ProgramParameter4dvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
-    (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
-    (void) memcpy((void *)(gc->pc + 36), (void *)(&w), 8);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&y), 8);
+    (void) memcpy((void *) (gc->pc + 28), (void *) (&z), 8);
+    (void) memcpy((void *) (gc->pc + 36), (void *) (&w), 8);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ProgramParameter4dvNV 4185
 void
-__indirect_glProgramParameter4dvNV(GLenum target, GLuint index, const GLdouble * params)
+__indirect_glProgramParameter4dvNV(GLenum target, GLuint index,
+                                   const GLdouble * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 44;
     emit_header(gc->pc, X_GLrop_ProgramParameter4dvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 32);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), 32);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ProgramParameter4fvNV 4184
 void
-__indirect_glProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+__indirect_glProgramParameter4fNV(GLenum target, GLuint index, GLfloat x,
+                                  GLfloat y, GLfloat z, GLfloat w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_ProgramParameter4fvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
-    (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 4);
+    (void) memcpy((void *) (gc->pc + 24), (void *) (&w), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ProgramParameter4fvNV 4184
 void
-__indirect_glProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat * params)
+__indirect_glProgramParameter4fvNV(GLenum target, GLuint index,
+                                   const GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_ProgramParameter4fvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(params), 16);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (params), 16);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ProgramParameters4dvNV 4187
 void
-__indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLuint num, const GLdouble * params)
+__indirect_glProgramParameters4dvNV(GLenum target, GLuint index, GLuint num,
+                                    const GLdouble * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16 + __GLX_PAD((num * 32));
     if (__builtin_expect(num >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_ProgramParameters4dvNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4);
-        (void) memcpy((void *)(gc->pc + 16), (void *)(params), (num * 32));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (&num), 4);
+        (void) memcpy((void *) (gc->pc + 16), (void *) (params), (num * 32));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
 #define X_GLrop_ProgramParameters4fvNV 4186
 void
-__indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint num, const GLfloat * params)
+__indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint num,
+                                    const GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16 + __GLX_PAD((num * 16));
     if (__builtin_expect(num >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_ProgramParameters4fvNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&index), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(&num), 4);
-        (void) memcpy((void *)(gc->pc + 16), (void *)(params), (num * 16));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&index), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (&num), 4);
+        (void) memcpy((void *) (gc->pc + 16), (void *) (params), (num * 16));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
@@ -7515,404 +8887,468 @@ __indirect_glProgramParameters4fvNV(GLenum target, GLuint index, GLuint num, con
 void
 __indirect_glRequestResidentProgramsNV(GLsizei n, const GLuint * ids)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
     if (__builtin_expect(n >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_RequestResidentProgramsNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(ids), (n * 4));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (ids), (n * 4));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
 #define X_GLrop_TrackMatrixNV 4188
 void
-__indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform)
+__indirect_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix,
+                           GLenum transform)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_TrackMatrixNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&address), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&matrix), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&transform), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&address), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&matrix), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&transform), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib1dvNV 4273
 void
 __indirect_glVertexAttrib1dNV(GLuint index, GLdouble x)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib1dvNV 4273
 void
 __indirect_glVertexAttrib1dvNV(GLuint index, const GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib1dvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib1fvNV 4269
 void
 __indirect_glVertexAttrib1fNV(GLuint index, GLfloat x)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib1fvNV 4269
 void
 __indirect_glVertexAttrib1fvNV(GLuint index, const GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib1fvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib1svNV 4265
 void
 __indirect_glVertexAttrib1sNV(GLuint index, GLshort x)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib1svNV 4265
 void
 __indirect_glVertexAttrib1svNV(GLuint index, const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib1svNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib2dvNV 4274
 void
 __indirect_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib2dvNV 4274
 void
 __indirect_glVertexAttrib2dvNV(GLuint index, const GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_VertexAttrib2dvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib2fvNV 4270
 void
 __indirect_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib2fvNV 4270
 void
 __indirect_glVertexAttrib2fvNV(GLuint index, const GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib2fvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib2svNV 4266
 void
 __indirect_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
-    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
+    (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib2svNV 4266
 void
 __indirect_glVertexAttrib2svNV(GLuint index, const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib2svNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib3dvNV 4275
 void
-__indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z)
+__indirect_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y,
+                              GLdouble z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 32;
     emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
-    (void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
+    (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib3dvNV 4275
 void
 __indirect_glVertexAttrib3dvNV(GLuint index, const GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 32;
     emit_header(gc->pc, X_GLrop_VertexAttrib3dvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 24);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 24);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib3fvNV 4271
 void
 __indirect_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib3fvNV 4271
 void
 __indirect_glVertexAttrib3fvNV(GLuint index, const GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_VertexAttrib3fvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 12);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib3svNV 4267
 void
 __indirect_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
-    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
+    (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib3svNV 4267
 void
 __indirect_glVertexAttrib3svNV(GLuint index, const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib3svNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 6);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4dvNV 4276
 void
-__indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+__indirect_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y,
+                              GLdouble z, GLdouble w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 40;
     emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 8);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 8);
-    (void) memcpy((void *)(gc->pc + 24), (void *)(&z), 8);
-    (void) memcpy((void *)(gc->pc + 32), (void *)(&w), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 8);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 8);
+    (void) memcpy((void *) (gc->pc + 24), (void *) (&z), 8);
+    (void) memcpy((void *) (gc->pc + 32), (void *) (&w), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4dvNV 4276
 void
 __indirect_glVertexAttrib4dvNV(GLuint index, const GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 40;
     emit_header(gc->pc, X_GLrop_VertexAttrib4dvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 32);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 32);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4fvNV 4272
 void
-__indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+__indirect_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z,
+                              GLfloat w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&w), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&z), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&w), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4fvNV 4272
 void
 __indirect_glVertexAttrib4fvNV(GLuint index, const GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_VertexAttrib4fvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 16);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4svNV 4268
 void
-__indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
+__indirect_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z,
+                              GLshort w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 2);
-    (void) memcpy((void *)(gc->pc + 10), (void *)(&y), 2);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 2);
-    (void) memcpy((void *)(gc->pc + 14), (void *)(&w), 2);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 2);
+    (void) memcpy((void *) (gc->pc + 10), (void *) (&y), 2);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&z), 2);
+    (void) memcpy((void *) (gc->pc + 14), (void *) (&w), 2);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4svNV 4268
 void
 __indirect_glVertexAttrib4svNV(GLuint index, const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 16;
     emit_header(gc->pc, X_GLrop_VertexAttrib4svNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 8);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4ubvNV 4277
 void
-__indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
+__indirect_glVertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z,
+                               GLubyte w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 1);
-    (void) memcpy((void *)(gc->pc + 9), (void *)(&y), 1);
-    (void) memcpy((void *)(gc->pc + 10), (void *)(&z), 1);
-    (void) memcpy((void *)(gc->pc + 11), (void *)(&w), 1);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&x), 1);
+    (void) memcpy((void *) (gc->pc + 9), (void *) (&y), 1);
+    (void) memcpy((void *) (gc->pc + 10), (void *) (&z), 1);
+    (void) memcpy((void *) (gc->pc + 11), (void *) (&w), 1);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttrib4ubvNV 4277
 void
 __indirect_glVertexAttrib4ubvNV(GLuint index, const GLubyte * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_VertexAttrib4ubvNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (v), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_VertexAttribs1dvNV 4210
 void
 __indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
     if (__builtin_expect(n >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_VertexAttribs1dvNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 8));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
@@ -7920,15 +9356,17 @@ __indirect_glVertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v)
 void
 __indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
     if (__builtin_expect(n >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_VertexAttribs1fvNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 4));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
@@ -7936,15 +9374,17 @@ __indirect_glVertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v)
 void
 __indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12 + __GLX_PAD((n * 2));
     if (__builtin_expect(n >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_VertexAttribs1svNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 2));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 2));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
@@ -7952,15 +9392,17 @@ __indirect_glVertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v)
 void
 __indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12 + __GLX_PAD((n * 16));
     if (__builtin_expect(n >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_VertexAttribs2dvNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 16));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 16));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
@@ -7968,15 +9410,17 @@ __indirect_glVertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v)
 void
 __indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
     if (__builtin_expect(n >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_VertexAttribs2fvNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 8));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
@@ -7984,15 +9428,17 @@ __indirect_glVertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v)
 void
 __indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
     if (__builtin_expect(n >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_VertexAttribs2svNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 4));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
@@ -8000,15 +9446,17 @@ __indirect_glVertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v)
 void
 __indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12 + __GLX_PAD((n * 24));
     if (__builtin_expect(n >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_VertexAttribs3dvNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 24));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 24));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
@@ -8016,15 +9464,17 @@ __indirect_glVertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v)
 void
 __indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12 + __GLX_PAD((n * 12));
     if (__builtin_expect(n >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_VertexAttribs3fvNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 12));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 12));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
@@ -8032,15 +9482,17 @@ __indirect_glVertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v)
 void
 __indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12 + __GLX_PAD((n * 6));
     if (__builtin_expect(n >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_VertexAttribs3svNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 6));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 6));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
@@ -8048,15 +9500,17 @@ __indirect_glVertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v)
 void
 __indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12 + __GLX_PAD((n * 32));
     if (__builtin_expect(n >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_VertexAttribs4dvNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 32));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 32));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
@@ -8064,15 +9518,17 @@ __indirect_glVertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v)
 void
 __indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12 + __GLX_PAD((n * 16));
     if (__builtin_expect(n >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_VertexAttribs4fvNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 16));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 16));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
@@ -8080,15 +9536,17 @@ __indirect_glVertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v)
 void
 __indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12 + __GLX_PAD((n * 8));
     if (__builtin_expect(n >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_VertexAttribs4svNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 8));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 8));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
@@ -8096,15 +9554,17 @@ __indirect_glVertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v)
 void
 __indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12 + __GLX_PAD((n * 4));
     if (__builtin_expect(n >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_VertexAttribs4ubvNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&index), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&n), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(v), (n * 4));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&index), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&n), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (v), (n * 4));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
@@ -8112,148 +9572,182 @@ __indirect_glVertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte * v)
 void
 __indirect_glPointParameteriNV(GLenum pname, GLint param)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&param), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_PointParameterivNV 4222
 void
 __indirect_glPointParameterivNV(GLenum pname, const GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint compsize = __glPointParameterivNV_size(pname);
     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
     emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&pname), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (params), (compsize * 4));
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_ActiveStencilFaceEXT 4220
 void
 __indirect_glActiveStencilFaceEXT(GLenum face)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&face), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLvop_GetProgramNamedParameterdvNV 1311
 void
-__indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble * params)
+__indirect_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len,
+                                          const GLubyte * name,
+                                          GLdouble * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8 + __GLX_PAD(len);
     if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramNamedParameterdvNV, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&len), 4);
-        (void) memcpy((void *)(pc + 8), (void *)(name), len);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GetProgramNamedParameterdvNV,
+                                    cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&len), 4);
+        (void) memcpy((void *) (pc + 8), (void *) (name), len);
         (void) __glXReadReply(dpy, 8, params, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
 
 #define X_GLvop_GetProgramNamedParameterfvNV 1310
 void
-__indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat * params)
+__indirect_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len,
+                                          const GLubyte * name,
+                                          GLfloat * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8 + __GLX_PAD(len);
     if (__builtin_expect((len >= 0) && (dpy != NULL), 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetProgramNamedParameterfvNV, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&id), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&len), 4);
-        (void) memcpy((void *)(pc + 8), (void *)(name), len);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GetProgramNamedParameterfvNV,
+                                    cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&id), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&len), 4);
+        (void) memcpy((void *) (pc + 8), (void *) (name), len);
         (void) __glXReadReply(dpy, 4, params, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
 
 #define X_GLrop_ProgramNamedParameter4dvNV 4219
 void
-__indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte * name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+__indirect_glProgramNamedParameter4dNV(GLuint id, GLsizei len,
+                                       const GLubyte * name, GLdouble x,
+                                       GLdouble y, GLdouble z, GLdouble w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 44 + __GLX_PAD(len);
     if (__builtin_expect(len >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
-        (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
-        (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
-        (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4);
-        (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4);
-        (void) memcpy((void *)(gc->pc + 44), (void *)(name), len);
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&x), 8);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (&y), 8);
+        (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 8);
+        (void) memcpy((void *) (gc->pc + 28), (void *) (&w), 8);
+        (void) memcpy((void *) (gc->pc + 36), (void *) (&id), 4);
+        (void) memcpy((void *) (gc->pc + 40), (void *) (&len), 4);
+        (void) memcpy((void *) (gc->pc + 44), (void *) (name), len);
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
 #define X_GLrop_ProgramNamedParameter4dvNV 4219
 void
-__indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte * name, const GLdouble * v)
+__indirect_glProgramNamedParameter4dvNV(GLuint id, GLsizei len,
+                                        const GLubyte * name,
+                                        const GLdouble * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 44 + __GLX_PAD(len);
     if (__builtin_expect(len >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_ProgramNamedParameter4dvNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
-        (void) memcpy((void *)(gc->pc + 36), (void *)(&id), 4);
-        (void) memcpy((void *)(gc->pc + 40), (void *)(&len), 4);
-        (void) memcpy((void *)(gc->pc + 44), (void *)(name), len);
+        (void) memcpy((void *) (gc->pc + 4), (void *) (v), 32);
+        (void) memcpy((void *) (gc->pc + 36), (void *) (&id), 4);
+        (void) memcpy((void *) (gc->pc + 40), (void *) (&len), 4);
+        (void) memcpy((void *) (gc->pc + 44), (void *) (name), len);
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
 #define X_GLrop_ProgramNamedParameter4fvNV 4218
 void
-__indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte * name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+__indirect_glProgramNamedParameter4fNV(GLuint id, GLsizei len,
+                                       const GLubyte * name, GLfloat x,
+                                       GLfloat y, GLfloat z, GLfloat w)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28 + __GLX_PAD(len);
     if (__builtin_expect(len >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
-        (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
-        (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 4);
-        (void) memcpy((void *)(gc->pc + 24), (void *)(&w), 4);
-        (void) memcpy((void *)(gc->pc + 28), (void *)(name), len);
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&id), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&len), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (&x), 4);
+        (void) memcpy((void *) (gc->pc + 16), (void *) (&y), 4);
+        (void) memcpy((void *) (gc->pc + 20), (void *) (&z), 4);
+        (void) memcpy((void *) (gc->pc + 24), (void *) (&w), 4);
+        (void) memcpy((void *) (gc->pc + 28), (void *) (name), len);
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
 #define X_GLrop_ProgramNamedParameter4fvNV 4218
 void
-__indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte * name, const GLfloat * v)
+__indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len,
+                                        const GLubyte * name,
+                                        const GLfloat * v)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28 + __GLX_PAD(len);
     if (__builtin_expect(len >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_ProgramNamedParameter4fvNV, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&id), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(&len), 4);
-        (void) memcpy((void *)(gc->pc + 12), (void *)(v), 16);
-        (void) memcpy((void *)(gc->pc + 28), (void *)(name), len);
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&id), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (&len), 4);
+        (void) memcpy((void *) (gc->pc + 12), (void *) (v), 16);
+        (void) memcpy((void *) (gc->pc + 28), (void *) (name), len);
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
@@ -8261,54 +9755,64 @@ __indirect_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte *
 void
 __indirect_glBlendEquationSeparateEXT(GLenum modeRGB, GLenum modeA)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_BlendEquationSeparateEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&modeRGB), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&modeA), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&modeRGB), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&modeA), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_BindFramebufferEXT 4319
 void
 __indirect_glBindFramebufferEXT(GLenum target, GLuint framebuffer)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_BindFramebufferEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&framebuffer), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&framebuffer), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_BindRenderbufferEXT 4316
 void
 __indirect_glBindRenderbufferEXT(GLenum target, GLuint renderbuffer)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 12;
     emit_header(gc->pc, X_GLrop_BindRenderbufferEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&renderbuffer), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&renderbuffer), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLvop_CheckFramebufferStatusEXT 1427
 GLenum
 __indirect_glCheckFramebufferStatusEXT(GLenum target)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     GLenum retval = (GLenum) 0;
     const GLuint cmdlen = 4;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_CheckFramebufferStatusEXT, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_CheckFramebufferStatusEXT,
+                                    cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
         retval = (GLenum) __glXReadReply(dpy, 0, NULL, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return retval;
 }
@@ -8317,14 +9821,17 @@ __indirect_glCheckFramebufferStatusEXT(GLenum target)
 void
 __indirect_glDeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
     if (__builtin_expect(n >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_DeleteFramebuffersEXT, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(framebuffers), (n * 4));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (framebuffers),
+                      (n * 4));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
@@ -8332,93 +9839,115 @@ __indirect_glDeleteFramebuffersEXT(GLsizei n, const GLuint * framebuffers)
 void
 __indirect_glDeleteRenderbuffersEXT(GLsizei n, const GLuint * renderbuffers)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8 + __GLX_PAD((n * 4));
     if (__builtin_expect(n >= 0, 1)) {
         emit_header(gc->pc, X_GLrop_DeleteRenderbuffersEXT, cmdlen);
-        (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
-        (void) memcpy((void *)(gc->pc + 8), (void *)(renderbuffers), (n * 4));
+        (void) memcpy((void *) (gc->pc + 4), (void *) (&n), 4);
+        (void) memcpy((void *) (gc->pc + 8), (void *) (renderbuffers),
+                      (n * 4));
         gc->pc += cmdlen;
-        if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+        if (__builtin_expect(gc->pc > gc->limit, 0)) {
+            (void) __glXFlushRenderBuffer(gc, gc->pc);
+        }
     }
 }
 
 #define X_GLrop_FramebufferRenderbufferEXT 4324
 void
-__indirect_glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
+__indirect_glFramebufferRenderbufferEXT(GLenum target, GLenum attachment,
+                                        GLenum renderbuffertarget,
+                                        GLuint renderbuffer)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_FramebufferRenderbufferEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&renderbuffertarget), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&renderbuffer), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&renderbuffertarget), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&renderbuffer), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_FramebufferTexture1DEXT 4321
 void
-__indirect_glFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+__indirect_glFramebufferTexture1DEXT(GLenum target, GLenum attachment,
+                                     GLenum textarget, GLuint texture,
+                                     GLint level)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_FramebufferTexture1DEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&textarget), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&texture), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&level), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_FramebufferTexture2DEXT 4322
 void
-__indirect_glFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+__indirect_glFramebufferTexture2DEXT(GLenum target, GLenum attachment,
+                                     GLenum textarget, GLuint texture,
+                                     GLint level)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 24;
     emit_header(gc->pc, X_GLrop_FramebufferTexture2DEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&textarget), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&texture), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&level), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLrop_FramebufferTexture3DEXT 4323
 void
-__indirect_glFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
+__indirect_glFramebufferTexture3DEXT(GLenum target, GLenum attachment,
+                                     GLenum textarget, GLuint texture,
+                                     GLint level, GLint zoffset)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 28;
     emit_header(gc->pc, X_GLrop_FramebufferTexture3DEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&attachment), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&textarget), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&texture), 4);
-    (void) memcpy((void *)(gc->pc + 20), (void *)(&level), 4);
-    (void) memcpy((void *)(gc->pc + 24), (void *)(&zoffset), 4);
-    gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&attachment), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&textarget), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&texture), 4);
+    (void) memcpy((void *) (gc->pc + 20), (void *) (&level), 4);
+    (void) memcpy((void *) (gc->pc + 24), (void *) (&zoffset), 4);
+    gc->pc += cmdlen;
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLvop_GenFramebuffersEXT 1426
 void
 __indirect_glGenFramebuffersEXT(GLsizei n, GLuint * framebuffers)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 4;
     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenFramebuffersEXT, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GenFramebuffersEXT, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
         (void) __glXReadReply(dpy, 4, framebuffers, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
@@ -8427,14 +9956,17 @@ __indirect_glGenFramebuffersEXT(GLsizei n, GLuint * framebuffers)
 void
 __indirect_glGenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 4;
     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenRenderbuffersEXT, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GenRenderbuffersEXT, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&n), 4);
         (void) __glXReadReply(dpy, 4, renderbuffers, GL_TRUE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
@@ -8443,45 +9975,59 @@ __indirect_glGenRenderbuffersEXT(GLsizei n, GLuint * renderbuffers)
 void
 __indirect_glGenerateMipmapEXT(GLenum target)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 8;
     emit_header(gc->pc, X_GLrop_GenerateMipmapEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 #define X_GLvop_GetFramebufferAttachmentParameterivEXT 1428
 void
-__indirect_glGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint * params)
+__indirect_glGetFramebufferAttachmentParameterivEXT(GLenum target,
+                                                    GLenum attachment,
+                                                    GLenum pname,
+                                                    GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 12;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetFramebufferAttachmentParameterivEXT, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&attachment), 4);
-        (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GetFramebufferAttachmentParameterivEXT,
+                                    cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&attachment), 4);
+        (void) memcpy((void *) (pc + 8), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
 
 #define X_GLvop_GetRenderbufferParameterivEXT 1424
 void
-__indirect_glGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint * params)
+__indirect_glGetRenderbufferParameterivEXT(GLenum target, GLenum pname,
+                                           GLint * params)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     const GLuint cmdlen = 8;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_GetRenderbufferParameterivEXT, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
-        (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_GetRenderbufferParameterivEXT,
+                                    cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&target), 4);
+        (void) memcpy((void *) (pc + 4), (void *) (&pname), 4);
         (void) __glXReadReply(dpy, 4, params, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return;
 }
@@ -8490,15 +10036,18 @@ __indirect_glGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint *
 GLboolean
 __indirect_glIsFramebufferEXT(GLuint framebuffer)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     GLboolean retval = (GLboolean) 0;
     const GLuint cmdlen = 4;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsFramebufferEXT, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&framebuffer), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_IsFramebufferEXT, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&framebuffer), 4);
         retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return retval;
 }
@@ -8507,32 +10056,38 @@ __indirect_glIsFramebufferEXT(GLuint framebuffer)
 GLboolean
 __indirect_glIsRenderbufferEXT(GLuint renderbuffer)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
-    Display * const dpy = gc->currentDpy;
+    __GLXcontext *const gc = __glXGetCurrentContext();
+    Display *const dpy = gc->currentDpy;
     GLboolean retval = (GLboolean) 0;
     const GLuint cmdlen = 4;
     if (__builtin_expect(dpy != NULL, 1)) {
-        GLubyte const * pc = __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsRenderbufferEXT, cmdlen);
-        (void) memcpy((void *)(pc + 0), (void *)(&renderbuffer), 4);
+        GLubyte const *pc =
+            __glXSetupVendorRequest(gc, X_GLXVendorPrivateWithReply,
+                                    X_GLvop_IsRenderbufferEXT, cmdlen);
+        (void) memcpy((void *) (pc + 0), (void *) (&renderbuffer), 4);
         retval = (GLboolean) __glXReadReply(dpy, 0, NULL, GL_FALSE);
-        UnlockDisplay(dpy); SyncHandle();
+        UnlockDisplay(dpy);
+        SyncHandle();
     }
     return retval;
 }
 
 #define X_GLrop_RenderbufferStorageEXT 4318
 void
-__indirect_glRenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
+__indirect_glRenderbufferStorageEXT(GLenum target, GLenum internalformat,
+                                    GLsizei width, GLsizei height)
 {
-    __GLXcontext * const gc = __glXGetCurrentContext();
+    __GLXcontext *const gc = __glXGetCurrentContext();
     const GLuint cmdlen = 20;
     emit_header(gc->pc, X_GLrop_RenderbufferStorageEXT, cmdlen);
-    (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
-    (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
-    (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
-    (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
+    (void) memcpy((void *) (gc->pc + 4), (void *) (&target), 4);
+    (void) memcpy((void *) (gc->pc + 8), (void *) (&internalformat), 4);
+    (void) memcpy((void *) (gc->pc + 12), (void *) (&width), 4);
+    (void) memcpy((void *) (gc->pc + 16), (void *) (&height), 4);
     gc->pc += cmdlen;
-    if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
+    if (__builtin_expect(gc->pc > gc->limit, 0)) {
+        (void) __glXFlushRenderBuffer(gc, gc->pc);
+    }
 }
 
 
diff --git a/src/glx/x11/indirect_init.c b/src/glx/x11/indirect_init.c
index ddbd8955220..b8e2617691d 100644
--- a/src/glx/x11/indirect_init.c
+++ b/src/glx/x11/indirect_init.c
@@ -74,15 +74,20 @@ __GLapi * __glXNewIndirectAPI( void )
 
     /* 1.0 */
 
-    glAPI->NewList = __indirect_glNewList;
-    glAPI->EndList = __indirect_glEndList;
-    glAPI->CallList = __indirect_glCallList;
-    glAPI->CallLists = __indirect_glCallLists;
-    glAPI->DeleteLists = __indirect_glDeleteLists;
-    glAPI->GenLists = __indirect_glGenLists;
-    glAPI->ListBase = __indirect_glListBase;
+    glAPI->Accum = __indirect_glAccum;
+    glAPI->AlphaFunc = __indirect_glAlphaFunc;
     glAPI->Begin = __indirect_glBegin;
     glAPI->Bitmap = __indirect_glBitmap;
+    glAPI->BlendFunc = __indirect_glBlendFunc;
+    glAPI->CallList = __indirect_glCallList;
+    glAPI->CallLists = __indirect_glCallLists;
+    glAPI->Clear = __indirect_glClear;
+    glAPI->ClearAccum = __indirect_glClearAccum;
+    glAPI->ClearColor = __indirect_glClearColor;
+    glAPI->ClearDepth = __indirect_glClearDepth;
+    glAPI->ClearIndex = __indirect_glClearIndex;
+    glAPI->ClearStencil = __indirect_glClearStencil;
+    glAPI->ClipPlane = __indirect_glClipPlane;
     glAPI->Color3b = __indirect_glColor3b;
     glAPI->Color3bv = __indirect_glColor3bv;
     glAPI->Color3d = __indirect_glColor3d;
@@ -115,9 +120,74 @@ __GLapi * __glXNewIndirectAPI( void )
     glAPI->Color4uiv = __indirect_glColor4uiv;
     glAPI->Color4us = __indirect_glColor4us;
     glAPI->Color4usv = __indirect_glColor4usv;
+    glAPI->ColorMask = __indirect_glColorMask;
+    glAPI->ColorMaterial = __indirect_glColorMaterial;
+    glAPI->CopyPixels = __indirect_glCopyPixels;
+    glAPI->CullFace = __indirect_glCullFace;
+    glAPI->DeleteLists = __indirect_glDeleteLists;
+    glAPI->DepthFunc = __indirect_glDepthFunc;
+    glAPI->DepthMask = __indirect_glDepthMask;
+    glAPI->DepthRange = __indirect_glDepthRange;
+    glAPI->Disable = __indirect_glDisable;
+    glAPI->DrawBuffer = __indirect_glDrawBuffer;
+    glAPI->DrawPixels = __indirect_glDrawPixels;
     glAPI->EdgeFlag = __indirect_glEdgeFlag;
     glAPI->EdgeFlagv = __indirect_glEdgeFlagv;
+    glAPI->Enable = __indirect_glEnable;
     glAPI->End = __indirect_glEnd;
+    glAPI->EndList = __indirect_glEndList;
+    glAPI->EvalCoord1d = __indirect_glEvalCoord1d;
+    glAPI->EvalCoord1dv = __indirect_glEvalCoord1dv;
+    glAPI->EvalCoord1f = __indirect_glEvalCoord1f;
+    glAPI->EvalCoord1fv = __indirect_glEvalCoord1fv;
+    glAPI->EvalCoord2d = __indirect_glEvalCoord2d;
+    glAPI->EvalCoord2dv = __indirect_glEvalCoord2dv;
+    glAPI->EvalCoord2f = __indirect_glEvalCoord2f;
+    glAPI->EvalCoord2fv = __indirect_glEvalCoord2fv;
+    glAPI->EvalMesh1 = __indirect_glEvalMesh1;
+    glAPI->EvalMesh2 = __indirect_glEvalMesh2;
+    glAPI->EvalPoint1 = __indirect_glEvalPoint1;
+    glAPI->EvalPoint2 = __indirect_glEvalPoint2;
+    glAPI->FeedbackBuffer = __indirect_glFeedbackBuffer;
+    glAPI->Finish = __indirect_glFinish;
+    glAPI->Flush = __indirect_glFlush;
+    glAPI->Fogf = __indirect_glFogf;
+    glAPI->Fogfv = __indirect_glFogfv;
+    glAPI->Fogi = __indirect_glFogi;
+    glAPI->Fogiv = __indirect_glFogiv;
+    glAPI->FrontFace = __indirect_glFrontFace;
+    glAPI->Frustum = __indirect_glFrustum;
+    glAPI->GenLists = __indirect_glGenLists;
+    glAPI->GetBooleanv = __indirect_glGetBooleanv;
+    glAPI->GetClipPlane = __indirect_glGetClipPlane;
+    glAPI->GetDoublev = __indirect_glGetDoublev;
+    glAPI->GetError = __indirect_glGetError;
+    glAPI->GetFloatv = __indirect_glGetFloatv;
+    glAPI->GetIntegerv = __indirect_glGetIntegerv;
+    glAPI->GetLightfv = __indirect_glGetLightfv;
+    glAPI->GetLightiv = __indirect_glGetLightiv;
+    glAPI->GetMapdv = __indirect_glGetMapdv;
+    glAPI->GetMapfv = __indirect_glGetMapfv;
+    glAPI->GetMapiv = __indirect_glGetMapiv;
+    glAPI->GetMaterialfv = __indirect_glGetMaterialfv;
+    glAPI->GetMaterialiv = __indirect_glGetMaterialiv;
+    glAPI->GetPixelMapfv = __indirect_glGetPixelMapfv;
+    glAPI->GetPixelMapuiv = __indirect_glGetPixelMapuiv;
+    glAPI->GetPixelMapusv = __indirect_glGetPixelMapusv;
+    glAPI->GetPolygonStipple = __indirect_glGetPolygonStipple;
+    glAPI->GetString = __indirect_glGetString;
+    glAPI->GetTexEnvfv = __indirect_glGetTexEnvfv;
+    glAPI->GetTexEnviv = __indirect_glGetTexEnviv;
+    glAPI->GetTexGendv = __indirect_glGetTexGendv;
+    glAPI->GetTexGenfv = __indirect_glGetTexGenfv;
+    glAPI->GetTexGeniv = __indirect_glGetTexGeniv;
+    glAPI->GetTexImage = __indirect_glGetTexImage;
+    glAPI->GetTexLevelParameterfv = __indirect_glGetTexLevelParameterfv;
+    glAPI->GetTexLevelParameteriv = __indirect_glGetTexLevelParameteriv;
+    glAPI->GetTexParameterfv = __indirect_glGetTexParameterfv;
+    glAPI->GetTexParameteriv = __indirect_glGetTexParameteriv;
+    glAPI->Hint = __indirect_glHint;
+    glAPI->IndexMask = __indirect_glIndexMask;
     glAPI->Indexd = __indirect_glIndexd;
     glAPI->Indexdv = __indirect_glIndexdv;
     glAPI->Indexf = __indirect_glIndexf;
@@ -126,6 +196,41 @@ __GLapi * __glXNewIndirectAPI( void )
     glAPI->Indexiv = __indirect_glIndexiv;
     glAPI->Indexs = __indirect_glIndexs;
     glAPI->Indexsv = __indirect_glIndexsv;
+    glAPI->InitNames = __indirect_glInitNames;
+    glAPI->IsEnabled = __indirect_glIsEnabled;
+    glAPI->IsList = __indirect_glIsList;
+    glAPI->LightModelf = __indirect_glLightModelf;
+    glAPI->LightModelfv = __indirect_glLightModelfv;
+    glAPI->LightModeli = __indirect_glLightModeli;
+    glAPI->LightModeliv = __indirect_glLightModeliv;
+    glAPI->Lightf = __indirect_glLightf;
+    glAPI->Lightfv = __indirect_glLightfv;
+    glAPI->Lighti = __indirect_glLighti;
+    glAPI->Lightiv = __indirect_glLightiv;
+    glAPI->LineStipple = __indirect_glLineStipple;
+    glAPI->LineWidth = __indirect_glLineWidth;
+    glAPI->ListBase = __indirect_glListBase;
+    glAPI->LoadIdentity = __indirect_glLoadIdentity;
+    glAPI->LoadMatrixd = __indirect_glLoadMatrixd;
+    glAPI->LoadMatrixf = __indirect_glLoadMatrixf;
+    glAPI->LoadName = __indirect_glLoadName;
+    glAPI->LogicOp = __indirect_glLogicOp;
+    glAPI->Map1d = __indirect_glMap1d;
+    glAPI->Map1f = __indirect_glMap1f;
+    glAPI->Map2d = __indirect_glMap2d;
+    glAPI->Map2f = __indirect_glMap2f;
+    glAPI->MapGrid1d = __indirect_glMapGrid1d;
+    glAPI->MapGrid1f = __indirect_glMapGrid1f;
+    glAPI->MapGrid2d = __indirect_glMapGrid2d;
+    glAPI->MapGrid2f = __indirect_glMapGrid2f;
+    glAPI->Materialf = __indirect_glMaterialf;
+    glAPI->Materialfv = __indirect_glMaterialfv;
+    glAPI->Materiali = __indirect_glMateriali;
+    glAPI->Materialiv = __indirect_glMaterialiv;
+    glAPI->MatrixMode = __indirect_glMatrixMode;
+    glAPI->MultMatrixd = __indirect_glMultMatrixd;
+    glAPI->MultMatrixf = __indirect_glMultMatrixf;
+    glAPI->NewList = __indirect_glNewList;
     glAPI->Normal3b = __indirect_glNormal3b;
     glAPI->Normal3bv = __indirect_glNormal3bv;
     glAPI->Normal3d = __indirect_glNormal3d;
@@ -136,6 +241,25 @@ __GLapi * __glXNewIndirectAPI( void )
     glAPI->Normal3iv = __indirect_glNormal3iv;
     glAPI->Normal3s = __indirect_glNormal3s;
     glAPI->Normal3sv = __indirect_glNormal3sv;
+    glAPI->Ortho = __indirect_glOrtho;
+    glAPI->PassThrough = __indirect_glPassThrough;
+    glAPI->PixelMapfv = __indirect_glPixelMapfv;
+    glAPI->PixelMapuiv = __indirect_glPixelMapuiv;
+    glAPI->PixelMapusv = __indirect_glPixelMapusv;
+    glAPI->PixelStoref = __indirect_glPixelStoref;
+    glAPI->PixelStorei = __indirect_glPixelStorei;
+    glAPI->PixelTransferf = __indirect_glPixelTransferf;
+    glAPI->PixelTransferi = __indirect_glPixelTransferi;
+    glAPI->PixelZoom = __indirect_glPixelZoom;
+    glAPI->PointSize = __indirect_glPointSize;
+    glAPI->PolygonMode = __indirect_glPolygonMode;
+    glAPI->PolygonStipple = __indirect_glPolygonStipple;
+    glAPI->PopAttrib = __indirect_glPopAttrib;
+    glAPI->PopMatrix = __indirect_glPopMatrix;
+    glAPI->PopName = __indirect_glPopName;
+    glAPI->PushAttrib = __indirect_glPushAttrib;
+    glAPI->PushMatrix = __indirect_glPushMatrix;
+    glAPI->PushName = __indirect_glPushName;
     glAPI->RasterPos2d = __indirect_glRasterPos2d;
     glAPI->RasterPos2dv = __indirect_glRasterPos2dv;
     glAPI->RasterPos2f = __indirect_glRasterPos2f;
@@ -160,6 +284,8 @@ __GLapi * __glXNewIndirectAPI( void )
     glAPI->RasterPos4iv = __indirect_glRasterPos4iv;
     glAPI->RasterPos4s = __indirect_glRasterPos4s;
     glAPI->RasterPos4sv = __indirect_glRasterPos4sv;
+    glAPI->ReadBuffer = __indirect_glReadBuffer;
+    glAPI->ReadPixels = __indirect_glReadPixels;
     glAPI->Rectd = __indirect_glRectd;
     glAPI->Rectdv = __indirect_glRectdv;
     glAPI->Rectf = __indirect_glRectf;
@@ -168,6 +294,17 @@ __GLapi * __glXNewIndirectAPI( void )
     glAPI->Rectiv = __indirect_glRectiv;
     glAPI->Rects = __indirect_glRects;
     glAPI->Rectsv = __indirect_glRectsv;
+    glAPI->RenderMode = __indirect_glRenderMode;
+    glAPI->Rotated = __indirect_glRotated;
+    glAPI->Rotatef = __indirect_glRotatef;
+    glAPI->Scaled = __indirect_glScaled;
+    glAPI->Scalef = __indirect_glScalef;
+    glAPI->Scissor = __indirect_glScissor;
+    glAPI->SelectBuffer = __indirect_glSelectBuffer;
+    glAPI->ShadeModel = __indirect_glShadeModel;
+    glAPI->StencilFunc = __indirect_glStencilFunc;
+    glAPI->StencilMask = __indirect_glStencilMask;
+    glAPI->StencilOp = __indirect_glStencilOp;
     glAPI->TexCoord1d = __indirect_glTexCoord1d;
     glAPI->TexCoord1dv = __indirect_glTexCoord1dv;
     glAPI->TexCoord1f = __indirect_glTexCoord1f;
@@ -200,6 +337,24 @@ __GLapi * __glXNewIndirectAPI( void )
     glAPI->TexCoord4iv = __indirect_glTexCoord4iv;
     glAPI->TexCoord4s = __indirect_glTexCoord4s;
     glAPI->TexCoord4sv = __indirect_glTexCoord4sv;
+    glAPI->TexEnvf = __indirect_glTexEnvf;
+    glAPI->TexEnvfv = __indirect_glTexEnvfv;
+    glAPI->TexEnvi = __indirect_glTexEnvi;
+    glAPI->TexEnviv = __indirect_glTexEnviv;
+    glAPI->TexGend = __indirect_glTexGend;
+    glAPI->TexGendv = __indirect_glTexGendv;
+    glAPI->TexGenf = __indirect_glTexGenf;
+    glAPI->TexGenfv = __indirect_glTexGenfv;
+    glAPI->TexGeni = __indirect_glTexGeni;
+    glAPI->TexGeniv = __indirect_glTexGeniv;
+    glAPI->TexImage1D = __indirect_glTexImage1D;
+    glAPI->TexImage2D = __indirect_glTexImage2D;
+    glAPI->TexParameterf = __indirect_glTexParameterf;
+    glAPI->TexParameterfv = __indirect_glTexParameterfv;
+    glAPI->TexParameteri = __indirect_glTexParameteri;
+    glAPI->TexParameteriv = __indirect_glTexParameteriv;
+    glAPI->Translated = __indirect_glTranslated;
+    glAPI->Translatef = __indirect_glTranslatef;
     glAPI->Vertex2d = __indirect_glVertex2d;
     glAPI->Vertex2dv = __indirect_glVertex2dv;
     glAPI->Vertex2f = __indirect_glVertex2f;
@@ -224,239 +379,94 @@ __GLapi * __glXNewIndirectAPI( void )
     glAPI->Vertex4iv = __indirect_glVertex4iv;
     glAPI->Vertex4s = __indirect_glVertex4s;
     glAPI->Vertex4sv = __indirect_glVertex4sv;
-    glAPI->ClipPlane = __indirect_glClipPlane;
-    glAPI->ColorMaterial = __indirect_glColorMaterial;
-    glAPI->CullFace = __indirect_glCullFace;
-    glAPI->Fogf = __indirect_glFogf;
-    glAPI->Fogfv = __indirect_glFogfv;
-    glAPI->Fogi = __indirect_glFogi;
-    glAPI->Fogiv = __indirect_glFogiv;
-    glAPI->FrontFace = __indirect_glFrontFace;
-    glAPI->Hint = __indirect_glHint;
-    glAPI->Lightf = __indirect_glLightf;
-    glAPI->Lightfv = __indirect_glLightfv;
-    glAPI->Lighti = __indirect_glLighti;
-    glAPI->Lightiv = __indirect_glLightiv;
-    glAPI->LightModelf = __indirect_glLightModelf;
-    glAPI->LightModelfv = __indirect_glLightModelfv;
-    glAPI->LightModeli = __indirect_glLightModeli;
-    glAPI->LightModeliv = __indirect_glLightModeliv;
-    glAPI->LineStipple = __indirect_glLineStipple;
-    glAPI->LineWidth = __indirect_glLineWidth;
-    glAPI->Materialf = __indirect_glMaterialf;
-    glAPI->Materialfv = __indirect_glMaterialfv;
-    glAPI->Materiali = __indirect_glMateriali;
-    glAPI->Materialiv = __indirect_glMaterialiv;
-    glAPI->PointSize = __indirect_glPointSize;
-    glAPI->PolygonMode = __indirect_glPolygonMode;
-    glAPI->PolygonStipple = __indirect_glPolygonStipple;
-    glAPI->Scissor = __indirect_glScissor;
-    glAPI->ShadeModel = __indirect_glShadeModel;
-    glAPI->TexParameterf = __indirect_glTexParameterf;
-    glAPI->TexParameterfv = __indirect_glTexParameterfv;
-    glAPI->TexParameteri = __indirect_glTexParameteri;
-    glAPI->TexParameteriv = __indirect_glTexParameteriv;
-    glAPI->TexImage1D = __indirect_glTexImage1D;
-    glAPI->TexImage2D = __indirect_glTexImage2D;
-    glAPI->TexEnvf = __indirect_glTexEnvf;
-    glAPI->TexEnvfv = __indirect_glTexEnvfv;
-    glAPI->TexEnvi = __indirect_glTexEnvi;
-    glAPI->TexEnviv = __indirect_glTexEnviv;
-    glAPI->TexGend = __indirect_glTexGend;
-    glAPI->TexGendv = __indirect_glTexGendv;
-    glAPI->TexGenf = __indirect_glTexGenf;
-    glAPI->TexGenfv = __indirect_glTexGenfv;
-    glAPI->TexGeni = __indirect_glTexGeni;
-    glAPI->TexGeniv = __indirect_glTexGeniv;
-    glAPI->FeedbackBuffer = __indirect_glFeedbackBuffer;
-    glAPI->SelectBuffer = __indirect_glSelectBuffer;
-    glAPI->RenderMode = __indirect_glRenderMode;
-    glAPI->InitNames = __indirect_glInitNames;
-    glAPI->LoadName = __indirect_glLoadName;
-    glAPI->PassThrough = __indirect_glPassThrough;
-    glAPI->PopName = __indirect_glPopName;
-    glAPI->PushName = __indirect_glPushName;
-    glAPI->DrawBuffer = __indirect_glDrawBuffer;
-    glAPI->Clear = __indirect_glClear;
-    glAPI->ClearAccum = __indirect_glClearAccum;
-    glAPI->ClearIndex = __indirect_glClearIndex;
-    glAPI->ClearColor = __indirect_glClearColor;
-    glAPI->ClearStencil = __indirect_glClearStencil;
-    glAPI->ClearDepth = __indirect_glClearDepth;
-    glAPI->StencilMask = __indirect_glStencilMask;
-    glAPI->ColorMask = __indirect_glColorMask;
-    glAPI->DepthMask = __indirect_glDepthMask;
-    glAPI->IndexMask = __indirect_glIndexMask;
-    glAPI->Accum = __indirect_glAccum;
-    glAPI->Disable = __indirect_glDisable;
-    glAPI->Enable = __indirect_glEnable;
-    glAPI->Finish = __indirect_glFinish;
-    glAPI->Flush = __indirect_glFlush;
-    glAPI->PopAttrib = __indirect_glPopAttrib;
-    glAPI->PushAttrib = __indirect_glPushAttrib;
-    glAPI->Map1d = __indirect_glMap1d;
-    glAPI->Map1f = __indirect_glMap1f;
-    glAPI->Map2d = __indirect_glMap2d;
-    glAPI->Map2f = __indirect_glMap2f;
-    glAPI->MapGrid1d = __indirect_glMapGrid1d;
-    glAPI->MapGrid1f = __indirect_glMapGrid1f;
-    glAPI->MapGrid2d = __indirect_glMapGrid2d;
-    glAPI->MapGrid2f = __indirect_glMapGrid2f;
-    glAPI->EvalCoord1d = __indirect_glEvalCoord1d;
-    glAPI->EvalCoord1dv = __indirect_glEvalCoord1dv;
-    glAPI->EvalCoord1f = __indirect_glEvalCoord1f;
-    glAPI->EvalCoord1fv = __indirect_glEvalCoord1fv;
-    glAPI->EvalCoord2d = __indirect_glEvalCoord2d;
-    glAPI->EvalCoord2dv = __indirect_glEvalCoord2dv;
-    glAPI->EvalCoord2f = __indirect_glEvalCoord2f;
-    glAPI->EvalCoord2fv = __indirect_glEvalCoord2fv;
-    glAPI->EvalMesh1 = __indirect_glEvalMesh1;
-    glAPI->EvalPoint1 = __indirect_glEvalPoint1;
-    glAPI->EvalMesh2 = __indirect_glEvalMesh2;
-    glAPI->EvalPoint2 = __indirect_glEvalPoint2;
-    glAPI->AlphaFunc = __indirect_glAlphaFunc;
-    glAPI->BlendFunc = __indirect_glBlendFunc;
-    glAPI->LogicOp = __indirect_glLogicOp;
-    glAPI->StencilFunc = __indirect_glStencilFunc;
-    glAPI->StencilOp = __indirect_glStencilOp;
-    glAPI->DepthFunc = __indirect_glDepthFunc;
-    glAPI->PixelZoom = __indirect_glPixelZoom;
-    glAPI->PixelTransferf = __indirect_glPixelTransferf;
-    glAPI->PixelTransferi = __indirect_glPixelTransferi;
-    glAPI->PixelStoref = __indirect_glPixelStoref;
-    glAPI->PixelStorei = __indirect_glPixelStorei;
-    glAPI->PixelMapfv = __indirect_glPixelMapfv;
-    glAPI->PixelMapuiv = __indirect_glPixelMapuiv;
-    glAPI->PixelMapusv = __indirect_glPixelMapusv;
-    glAPI->ReadBuffer = __indirect_glReadBuffer;
-    glAPI->CopyPixels = __indirect_glCopyPixels;
-    glAPI->ReadPixels = __indirect_glReadPixels;
-    glAPI->DrawPixels = __indirect_glDrawPixels;
-    glAPI->GetBooleanv = __indirect_glGetBooleanv;
-    glAPI->GetClipPlane = __indirect_glGetClipPlane;
-    glAPI->GetDoublev = __indirect_glGetDoublev;
-    glAPI->GetError = __indirect_glGetError;
-    glAPI->GetFloatv = __indirect_glGetFloatv;
-    glAPI->GetIntegerv = __indirect_glGetIntegerv;
-    glAPI->GetLightfv = __indirect_glGetLightfv;
-    glAPI->GetLightiv = __indirect_glGetLightiv;
-    glAPI->GetMapdv = __indirect_glGetMapdv;
-    glAPI->GetMapfv = __indirect_glGetMapfv;
-    glAPI->GetMapiv = __indirect_glGetMapiv;
-    glAPI->GetMaterialfv = __indirect_glGetMaterialfv;
-    glAPI->GetMaterialiv = __indirect_glGetMaterialiv;
-    glAPI->GetPixelMapfv = __indirect_glGetPixelMapfv;
-    glAPI->GetPixelMapuiv = __indirect_glGetPixelMapuiv;
-    glAPI->GetPixelMapusv = __indirect_glGetPixelMapusv;
-    glAPI->GetPolygonStipple = __indirect_glGetPolygonStipple;
-    glAPI->GetString = __indirect_glGetString;
-    glAPI->GetTexEnvfv = __indirect_glGetTexEnvfv;
-    glAPI->GetTexEnviv = __indirect_glGetTexEnviv;
-    glAPI->GetTexGendv = __indirect_glGetTexGendv;
-    glAPI->GetTexGenfv = __indirect_glGetTexGenfv;
-    glAPI->GetTexGeniv = __indirect_glGetTexGeniv;
-    glAPI->GetTexImage = __indirect_glGetTexImage;
-    glAPI->GetTexParameterfv = __indirect_glGetTexParameterfv;
-    glAPI->GetTexParameteriv = __indirect_glGetTexParameteriv;
-    glAPI->GetTexLevelParameterfv = __indirect_glGetTexLevelParameterfv;
-    glAPI->GetTexLevelParameteriv = __indirect_glGetTexLevelParameteriv;
-    glAPI->IsEnabled = __indirect_glIsEnabled;
-    glAPI->IsList = __indirect_glIsList;
-    glAPI->DepthRange = __indirect_glDepthRange;
-    glAPI->Frustum = __indirect_glFrustum;
-    glAPI->LoadIdentity = __indirect_glLoadIdentity;
-    glAPI->LoadMatrixf = __indirect_glLoadMatrixf;
-    glAPI->LoadMatrixd = __indirect_glLoadMatrixd;
-    glAPI->MatrixMode = __indirect_glMatrixMode;
-    glAPI->MultMatrixf = __indirect_glMultMatrixf;
-    glAPI->MultMatrixd = __indirect_glMultMatrixd;
-    glAPI->Ortho = __indirect_glOrtho;
-    glAPI->PopMatrix = __indirect_glPopMatrix;
-    glAPI->PushMatrix = __indirect_glPushMatrix;
-    glAPI->Rotated = __indirect_glRotated;
-    glAPI->Rotatef = __indirect_glRotatef;
-    glAPI->Scaled = __indirect_glScaled;
-    glAPI->Scalef = __indirect_glScalef;
-    glAPI->Translated = __indirect_glTranslated;
-    glAPI->Translatef = __indirect_glTranslatef;
     glAPI->Viewport = __indirect_glViewport;
 
     /* 1.1 */
 
+    glAPI->AreTexturesResident = __indirect_glAreTexturesResident;
     glAPI->ArrayElement = __indirect_glArrayElement;
     glAPI->BindTexture = __indirect_glBindTexture;
     glAPI->ColorPointer = __indirect_glColorPointer;
+    glAPI->CopyTexImage1D = __indirect_glCopyTexImage1D;
+    glAPI->CopyTexImage2D = __indirect_glCopyTexImage2D;
+    glAPI->CopyTexSubImage1D = __indirect_glCopyTexSubImage1D;
+    glAPI->CopyTexSubImage2D = __indirect_glCopyTexSubImage2D;
+    glAPI->DeleteTextures = __indirect_glDeleteTextures;
     glAPI->DisableClientState = __indirect_glDisableClientState;
     glAPI->DrawArrays = __indirect_glDrawArrays;
     glAPI->DrawElements = __indirect_glDrawElements;
     glAPI->EdgeFlagPointer = __indirect_glEdgeFlagPointer;
     glAPI->EnableClientState = __indirect_glEnableClientState;
+    glAPI->GenTextures = __indirect_glGenTextures;
+    glAPI->GetPointerv = __indirect_glGetPointerv;
     glAPI->IndexPointer = __indirect_glIndexPointer;
     glAPI->Indexub = __indirect_glIndexub;
     glAPI->Indexubv = __indirect_glIndexubv;
     glAPI->InterleavedArrays = __indirect_glInterleavedArrays;
+    glAPI->IsTexture = __indirect_glIsTexture;
     glAPI->NormalPointer = __indirect_glNormalPointer;
     glAPI->PolygonOffset = __indirect_glPolygonOffset;
-    glAPI->TexCoordPointer = __indirect_glTexCoordPointer;
-    glAPI->VertexPointer = __indirect_glVertexPointer;
-    glAPI->AreTexturesResident = __indirect_glAreTexturesResident;
-    glAPI->CopyTexImage1D = __indirect_glCopyTexImage1D;
-    glAPI->CopyTexImage2D = __indirect_glCopyTexImage2D;
-    glAPI->CopyTexSubImage1D = __indirect_glCopyTexSubImage1D;
-    glAPI->CopyTexSubImage2D = __indirect_glCopyTexSubImage2D;
-    glAPI->DeleteTextures = __indirect_glDeleteTextures;
-    glAPI->GenTextures = __indirect_glGenTextures;
-    glAPI->GetPointerv = __indirect_glGetPointerv;
-    glAPI->IsTexture = __indirect_glIsTexture;
+    glAPI->PopClientAttrib = __indirect_glPopClientAttrib;
     glAPI->PrioritizeTextures = __indirect_glPrioritizeTextures;
+    glAPI->PushClientAttrib = __indirect_glPushClientAttrib;
+    glAPI->TexCoordPointer = __indirect_glTexCoordPointer;
     glAPI->TexSubImage1D = __indirect_glTexSubImage1D;
     glAPI->TexSubImage2D = __indirect_glTexSubImage2D;
-    glAPI->PopClientAttrib = __indirect_glPopClientAttrib;
-    glAPI->PushClientAttrib = __indirect_glPushClientAttrib;
+    glAPI->VertexPointer = __indirect_glVertexPointer;
 
     /* 1.2 */
 
     glAPI->BlendColor = __indirect_glBlendColor;
     glAPI->BlendEquation = __indirect_glBlendEquation;
-    glAPI->DrawRangeElements = __indirect_glDrawRangeElements;
+    glAPI->ColorSubTable = __indirect_glColorSubTable;
     glAPI->ColorTable = __indirect_glColorTable;
     glAPI->ColorTableParameterfv = __indirect_glColorTableParameterfv;
     glAPI->ColorTableParameteriv = __indirect_glColorTableParameteriv;
-    glAPI->CopyColorTable = __indirect_glCopyColorTable;
-    glAPI->GetColorTable = __indirect_glGetColorTable;
-    glAPI->GetColorTableParameterfv = __indirect_glGetColorTableParameterfv;
-    glAPI->GetColorTableParameteriv = __indirect_glGetColorTableParameteriv;
-    glAPI->ColorSubTable = __indirect_glColorSubTable;
-    glAPI->CopyColorSubTable = __indirect_glCopyColorSubTable;
     glAPI->ConvolutionFilter1D = __indirect_glConvolutionFilter1D;
     glAPI->ConvolutionFilter2D = __indirect_glConvolutionFilter2D;
     glAPI->ConvolutionParameterf = __indirect_glConvolutionParameterf;
     glAPI->ConvolutionParameterfv = __indirect_glConvolutionParameterfv;
     glAPI->ConvolutionParameteri = __indirect_glConvolutionParameteri;
     glAPI->ConvolutionParameteriv = __indirect_glConvolutionParameteriv;
+    glAPI->CopyColorSubTable = __indirect_glCopyColorSubTable;
+    glAPI->CopyColorTable = __indirect_glCopyColorTable;
     glAPI->CopyConvolutionFilter1D = __indirect_glCopyConvolutionFilter1D;
     glAPI->CopyConvolutionFilter2D = __indirect_glCopyConvolutionFilter2D;
+    glAPI->CopyTexSubImage3D = __indirect_glCopyTexSubImage3D;
+    glAPI->DrawRangeElements = __indirect_glDrawRangeElements;
+    glAPI->GetColorTable = __indirect_glGetColorTable;
+    glAPI->GetColorTableParameterfv = __indirect_glGetColorTableParameterfv;
+    glAPI->GetColorTableParameteriv = __indirect_glGetColorTableParameteriv;
     glAPI->GetConvolutionFilter = __indirect_glGetConvolutionFilter;
     glAPI->GetConvolutionParameterfv = __indirect_glGetConvolutionParameterfv;
     glAPI->GetConvolutionParameteriv = __indirect_glGetConvolutionParameteriv;
-    glAPI->GetSeparableFilter = __indirect_glGetSeparableFilter;
-    glAPI->SeparableFilter2D = __indirect_glSeparableFilter2D;
     glAPI->GetHistogram = __indirect_glGetHistogram;
     glAPI->GetHistogramParameterfv = __indirect_glGetHistogramParameterfv;
     glAPI->GetHistogramParameteriv = __indirect_glGetHistogramParameteriv;
     glAPI->GetMinmax = __indirect_glGetMinmax;
     glAPI->GetMinmaxParameterfv = __indirect_glGetMinmaxParameterfv;
     glAPI->GetMinmaxParameteriv = __indirect_glGetMinmaxParameteriv;
+    glAPI->GetSeparableFilter = __indirect_glGetSeparableFilter;
     glAPI->Histogram = __indirect_glHistogram;
     glAPI->Minmax = __indirect_glMinmax;
     glAPI->ResetHistogram = __indirect_glResetHistogram;
     glAPI->ResetMinmax = __indirect_glResetMinmax;
+    glAPI->SeparableFilter2D = __indirect_glSeparableFilter2D;
     glAPI->TexImage3D = __indirect_glTexImage3D;
     glAPI->TexSubImage3D = __indirect_glTexSubImage3D;
-    glAPI->CopyTexSubImage3D = __indirect_glCopyTexSubImage3D;
 
     /*   1. GL_ARB_multitexture */
 
+    glAPI->ActiveTextureARB = __indirect_glActiveTextureARB;
+    glAPI->ClientActiveTextureARB = __indirect_glClientActiveTextureARB;
+    glAPI->MultiTexCoord1dARB = __indirect_glMultiTexCoord1dARB;
+    glAPI->MultiTexCoord1dvARB = __indirect_glMultiTexCoord1dvARB;
+    glAPI->MultiTexCoord1fARB = __indirect_glMultiTexCoord1fARB;
+    glAPI->MultiTexCoord1fvARB = __indirect_glMultiTexCoord1fvARB;
+    glAPI->MultiTexCoord1iARB = __indirect_glMultiTexCoord1iARB;
+    glAPI->MultiTexCoord1ivARB = __indirect_glMultiTexCoord1ivARB;
+    glAPI->MultiTexCoord1sARB = __indirect_glMultiTexCoord1sARB;
+    glAPI->MultiTexCoord1svARB = __indirect_glMultiTexCoord1svARB;
     glAPI->MultiTexCoord2dARB = __indirect_glMultiTexCoord2dARB;
     glAPI->MultiTexCoord2dvARB = __indirect_glMultiTexCoord2dvARB;
     glAPI->MultiTexCoord2fARB = __indirect_glMultiTexCoord2fARB;
@@ -481,16 +491,6 @@ __GLapi * __glXNewIndirectAPI( void )
     glAPI->MultiTexCoord4ivARB = __indirect_glMultiTexCoord4ivARB;
     glAPI->MultiTexCoord4sARB = __indirect_glMultiTexCoord4sARB;
     glAPI->MultiTexCoord4svARB = __indirect_glMultiTexCoord4svARB;
-    glAPI->ActiveTextureARB = __indirect_glActiveTextureARB;
-    glAPI->ClientActiveTextureARB = __indirect_glClientActiveTextureARB;
-    glAPI->MultiTexCoord1dARB = __indirect_glMultiTexCoord1dARB;
-    glAPI->MultiTexCoord1dvARB = __indirect_glMultiTexCoord1dvARB;
-    glAPI->MultiTexCoord1fARB = __indirect_glMultiTexCoord1fARB;
-    glAPI->MultiTexCoord1fvARB = __indirect_glMultiTexCoord1fvARB;
-    glAPI->MultiTexCoord1iARB = __indirect_glMultiTexCoord1iARB;
-    glAPI->MultiTexCoord1ivARB = __indirect_glMultiTexCoord1ivARB;
-    glAPI->MultiTexCoord1sARB = __indirect_glMultiTexCoord1sARB;
-    glAPI->MultiTexCoord1svARB = __indirect_glMultiTexCoord1svARB;
 
     /*   3. GL_ARB_transpose_matrix */
 
@@ -646,11 +646,11 @@ __GLapi * __glXNewIndirectAPI( void )
 
     /* 149. GL_EXT_fog_coord */
 
+    glAPI->FogCoordPointerEXT = __indirect_glFogCoordPointerEXT;
+    glAPI->FogCoorddEXT = __indirect_glFogCoorddEXT;
     glAPI->FogCoorddvEXT = __indirect_glFogCoorddvEXT;
     glAPI->FogCoordfEXT = __indirect_glFogCoordfEXT;
     glAPI->FogCoordfvEXT = __indirect_glFogCoordfvEXT;
-    glAPI->FogCoordPointerEXT = __indirect_glFogCoordPointerEXT;
-    glAPI->FogCoorddEXT = __indirect_glFogCoorddEXT;
 
     /* 173. GL_EXT_blend_func_separate */
 
diff --git a/src/glx/x11/indirect_size.c b/src/glx/x11/indirect_size.c
index 79d57d55b68..12214d7fe40 100644
--- a/src/glx/x11/indirect_size.c
+++ b/src/glx/x11/indirect_size.c
@@ -64,307 +64,319 @@
 
 
 INTERNAL PURE FASTCALL GLint
-__glCallLists_size( GLenum e )
+__glCallLists_size(GLenum e)
 {
-    switch( e ) {
-        case GL_BYTE:
-        case GL_UNSIGNED_BYTE:
-            return 1;
-        case GL_SHORT:
-        case GL_UNSIGNED_SHORT:
-        case GL_2_BYTES:
-            return 2;
-        case GL_3_BYTES:
-            return 3;
-        case GL_INT:
-        case GL_UNSIGNED_INT:
-        case GL_FLOAT:
-        case GL_4_BYTES:
-            return 4;
-        default: return 0;
+    switch (e) {
+    case GL_BYTE:
+    case GL_UNSIGNED_BYTE:
+        return 1;
+    case GL_SHORT:
+    case GL_UNSIGNED_SHORT:
+    case GL_2_BYTES:
+        return 2;
+    case GL_3_BYTES:
+        return 3;
+    case GL_INT:
+    case GL_UNSIGNED_INT:
+    case GL_FLOAT:
+    case GL_4_BYTES:
+        return 4;
+    default:
+        return 0;
     }
 }
 
 INTERNAL PURE FASTCALL GLint
-__glFogfv_size( GLenum e )
+__glFogfv_size(GLenum e)
 {
-    switch( e ) {
-        case GL_FOG_INDEX:
-        case GL_FOG_DENSITY:
-        case GL_FOG_START:
-        case GL_FOG_END:
-        case GL_FOG_MODE:
-        case GL_FOG_OFFSET_VALUE_SGIX:
-        case GL_FOG_DISTANCE_MODE_NV:
-            return 1;
-        case GL_FOG_COLOR:
-            return 4;
-        default: return 0;
+    switch (e) {
+    case GL_FOG_INDEX:
+    case GL_FOG_DENSITY:
+    case GL_FOG_START:
+    case GL_FOG_END:
+    case GL_FOG_MODE:
+    case GL_FOG_OFFSET_VALUE_SGIX:
+    case GL_FOG_DISTANCE_MODE_NV:
+        return 1;
+    case GL_FOG_COLOR:
+        return 4;
+    default:
+        return 0;
     }
 }
 
 INTERNAL PURE FASTCALL GLint
-__glLightfv_size( GLenum e )
+__glLightfv_size(GLenum e)
 {
-    switch( e ) {
-        case GL_SPOT_EXPONENT:
-        case GL_SPOT_CUTOFF:
-        case GL_CONSTANT_ATTENUATION:
-        case GL_LINEAR_ATTENUATION:
-        case GL_QUADRATIC_ATTENUATION:
-            return 1;
-        case GL_SPOT_DIRECTION:
-            return 3;
-        case GL_AMBIENT:
-        case GL_DIFFUSE:
-        case GL_SPECULAR:
-        case GL_POSITION:
-            return 4;
-        default: return 0;
+    switch (e) {
+    case GL_SPOT_EXPONENT:
+    case GL_SPOT_CUTOFF:
+    case GL_CONSTANT_ATTENUATION:
+    case GL_LINEAR_ATTENUATION:
+    case GL_QUADRATIC_ATTENUATION:
+        return 1;
+    case GL_SPOT_DIRECTION:
+        return 3;
+    case GL_AMBIENT:
+    case GL_DIFFUSE:
+    case GL_SPECULAR:
+    case GL_POSITION:
+        return 4;
+    default:
+        return 0;
     }
 }
 
 INTERNAL PURE FASTCALL GLint
-__glLightModelfv_size( GLenum e )
+__glLightModelfv_size(GLenum e)
 {
-    switch( e ) {
-        case GL_LIGHT_MODEL_LOCAL_VIEWER:
-        case GL_LIGHT_MODEL_TWO_SIDE:
-        case GL_LIGHT_MODEL_COLOR_CONTROL:
+    switch (e) {
+    case GL_LIGHT_MODEL_LOCAL_VIEWER:
+    case GL_LIGHT_MODEL_TWO_SIDE:
+    case GL_LIGHT_MODEL_COLOR_CONTROL:
 /*      case GL_LIGHT_MODEL_COLOR_CONTROL_EXT:*/
-            return 1;
-        case GL_LIGHT_MODEL_AMBIENT:
-            return 4;
-        default: return 0;
+        return 1;
+    case GL_LIGHT_MODEL_AMBIENT:
+        return 4;
+    default:
+        return 0;
     }
 }
 
 INTERNAL PURE FASTCALL GLint
-__glMaterialfv_size( GLenum e )
+__glMaterialfv_size(GLenum e)
 {
-    switch( e ) {
-        case GL_SHININESS:
-            return 1;
-        case GL_COLOR_INDEXES:
-            return 3;
-        case GL_AMBIENT:
-        case GL_DIFFUSE:
-        case GL_SPECULAR:
-        case GL_EMISSION:
-        case GL_AMBIENT_AND_DIFFUSE:
-            return 4;
-        default: return 0;
+    switch (e) {
+    case GL_SHININESS:
+        return 1;
+    case GL_COLOR_INDEXES:
+        return 3;
+    case GL_AMBIENT:
+    case GL_DIFFUSE:
+    case GL_SPECULAR:
+    case GL_EMISSION:
+    case GL_AMBIENT_AND_DIFFUSE:
+        return 4;
+    default:
+        return 0;
     }
 }
 
 INTERNAL PURE FASTCALL GLint
-__glTexParameterfv_size( GLenum e )
+__glTexParameterfv_size(GLenum e)
 {
-    switch( e ) {
-        case GL_TEXTURE_MAG_FILTER:
-        case GL_TEXTURE_MIN_FILTER:
-        case GL_TEXTURE_WRAP_S:
-        case GL_TEXTURE_WRAP_T:
-        case GL_TEXTURE_PRIORITY:
-        case GL_TEXTURE_WRAP_R:
-        case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
+    switch (e) {
+    case GL_TEXTURE_MAG_FILTER:
+    case GL_TEXTURE_MIN_FILTER:
+    case GL_TEXTURE_WRAP_S:
+    case GL_TEXTURE_WRAP_T:
+    case GL_TEXTURE_PRIORITY:
+    case GL_TEXTURE_WRAP_R:
+    case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
 /*      case GL_SHADOW_AMBIENT_SGIX:*/
-        case GL_TEXTURE_MIN_LOD:
-        case GL_TEXTURE_MAX_LOD:
-        case GL_TEXTURE_BASE_LEVEL:
-        case GL_TEXTURE_MAX_LEVEL:
-        case GL_TEXTURE_CLIPMAP_FRAME_SGIX:
-        case GL_TEXTURE_LOD_BIAS_S_SGIX:
-        case GL_TEXTURE_LOD_BIAS_T_SGIX:
-        case GL_TEXTURE_LOD_BIAS_R_SGIX:
-        case GL_GENERATE_MIPMAP:
+    case GL_TEXTURE_MIN_LOD:
+    case GL_TEXTURE_MAX_LOD:
+    case GL_TEXTURE_BASE_LEVEL:
+    case GL_TEXTURE_MAX_LEVEL:
+    case GL_TEXTURE_CLIPMAP_FRAME_SGIX:
+    case GL_TEXTURE_LOD_BIAS_S_SGIX:
+    case GL_TEXTURE_LOD_BIAS_T_SGIX:
+    case GL_TEXTURE_LOD_BIAS_R_SGIX:
+    case GL_GENERATE_MIPMAP:
 /*      case GL_GENERATE_MIPMAP_SGIS:*/
-        case GL_TEXTURE_COMPARE_SGIX:
-        case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
-        case GL_TEXTURE_MAX_CLAMP_S_SGIX:
-        case GL_TEXTURE_MAX_CLAMP_T_SGIX:
-        case GL_TEXTURE_MAX_CLAMP_R_SGIX:
-        case GL_TEXTURE_MAX_ANISOTROPY_EXT:
-        case GL_TEXTURE_LOD_BIAS:
+    case GL_TEXTURE_COMPARE_SGIX:
+    case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
+    case GL_TEXTURE_MAX_CLAMP_S_SGIX:
+    case GL_TEXTURE_MAX_CLAMP_T_SGIX:
+    case GL_TEXTURE_MAX_CLAMP_R_SGIX:
+    case GL_TEXTURE_MAX_ANISOTROPY_EXT:
+    case GL_TEXTURE_LOD_BIAS:
 /*      case GL_TEXTURE_LOD_BIAS_EXT:*/
-        case GL_DEPTH_TEXTURE_MODE:
+    case GL_DEPTH_TEXTURE_MODE:
 /*      case GL_DEPTH_TEXTURE_MODE_ARB:*/
-        case GL_TEXTURE_COMPARE_MODE:
+    case GL_TEXTURE_COMPARE_MODE:
 /*      case GL_TEXTURE_COMPARE_MODE_ARB:*/
-        case GL_TEXTURE_COMPARE_FUNC:
+    case GL_TEXTURE_COMPARE_FUNC:
 /*      case GL_TEXTURE_COMPARE_FUNC_ARB:*/
-        case GL_TEXTURE_UNSIGNED_REMAP_MODE_NV:
-            return 1;
-        case GL_TEXTURE_CLIPMAP_CENTER_SGIX:
-        case GL_TEXTURE_CLIPMAP_OFFSET_SGIX:
-            return 2;
-        case GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX:
-            return 3;
-        case GL_TEXTURE_BORDER_COLOR:
-        case GL_POST_TEXTURE_FILTER_BIAS_SGIX:
-        case GL_POST_TEXTURE_FILTER_SCALE_SGIX:
-            return 4;
-        default: return 0;
+    case GL_TEXTURE_UNSIGNED_REMAP_MODE_NV:
+        return 1;
+    case GL_TEXTURE_CLIPMAP_CENTER_SGIX:
+    case GL_TEXTURE_CLIPMAP_OFFSET_SGIX:
+        return 2;
+    case GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX:
+        return 3;
+    case GL_TEXTURE_BORDER_COLOR:
+    case GL_POST_TEXTURE_FILTER_BIAS_SGIX:
+    case GL_POST_TEXTURE_FILTER_SCALE_SGIX:
+        return 4;
+    default:
+        return 0;
     }
 }
 
 INTERNAL PURE FASTCALL GLint
-__glTexEnvfv_size( GLenum e )
+__glTexEnvfv_size(GLenum e)
 {
-    switch( e ) {
-        case GL_ALPHA_SCALE:
-        case GL_TEXTURE_ENV_MODE:
-        case GL_TEXTURE_LOD_BIAS:
-        case GL_COMBINE_RGB:
-        case GL_COMBINE_ALPHA:
-        case GL_RGB_SCALE:
-        case GL_SOURCE0_RGB:
-        case GL_SOURCE1_RGB:
-        case GL_SOURCE2_RGB:
-        case GL_SOURCE3_RGB_NV:
-        case GL_SOURCE0_ALPHA:
-        case GL_SOURCE1_ALPHA:
-        case GL_SOURCE2_ALPHA:
-        case GL_SOURCE3_ALPHA_NV:
-        case GL_OPERAND0_RGB:
-        case GL_OPERAND1_RGB:
-        case GL_OPERAND2_RGB:
-        case GL_OPERAND3_RGB_NV:
-        case GL_OPERAND0_ALPHA:
-        case GL_OPERAND1_ALPHA:
-        case GL_OPERAND2_ALPHA:
-        case GL_OPERAND3_ALPHA_NV:
-        case GL_COORD_REPLACE_ARB:
+    switch (e) {
+    case GL_ALPHA_SCALE:
+    case GL_TEXTURE_ENV_MODE:
+    case GL_TEXTURE_LOD_BIAS:
+    case GL_COMBINE_RGB:
+    case GL_COMBINE_ALPHA:
+    case GL_RGB_SCALE:
+    case GL_SOURCE0_RGB:
+    case GL_SOURCE1_RGB:
+    case GL_SOURCE2_RGB:
+    case GL_SOURCE3_RGB_NV:
+    case GL_SOURCE0_ALPHA:
+    case GL_SOURCE1_ALPHA:
+    case GL_SOURCE2_ALPHA:
+    case GL_SOURCE3_ALPHA_NV:
+    case GL_OPERAND0_RGB:
+    case GL_OPERAND1_RGB:
+    case GL_OPERAND2_RGB:
+    case GL_OPERAND3_RGB_NV:
+    case GL_OPERAND0_ALPHA:
+    case GL_OPERAND1_ALPHA:
+    case GL_OPERAND2_ALPHA:
+    case GL_OPERAND3_ALPHA_NV:
+    case GL_COORD_REPLACE_ARB:
 /*      case GL_COORD_REPLACE_NV:*/
-            return 1;
-        case GL_TEXTURE_ENV_COLOR:
-            return 4;
-        default: return 0;
+        return 1;
+    case GL_TEXTURE_ENV_COLOR:
+        return 4;
+    default:
+        return 0;
     }
 }
 
 INTERNAL PURE FASTCALL GLint
-__glTexGendv_size( GLenum e )
+__glTexGendv_size(GLenum e)
 {
-    switch( e ) {
-        case GL_TEXTURE_GEN_MODE:
-            return 1;
-        case GL_OBJECT_PLANE:
-        case GL_EYE_PLANE:
-            return 4;
-        default: return 0;
+    switch (e) {
+    case GL_TEXTURE_GEN_MODE:
+        return 1;
+    case GL_OBJECT_PLANE:
+    case GL_EYE_PLANE:
+        return 4;
+    default:
+        return 0;
     }
 }
 
 INTERNAL PURE FASTCALL GLint
-__glMap1d_size( GLenum e )
+__glMap1d_size(GLenum e)
 {
-    switch( e ) {
-        case GL_MAP1_INDEX:
-        case GL_MAP1_TEXTURE_COORD_1:
-            return 1;
-        case GL_MAP1_TEXTURE_COORD_2:
-            return 2;
-        case GL_MAP1_NORMAL:
-        case GL_MAP1_TEXTURE_COORD_3:
-        case GL_MAP1_VERTEX_3:
-            return 3;
-        case GL_MAP1_COLOR_4:
-        case GL_MAP1_TEXTURE_COORD_4:
-        case GL_MAP1_VERTEX_4:
-            return 4;
-        default: return 0;
+    switch (e) {
+    case GL_MAP1_INDEX:
+    case GL_MAP1_TEXTURE_COORD_1:
+        return 1;
+    case GL_MAP1_TEXTURE_COORD_2:
+        return 2;
+    case GL_MAP1_NORMAL:
+    case GL_MAP1_TEXTURE_COORD_3:
+    case GL_MAP1_VERTEX_3:
+        return 3;
+    case GL_MAP1_COLOR_4:
+    case GL_MAP1_TEXTURE_COORD_4:
+    case GL_MAP1_VERTEX_4:
+        return 4;
+    default:
+        return 0;
     }
 }
 
 INTERNAL PURE FASTCALL GLint
-__glMap2d_size( GLenum e )
+__glMap2d_size(GLenum e)
 {
-    switch( e ) {
-        case GL_MAP2_INDEX:
-        case GL_MAP2_TEXTURE_COORD_1:
-            return 1;
-        case GL_MAP2_TEXTURE_COORD_2:
-            return 2;
-        case GL_MAP2_NORMAL:
-        case GL_MAP2_TEXTURE_COORD_3:
-        case GL_MAP2_VERTEX_3:
-            return 3;
-        case GL_MAP2_COLOR_4:
-        case GL_MAP2_TEXTURE_COORD_4:
-        case GL_MAP2_VERTEX_4:
-            return 4;
-        default: return 0;
+    switch (e) {
+    case GL_MAP2_INDEX:
+    case GL_MAP2_TEXTURE_COORD_1:
+        return 1;
+    case GL_MAP2_TEXTURE_COORD_2:
+        return 2;
+    case GL_MAP2_NORMAL:
+    case GL_MAP2_TEXTURE_COORD_3:
+    case GL_MAP2_VERTEX_3:
+        return 3;
+    case GL_MAP2_COLOR_4:
+    case GL_MAP2_TEXTURE_COORD_4:
+    case GL_MAP2_VERTEX_4:
+        return 4;
+    default:
+        return 0;
     }
 }
 
 INTERNAL PURE FASTCALL GLint
-__glColorTableParameterfv_size( GLenum e )
+__glColorTableParameterfv_size(GLenum e)
 {
-    switch( e ) {
-        case GL_COLOR_TABLE_SCALE:
-        case GL_COLOR_TABLE_BIAS:
-            return 4;
-        default: return 0;
+    switch (e) {
+    case GL_COLOR_TABLE_SCALE:
+    case GL_COLOR_TABLE_BIAS:
+        return 4;
+    default:
+        return 0;
     }
 }
 
 INTERNAL PURE FASTCALL GLint
-__glConvolutionParameterfv_size( GLenum e )
+__glConvolutionParameterfv_size(GLenum e)
 {
-    switch( e ) {
-        case GL_CONVOLUTION_BORDER_MODE:
+    switch (e) {
+    case GL_CONVOLUTION_BORDER_MODE:
 /*      case GL_CONVOLUTION_BORDER_MODE_EXT:*/
-            return 1;
-        case GL_CONVOLUTION_FILTER_SCALE:
+        return 1;
+    case GL_CONVOLUTION_FILTER_SCALE:
 /*      case GL_CONVOLUTION_FILTER_SCALE_EXT:*/
-        case GL_CONVOLUTION_FILTER_BIAS:
+    case GL_CONVOLUTION_FILTER_BIAS:
 /*      case GL_CONVOLUTION_FILTER_BIAS_EXT:*/
-        case GL_CONVOLUTION_BORDER_COLOR:
+    case GL_CONVOLUTION_BORDER_COLOR:
 /*      case GL_CONVOLUTION_BORDER_COLOR_HP:*/
-            return 4;
-        default: return 0;
+        return 4;
+    default:
+        return 0;
     }
 }
 
 INTERNAL PURE FASTCALL GLint
-__glPointParameterfvEXT_size( GLenum e )
+__glPointParameterfvEXT_size(GLenum e)
 {
-    switch( e ) {
-        case GL_POINT_SIZE_MIN:
+    switch (e) {
+    case GL_POINT_SIZE_MIN:
 /*      case GL_POINT_SIZE_MIN_ARB:*/
 /*      case GL_POINT_SIZE_MIN_SGIS:*/
-        case GL_POINT_SIZE_MAX:
+    case GL_POINT_SIZE_MAX:
 /*      case GL_POINT_SIZE_MAX_ARB:*/
 /*      case GL_POINT_SIZE_MAX_SGIS:*/
-        case GL_POINT_FADE_THRESHOLD_SIZE:
+    case GL_POINT_FADE_THRESHOLD_SIZE:
 /*      case GL_POINT_FADE_THRESHOLD_SIZE_ARB:*/
 /*      case GL_POINT_FADE_THRESHOLD_SIZE_SGIS:*/
-        case GL_POINT_SPRITE_R_MODE_NV:
-        case GL_POINT_SPRITE_COORD_ORIGIN:
-            return 1;
-        case GL_POINT_DISTANCE_ATTENUATION:
+    case GL_POINT_SPRITE_R_MODE_NV:
+    case GL_POINT_SPRITE_COORD_ORIGIN:
+        return 1;
+    case GL_POINT_DISTANCE_ATTENUATION:
 /*      case GL_POINT_DISTANCE_ATTENUATION_ARB:*/
 /*      case GL_POINT_DISTANCE_ATTENUATION_SGIS:*/
-            return 3;
-        default: return 0;
+        return 3;
+    default:
+        return 0;
     }
 }
 
-ALIAS( Fogiv, Fogfv )
-ALIAS( Lightiv, Lightfv )
-ALIAS( LightModeliv, LightModelfv )
-ALIAS( Materialiv, Materialfv )
-ALIAS( TexParameteriv, TexParameterfv )
-ALIAS( TexEnviv, TexEnvfv )
-ALIAS( TexGenfv, TexGendv )
-ALIAS( TexGeniv, TexGendv )
-ALIAS( Map1f, Map1d )
-ALIAS( Map2f, Map2d )
-ALIAS( ColorTableParameteriv, ColorTableParameterfv )
-ALIAS( ConvolutionParameteriv, ConvolutionParameterfv )
-ALIAS( PointParameterivNV, PointParameterfvEXT )
-
+ALIAS(Fogiv, Fogfv)
+    ALIAS(Lightiv, Lightfv)
+    ALIAS(LightModeliv, LightModelfv)
+    ALIAS(Materialiv, Materialfv)
+    ALIAS(TexParameteriv, TexParameterfv)
+    ALIAS(TexEnviv, TexEnvfv)
+    ALIAS(TexGenfv, TexGendv)
+    ALIAS(TexGeniv, TexGendv)
+    ALIAS(Map1f, Map1d)
+    ALIAS(Map2f, Map2d)
+    ALIAS(ColorTableParameteriv, ColorTableParameterfv)
+    ALIAS(ConvolutionParameteriv, ConvolutionParameterfv)
+    ALIAS(PointParameterivNV, PointParameterfvEXT)
 #  undef PURE
 #  undef FASTCALL
 #  undef INTERNAL