src/glx/x11/indirect.c

   1 /* DO NOT EDIT - This file generated automatically by glX_proto_send.py (from Mesa) script */
   2
   3 /*
   4  * (C) Copyright IBM Corporation 2004
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sub license,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the next
  15  * paragraph) shall be included in all copies or substantial portions of the
  16  * Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
  21  * IBM,
  22  * AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  23  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  24  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  25  * SOFTWARE.
  26  */
  27
  28
  29 #include <GL/gl.h>
  30 #include "indirect.h"
  31 #include "glxclient.h"
  32 #include "size.h"
  33 #include <GL/glxproto.h>
  34
  35 #define __GLX_PAD(n) (((n) + 3) & ~3)
  36
  37 #  if defined(__i386__) && defined(__GNUC__)
  38 #    define FASTCALL __attribute__((fastcall))
  39 #  else
  40 #    define FASTCALL
  41 #  endif
  42 #  if defined(__GNUC__)
  43 #    define NOINLINE __attribute__((noinline))
  44 #  else
  45 #    define NOINLINE
  46 #  endif
  47
  48 #if !defined __GNUC__ || __GNUC__ < 3
  49 #  define __builtin_expect(x, y) x
  50 #endif
  51
  52 /* If the size and opcode values are known at compile-time, this will, on
  53  * x86 at least, emit them with a single instruction.
  54  */
  55 #define emit_header(dest, op, size)            \
  56     do { union { short s[2]; int i; } temp;    \
  57          temp.s[0] = (size); temp.s[1] = (op); \
  58          *((int *)(dest)) = temp.i; } while(0)
  59
  60 static NOINLINE CARD32
  61 read_reply( Display *dpy, size_t size, void * dest, GLboolean reply_is_always_array )
  62 {
  63     xGLXSingleReply reply;
  64
  65     (void) _XReply(dpy, (xReply *) & reply, 0, False);
  66     if (size != 0) {
  67         if ((reply.length > 0) || reply_is_always_array) {
  68             const GLint bytes = (reply_is_always_array)
  69               ? (4 * reply.length) : (reply.size * size);
  70             const GLint extra = 4 - (bytes & 3);
  71
  72             _XRead(dpy, dest, bytes);
  73             if ( extra < 4 ) {
  74                 _XEatData(dpy, extra);
  75             }
  76         }
  77         else {
  78             (void) memcpy( dest, &(reply.pad3), size);
  79         }
  80     }
  81
  82     return reply.retval;
  83 }
  84
  85 #define X_GLXSingle 0
  86
  87 static NOINLINE FASTCALL GLubyte *
  88 setup_single_request( __GLXcontext * gc, GLint sop, GLint cmdlen )
  89 {
  90     xGLXSingleReq * req;
  91     Display * const dpy = gc->currentDpy;
  92
  93     (void) __glXFlushRenderBuffer(gc, gc->pc);
  94     LockDisplay(dpy);
  95     GetReqExtra(GLXSingle, cmdlen, req);
  96     req->reqType = gc->majorOpcode;
  97     req->contextTag = gc->currentContextTag;
  98     req->glxCode = sop;
  99     return (GLubyte *)(req) + sz_xGLXSingleReq;
 100 }
 101
 102 static NOINLINE FASTCALL GLubyte *
 103 setup_vendor_request( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen )
 104 {
 105     xGLXVendorPrivateReq * req;
 106     Display * const dpy = gc->currentDpy;
 107
 108     (void) __glXFlushRenderBuffer(gc, gc->pc);
 109     LockDisplay(dpy);
 110     GetReqExtra(GLXVendorPrivate, cmdlen, req);
 111     req->reqType = gc->majorOpcode;
 112     req->glxCode = code;
 113     req->vendorCode = vop;
 114     req->contextTag = gc->currentContextTag;
 115     return (GLubyte *)(req) + sz_xGLXVendorPrivateReq;
 116 }
 117
 118 static FASTCALL NOINLINE void
 119 generic_3_byte( GLint rop, const void * ptr )
 120 {
 121     __GLXcontext * const gc = __glXGetCurrentContext();
 122     const GLuint cmdlen = 7;
 123
 124     emit_header(gc->pc, rop, cmdlen);
 125     (void) memcpy((void *)(gc->pc + 4), ptr, 3);
 126     gc->pc += cmdlen;
 127     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 128 }
 129
 130 static FASTCALL NOINLINE void
 131 generic_4_byte( GLint rop, const void * ptr )
 132 {
 133     __GLXcontext * const gc = __glXGetCurrentContext();
 134     const GLuint cmdlen = 8;
 135
 136     emit_header(gc->pc, rop, cmdlen);
 137     (void) memcpy((void *)(gc->pc + 4), ptr, 4);
 138     gc->pc += cmdlen;
 139     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 140 }
 141
 142 static FASTCALL NOINLINE void
 143 generic_6_byte( GLint rop, const void * ptr )
 144 {
 145     __GLXcontext * const gc = __glXGetCurrentContext();
 146     const GLuint cmdlen = 10;
 147
 148     emit_header(gc->pc, rop, cmdlen);
 149     (void) memcpy((void *)(gc->pc + 4), ptr, 6);
 150     gc->pc += cmdlen;
 151     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 152 }
 153
 154 static FASTCALL NOINLINE void
 155 generic_8_byte( GLint rop, const void * ptr )
 156 {
 157     __GLXcontext * const gc = __glXGetCurrentContext();
 158     const GLuint cmdlen = 12;
 159
 160     emit_header(gc->pc, rop, cmdlen);
 161     (void) memcpy((void *)(gc->pc + 4), ptr, 8);
 162     gc->pc += cmdlen;
 163     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 164 }
 165
 166 static FASTCALL NOINLINE void
 167 generic_12_byte( GLint rop, const void * ptr )
 168 {
 169     __GLXcontext * const gc = __glXGetCurrentContext();
 170     const GLuint cmdlen = 16;
 171
 172     emit_header(gc->pc, rop, cmdlen);
 173     (void) memcpy((void *)(gc->pc + 4), ptr, 12);
 174     gc->pc += cmdlen;
 175     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 176 }
 177
 178 static FASTCALL NOINLINE void
 179 generic_16_byte( GLint rop, const void * ptr )
 180 {
 181     __GLXcontext * const gc = __glXGetCurrentContext();
 182     const GLuint cmdlen = 20;
 183
 184     emit_header(gc->pc, rop, cmdlen);
 185     (void) memcpy((void *)(gc->pc + 4), ptr, 16);
 186     gc->pc += cmdlen;
 187     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 188 }
 189
 190 static FASTCALL NOINLINE void
 191 generic_24_byte( GLint rop, const void * ptr )
 192 {
 193     __GLXcontext * const gc = __glXGetCurrentContext();
 194     const GLuint cmdlen = 28;
 195
 196     emit_header(gc->pc, rop, cmdlen);
 197     (void) memcpy((void *)(gc->pc + 4), ptr, 24);
 198     gc->pc += cmdlen;
 199     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 200 }
 201
 202 static FASTCALL NOINLINE void
 203 generic_32_byte( GLint rop, const void * ptr )
 204 {
 205     __GLXcontext * const gc = __glXGetCurrentContext();
 206     const GLuint cmdlen = 36;
 207
 208     emit_header(gc->pc, rop, cmdlen);
 209     (void) memcpy((void *)(gc->pc + 4), ptr, 32);
 210     gc->pc += cmdlen;
 211     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 212 }
 213
 214 #define X_GLsop_NewList 101
 215 void
 216 __indirect_glNewList(GLuint list, GLenum mode)
 217 {
 218     __GLXcontext * const gc = __glXGetCurrentContext();
 219     Display * const dpy = gc->currentDpy;
 220     const GLuint cmdlen = 8;
 221     if (__builtin_expect(dpy != NULL, 1)) {
 222         GLubyte const * pc = setup_single_request(gc, X_GLsop_NewList, cmdlen);
 223         (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
 224         (void) memcpy((void *)(pc + 4), (void *)(&mode), 4);
 225         UnlockDisplay(dpy); SyncHandle();
 226     }
 227     return;
 228 }
 229
 230 #define X_GLsop_EndList 102
 231 void
 232 __indirect_glEndList(void)
 233 {
 234     __GLXcontext * const gc = __glXGetCurrentContext();
 235     Display * const dpy = gc->currentDpy;
 236     const GLuint cmdlen = 0;
 237     if (__builtin_expect(dpy != NULL, 1)) {
 238         (void) setup_single_request(gc, X_GLsop_EndList, cmdlen);
 239         UnlockDisplay(dpy); SyncHandle();
 240     }
 241     return;
 242 }
 243
 244 #define X_GLrop_CallList 1
 245 void
 246 __indirect_glCallList(GLuint list)
 247 {
 248     __GLXcontext * const gc = __glXGetCurrentContext();
 249     const GLuint cmdlen = 8;
 250     emit_header(gc->pc, X_GLrop_CallList, cmdlen);
 251     (void) memcpy((void *)(gc->pc + 4), (void *)(&list), 4);
 252     gc->pc += cmdlen;
 253     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 254 }
 255
 256 #define X_GLrop_CallLists 2
 257 void
 258 __indirect_glCallLists(GLsizei n, GLenum type, const GLvoid * lists)
 259 {
 260     __GLXcontext * const gc = __glXGetCurrentContext();
 261     const GLuint compsize = __glCallLists_size(type);
 262     const GLuint cmdlen = 12 + __GLX_PAD((compsize * n));
 263     if (__builtin_expect(gc->currentDpy != NULL, 1)) {
 264         if (cmdlen <= gc->maxSmallRenderCommandSize) {
 265             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
 266                 (void) __glXFlushRenderBuffer(gc, gc->pc);
 267             }
 268             emit_header(gc->pc, X_GLrop_CallLists, cmdlen);
 269             (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
 270             (void) memcpy((void *)(gc->pc + 8), (void *)(&type), 4);
 271             (void) memcpy((void *)(gc->pc + 12), (void *)(lists), (compsize * n));
 272             gc->pc += cmdlen;
 273             if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 274         }
 275         else {
 276             const GLint op = X_GLrop_CallLists;
 277             const GLuint cmdlenLarge = cmdlen + 4;
 278             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
 279             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
 280             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
 281             (void) memcpy((void *)(pc + 8), (void *)(&n), 4);
 282             (void) memcpy((void *)(pc + 12), (void *)(&type), 4);
 283             __glXSendLargeCommand(gc, pc, 16, lists, (compsize * n));
 284         }
 285     }
 286 }
 287
 288 #define X_GLsop_DeleteLists 103
 289 void
 290 __indirect_glDeleteLists(GLuint list, GLsizei range)
 291 {
 292     __GLXcontext * const gc = __glXGetCurrentContext();
 293     Display * const dpy = gc->currentDpy;
 294     const GLuint cmdlen = 8;
 295     if (__builtin_expect(dpy != NULL, 1)) {
 296         GLubyte const * pc = setup_single_request(gc, X_GLsop_DeleteLists, cmdlen);
 297         (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
 298         (void) memcpy((void *)(pc + 4), (void *)(&range), 4);
 299         UnlockDisplay(dpy); SyncHandle();
 300     }
 301     return;
 302 }
 303
 304 #define X_GLsop_GenLists 104
 305 GLuint
 306 __indirect_glGenLists(GLsizei range)
 307 {
 308     __GLXcontext * const gc = __glXGetCurrentContext();
 309     Display * const dpy = gc->currentDpy;
 310     GLuint retval = (GLuint) 0;
 311     const GLuint cmdlen = 4;
 312     if (__builtin_expect(dpy != NULL, 1)) {
 313         GLubyte const * pc = setup_single_request(gc, X_GLsop_GenLists, cmdlen);
 314         (void) memcpy((void *)(pc + 0), (void *)(&range), 4);
 315         retval = (GLuint) read_reply(dpy, 0, NULL, GL_FALSE);
 316         UnlockDisplay(dpy); SyncHandle();
 317     }
 318     return retval;
 319 }
 320
 321 #define X_GLrop_ListBase 3
 322 void
 323 __indirect_glListBase(GLuint base)
 324 {
 325     __GLXcontext * const gc = __glXGetCurrentContext();
 326     const GLuint cmdlen = 8;
 327     emit_header(gc->pc, X_GLrop_ListBase, cmdlen);
 328     (void) memcpy((void *)(gc->pc + 4), (void *)(&base), 4);
 329     gc->pc += cmdlen;
 330     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 331 }
 332
 333 #define X_GLrop_Begin 4
 334 void
 335 __indirect_glBegin(GLenum mode)
 336 {
 337     __GLXcontext * const gc = __glXGetCurrentContext();
 338     const GLuint cmdlen = 8;
 339     emit_header(gc->pc, X_GLrop_Begin, cmdlen);
 340     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
 341     gc->pc += cmdlen;
 342     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 343 }
 344
 345 #define X_GLrop_Color3bv 6
 346 void
 347 __indirect_glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 348 {
 349     __GLXcontext * const gc = __glXGetCurrentContext();
 350     const GLuint cmdlen = 8;
 351     emit_header(gc->pc, X_GLrop_Color3bv, cmdlen);
 352     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
 353     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
 354     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
 355     gc->pc += cmdlen;
 356     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 357 }
 358
 359 #define X_GLrop_Color3bv 6
 360 void
 361 __indirect_glColor3bv(const GLbyte * v)
 362 {
 363     generic_3_byte( X_GLrop_Color3bv, v );
 364 }
 365
 366 #define X_GLrop_Color3dv 7
 367 void
 368 __indirect_glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 369 {
 370     __GLXcontext * const gc = __glXGetCurrentContext();
 371     const GLuint cmdlen = 28;
 372     emit_header(gc->pc, X_GLrop_Color3dv, cmdlen);
 373     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
 374     (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
 375     (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
 376     gc->pc += cmdlen;
 377     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 378 }
 379
 380 #define X_GLrop_Color3dv 7
 381 void
 382 __indirect_glColor3dv(const GLdouble * v)
 383 {
 384     generic_24_byte( X_GLrop_Color3dv, v );
 385 }
 386
 387 #define X_GLrop_Color3fv 8
 388 void
 389 __indirect_glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 390 {
 391     __GLXcontext * const gc = __glXGetCurrentContext();
 392     const GLuint cmdlen = 16;
 393     emit_header(gc->pc, X_GLrop_Color3fv, cmdlen);
 394     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 395     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 396     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 397     gc->pc += cmdlen;
 398     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 399 }
 400
 401 #define X_GLrop_Color3fv 8
 402 void
 403 __indirect_glColor3fv(const GLfloat * v)
 404 {
 405     generic_12_byte( X_GLrop_Color3fv, v );
 406 }
 407
 408 #define X_GLrop_Color3iv 9
 409 void
 410 __indirect_glColor3i(GLint red, GLint green, GLint blue)
 411 {
 412     __GLXcontext * const gc = __glXGetCurrentContext();
 413     const GLuint cmdlen = 16;
 414     emit_header(gc->pc, X_GLrop_Color3iv, cmdlen);
 415     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 416     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 417     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 418     gc->pc += cmdlen;
 419     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 420 }
 421
 422 #define X_GLrop_Color3iv 9
 423 void
 424 __indirect_glColor3iv(const GLint * v)
 425 {
 426     generic_12_byte( X_GLrop_Color3iv, v );
 427 }
 428
 429 #define X_GLrop_Color3sv 10
 430 void
 431 __indirect_glColor3s(GLshort red, GLshort green, GLshort blue)
 432 {
 433     __GLXcontext * const gc = __glXGetCurrentContext();
 434     const GLuint cmdlen = 12;
 435     emit_header(gc->pc, X_GLrop_Color3sv, cmdlen);
 436     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
 437     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
 438     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
 439     gc->pc += cmdlen;
 440     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 441 }
 442
 443 #define X_GLrop_Color3sv 10
 444 void
 445 __indirect_glColor3sv(const GLshort * v)
 446 {
 447     generic_6_byte( X_GLrop_Color3sv, v );
 448 }
 449
 450 #define X_GLrop_Color3ubv 11
 451 void
 452 __indirect_glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 453 {
 454     __GLXcontext * const gc = __glXGetCurrentContext();
 455     const GLuint cmdlen = 8;
 456     emit_header(gc->pc, X_GLrop_Color3ubv, cmdlen);
 457     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
 458     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
 459     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
 460     gc->pc += cmdlen;
 461     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 462 }
 463
 464 #define X_GLrop_Color3ubv 11
 465 void
 466 __indirect_glColor3ubv(const GLubyte * v)
 467 {
 468     generic_3_byte( X_GLrop_Color3ubv, v );
 469 }
 470
 471 #define X_GLrop_Color3uiv 12
 472 void
 473 __indirect_glColor3ui(GLuint red, GLuint green, GLuint blue)
 474 {
 475     __GLXcontext * const gc = __glXGetCurrentContext();
 476     const GLuint cmdlen = 16;
 477     emit_header(gc->pc, X_GLrop_Color3uiv, cmdlen);
 478     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 479     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 480     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 481     gc->pc += cmdlen;
 482     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 483 }
 484
 485 #define X_GLrop_Color3uiv 12
 486 void
 487 __indirect_glColor3uiv(const GLuint * v)
 488 {
 489     generic_12_byte( X_GLrop_Color3uiv, v );
 490 }
 491
 492 #define X_GLrop_Color3usv 13
 493 void
 494 __indirect_glColor3us(GLushort red, GLushort green, GLushort blue)
 495 {
 496     __GLXcontext * const gc = __glXGetCurrentContext();
 497     const GLuint cmdlen = 12;
 498     emit_header(gc->pc, X_GLrop_Color3usv, cmdlen);
 499     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
 500     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
 501     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
 502     gc->pc += cmdlen;
 503     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 504 }
 505
 506 #define X_GLrop_Color3usv 13
 507 void
 508 __indirect_glColor3usv(const GLushort * v)
 509 {
 510     generic_6_byte( X_GLrop_Color3usv, v );
 511 }
 512
 513 #define X_GLrop_Color4bv 14
 514 void
 515 __indirect_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 516 {
 517     __GLXcontext * const gc = __glXGetCurrentContext();
 518     const GLuint cmdlen = 8;
 519     emit_header(gc->pc, X_GLrop_Color4bv, cmdlen);
 520     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
 521     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
 522     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
 523     (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
 524     gc->pc += cmdlen;
 525     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 526 }
 527
 528 #define X_GLrop_Color4bv 14
 529 void
 530 __indirect_glColor4bv(const GLbyte * v)
 531 {
 532     generic_4_byte( X_GLrop_Color4bv, v );
 533 }
 534
 535 #define X_GLrop_Color4dv 15
 536 void
 537 __indirect_glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 538 {
 539     __GLXcontext * const gc = __glXGetCurrentContext();
 540     const GLuint cmdlen = 36;
 541     emit_header(gc->pc, X_GLrop_Color4dv, cmdlen);
 542     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
 543     (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
 544     (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
 545     (void) memcpy((void *)(gc->pc + 28), (void *)(&alpha), 8);
 546     gc->pc += cmdlen;
 547     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 548 }
 549
 550 #define X_GLrop_Color4dv 15
 551 void
 552 __indirect_glColor4dv(const GLdouble * v)
 553 {
 554     generic_32_byte( X_GLrop_Color4dv, v );
 555 }
 556
 557 #define X_GLrop_Color4fv 16
 558 void
 559 __indirect_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 560 {
 561     __GLXcontext * const gc = __glXGetCurrentContext();
 562     const GLuint cmdlen = 20;
 563     emit_header(gc->pc, X_GLrop_Color4fv, cmdlen);
 564     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 565     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 566     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 567     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
 568     gc->pc += cmdlen;
 569     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 570 }
 571
 572 #define X_GLrop_Color4fv 16
 573 void
 574 __indirect_glColor4fv(const GLfloat * v)
 575 {
 576     generic_16_byte( X_GLrop_Color4fv, v );
 577 }
 578
 579 #define X_GLrop_Color4iv 17
 580 void
 581 __indirect_glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 582 {
 583     __GLXcontext * const gc = __glXGetCurrentContext();
 584     const GLuint cmdlen = 20;
 585     emit_header(gc->pc, X_GLrop_Color4iv, cmdlen);
 586     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 587     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 588     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 589     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
 590     gc->pc += cmdlen;
 591     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 592 }
 593
 594 #define X_GLrop_Color4iv 17
 595 void
 596 __indirect_glColor4iv(const GLint * v)
 597 {
 598     generic_16_byte( X_GLrop_Color4iv, v );
 599 }
 600
 601 #define X_GLrop_Color4sv 18
 602 void
 603 __indirect_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 604 {
 605     __GLXcontext * const gc = __glXGetCurrentContext();
 606     const GLuint cmdlen = 12;
 607     emit_header(gc->pc, X_GLrop_Color4sv, cmdlen);
 608     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
 609     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
 610     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
 611     (void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2);
 612     gc->pc += cmdlen;
 613     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 614 }
 615
 616 #define X_GLrop_Color4sv 18
 617 void
 618 __indirect_glColor4sv(const GLshort * v)
 619 {
 620     generic_8_byte( X_GLrop_Color4sv, v );
 621 }
 622
 623 #define X_GLrop_Color4ubv 19
 624 void
 625 __indirect_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 626 {
 627     __GLXcontext * const gc = __glXGetCurrentContext();
 628     const GLuint cmdlen = 8;
 629     emit_header(gc->pc, X_GLrop_Color4ubv, cmdlen);
 630     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
 631     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
 632     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
 633     (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
 634     gc->pc += cmdlen;
 635     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 636 }
 637
 638 #define X_GLrop_Color4ubv 19
 639 void
 640 __indirect_glColor4ubv(const GLubyte * v)
 641 {
 642     generic_4_byte( X_GLrop_Color4ubv, v );
 643 }
 644
 645 #define X_GLrop_Color4uiv 20
 646 void
 647 __indirect_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 648 {
 649     __GLXcontext * const gc = __glXGetCurrentContext();
 650     const GLuint cmdlen = 20;
 651     emit_header(gc->pc, X_GLrop_Color4uiv, cmdlen);
 652     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
 653     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
 654     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
 655     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
 656     gc->pc += cmdlen;
 657     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 658 }
 659
 660 #define X_GLrop_Color4uiv 20
 661 void
 662 __indirect_glColor4uiv(const GLuint * v)
 663 {
 664     generic_16_byte( X_GLrop_Color4uiv, v );
 665 }
 666
 667 #define X_GLrop_Color4usv 21
 668 void
 669 __indirect_glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 670 {
 671     __GLXcontext * const gc = __glXGetCurrentContext();
 672     const GLuint cmdlen = 12;
 673     emit_header(gc->pc, X_GLrop_Color4usv, cmdlen);
 674     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
 675     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
 676     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
 677     (void) memcpy((void *)(gc->pc + 10), (void *)(&alpha), 2);
 678     gc->pc += cmdlen;
 679     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 680 }
 681
 682 #define X_GLrop_Color4usv 21
 683 void
 684 __indirect_glColor4usv(const GLushort * v)
 685 {
 686     generic_8_byte( X_GLrop_Color4usv, v );
 687 }
 688
 689 #define X_GLrop_EdgeFlagv 22
 690 void
 691 __indirect_glEdgeFlag(GLboolean flag)
 692 {
 693     __GLXcontext * const gc = __glXGetCurrentContext();
 694     const GLuint cmdlen = 8;
 695     emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
 696     (void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1);
 697     gc->pc += cmdlen;
 698     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 699 }
 700
 701 #define X_GLrop_EdgeFlagv 22
 702 void
 703 __indirect_glEdgeFlagv(const GLboolean * flag)
 704 {
 705     __GLXcontext * const gc = __glXGetCurrentContext();
 706     const GLuint cmdlen = 8;
 707     emit_header(gc->pc, X_GLrop_EdgeFlagv, cmdlen);
 708     (void) memcpy((void *)(gc->pc + 4), (void *)(flag), 1);
 709     gc->pc += cmdlen;
 710     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 711 }
 712
 713 #define X_GLrop_End 23
 714 void
 715 __indirect_glEnd(void)
 716 {
 717     __GLXcontext * const gc = __glXGetCurrentContext();
 718     const GLuint cmdlen = 4;
 719     emit_header(gc->pc, X_GLrop_End, cmdlen);
 720     gc->pc += cmdlen;
 721     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 722 }
 723
 724 #define X_GLrop_Indexdv 24
 725 void
 726 __indirect_glIndexd(GLdouble c)
 727 {
 728     __GLXcontext * const gc = __glXGetCurrentContext();
 729     const GLuint cmdlen = 12;
 730     emit_header(gc->pc, X_GLrop_Indexdv, cmdlen);
 731     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 8);
 732     gc->pc += cmdlen;
 733     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 734 }
 735
 736 #define X_GLrop_Indexdv 24
 737 void
 738 __indirect_glIndexdv(const GLdouble * c)
 739 {
 740     generic_8_byte( X_GLrop_Indexdv, c );
 741 }
 742
 743 #define X_GLrop_Indexfv 25
 744 void
 745 __indirect_glIndexf(GLfloat c)
 746 {
 747     __GLXcontext * const gc = __glXGetCurrentContext();
 748     const GLuint cmdlen = 8;
 749     emit_header(gc->pc, X_GLrop_Indexfv, cmdlen);
 750     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
 751     gc->pc += cmdlen;
 752     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 753 }
 754
 755 #define X_GLrop_Indexfv 25
 756 void
 757 __indirect_glIndexfv(const GLfloat * c)
 758 {
 759     generic_4_byte( X_GLrop_Indexfv, c );
 760 }
 761
 762 #define X_GLrop_Indexiv 26
 763 void
 764 __indirect_glIndexi(GLint c)
 765 {
 766     __GLXcontext * const gc = __glXGetCurrentContext();
 767     const GLuint cmdlen = 8;
 768     emit_header(gc->pc, X_GLrop_Indexiv, cmdlen);
 769     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
 770     gc->pc += cmdlen;
 771     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 772 }
 773
 774 #define X_GLrop_Indexiv 26
 775 void
 776 __indirect_glIndexiv(const GLint * c)
 777 {
 778     generic_4_byte( X_GLrop_Indexiv, c );
 779 }
 780
 781 #define X_GLrop_Indexsv 27
 782 void
 783 __indirect_glIndexs(GLshort c)
 784 {
 785     __GLXcontext * const gc = __glXGetCurrentContext();
 786     const GLuint cmdlen = 8;
 787     emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
 788     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 2);
 789     gc->pc += cmdlen;
 790     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 791 }
 792
 793 #define X_GLrop_Indexsv 27
 794 void
 795 __indirect_glIndexsv(const GLshort * c)
 796 {
 797     __GLXcontext * const gc = __glXGetCurrentContext();
 798     const GLuint cmdlen = 8;
 799     emit_header(gc->pc, X_GLrop_Indexsv, cmdlen);
 800     (void) memcpy((void *)(gc->pc + 4), (void *)(c), 2);
 801     gc->pc += cmdlen;
 802     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 803 }
 804
 805 #define X_GLrop_Normal3bv 28
 806 void
 807 __indirect_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 808 {
 809     __GLXcontext * const gc = __glXGetCurrentContext();
 810     const GLuint cmdlen = 8;
 811     emit_header(gc->pc, X_GLrop_Normal3bv, cmdlen);
 812     (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 1);
 813     (void) memcpy((void *)(gc->pc + 5), (void *)(&ny), 1);
 814     (void) memcpy((void *)(gc->pc + 6), (void *)(&nz), 1);
 815     gc->pc += cmdlen;
 816     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 817 }
 818
 819 #define X_GLrop_Normal3bv 28
 820 void
 821 __indirect_glNormal3bv(const GLbyte * v)
 822 {
 823     generic_3_byte( X_GLrop_Normal3bv, v );
 824 }
 825
 826 #define X_GLrop_Normal3dv 29
 827 void
 828 __indirect_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 829 {
 830     __GLXcontext * const gc = __glXGetCurrentContext();
 831     const GLuint cmdlen = 28;
 832     emit_header(gc->pc, X_GLrop_Normal3dv, cmdlen);
 833     (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 8);
 834     (void) memcpy((void *)(gc->pc + 12), (void *)(&ny), 8);
 835     (void) memcpy((void *)(gc->pc + 20), (void *)(&nz), 8);
 836     gc->pc += cmdlen;
 837     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 838 }
 839
 840 #define X_GLrop_Normal3dv 29
 841 void
 842 __indirect_glNormal3dv(const GLdouble * v)
 843 {
 844     generic_24_byte( X_GLrop_Normal3dv, v );
 845 }
 846
 847 #define X_GLrop_Normal3fv 30
 848 void
 849 __indirect_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 850 {
 851     __GLXcontext * const gc = __glXGetCurrentContext();
 852     const GLuint cmdlen = 16;
 853     emit_header(gc->pc, X_GLrop_Normal3fv, cmdlen);
 854     (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4);
 855     (void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4);
 856     (void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4);
 857     gc->pc += cmdlen;
 858     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 859 }
 860
 861 #define X_GLrop_Normal3fv 30
 862 void
 863 __indirect_glNormal3fv(const GLfloat * v)
 864 {
 865     generic_12_byte( X_GLrop_Normal3fv, v );
 866 }
 867
 868 #define X_GLrop_Normal3iv 31
 869 void
 870 __indirect_glNormal3i(GLint nx, GLint ny, GLint nz)
 871 {
 872     __GLXcontext * const gc = __glXGetCurrentContext();
 873     const GLuint cmdlen = 16;
 874     emit_header(gc->pc, X_GLrop_Normal3iv, cmdlen);
 875     (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 4);
 876     (void) memcpy((void *)(gc->pc + 8), (void *)(&ny), 4);
 877     (void) memcpy((void *)(gc->pc + 12), (void *)(&nz), 4);
 878     gc->pc += cmdlen;
 879     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 880 }
 881
 882 #define X_GLrop_Normal3iv 31
 883 void
 884 __indirect_glNormal3iv(const GLint * v)
 885 {
 886     generic_12_byte( X_GLrop_Normal3iv, v );
 887 }
 888
 889 #define X_GLrop_Normal3sv 32
 890 void
 891 __indirect_glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 892 {
 893     __GLXcontext * const gc = __glXGetCurrentContext();
 894     const GLuint cmdlen = 12;
 895     emit_header(gc->pc, X_GLrop_Normal3sv, cmdlen);
 896     (void) memcpy((void *)(gc->pc + 4), (void *)(&nx), 2);
 897     (void) memcpy((void *)(gc->pc + 6), (void *)(&ny), 2);
 898     (void) memcpy((void *)(gc->pc + 8), (void *)(&nz), 2);
 899     gc->pc += cmdlen;
 900     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 901 }
 902
 903 #define X_GLrop_Normal3sv 32
 904 void
 905 __indirect_glNormal3sv(const GLshort * v)
 906 {
 907     generic_6_byte( X_GLrop_Normal3sv, v );
 908 }
 909
 910 #define X_GLrop_RasterPos2dv 33
 911 void
 912 __indirect_glRasterPos2d(GLdouble x, GLdouble y)
 913 {
 914     __GLXcontext * const gc = __glXGetCurrentContext();
 915     const GLuint cmdlen = 20;
 916     emit_header(gc->pc, X_GLrop_RasterPos2dv, cmdlen);
 917     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
 918     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
 919     gc->pc += cmdlen;
 920     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 921 }
 922
 923 #define X_GLrop_RasterPos2dv 33
 924 void
 925 __indirect_glRasterPos2dv(const GLdouble * v)
 926 {
 927     generic_16_byte( X_GLrop_RasterPos2dv, v );
 928 }
 929
 930 #define X_GLrop_RasterPos2fv 34
 931 void
 932 __indirect_glRasterPos2f(GLfloat x, GLfloat y)
 933 {
 934     __GLXcontext * const gc = __glXGetCurrentContext();
 935     const GLuint cmdlen = 12;
 936     emit_header(gc->pc, X_GLrop_RasterPos2fv, cmdlen);
 937     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
 938     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
 939     gc->pc += cmdlen;
 940     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 941 }
 942
 943 #define X_GLrop_RasterPos2fv 34
 944 void
 945 __indirect_glRasterPos2fv(const GLfloat * v)
 946 {
 947     generic_8_byte( X_GLrop_RasterPos2fv, v );
 948 }
 949
 950 #define X_GLrop_RasterPos2iv 35
 951 void
 952 __indirect_glRasterPos2i(GLint x, GLint y)
 953 {
 954     __GLXcontext * const gc = __glXGetCurrentContext();
 955     const GLuint cmdlen = 12;
 956     emit_header(gc->pc, X_GLrop_RasterPos2iv, cmdlen);
 957     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
 958     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
 959     gc->pc += cmdlen;
 960     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 961 }
 962
 963 #define X_GLrop_RasterPos2iv 35
 964 void
 965 __indirect_glRasterPos2iv(const GLint * v)
 966 {
 967     generic_8_byte( X_GLrop_RasterPos2iv, v );
 968 }
 969
 970 #define X_GLrop_RasterPos2sv 36
 971 void
 972 __indirect_glRasterPos2s(GLshort x, GLshort y)
 973 {
 974     __GLXcontext * const gc = __glXGetCurrentContext();
 975     const GLuint cmdlen = 8;
 976     emit_header(gc->pc, X_GLrop_RasterPos2sv, cmdlen);
 977     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
 978     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
 979     gc->pc += cmdlen;
 980     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
 981 }
 982
 983 #define X_GLrop_RasterPos2sv 36
 984 void
 985 __indirect_glRasterPos2sv(const GLshort * v)
 986 {
 987     generic_4_byte( X_GLrop_RasterPos2sv, v );
 988 }
 989
 990 #define X_GLrop_RasterPos3dv 37
 991 void
 992 __indirect_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 993 {
 994     __GLXcontext * const gc = __glXGetCurrentContext();
 995     const GLuint cmdlen = 28;
 996     emit_header(gc->pc, X_GLrop_RasterPos3dv, cmdlen);
 997     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
 998     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
 999     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1000     gc->pc += cmdlen;
1001     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1002 }
1003
1004 #define X_GLrop_RasterPos3dv 37
1005 void
1006 __indirect_glRasterPos3dv(const GLdouble * v)
1007 {
1008     generic_24_byte( X_GLrop_RasterPos3dv, v );
1009 }
1010
1011 #define X_GLrop_RasterPos3fv 38
1012 void
1013 __indirect_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
1014 {
1015     __GLXcontext * const gc = __glXGetCurrentContext();
1016     const GLuint cmdlen = 16;
1017     emit_header(gc->pc, X_GLrop_RasterPos3fv, cmdlen);
1018     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1019     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1020     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1021     gc->pc += cmdlen;
1022     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1023 }
1024
1025 #define X_GLrop_RasterPos3fv 38
1026 void
1027 __indirect_glRasterPos3fv(const GLfloat * v)
1028 {
1029     generic_12_byte( X_GLrop_RasterPos3fv, v );
1030 }
1031
1032 #define X_GLrop_RasterPos3iv 39
1033 void
1034 __indirect_glRasterPos3i(GLint x, GLint y, GLint z)
1035 {
1036     __GLXcontext * const gc = __glXGetCurrentContext();
1037     const GLuint cmdlen = 16;
1038     emit_header(gc->pc, X_GLrop_RasterPos3iv, cmdlen);
1039     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1040     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1041     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1042     gc->pc += cmdlen;
1043     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1044 }
1045
1046 #define X_GLrop_RasterPos3iv 39
1047 void
1048 __indirect_glRasterPos3iv(const GLint * v)
1049 {
1050     generic_12_byte( X_GLrop_RasterPos3iv, v );
1051 }
1052
1053 #define X_GLrop_RasterPos3sv 40
1054 void
1055 __indirect_glRasterPos3s(GLshort x, GLshort y, GLshort z)
1056 {
1057     __GLXcontext * const gc = __glXGetCurrentContext();
1058     const GLuint cmdlen = 12;
1059     emit_header(gc->pc, X_GLrop_RasterPos3sv, cmdlen);
1060     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1061     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1062     (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1063     gc->pc += cmdlen;
1064     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1065 }
1066
1067 #define X_GLrop_RasterPos3sv 40
1068 void
1069 __indirect_glRasterPos3sv(const GLshort * v)
1070 {
1071     generic_6_byte( X_GLrop_RasterPos3sv, v );
1072 }
1073
1074 #define X_GLrop_RasterPos4dv 41
1075 void
1076 __indirect_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1077 {
1078     __GLXcontext * const gc = __glXGetCurrentContext();
1079     const GLuint cmdlen = 36;
1080     emit_header(gc->pc, X_GLrop_RasterPos4dv, cmdlen);
1081     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1082     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1083     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1084     (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
1085     gc->pc += cmdlen;
1086     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1087 }
1088
1089 #define X_GLrop_RasterPos4dv 41
1090 void
1091 __indirect_glRasterPos4dv(const GLdouble * v)
1092 {
1093     generic_32_byte( X_GLrop_RasterPos4dv, v );
1094 }
1095
1096 #define X_GLrop_RasterPos4fv 42
1097 void
1098 __indirect_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1099 {
1100     __GLXcontext * const gc = __glXGetCurrentContext();
1101     const GLuint cmdlen = 20;
1102     emit_header(gc->pc, X_GLrop_RasterPos4fv, cmdlen);
1103     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1104     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1105     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1106     (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1107     gc->pc += cmdlen;
1108     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1109 }
1110
1111 #define X_GLrop_RasterPos4fv 42
1112 void
1113 __indirect_glRasterPos4fv(const GLfloat * v)
1114 {
1115     generic_16_byte( X_GLrop_RasterPos4fv, v );
1116 }
1117
1118 #define X_GLrop_RasterPos4iv 43
1119 void
1120 __indirect_glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
1121 {
1122     __GLXcontext * const gc = __glXGetCurrentContext();
1123     const GLuint cmdlen = 20;
1124     emit_header(gc->pc, X_GLrop_RasterPos4iv, cmdlen);
1125     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1126     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1127     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1128     (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1129     gc->pc += cmdlen;
1130     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1131 }
1132
1133 #define X_GLrop_RasterPos4iv 43
1134 void
1135 __indirect_glRasterPos4iv(const GLint * v)
1136 {
1137     generic_16_byte( X_GLrop_RasterPos4iv, v );
1138 }
1139
1140 #define X_GLrop_RasterPos4sv 44
1141 void
1142 __indirect_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
1143 {
1144     __GLXcontext * const gc = __glXGetCurrentContext();
1145     const GLuint cmdlen = 12;
1146     emit_header(gc->pc, X_GLrop_RasterPos4sv, cmdlen);
1147     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1148     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1149     (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1150     (void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2);
1151     gc->pc += cmdlen;
1152     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1153 }
1154
1155 #define X_GLrop_RasterPos4sv 44
1156 void
1157 __indirect_glRasterPos4sv(const GLshort * v)
1158 {
1159     generic_8_byte( X_GLrop_RasterPos4sv, v );
1160 }
1161
1162 #define X_GLrop_Rectdv 45
1163 void
1164 __indirect_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
1165 {
1166     __GLXcontext * const gc = __glXGetCurrentContext();
1167     const GLuint cmdlen = 36;
1168     emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
1169     (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 8);
1170     (void) memcpy((void *)(gc->pc + 12), (void *)(&y1), 8);
1171     (void) memcpy((void *)(gc->pc + 20), (void *)(&x2), 8);
1172     (void) memcpy((void *)(gc->pc + 28), (void *)(&y2), 8);
1173     gc->pc += cmdlen;
1174     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1175 }
1176
1177 #define X_GLrop_Rectdv 45
1178 void
1179 __indirect_glRectdv(const GLdouble * v1, const GLdouble * v2)
1180 {
1181     __GLXcontext * const gc = __glXGetCurrentContext();
1182     const GLuint cmdlen = 36;
1183     emit_header(gc->pc, X_GLrop_Rectdv, cmdlen);
1184     (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 16);
1185     (void) memcpy((void *)(gc->pc + 20), (void *)(v2), 16);
1186     gc->pc += cmdlen;
1187     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1188 }
1189
1190 #define X_GLrop_Rectfv 46
1191 void
1192 __indirect_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
1193 {
1194     __GLXcontext * const gc = __glXGetCurrentContext();
1195     const GLuint cmdlen = 20;
1196     emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
1197     (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4);
1198     (void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4);
1199     (void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4);
1200     (void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4);
1201     gc->pc += cmdlen;
1202     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1203 }
1204
1205 #define X_GLrop_Rectfv 46
1206 void
1207 __indirect_glRectfv(const GLfloat * v1, const GLfloat * v2)
1208 {
1209     __GLXcontext * const gc = __glXGetCurrentContext();
1210     const GLuint cmdlen = 20;
1211     emit_header(gc->pc, X_GLrop_Rectfv, cmdlen);
1212     (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8);
1213     (void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8);
1214     gc->pc += cmdlen;
1215     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1216 }
1217
1218 #define X_GLrop_Rectiv 47
1219 void
1220 __indirect_glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
1221 {
1222     __GLXcontext * const gc = __glXGetCurrentContext();
1223     const GLuint cmdlen = 20;
1224     emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
1225     (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 4);
1226     (void) memcpy((void *)(gc->pc + 8), (void *)(&y1), 4);
1227     (void) memcpy((void *)(gc->pc + 12), (void *)(&x2), 4);
1228     (void) memcpy((void *)(gc->pc + 16), (void *)(&y2), 4);
1229     gc->pc += cmdlen;
1230     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1231 }
1232
1233 #define X_GLrop_Rectiv 47
1234 void
1235 __indirect_glRectiv(const GLint * v1, const GLint * v2)
1236 {
1237     __GLXcontext * const gc = __glXGetCurrentContext();
1238     const GLuint cmdlen = 20;
1239     emit_header(gc->pc, X_GLrop_Rectiv, cmdlen);
1240     (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 8);
1241     (void) memcpy((void *)(gc->pc + 12), (void *)(v2), 8);
1242     gc->pc += cmdlen;
1243     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1244 }
1245
1246 #define X_GLrop_Rectsv 48
1247 void
1248 __indirect_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
1249 {
1250     __GLXcontext * const gc = __glXGetCurrentContext();
1251     const GLuint cmdlen = 12;
1252     emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
1253     (void) memcpy((void *)(gc->pc + 4), (void *)(&x1), 2);
1254     (void) memcpy((void *)(gc->pc + 6), (void *)(&y1), 2);
1255     (void) memcpy((void *)(gc->pc + 8), (void *)(&x2), 2);
1256     (void) memcpy((void *)(gc->pc + 10), (void *)(&y2), 2);
1257     gc->pc += cmdlen;
1258     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1259 }
1260
1261 #define X_GLrop_Rectsv 48
1262 void
1263 __indirect_glRectsv(const GLshort * v1, const GLshort * v2)
1264 {
1265     __GLXcontext * const gc = __glXGetCurrentContext();
1266     const GLuint cmdlen = 12;
1267     emit_header(gc->pc, X_GLrop_Rectsv, cmdlen);
1268     (void) memcpy((void *)(gc->pc + 4), (void *)(v1), 4);
1269     (void) memcpy((void *)(gc->pc + 8), (void *)(v2), 4);
1270     gc->pc += cmdlen;
1271     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1272 }
1273
1274 #define X_GLrop_TexCoord1dv 49
1275 void
1276 __indirect_glTexCoord1d(GLdouble s)
1277 {
1278     __GLXcontext * const gc = __glXGetCurrentContext();
1279     const GLuint cmdlen = 12;
1280     emit_header(gc->pc, X_GLrop_TexCoord1dv, cmdlen);
1281     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1282     gc->pc += cmdlen;
1283     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1284 }
1285
1286 #define X_GLrop_TexCoord1dv 49
1287 void
1288 __indirect_glTexCoord1dv(const GLdouble * v)
1289 {
1290     generic_8_byte( X_GLrop_TexCoord1dv, v );
1291 }
1292
1293 #define X_GLrop_TexCoord1fv 50
1294 void
1295 __indirect_glTexCoord1f(GLfloat s)
1296 {
1297     __GLXcontext * const gc = __glXGetCurrentContext();
1298     const GLuint cmdlen = 8;
1299     emit_header(gc->pc, X_GLrop_TexCoord1fv, cmdlen);
1300     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1301     gc->pc += cmdlen;
1302     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1303 }
1304
1305 #define X_GLrop_TexCoord1fv 50
1306 void
1307 __indirect_glTexCoord1fv(const GLfloat * v)
1308 {
1309     generic_4_byte( X_GLrop_TexCoord1fv, v );
1310 }
1311
1312 #define X_GLrop_TexCoord1iv 51
1313 void
1314 __indirect_glTexCoord1i(GLint s)
1315 {
1316     __GLXcontext * const gc = __glXGetCurrentContext();
1317     const GLuint cmdlen = 8;
1318     emit_header(gc->pc, X_GLrop_TexCoord1iv, cmdlen);
1319     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1320     gc->pc += cmdlen;
1321     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1322 }
1323
1324 #define X_GLrop_TexCoord1iv 51
1325 void
1326 __indirect_glTexCoord1iv(const GLint * v)
1327 {
1328     generic_4_byte( X_GLrop_TexCoord1iv, v );
1329 }
1330
1331 #define X_GLrop_TexCoord1sv 52
1332 void
1333 __indirect_glTexCoord1s(GLshort s)
1334 {
1335     __GLXcontext * const gc = __glXGetCurrentContext();
1336     const GLuint cmdlen = 8;
1337     emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
1338     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1339     gc->pc += cmdlen;
1340     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1341 }
1342
1343 #define X_GLrop_TexCoord1sv 52
1344 void
1345 __indirect_glTexCoord1sv(const GLshort * v)
1346 {
1347     __GLXcontext * const gc = __glXGetCurrentContext();
1348     const GLuint cmdlen = 8;
1349     emit_header(gc->pc, X_GLrop_TexCoord1sv, cmdlen);
1350     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 2);
1351     gc->pc += cmdlen;
1352     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1353 }
1354
1355 #define X_GLrop_TexCoord2dv 53
1356 void
1357 __indirect_glTexCoord2d(GLdouble s, GLdouble t)
1358 {
1359     __GLXcontext * const gc = __glXGetCurrentContext();
1360     const GLuint cmdlen = 20;
1361     emit_header(gc->pc, X_GLrop_TexCoord2dv, cmdlen);
1362     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1363     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
1364     gc->pc += cmdlen;
1365     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1366 }
1367
1368 #define X_GLrop_TexCoord2dv 53
1369 void
1370 __indirect_glTexCoord2dv(const GLdouble * v)
1371 {
1372     generic_16_byte( X_GLrop_TexCoord2dv, v );
1373 }
1374
1375 #define X_GLrop_TexCoord2fv 54
1376 void
1377 __indirect_glTexCoord2f(GLfloat s, GLfloat t)
1378 {
1379     __GLXcontext * const gc = __glXGetCurrentContext();
1380     const GLuint cmdlen = 12;
1381     emit_header(gc->pc, X_GLrop_TexCoord2fv, cmdlen);
1382     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1383     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1384     gc->pc += cmdlen;
1385     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1386 }
1387
1388 #define X_GLrop_TexCoord2fv 54
1389 void
1390 __indirect_glTexCoord2fv(const GLfloat * v)
1391 {
1392     generic_8_byte( X_GLrop_TexCoord2fv, v );
1393 }
1394
1395 #define X_GLrop_TexCoord2iv 55
1396 void
1397 __indirect_glTexCoord2i(GLint s, GLint t)
1398 {
1399     __GLXcontext * const gc = __glXGetCurrentContext();
1400     const GLuint cmdlen = 12;
1401     emit_header(gc->pc, X_GLrop_TexCoord2iv, cmdlen);
1402     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1403     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1404     gc->pc += cmdlen;
1405     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1406 }
1407
1408 #define X_GLrop_TexCoord2iv 55
1409 void
1410 __indirect_glTexCoord2iv(const GLint * v)
1411 {
1412     generic_8_byte( X_GLrop_TexCoord2iv, v );
1413 }
1414
1415 #define X_GLrop_TexCoord2sv 56
1416 void
1417 __indirect_glTexCoord2s(GLshort s, GLshort t)
1418 {
1419     __GLXcontext * const gc = __glXGetCurrentContext();
1420     const GLuint cmdlen = 8;
1421     emit_header(gc->pc, X_GLrop_TexCoord2sv, cmdlen);
1422     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1423     (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
1424     gc->pc += cmdlen;
1425     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1426 }
1427
1428 #define X_GLrop_TexCoord2sv 56
1429 void
1430 __indirect_glTexCoord2sv(const GLshort * v)
1431 {
1432     generic_4_byte( X_GLrop_TexCoord2sv, v );
1433 }
1434
1435 #define X_GLrop_TexCoord3dv 57
1436 void
1437 __indirect_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
1438 {
1439     __GLXcontext * const gc = __glXGetCurrentContext();
1440     const GLuint cmdlen = 28;
1441     emit_header(gc->pc, X_GLrop_TexCoord3dv, cmdlen);
1442     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1443     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
1444     (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
1445     gc->pc += cmdlen;
1446     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1447 }
1448
1449 #define X_GLrop_TexCoord3dv 57
1450 void
1451 __indirect_glTexCoord3dv(const GLdouble * v)
1452 {
1453     generic_24_byte( X_GLrop_TexCoord3dv, v );
1454 }
1455
1456 #define X_GLrop_TexCoord3fv 58
1457 void
1458 __indirect_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
1459 {
1460     __GLXcontext * const gc = __glXGetCurrentContext();
1461     const GLuint cmdlen = 16;
1462     emit_header(gc->pc, X_GLrop_TexCoord3fv, cmdlen);
1463     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1464     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1465     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1466     gc->pc += cmdlen;
1467     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1468 }
1469
1470 #define X_GLrop_TexCoord3fv 58
1471 void
1472 __indirect_glTexCoord3fv(const GLfloat * v)
1473 {
1474     generic_12_byte( X_GLrop_TexCoord3fv, v );
1475 }
1476
1477 #define X_GLrop_TexCoord3iv 59
1478 void
1479 __indirect_glTexCoord3i(GLint s, GLint t, GLint r)
1480 {
1481     __GLXcontext * const gc = __glXGetCurrentContext();
1482     const GLuint cmdlen = 16;
1483     emit_header(gc->pc, X_GLrop_TexCoord3iv, cmdlen);
1484     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1485     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1486     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1487     gc->pc += cmdlen;
1488     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1489 }
1490
1491 #define X_GLrop_TexCoord3iv 59
1492 void
1493 __indirect_glTexCoord3iv(const GLint * v)
1494 {
1495     generic_12_byte( X_GLrop_TexCoord3iv, v );
1496 }
1497
1498 #define X_GLrop_TexCoord3sv 60
1499 void
1500 __indirect_glTexCoord3s(GLshort s, GLshort t, GLshort r)
1501 {
1502     __GLXcontext * const gc = __glXGetCurrentContext();
1503     const GLuint cmdlen = 12;
1504     emit_header(gc->pc, X_GLrop_TexCoord3sv, cmdlen);
1505     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1506     (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
1507     (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
1508     gc->pc += cmdlen;
1509     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1510 }
1511
1512 #define X_GLrop_TexCoord3sv 60
1513 void
1514 __indirect_glTexCoord3sv(const GLshort * v)
1515 {
1516     generic_6_byte( X_GLrop_TexCoord3sv, v );
1517 }
1518
1519 #define X_GLrop_TexCoord4dv 61
1520 void
1521 __indirect_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
1522 {
1523     __GLXcontext * const gc = __glXGetCurrentContext();
1524     const GLuint cmdlen = 36;
1525     emit_header(gc->pc, X_GLrop_TexCoord4dv, cmdlen);
1526     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
1527     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
1528     (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
1529     (void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8);
1530     gc->pc += cmdlen;
1531     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1532 }
1533
1534 #define X_GLrop_TexCoord4dv 61
1535 void
1536 __indirect_glTexCoord4dv(const GLdouble * v)
1537 {
1538     generic_32_byte( X_GLrop_TexCoord4dv, v );
1539 }
1540
1541 #define X_GLrop_TexCoord4fv 62
1542 void
1543 __indirect_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
1544 {
1545     __GLXcontext * const gc = __glXGetCurrentContext();
1546     const GLuint cmdlen = 20;
1547     emit_header(gc->pc, X_GLrop_TexCoord4fv, cmdlen);
1548     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1549     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1550     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1551     (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
1552     gc->pc += cmdlen;
1553     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1554 }
1555
1556 #define X_GLrop_TexCoord4fv 62
1557 void
1558 __indirect_glTexCoord4fv(const GLfloat * v)
1559 {
1560     generic_16_byte( X_GLrop_TexCoord4fv, v );
1561 }
1562
1563 #define X_GLrop_TexCoord4iv 63
1564 void
1565 __indirect_glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
1566 {
1567     __GLXcontext * const gc = __glXGetCurrentContext();
1568     const GLuint cmdlen = 20;
1569     emit_header(gc->pc, X_GLrop_TexCoord4iv, cmdlen);
1570     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
1571     (void) memcpy((void *)(gc->pc + 8), (void *)(&t), 4);
1572     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 4);
1573     (void) memcpy((void *)(gc->pc + 16), (void *)(&q), 4);
1574     gc->pc += cmdlen;
1575     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1576 }
1577
1578 #define X_GLrop_TexCoord4iv 63
1579 void
1580 __indirect_glTexCoord4iv(const GLint * v)
1581 {
1582     generic_16_byte( X_GLrop_TexCoord4iv, v );
1583 }
1584
1585 #define X_GLrop_TexCoord4sv 64
1586 void
1587 __indirect_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
1588 {
1589     __GLXcontext * const gc = __glXGetCurrentContext();
1590     const GLuint cmdlen = 12;
1591     emit_header(gc->pc, X_GLrop_TexCoord4sv, cmdlen);
1592     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 2);
1593     (void) memcpy((void *)(gc->pc + 6), (void *)(&t), 2);
1594     (void) memcpy((void *)(gc->pc + 8), (void *)(&r), 2);
1595     (void) memcpy((void *)(gc->pc + 10), (void *)(&q), 2);
1596     gc->pc += cmdlen;
1597     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1598 }
1599
1600 #define X_GLrop_TexCoord4sv 64
1601 void
1602 __indirect_glTexCoord4sv(const GLshort * v)
1603 {
1604     generic_8_byte( X_GLrop_TexCoord4sv, v );
1605 }
1606
1607 #define X_GLrop_Vertex2dv 65
1608 void
1609 __indirect_glVertex2d(GLdouble x, GLdouble y)
1610 {
1611     __GLXcontext * const gc = __glXGetCurrentContext();
1612     const GLuint cmdlen = 20;
1613     emit_header(gc->pc, X_GLrop_Vertex2dv, cmdlen);
1614     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1615     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1616     gc->pc += cmdlen;
1617     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1618 }
1619
1620 #define X_GLrop_Vertex2dv 65
1621 void
1622 __indirect_glVertex2dv(const GLdouble * v)
1623 {
1624     generic_16_byte( X_GLrop_Vertex2dv, v );
1625 }
1626
1627 #define X_GLrop_Vertex2fv 66
1628 void
1629 __indirect_glVertex2f(GLfloat x, GLfloat y)
1630 {
1631     __GLXcontext * const gc = __glXGetCurrentContext();
1632     const GLuint cmdlen = 12;
1633     emit_header(gc->pc, X_GLrop_Vertex2fv, cmdlen);
1634     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1635     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1636     gc->pc += cmdlen;
1637     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1638 }
1639
1640 #define X_GLrop_Vertex2fv 66
1641 void
1642 __indirect_glVertex2fv(const GLfloat * v)
1643 {
1644     generic_8_byte( X_GLrop_Vertex2fv, v );
1645 }
1646
1647 #define X_GLrop_Vertex2iv 67
1648 void
1649 __indirect_glVertex2i(GLint x, GLint y)
1650 {
1651     __GLXcontext * const gc = __glXGetCurrentContext();
1652     const GLuint cmdlen = 12;
1653     emit_header(gc->pc, X_GLrop_Vertex2iv, cmdlen);
1654     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1655     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1656     gc->pc += cmdlen;
1657     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1658 }
1659
1660 #define X_GLrop_Vertex2iv 67
1661 void
1662 __indirect_glVertex2iv(const GLint * v)
1663 {
1664     generic_8_byte( X_GLrop_Vertex2iv, v );
1665 }
1666
1667 #define X_GLrop_Vertex2sv 68
1668 void
1669 __indirect_glVertex2s(GLshort x, GLshort y)
1670 {
1671     __GLXcontext * const gc = __glXGetCurrentContext();
1672     const GLuint cmdlen = 8;
1673     emit_header(gc->pc, X_GLrop_Vertex2sv, cmdlen);
1674     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1675     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1676     gc->pc += cmdlen;
1677     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1678 }
1679
1680 #define X_GLrop_Vertex2sv 68
1681 void
1682 __indirect_glVertex2sv(const GLshort * v)
1683 {
1684     generic_4_byte( X_GLrop_Vertex2sv, v );
1685 }
1686
1687 #define X_GLrop_Vertex3dv 69
1688 void
1689 __indirect_glVertex3d(GLdouble x, GLdouble y, GLdouble z)
1690 {
1691     __GLXcontext * const gc = __glXGetCurrentContext();
1692     const GLuint cmdlen = 28;
1693     emit_header(gc->pc, X_GLrop_Vertex3dv, cmdlen);
1694     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1695     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1696     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1697     gc->pc += cmdlen;
1698     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1699 }
1700
1701 #define X_GLrop_Vertex3dv 69
1702 void
1703 __indirect_glVertex3dv(const GLdouble * v)
1704 {
1705     generic_24_byte( X_GLrop_Vertex3dv, v );
1706 }
1707
1708 #define X_GLrop_Vertex3fv 70
1709 void
1710 __indirect_glVertex3f(GLfloat x, GLfloat y, GLfloat z)
1711 {
1712     __GLXcontext * const gc = __glXGetCurrentContext();
1713     const GLuint cmdlen = 16;
1714     emit_header(gc->pc, X_GLrop_Vertex3fv, cmdlen);
1715     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1716     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1717     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1718     gc->pc += cmdlen;
1719     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1720 }
1721
1722 #define X_GLrop_Vertex3fv 70
1723 void
1724 __indirect_glVertex3fv(const GLfloat * v)
1725 {
1726     generic_12_byte( X_GLrop_Vertex3fv, v );
1727 }
1728
1729 #define X_GLrop_Vertex3iv 71
1730 void
1731 __indirect_glVertex3i(GLint x, GLint y, GLint z)
1732 {
1733     __GLXcontext * const gc = __glXGetCurrentContext();
1734     const GLuint cmdlen = 16;
1735     emit_header(gc->pc, X_GLrop_Vertex3iv, cmdlen);
1736     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1737     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1738     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1739     gc->pc += cmdlen;
1740     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1741 }
1742
1743 #define X_GLrop_Vertex3iv 71
1744 void
1745 __indirect_glVertex3iv(const GLint * v)
1746 {
1747     generic_12_byte( X_GLrop_Vertex3iv, v );
1748 }
1749
1750 #define X_GLrop_Vertex3sv 72
1751 void
1752 __indirect_glVertex3s(GLshort x, GLshort y, GLshort z)
1753 {
1754     __GLXcontext * const gc = __glXGetCurrentContext();
1755     const GLuint cmdlen = 12;
1756     emit_header(gc->pc, X_GLrop_Vertex3sv, cmdlen);
1757     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1758     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1759     (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1760     gc->pc += cmdlen;
1761     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1762 }
1763
1764 #define X_GLrop_Vertex3sv 72
1765 void
1766 __indirect_glVertex3sv(const GLshort * v)
1767 {
1768     generic_6_byte( X_GLrop_Vertex3sv, v );
1769 }
1770
1771 #define X_GLrop_Vertex4dv 73
1772 void
1773 __indirect_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
1774 {
1775     __GLXcontext * const gc = __glXGetCurrentContext();
1776     const GLuint cmdlen = 36;
1777     emit_header(gc->pc, X_GLrop_Vertex4dv, cmdlen);
1778     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
1779     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
1780     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
1781     (void) memcpy((void *)(gc->pc + 28), (void *)(&w), 8);
1782     gc->pc += cmdlen;
1783     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1784 }
1785
1786 #define X_GLrop_Vertex4dv 73
1787 void
1788 __indirect_glVertex4dv(const GLdouble * v)
1789 {
1790     generic_32_byte( X_GLrop_Vertex4dv, v );
1791 }
1792
1793 #define X_GLrop_Vertex4fv 74
1794 void
1795 __indirect_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
1796 {
1797     __GLXcontext * const gc = __glXGetCurrentContext();
1798     const GLuint cmdlen = 20;
1799     emit_header(gc->pc, X_GLrop_Vertex4fv, cmdlen);
1800     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1801     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1802     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1803     (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1804     gc->pc += cmdlen;
1805     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1806 }
1807
1808 #define X_GLrop_Vertex4fv 74
1809 void
1810 __indirect_glVertex4fv(const GLfloat * v)
1811 {
1812     generic_16_byte( X_GLrop_Vertex4fv, v );
1813 }
1814
1815 #define X_GLrop_Vertex4iv 75
1816 void
1817 __indirect_glVertex4i(GLint x, GLint y, GLint z, GLint w)
1818 {
1819     __GLXcontext * const gc = __glXGetCurrentContext();
1820     const GLuint cmdlen = 20;
1821     emit_header(gc->pc, X_GLrop_Vertex4iv, cmdlen);
1822     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
1823     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
1824     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
1825     (void) memcpy((void *)(gc->pc + 16), (void *)(&w), 4);
1826     gc->pc += cmdlen;
1827     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1828 }
1829
1830 #define X_GLrop_Vertex4iv 75
1831 void
1832 __indirect_glVertex4iv(const GLint * v)
1833 {
1834     generic_16_byte( X_GLrop_Vertex4iv, v );
1835 }
1836
1837 #define X_GLrop_Vertex4sv 76
1838 void
1839 __indirect_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
1840 {
1841     __GLXcontext * const gc = __glXGetCurrentContext();
1842     const GLuint cmdlen = 12;
1843     emit_header(gc->pc, X_GLrop_Vertex4sv, cmdlen);
1844     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 2);
1845     (void) memcpy((void *)(gc->pc + 6), (void *)(&y), 2);
1846     (void) memcpy((void *)(gc->pc + 8), (void *)(&z), 2);
1847     (void) memcpy((void *)(gc->pc + 10), (void *)(&w), 2);
1848     gc->pc += cmdlen;
1849     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1850 }
1851
1852 #define X_GLrop_Vertex4sv 76
1853 void
1854 __indirect_glVertex4sv(const GLshort * v)
1855 {
1856     generic_8_byte( X_GLrop_Vertex4sv, v );
1857 }
1858
1859 #define X_GLrop_ClipPlane 77
1860 void
1861 __indirect_glClipPlane(GLenum plane, const GLdouble * equation)
1862 {
1863     __GLXcontext * const gc = __glXGetCurrentContext();
1864     const GLuint cmdlen = 40;
1865     emit_header(gc->pc, X_GLrop_ClipPlane, cmdlen);
1866     (void) memcpy((void *)(gc->pc + 4), (void *)(equation), 32);
1867     (void) memcpy((void *)(gc->pc + 36), (void *)(&plane), 4);
1868     gc->pc += cmdlen;
1869     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1870 }
1871
1872 #define X_GLrop_ColorMaterial 78
1873 void
1874 __indirect_glColorMaterial(GLenum face, GLenum mode)
1875 {
1876     __GLXcontext * const gc = __glXGetCurrentContext();
1877     const GLuint cmdlen = 12;
1878     emit_header(gc->pc, X_GLrop_ColorMaterial, cmdlen);
1879     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
1880     (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
1881     gc->pc += cmdlen;
1882     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1883 }
1884
1885 #define X_GLrop_CullFace 79
1886 void
1887 __indirect_glCullFace(GLenum mode)
1888 {
1889     __GLXcontext * const gc = __glXGetCurrentContext();
1890     const GLuint cmdlen = 8;
1891     emit_header(gc->pc, X_GLrop_CullFace, cmdlen);
1892     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
1893     gc->pc += cmdlen;
1894     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1895 }
1896
1897 #define X_GLrop_Fogf 80
1898 void
1899 __indirect_glFogf(GLenum pname, GLfloat param)
1900 {
1901     __GLXcontext * const gc = __glXGetCurrentContext();
1902     const GLuint cmdlen = 12;
1903     emit_header(gc->pc, X_GLrop_Fogf, cmdlen);
1904     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
1905     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
1906     gc->pc += cmdlen;
1907     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1908 }
1909
1910 #define X_GLrop_Fogfv 81
1911 void
1912 __indirect_glFogfv(GLenum pname, const GLfloat * params)
1913 {
1914     __GLXcontext * const gc = __glXGetCurrentContext();
1915     const GLuint compsize = __glFogfv_size(pname);
1916     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
1917     emit_header(gc->pc, X_GLrop_Fogfv, cmdlen);
1918     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
1919     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
1920     gc->pc += cmdlen;
1921     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1922 }
1923
1924 #define X_GLrop_Fogi 82
1925 void
1926 __indirect_glFogi(GLenum pname, GLint param)
1927 {
1928     __GLXcontext * const gc = __glXGetCurrentContext();
1929     const GLuint cmdlen = 12;
1930     emit_header(gc->pc, X_GLrop_Fogi, cmdlen);
1931     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
1932     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
1933     gc->pc += cmdlen;
1934     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1935 }
1936
1937 #define X_GLrop_Fogiv 83
1938 void
1939 __indirect_glFogiv(GLenum pname, const GLint * params)
1940 {
1941     __GLXcontext * const gc = __glXGetCurrentContext();
1942     const GLuint compsize = __glFogiv_size(pname);
1943     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
1944     emit_header(gc->pc, X_GLrop_Fogiv, cmdlen);
1945     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
1946     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
1947     gc->pc += cmdlen;
1948     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1949 }
1950
1951 #define X_GLrop_FrontFace 84
1952 void
1953 __indirect_glFrontFace(GLenum mode)
1954 {
1955     __GLXcontext * const gc = __glXGetCurrentContext();
1956     const GLuint cmdlen = 8;
1957     emit_header(gc->pc, X_GLrop_FrontFace, cmdlen);
1958     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
1959     gc->pc += cmdlen;
1960     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1961 }
1962
1963 #define X_GLrop_Hint 85
1964 void
1965 __indirect_glHint(GLenum target, GLenum mode)
1966 {
1967     __GLXcontext * const gc = __glXGetCurrentContext();
1968     const GLuint cmdlen = 12;
1969     emit_header(gc->pc, X_GLrop_Hint, cmdlen);
1970     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
1971     (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
1972     gc->pc += cmdlen;
1973     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1974 }
1975
1976 #define X_GLrop_Lightf 86
1977 void
1978 __indirect_glLightf(GLenum light, GLenum pname, GLfloat param)
1979 {
1980     __GLXcontext * const gc = __glXGetCurrentContext();
1981     const GLuint cmdlen = 16;
1982     emit_header(gc->pc, X_GLrop_Lightf, cmdlen);
1983     (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
1984     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
1985     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
1986     gc->pc += cmdlen;
1987     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
1988 }
1989
1990 #define X_GLrop_Lightfv 87
1991 void
1992 __indirect_glLightfv(GLenum light, GLenum pname, const GLfloat * params)
1993 {
1994     __GLXcontext * const gc = __glXGetCurrentContext();
1995     const GLuint compsize = __glLightfv_size(pname);
1996     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
1997     emit_header(gc->pc, X_GLrop_Lightfv, cmdlen);
1998     (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
1999     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2000     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2001     gc->pc += cmdlen;
2002     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2003 }
2004
2005 #define X_GLrop_Lighti 88
2006 void
2007 __indirect_glLighti(GLenum light, GLenum pname, GLint param)
2008 {
2009     __GLXcontext * const gc = __glXGetCurrentContext();
2010     const GLuint cmdlen = 16;
2011     emit_header(gc->pc, X_GLrop_Lighti, cmdlen);
2012     (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
2013     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2014     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2015     gc->pc += cmdlen;
2016     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2017 }
2018
2019 #define X_GLrop_Lightiv 89
2020 void
2021 __indirect_glLightiv(GLenum light, GLenum pname, const GLint * params)
2022 {
2023     __GLXcontext * const gc = __glXGetCurrentContext();
2024     const GLuint compsize = __glLightiv_size(pname);
2025     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2026     emit_header(gc->pc, X_GLrop_Lightiv, cmdlen);
2027     (void) memcpy((void *)(gc->pc + 4), (void *)(&light), 4);
2028     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2029     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2030     gc->pc += cmdlen;
2031     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2032 }
2033
2034 #define X_GLrop_LightModelf 90
2035 void
2036 __indirect_glLightModelf(GLenum pname, GLfloat param)
2037 {
2038     __GLXcontext * const gc = __glXGetCurrentContext();
2039     const GLuint cmdlen = 12;
2040     emit_header(gc->pc, X_GLrop_LightModelf, cmdlen);
2041     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2042     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
2043     gc->pc += cmdlen;
2044     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2045 }
2046
2047 #define X_GLrop_LightModelfv 91
2048 void
2049 __indirect_glLightModelfv(GLenum pname, const GLfloat * params)
2050 {
2051     __GLXcontext * const gc = __glXGetCurrentContext();
2052     const GLuint compsize = __glLightModelfv_size(pname);
2053     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2054     emit_header(gc->pc, X_GLrop_LightModelfv, cmdlen);
2055     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2056     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
2057     gc->pc += cmdlen;
2058     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2059 }
2060
2061 #define X_GLrop_LightModeli 92
2062 void
2063 __indirect_glLightModeli(GLenum pname, GLint param)
2064 {
2065     __GLXcontext * const gc = __glXGetCurrentContext();
2066     const GLuint cmdlen = 12;
2067     emit_header(gc->pc, X_GLrop_LightModeli, cmdlen);
2068     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2069     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
2070     gc->pc += cmdlen;
2071     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2072 }
2073
2074 #define X_GLrop_LightModeliv 93
2075 void
2076 __indirect_glLightModeliv(GLenum pname, const GLint * params)
2077 {
2078     __GLXcontext * const gc = __glXGetCurrentContext();
2079     const GLuint compsize = __glLightModeliv_size(pname);
2080     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
2081     emit_header(gc->pc, X_GLrop_LightModeliv, cmdlen);
2082     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2083     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
2084     gc->pc += cmdlen;
2085     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2086 }
2087
2088 #define X_GLrop_LineStipple 94
2089 void
2090 __indirect_glLineStipple(GLint factor, GLushort pattern)
2091 {
2092     __GLXcontext * const gc = __glXGetCurrentContext();
2093     const GLuint cmdlen = 12;
2094     emit_header(gc->pc, X_GLrop_LineStipple, cmdlen);
2095     (void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4);
2096     (void) memcpy((void *)(gc->pc + 8), (void *)(&pattern), 2);
2097     gc->pc += cmdlen;
2098     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2099 }
2100
2101 #define X_GLrop_LineWidth 95
2102 void
2103 __indirect_glLineWidth(GLfloat width)
2104 {
2105     __GLXcontext * const gc = __glXGetCurrentContext();
2106     const GLuint cmdlen = 8;
2107     emit_header(gc->pc, X_GLrop_LineWidth, cmdlen);
2108     (void) memcpy((void *)(gc->pc + 4), (void *)(&width), 4);
2109     gc->pc += cmdlen;
2110     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2111 }
2112
2113 #define X_GLrop_Materialf 96
2114 void
2115 __indirect_glMaterialf(GLenum face, GLenum pname, GLfloat param)
2116 {
2117     __GLXcontext * const gc = __glXGetCurrentContext();
2118     const GLuint cmdlen = 16;
2119     emit_header(gc->pc, X_GLrop_Materialf, cmdlen);
2120     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2121     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2122     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2123     gc->pc += cmdlen;
2124     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2125 }
2126
2127 #define X_GLrop_Materialfv 97
2128 void
2129 __indirect_glMaterialfv(GLenum face, GLenum pname, const GLfloat * params)
2130 {
2131     __GLXcontext * const gc = __glXGetCurrentContext();
2132     const GLuint compsize = __glMaterialfv_size(pname);
2133     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2134     emit_header(gc->pc, X_GLrop_Materialfv, cmdlen);
2135     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2136     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2137     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2138     gc->pc += cmdlen;
2139     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2140 }
2141
2142 #define X_GLrop_Materiali 98
2143 void
2144 __indirect_glMateriali(GLenum face, GLenum pname, GLint param)
2145 {
2146     __GLXcontext * const gc = __glXGetCurrentContext();
2147     const GLuint cmdlen = 16;
2148     emit_header(gc->pc, X_GLrop_Materiali, cmdlen);
2149     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2150     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2151     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2152     gc->pc += cmdlen;
2153     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2154 }
2155
2156 #define X_GLrop_Materialiv 99
2157 void
2158 __indirect_glMaterialiv(GLenum face, GLenum pname, const GLint * params)
2159 {
2160     __GLXcontext * const gc = __glXGetCurrentContext();
2161     const GLuint compsize = __glMaterialiv_size(pname);
2162     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2163     emit_header(gc->pc, X_GLrop_Materialiv, cmdlen);
2164     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2165     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2166     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2167     gc->pc += cmdlen;
2168     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2169 }
2170
2171 #define X_GLrop_PointSize 100
2172 void
2173 __indirect_glPointSize(GLfloat size)
2174 {
2175     __GLXcontext * const gc = __glXGetCurrentContext();
2176     const GLuint cmdlen = 8;
2177     emit_header(gc->pc, X_GLrop_PointSize, cmdlen);
2178     (void) memcpy((void *)(gc->pc + 4), (void *)(&size), 4);
2179     gc->pc += cmdlen;
2180     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2181 }
2182
2183 #define X_GLrop_PolygonMode 101
2184 void
2185 __indirect_glPolygonMode(GLenum face, GLenum mode)
2186 {
2187     __GLXcontext * const gc = __glXGetCurrentContext();
2188     const GLuint cmdlen = 12;
2189     emit_header(gc->pc, X_GLrop_PolygonMode, cmdlen);
2190     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
2191     (void) memcpy((void *)(gc->pc + 8), (void *)(&mode), 4);
2192     gc->pc += cmdlen;
2193     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2194 }
2195
2196 #define X_GLrop_Scissor 103
2197 void
2198 __indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
2199 {
2200     __GLXcontext * const gc = __glXGetCurrentContext();
2201     const GLuint cmdlen = 20;
2202     emit_header(gc->pc, X_GLrop_Scissor, cmdlen);
2203     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
2204     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
2205     (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
2206     (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
2207     gc->pc += cmdlen;
2208     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2209 }
2210
2211 #define X_GLrop_ShadeModel 104
2212 void
2213 __indirect_glShadeModel(GLenum mode)
2214 {
2215     __GLXcontext * const gc = __glXGetCurrentContext();
2216     const GLuint cmdlen = 8;
2217     emit_header(gc->pc, X_GLrop_ShadeModel, cmdlen);
2218     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2219     gc->pc += cmdlen;
2220     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2221 }
2222
2223 #define X_GLrop_TexParameterf 105
2224 void
2225 __indirect_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
2226 {
2227     __GLXcontext * const gc = __glXGetCurrentContext();
2228     const GLuint cmdlen = 16;
2229     emit_header(gc->pc, X_GLrop_TexParameterf, cmdlen);
2230     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2231     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2232     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2233     gc->pc += cmdlen;
2234     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2235 }
2236
2237 #define X_GLrop_TexParameterfv 106
2238 void
2239 __indirect_glTexParameterfv(GLenum target, GLenum pname, const GLfloat * params)
2240 {
2241     __GLXcontext * const gc = __glXGetCurrentContext();
2242     const GLuint compsize = __glTexParameterfv_size(pname);
2243     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2244     emit_header(gc->pc, X_GLrop_TexParameterfv, cmdlen);
2245     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2246     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2247     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2248     gc->pc += cmdlen;
2249     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2250 }
2251
2252 #define X_GLrop_TexParameteri 107
2253 void
2254 __indirect_glTexParameteri(GLenum target, GLenum pname, GLint param)
2255 {
2256     __GLXcontext * const gc = __glXGetCurrentContext();
2257     const GLuint cmdlen = 16;
2258     emit_header(gc->pc, X_GLrop_TexParameteri, cmdlen);
2259     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2260     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2261     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2262     gc->pc += cmdlen;
2263     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2264 }
2265
2266 #define X_GLrop_TexParameteriv 108
2267 void
2268 __indirect_glTexParameteriv(GLenum target, GLenum pname, const GLint * params)
2269 {
2270     __GLXcontext * const gc = __glXGetCurrentContext();
2271     const GLuint compsize = __glTexParameteriv_size(pname);
2272     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2273     emit_header(gc->pc, X_GLrop_TexParameteriv, cmdlen);
2274     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2275     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2276     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2277     gc->pc += cmdlen;
2278     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2279 }
2280
2281 #define X_GLrop_TexEnvf 111
2282 void
2283 __indirect_glTexEnvf(GLenum target, GLenum pname, GLfloat param)
2284 {
2285     __GLXcontext * const gc = __glXGetCurrentContext();
2286     const GLuint cmdlen = 16;
2287     emit_header(gc->pc, X_GLrop_TexEnvf, cmdlen);
2288     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2289     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2290     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2291     gc->pc += cmdlen;
2292     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2293 }
2294
2295 #define X_GLrop_TexEnvfv 112
2296 void
2297 __indirect_glTexEnvfv(GLenum target, GLenum pname, const GLfloat * params)
2298 {
2299     __GLXcontext * const gc = __glXGetCurrentContext();
2300     const GLuint compsize = __glTexEnvfv_size(pname);
2301     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2302     emit_header(gc->pc, X_GLrop_TexEnvfv, cmdlen);
2303     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2304     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2305     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2306     gc->pc += cmdlen;
2307     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2308 }
2309
2310 #define X_GLrop_TexEnvi 113
2311 void
2312 __indirect_glTexEnvi(GLenum target, GLenum pname, GLint param)
2313 {
2314     __GLXcontext * const gc = __glXGetCurrentContext();
2315     const GLuint cmdlen = 16;
2316     emit_header(gc->pc, X_GLrop_TexEnvi, cmdlen);
2317     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2318     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2319     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2320     gc->pc += cmdlen;
2321     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2322 }
2323
2324 #define X_GLrop_TexEnviv 114
2325 void
2326 __indirect_glTexEnviv(GLenum target, GLenum pname, const GLint * params)
2327 {
2328     __GLXcontext * const gc = __glXGetCurrentContext();
2329     const GLuint compsize = __glTexEnviv_size(pname);
2330     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2331     emit_header(gc->pc, X_GLrop_TexEnviv, cmdlen);
2332     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
2333     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2334     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2335     gc->pc += cmdlen;
2336     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2337 }
2338
2339 #define X_GLrop_TexGend 115
2340 void
2341 __indirect_glTexGend(GLenum coord, GLenum pname, GLdouble param)
2342 {
2343     __GLXcontext * const gc = __glXGetCurrentContext();
2344     const GLuint cmdlen = 20;
2345     emit_header(gc->pc, X_GLrop_TexGend, cmdlen);
2346     (void) memcpy((void *)(gc->pc + 4), (void *)(&param), 8);
2347     (void) memcpy((void *)(gc->pc + 12), (void *)(&coord), 4);
2348     (void) memcpy((void *)(gc->pc + 16), (void *)(&pname), 4);
2349     gc->pc += cmdlen;
2350     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2351 }
2352
2353 #define X_GLrop_TexGendv 116
2354 void
2355 __indirect_glTexGendv(GLenum coord, GLenum pname, const GLdouble * params)
2356 {
2357     __GLXcontext * const gc = __glXGetCurrentContext();
2358     const GLuint compsize = __glTexGendv_size(pname);
2359     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 8));
2360     emit_header(gc->pc, X_GLrop_TexGendv, cmdlen);
2361     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2362     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2363     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 8));
2364     gc->pc += cmdlen;
2365     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2366 }
2367
2368 #define X_GLrop_TexGenf 117
2369 void
2370 __indirect_glTexGenf(GLenum coord, GLenum pname, GLfloat param)
2371 {
2372     __GLXcontext * const gc = __glXGetCurrentContext();
2373     const GLuint cmdlen = 16;
2374     emit_header(gc->pc, X_GLrop_TexGenf, cmdlen);
2375     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2376     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2377     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2378     gc->pc += cmdlen;
2379     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2380 }
2381
2382 #define X_GLrop_TexGenfv 118
2383 void
2384 __indirect_glTexGenfv(GLenum coord, GLenum pname, const GLfloat * params)
2385 {
2386     __GLXcontext * const gc = __glXGetCurrentContext();
2387     const GLuint compsize = __glTexGenfv_size(pname);
2388     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2389     emit_header(gc->pc, X_GLrop_TexGenfv, cmdlen);
2390     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2391     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2392     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2393     gc->pc += cmdlen;
2394     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2395 }
2396
2397 #define X_GLrop_TexGeni 119
2398 void
2399 __indirect_glTexGeni(GLenum coord, GLenum pname, GLint param)
2400 {
2401     __GLXcontext * const gc = __glXGetCurrentContext();
2402     const GLuint cmdlen = 16;
2403     emit_header(gc->pc, X_GLrop_TexGeni, cmdlen);
2404     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2405     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2406     (void) memcpy((void *)(gc->pc + 12), (void *)(&param), 4);
2407     gc->pc += cmdlen;
2408     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2409 }
2410
2411 #define X_GLrop_TexGeniv 120
2412 void
2413 __indirect_glTexGeniv(GLenum coord, GLenum pname, const GLint * params)
2414 {
2415     __GLXcontext * const gc = __glXGetCurrentContext();
2416     const GLuint compsize = __glTexGeniv_size(pname);
2417     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
2418     emit_header(gc->pc, X_GLrop_TexGeniv, cmdlen);
2419     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
2420     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
2421     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
2422     gc->pc += cmdlen;
2423     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2424 }
2425
2426 #define X_GLrop_InitNames 121
2427 void
2428 __indirect_glInitNames(void)
2429 {
2430     __GLXcontext * const gc = __glXGetCurrentContext();
2431     const GLuint cmdlen = 4;
2432     emit_header(gc->pc, X_GLrop_InitNames, cmdlen);
2433     gc->pc += cmdlen;
2434     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2435 }
2436
2437 #define X_GLrop_LoadName 122
2438 void
2439 __indirect_glLoadName(GLuint name)
2440 {
2441     __GLXcontext * const gc = __glXGetCurrentContext();
2442     const GLuint cmdlen = 8;
2443     emit_header(gc->pc, X_GLrop_LoadName, cmdlen);
2444     (void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4);
2445     gc->pc += cmdlen;
2446     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2447 }
2448
2449 #define X_GLrop_PassThrough 123
2450 void
2451 __indirect_glPassThrough(GLfloat token)
2452 {
2453     __GLXcontext * const gc = __glXGetCurrentContext();
2454     const GLuint cmdlen = 8;
2455     emit_header(gc->pc, X_GLrop_PassThrough, cmdlen);
2456     (void) memcpy((void *)(gc->pc + 4), (void *)(&token), 4);
2457     gc->pc += cmdlen;
2458     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2459 }
2460
2461 #define X_GLrop_PopName 124
2462 void
2463 __indirect_glPopName(void)
2464 {
2465     __GLXcontext * const gc = __glXGetCurrentContext();
2466     const GLuint cmdlen = 4;
2467     emit_header(gc->pc, X_GLrop_PopName, cmdlen);
2468     gc->pc += cmdlen;
2469     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2470 }
2471
2472 #define X_GLrop_PushName 125
2473 void
2474 __indirect_glPushName(GLuint name)
2475 {
2476     __GLXcontext * const gc = __glXGetCurrentContext();
2477     const GLuint cmdlen = 8;
2478     emit_header(gc->pc, X_GLrop_PushName, cmdlen);
2479     (void) memcpy((void *)(gc->pc + 4), (void *)(&name), 4);
2480     gc->pc += cmdlen;
2481     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2482 }
2483
2484 #define X_GLrop_DrawBuffer 126
2485 void
2486 __indirect_glDrawBuffer(GLenum mode)
2487 {
2488     __GLXcontext * const gc = __glXGetCurrentContext();
2489     const GLuint cmdlen = 8;
2490     emit_header(gc->pc, X_GLrop_DrawBuffer, cmdlen);
2491     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2492     gc->pc += cmdlen;
2493     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2494 }
2495
2496 #define X_GLrop_Clear 127
2497 void
2498 __indirect_glClear(GLbitfield mask)
2499 {
2500     __GLXcontext * const gc = __glXGetCurrentContext();
2501     const GLuint cmdlen = 8;
2502     emit_header(gc->pc, X_GLrop_Clear, cmdlen);
2503     (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2504     gc->pc += cmdlen;
2505     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2506 }
2507
2508 #define X_GLrop_ClearAccum 128
2509 void
2510 __indirect_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
2511 {
2512     __GLXcontext * const gc = __glXGetCurrentContext();
2513     const GLuint cmdlen = 20;
2514     emit_header(gc->pc, X_GLrop_ClearAccum, cmdlen);
2515     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
2516     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
2517     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
2518     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
2519     gc->pc += cmdlen;
2520     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2521 }
2522
2523 #define X_GLrop_ClearIndex 129
2524 void
2525 __indirect_glClearIndex(GLfloat c)
2526 {
2527     __GLXcontext * const gc = __glXGetCurrentContext();
2528     const GLuint cmdlen = 8;
2529     emit_header(gc->pc, X_GLrop_ClearIndex, cmdlen);
2530     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 4);
2531     gc->pc += cmdlen;
2532     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2533 }
2534
2535 #define X_GLrop_ClearColor 130
2536 void
2537 __indirect_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
2538 {
2539     __GLXcontext * const gc = __glXGetCurrentContext();
2540     const GLuint cmdlen = 20;
2541     emit_header(gc->pc, X_GLrop_ClearColor, cmdlen);
2542     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
2543     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
2544     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
2545     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
2546     gc->pc += cmdlen;
2547     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2548 }
2549
2550 #define X_GLrop_ClearStencil 131
2551 void
2552 __indirect_glClearStencil(GLint s)
2553 {
2554     __GLXcontext * const gc = __glXGetCurrentContext();
2555     const GLuint cmdlen = 8;
2556     emit_header(gc->pc, X_GLrop_ClearStencil, cmdlen);
2557     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 4);
2558     gc->pc += cmdlen;
2559     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2560 }
2561
2562 #define X_GLrop_ClearDepth 132
2563 void
2564 __indirect_glClearDepth(GLclampd depth)
2565 {
2566     __GLXcontext * const gc = __glXGetCurrentContext();
2567     const GLuint cmdlen = 12;
2568     emit_header(gc->pc, X_GLrop_ClearDepth, cmdlen);
2569     (void) memcpy((void *)(gc->pc + 4), (void *)(&depth), 8);
2570     gc->pc += cmdlen;
2571     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2572 }
2573
2574 #define X_GLrop_StencilMask 133
2575 void
2576 __indirect_glStencilMask(GLuint mask)
2577 {
2578     __GLXcontext * const gc = __glXGetCurrentContext();
2579     const GLuint cmdlen = 8;
2580     emit_header(gc->pc, X_GLrop_StencilMask, cmdlen);
2581     (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2582     gc->pc += cmdlen;
2583     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2584 }
2585
2586 #define X_GLrop_ColorMask 134
2587 void
2588 __indirect_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
2589 {
2590     __GLXcontext * const gc = __glXGetCurrentContext();
2591     const GLuint cmdlen = 8;
2592     emit_header(gc->pc, X_GLrop_ColorMask, cmdlen);
2593     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
2594     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
2595     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
2596     (void) memcpy((void *)(gc->pc + 7), (void *)(&alpha), 1);
2597     gc->pc += cmdlen;
2598     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2599 }
2600
2601 #define X_GLrop_DepthMask 135
2602 void
2603 __indirect_glDepthMask(GLboolean flag)
2604 {
2605     __GLXcontext * const gc = __glXGetCurrentContext();
2606     const GLuint cmdlen = 8;
2607     emit_header(gc->pc, X_GLrop_DepthMask, cmdlen);
2608     (void) memcpy((void *)(gc->pc + 4), (void *)(&flag), 1);
2609     gc->pc += cmdlen;
2610     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2611 }
2612
2613 #define X_GLrop_IndexMask 136
2614 void
2615 __indirect_glIndexMask(GLuint mask)
2616 {
2617     __GLXcontext * const gc = __glXGetCurrentContext();
2618     const GLuint cmdlen = 8;
2619     emit_header(gc->pc, X_GLrop_IndexMask, cmdlen);
2620     (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2621     gc->pc += cmdlen;
2622     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2623 }
2624
2625 #define X_GLrop_Accum 137
2626 void
2627 __indirect_glAccum(GLenum op, GLfloat value)
2628 {
2629     __GLXcontext * const gc = __glXGetCurrentContext();
2630     const GLuint cmdlen = 12;
2631     emit_header(gc->pc, X_GLrop_Accum, cmdlen);
2632     (void) memcpy((void *)(gc->pc + 4), (void *)(&op), 4);
2633     (void) memcpy((void *)(gc->pc + 8), (void *)(&value), 4);
2634     gc->pc += cmdlen;
2635     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2636 }
2637
2638 #define X_GLrop_PopAttrib 141
2639 void
2640 __indirect_glPopAttrib(void)
2641 {
2642     __GLXcontext * const gc = __glXGetCurrentContext();
2643     const GLuint cmdlen = 4;
2644     emit_header(gc->pc, X_GLrop_PopAttrib, cmdlen);
2645     gc->pc += cmdlen;
2646     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2647 }
2648
2649 #define X_GLrop_PushAttrib 142
2650 void
2651 __indirect_glPushAttrib(GLbitfield mask)
2652 {
2653     __GLXcontext * const gc = __glXGetCurrentContext();
2654     const GLuint cmdlen = 8;
2655     emit_header(gc->pc, X_GLrop_PushAttrib, cmdlen);
2656     (void) memcpy((void *)(gc->pc + 4), (void *)(&mask), 4);
2657     gc->pc += cmdlen;
2658     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2659 }
2660
2661 #define X_GLrop_MapGrid1d 147
2662 void
2663 __indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
2664 {
2665     __GLXcontext * const gc = __glXGetCurrentContext();
2666     const GLuint cmdlen = 24;
2667     emit_header(gc->pc, X_GLrop_MapGrid1d, cmdlen);
2668     (void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8);
2669     (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8);
2670     (void) memcpy((void *)(gc->pc + 20), (void *)(&un), 4);
2671     gc->pc += cmdlen;
2672     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2673 }
2674
2675 #define X_GLrop_MapGrid1f 148
2676 void
2677 __indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
2678 {
2679     __GLXcontext * const gc = __glXGetCurrentContext();
2680     const GLuint cmdlen = 16;
2681     emit_header(gc->pc, X_GLrop_MapGrid1f, cmdlen);
2682     (void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4);
2683     (void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4);
2684     (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4);
2685     gc->pc += cmdlen;
2686     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2687 }
2688
2689 #define X_GLrop_MapGrid2d 149
2690 void
2691 __indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
2692 {
2693     __GLXcontext * const gc = __glXGetCurrentContext();
2694     const GLuint cmdlen = 44;
2695     emit_header(gc->pc, X_GLrop_MapGrid2d, cmdlen);
2696     (void) memcpy((void *)(gc->pc + 4), (void *)(&u1), 8);
2697     (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 8);
2698     (void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 8);
2699     (void) memcpy((void *)(gc->pc + 28), (void *)(&v2), 8);
2700     (void) memcpy((void *)(gc->pc + 36), (void *)(&un), 4);
2701     (void) memcpy((void *)(gc->pc + 40), (void *)(&vn), 4);
2702     gc->pc += cmdlen;
2703     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2704 }
2705
2706 #define X_GLrop_MapGrid2f 150
2707 void
2708 __indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
2709 {
2710     __GLXcontext * const gc = __glXGetCurrentContext();
2711     const GLuint cmdlen = 28;
2712     emit_header(gc->pc, X_GLrop_MapGrid2f, cmdlen);
2713     (void) memcpy((void *)(gc->pc + 4), (void *)(&un), 4);
2714     (void) memcpy((void *)(gc->pc + 8), (void *)(&u1), 4);
2715     (void) memcpy((void *)(gc->pc + 12), (void *)(&u2), 4);
2716     (void) memcpy((void *)(gc->pc + 16), (void *)(&vn), 4);
2717     (void) memcpy((void *)(gc->pc + 20), (void *)(&v1), 4);
2718     (void) memcpy((void *)(gc->pc + 24), (void *)(&v2), 4);
2719     gc->pc += cmdlen;
2720     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2721 }
2722
2723 #define X_GLrop_EvalCoord1dv 151
2724 void
2725 __indirect_glEvalCoord1d(GLdouble u)
2726 {
2727     __GLXcontext * const gc = __glXGetCurrentContext();
2728     const GLuint cmdlen = 12;
2729     emit_header(gc->pc, X_GLrop_EvalCoord1dv, cmdlen);
2730     (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8);
2731     gc->pc += cmdlen;
2732     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2733 }
2734
2735 #define X_GLrop_EvalCoord1dv 151
2736 void
2737 __indirect_glEvalCoord1dv(const GLdouble * u)
2738 {
2739     generic_8_byte( X_GLrop_EvalCoord1dv, u );
2740 }
2741
2742 #define X_GLrop_EvalCoord1fv 152
2743 void
2744 __indirect_glEvalCoord1f(GLfloat u)
2745 {
2746     __GLXcontext * const gc = __glXGetCurrentContext();
2747     const GLuint cmdlen = 8;
2748     emit_header(gc->pc, X_GLrop_EvalCoord1fv, cmdlen);
2749     (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4);
2750     gc->pc += cmdlen;
2751     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2752 }
2753
2754 #define X_GLrop_EvalCoord1fv 152
2755 void
2756 __indirect_glEvalCoord1fv(const GLfloat * u)
2757 {
2758     generic_4_byte( X_GLrop_EvalCoord1fv, u );
2759 }
2760
2761 #define X_GLrop_EvalCoord2dv 153
2762 void
2763 __indirect_glEvalCoord2d(GLdouble u, GLdouble v)
2764 {
2765     __GLXcontext * const gc = __glXGetCurrentContext();
2766     const GLuint cmdlen = 20;
2767     emit_header(gc->pc, X_GLrop_EvalCoord2dv, cmdlen);
2768     (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 8);
2769     (void) memcpy((void *)(gc->pc + 12), (void *)(&v), 8);
2770     gc->pc += cmdlen;
2771     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2772 }
2773
2774 #define X_GLrop_EvalCoord2dv 153
2775 void
2776 __indirect_glEvalCoord2dv(const GLdouble * u)
2777 {
2778     generic_16_byte( X_GLrop_EvalCoord2dv, u );
2779 }
2780
2781 #define X_GLrop_EvalCoord2fv 154
2782 void
2783 __indirect_glEvalCoord2f(GLfloat u, GLfloat v)
2784 {
2785     __GLXcontext * const gc = __glXGetCurrentContext();
2786     const GLuint cmdlen = 12;
2787     emit_header(gc->pc, X_GLrop_EvalCoord2fv, cmdlen);
2788     (void) memcpy((void *)(gc->pc + 4), (void *)(&u), 4);
2789     (void) memcpy((void *)(gc->pc + 8), (void *)(&v), 4);
2790     gc->pc += cmdlen;
2791     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2792 }
2793
2794 #define X_GLrop_EvalCoord2fv 154
2795 void
2796 __indirect_glEvalCoord2fv(const GLfloat * u)
2797 {
2798     generic_8_byte( X_GLrop_EvalCoord2fv, u );
2799 }
2800
2801 #define X_GLrop_EvalMesh1 155
2802 void
2803 __indirect_glEvalMesh1(GLenum mode, GLint i1, GLint i2)
2804 {
2805     __GLXcontext * const gc = __glXGetCurrentContext();
2806     const GLuint cmdlen = 16;
2807     emit_header(gc->pc, X_GLrop_EvalMesh1, cmdlen);
2808     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2809     (void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4);
2810     (void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4);
2811     gc->pc += cmdlen;
2812     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2813 }
2814
2815 #define X_GLrop_EvalPoint1 156
2816 void
2817 __indirect_glEvalPoint1(GLint i)
2818 {
2819     __GLXcontext * const gc = __glXGetCurrentContext();
2820     const GLuint cmdlen = 8;
2821     emit_header(gc->pc, X_GLrop_EvalPoint1, cmdlen);
2822     (void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4);
2823     gc->pc += cmdlen;
2824     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2825 }
2826
2827 #define X_GLrop_EvalMesh2 157
2828 void
2829 __indirect_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
2830 {
2831     __GLXcontext * const gc = __glXGetCurrentContext();
2832     const GLuint cmdlen = 24;
2833     emit_header(gc->pc, X_GLrop_EvalMesh2, cmdlen);
2834     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
2835     (void) memcpy((void *)(gc->pc + 8), (void *)(&i1), 4);
2836     (void) memcpy((void *)(gc->pc + 12), (void *)(&i2), 4);
2837     (void) memcpy((void *)(gc->pc + 16), (void *)(&j1), 4);
2838     (void) memcpy((void *)(gc->pc + 20), (void *)(&j2), 4);
2839     gc->pc += cmdlen;
2840     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2841 }
2842
2843 #define X_GLrop_EvalPoint2 158
2844 void
2845 __indirect_glEvalPoint2(GLint i, GLint j)
2846 {
2847     __GLXcontext * const gc = __glXGetCurrentContext();
2848     const GLuint cmdlen = 12;
2849     emit_header(gc->pc, X_GLrop_EvalPoint2, cmdlen);
2850     (void) memcpy((void *)(gc->pc + 4), (void *)(&i), 4);
2851     (void) memcpy((void *)(gc->pc + 8), (void *)(&j), 4);
2852     gc->pc += cmdlen;
2853     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2854 }
2855
2856 #define X_GLrop_AlphaFunc 159
2857 void
2858 __indirect_glAlphaFunc(GLenum func, GLclampf ref)
2859 {
2860     __GLXcontext * const gc = __glXGetCurrentContext();
2861     const GLuint cmdlen = 12;
2862     emit_header(gc->pc, X_GLrop_AlphaFunc, cmdlen);
2863     (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
2864     (void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4);
2865     gc->pc += cmdlen;
2866     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2867 }
2868
2869 #define X_GLrop_BlendFunc 160
2870 void
2871 __indirect_glBlendFunc(GLenum sfactor, GLenum dfactor)
2872 {
2873     __GLXcontext * const gc = __glXGetCurrentContext();
2874     const GLuint cmdlen = 12;
2875     emit_header(gc->pc, X_GLrop_BlendFunc, cmdlen);
2876     (void) memcpy((void *)(gc->pc + 4), (void *)(&sfactor), 4);
2877     (void) memcpy((void *)(gc->pc + 8), (void *)(&dfactor), 4);
2878     gc->pc += cmdlen;
2879     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2880 }
2881
2882 #define X_GLrop_LogicOp 161
2883 void
2884 __indirect_glLogicOp(GLenum opcode)
2885 {
2886     __GLXcontext * const gc = __glXGetCurrentContext();
2887     const GLuint cmdlen = 8;
2888     emit_header(gc->pc, X_GLrop_LogicOp, cmdlen);
2889     (void) memcpy((void *)(gc->pc + 4), (void *)(&opcode), 4);
2890     gc->pc += cmdlen;
2891     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2892 }
2893
2894 #define X_GLrop_StencilFunc 162
2895 void
2896 __indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask)
2897 {
2898     __GLXcontext * const gc = __glXGetCurrentContext();
2899     const GLuint cmdlen = 16;
2900     emit_header(gc->pc, X_GLrop_StencilFunc, cmdlen);
2901     (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
2902     (void) memcpy((void *)(gc->pc + 8), (void *)(&ref), 4);
2903     (void) memcpy((void *)(gc->pc + 12), (void *)(&mask), 4);
2904     gc->pc += cmdlen;
2905     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2906 }
2907
2908 #define X_GLrop_StencilOp 163
2909 void
2910 __indirect_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
2911 {
2912     __GLXcontext * const gc = __glXGetCurrentContext();
2913     const GLuint cmdlen = 16;
2914     emit_header(gc->pc, X_GLrop_StencilOp, cmdlen);
2915     (void) memcpy((void *)(gc->pc + 4), (void *)(&fail), 4);
2916     (void) memcpy((void *)(gc->pc + 8), (void *)(&zfail), 4);
2917     (void) memcpy((void *)(gc->pc + 12), (void *)(&zpass), 4);
2918     gc->pc += cmdlen;
2919     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2920 }
2921
2922 #define X_GLrop_DepthFunc 164
2923 void
2924 __indirect_glDepthFunc(GLenum func)
2925 {
2926     __GLXcontext * const gc = __glXGetCurrentContext();
2927     const GLuint cmdlen = 8;
2928     emit_header(gc->pc, X_GLrop_DepthFunc, cmdlen);
2929     (void) memcpy((void *)(gc->pc + 4), (void *)(&func), 4);
2930     gc->pc += cmdlen;
2931     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2932 }
2933
2934 #define X_GLrop_PixelZoom 165
2935 void
2936 __indirect_glPixelZoom(GLfloat xfactor, GLfloat yfactor)
2937 {
2938     __GLXcontext * const gc = __glXGetCurrentContext();
2939     const GLuint cmdlen = 12;
2940     emit_header(gc->pc, X_GLrop_PixelZoom, cmdlen);
2941     (void) memcpy((void *)(gc->pc + 4), (void *)(&xfactor), 4);
2942     (void) memcpy((void *)(gc->pc + 8), (void *)(&yfactor), 4);
2943     gc->pc += cmdlen;
2944     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2945 }
2946
2947 #define X_GLrop_PixelTransferf 166
2948 void
2949 __indirect_glPixelTransferf(GLenum pname, GLfloat param)
2950 {
2951     __GLXcontext * const gc = __glXGetCurrentContext();
2952     const GLuint cmdlen = 12;
2953     emit_header(gc->pc, X_GLrop_PixelTransferf, cmdlen);
2954     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2955     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
2956     gc->pc += cmdlen;
2957     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2958 }
2959
2960 #define X_GLrop_PixelTransferi 167
2961 void
2962 __indirect_glPixelTransferi(GLenum pname, GLint param)
2963 {
2964     __GLXcontext * const gc = __glXGetCurrentContext();
2965     const GLuint cmdlen = 12;
2966     emit_header(gc->pc, X_GLrop_PixelTransferi, cmdlen);
2967     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
2968     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
2969     gc->pc += cmdlen;
2970     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2971 }
2972
2973 #define X_GLrop_PixelMapfv 168
2974 void
2975 __indirect_glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values)
2976 {
2977     __GLXcontext * const gc = __glXGetCurrentContext();
2978     const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
2979     if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
2980         if (cmdlen <= gc->maxSmallRenderCommandSize) {
2981             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
2982                 (void) __glXFlushRenderBuffer(gc, gc->pc);
2983             }
2984             emit_header(gc->pc, X_GLrop_PixelMapfv, cmdlen);
2985             (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
2986             (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
2987             (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
2988             gc->pc += cmdlen;
2989             if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
2990         }
2991         else {
2992             const GLint op = X_GLrop_PixelMapfv;
2993             const GLuint cmdlenLarge = cmdlen + 4;
2994             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
2995             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
2996             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
2997             (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
2998             (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
2999             __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
3000         }
3001     }
3002 }
3003
3004 #define X_GLrop_PixelMapuiv 169
3005 void
3006 __indirect_glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values)
3007 {
3008     __GLXcontext * const gc = __glXGetCurrentContext();
3009     const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 4));
3010     if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
3011         if (cmdlen <= gc->maxSmallRenderCommandSize) {
3012             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
3013                 (void) __glXFlushRenderBuffer(gc, gc->pc);
3014             }
3015             emit_header(gc->pc, X_GLrop_PixelMapuiv, cmdlen);
3016             (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
3017             (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
3018             (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 4));
3019             gc->pc += cmdlen;
3020             if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3021         }
3022         else {
3023             const GLint op = X_GLrop_PixelMapuiv;
3024             const GLuint cmdlenLarge = cmdlen + 4;
3025             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
3026             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
3027             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
3028             (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
3029             (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
3030             __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 4));
3031         }
3032     }
3033 }
3034
3035 #define X_GLrop_PixelMapusv 170
3036 void
3037 __indirect_glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort * values)
3038 {
3039     __GLXcontext * const gc = __glXGetCurrentContext();
3040     const GLuint cmdlen = 12 + __GLX_PAD((mapsize * 2));
3041     if (__builtin_expect((mapsize >= 0) && (gc->currentDpy != NULL), 1)) {
3042         if (cmdlen <= gc->maxSmallRenderCommandSize) {
3043             if ( (gc->pc + cmdlen) > gc->bufEnd ) {
3044                 (void) __glXFlushRenderBuffer(gc, gc->pc);
3045             }
3046             emit_header(gc->pc, X_GLrop_PixelMapusv, cmdlen);
3047             (void) memcpy((void *)(gc->pc + 4), (void *)(&map), 4);
3048             (void) memcpy((void *)(gc->pc + 8), (void *)(&mapsize), 4);
3049             (void) memcpy((void *)(gc->pc + 12), (void *)(values), (mapsize * 2));
3050             gc->pc += cmdlen;
3051             if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3052         }
3053         else {
3054             const GLint op = X_GLrop_PixelMapusv;
3055             const GLuint cmdlenLarge = cmdlen + 4;
3056             GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);
3057             (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);
3058             (void) memcpy((void *)(pc + 4), (void *)(&op), 4);
3059             (void) memcpy((void *)(pc + 8), (void *)(&map), 4);
3060             (void) memcpy((void *)(pc + 12), (void *)(&mapsize), 4);
3061             __glXSendLargeCommand(gc, pc, 16, values, (mapsize * 2));
3062         }
3063     }
3064 }
3065
3066 #define X_GLrop_ReadBuffer 171
3067 void
3068 __indirect_glReadBuffer(GLenum mode)
3069 {
3070     __GLXcontext * const gc = __glXGetCurrentContext();
3071     const GLuint cmdlen = 8;
3072     emit_header(gc->pc, X_GLrop_ReadBuffer, cmdlen);
3073     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
3074     gc->pc += cmdlen;
3075     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3076 }
3077
3078 #define X_GLrop_CopyPixels 172
3079 void
3080 __indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
3081 {
3082     __GLXcontext * const gc = __glXGetCurrentContext();
3083     const GLuint cmdlen = 24;
3084     emit_header(gc->pc, X_GLrop_CopyPixels, cmdlen);
3085     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
3086     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
3087     (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
3088     (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
3089     (void) memcpy((void *)(gc->pc + 20), (void *)(&type), 4);
3090     gc->pc += cmdlen;
3091     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3092 }
3093
3094 #define X_GLsop_GetClipPlane 113
3095 void
3096 __indirect_glGetClipPlane(GLenum plane, GLdouble * equation)
3097 {
3098     __GLXcontext * const gc = __glXGetCurrentContext();
3099     Display * const dpy = gc->currentDpy;
3100     const GLuint cmdlen = 4;
3101     if (__builtin_expect(dpy != NULL, 1)) {
3102         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetClipPlane, cmdlen);
3103         (void) memcpy((void *)(pc + 0), (void *)(&plane), 4);
3104         (void) read_reply(dpy, 8, equation, GL_TRUE);
3105         UnlockDisplay(dpy); SyncHandle();
3106     }
3107     return;
3108 }
3109
3110 #define X_GLsop_GetLightfv 118
3111 void
3112 __indirect_glGetLightfv(GLenum light, GLenum pname, GLfloat * params)
3113 {
3114     __GLXcontext * const gc = __glXGetCurrentContext();
3115     Display * const dpy = gc->currentDpy;
3116     const GLuint cmdlen = 8;
3117     if (__builtin_expect(dpy != NULL, 1)) {
3118         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetLightfv, cmdlen);
3119         (void) memcpy((void *)(pc + 0), (void *)(&light), 4);
3120         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3121         (void) read_reply(dpy, 4, params, GL_FALSE);
3122         UnlockDisplay(dpy); SyncHandle();
3123     }
3124     return;
3125 }
3126
3127 #define X_GLsop_GetLightiv 119
3128 void
3129 __indirect_glGetLightiv(GLenum light, GLenum pname, GLint * params)
3130 {
3131     __GLXcontext * const gc = __glXGetCurrentContext();
3132     Display * const dpy = gc->currentDpy;
3133     const GLuint cmdlen = 8;
3134     if (__builtin_expect(dpy != NULL, 1)) {
3135         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetLightiv, cmdlen);
3136         (void) memcpy((void *)(pc + 0), (void *)(&light), 4);
3137         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3138         (void) read_reply(dpy, 4, params, GL_FALSE);
3139         UnlockDisplay(dpy); SyncHandle();
3140     }
3141     return;
3142 }
3143
3144 #define X_GLsop_GetMapdv 120
3145 void
3146 __indirect_glGetMapdv(GLenum target, GLenum query, GLdouble * v)
3147 {
3148     __GLXcontext * const gc = __glXGetCurrentContext();
3149     Display * const dpy = gc->currentDpy;
3150     const GLuint cmdlen = 8;
3151     if (__builtin_expect(dpy != NULL, 1)) {
3152         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMapdv, cmdlen);
3153         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3154         (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
3155         (void) read_reply(dpy, 8, v, GL_FALSE);
3156         UnlockDisplay(dpy); SyncHandle();
3157     }
3158     return;
3159 }
3160
3161 #define X_GLsop_GetMapfv 121
3162 void
3163 __indirect_glGetMapfv(GLenum target, GLenum query, GLfloat * v)
3164 {
3165     __GLXcontext * const gc = __glXGetCurrentContext();
3166     Display * const dpy = gc->currentDpy;
3167     const GLuint cmdlen = 8;
3168     if (__builtin_expect(dpy != NULL, 1)) {
3169         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMapfv, cmdlen);
3170         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3171         (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
3172         (void) read_reply(dpy, 4, v, GL_FALSE);
3173         UnlockDisplay(dpy); SyncHandle();
3174     }
3175     return;
3176 }
3177
3178 #define X_GLsop_GetMapiv 122
3179 void
3180 __indirect_glGetMapiv(GLenum target, GLenum query, GLint * v)
3181 {
3182     __GLXcontext * const gc = __glXGetCurrentContext();
3183     Display * const dpy = gc->currentDpy;
3184     const GLuint cmdlen = 8;
3185     if (__builtin_expect(dpy != NULL, 1)) {
3186         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMapiv, cmdlen);
3187         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3188         (void) memcpy((void *)(pc + 4), (void *)(&query), 4);
3189         (void) read_reply(dpy, 4, v, GL_FALSE);
3190         UnlockDisplay(dpy); SyncHandle();
3191     }
3192     return;
3193 }
3194
3195 #define X_GLsop_GetMaterialfv 123
3196 void
3197 __indirect_glGetMaterialfv(GLenum face, GLenum pname, GLfloat * params)
3198 {
3199     __GLXcontext * const gc = __glXGetCurrentContext();
3200     Display * const dpy = gc->currentDpy;
3201     const GLuint cmdlen = 8;
3202     if (__builtin_expect(dpy != NULL, 1)) {
3203         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMaterialfv, cmdlen);
3204         (void) memcpy((void *)(pc + 0), (void *)(&face), 4);
3205         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3206         (void) read_reply(dpy, 4, params, GL_FALSE);
3207         UnlockDisplay(dpy); SyncHandle();
3208     }
3209     return;
3210 }
3211
3212 #define X_GLsop_GetMaterialiv 124
3213 void
3214 __indirect_glGetMaterialiv(GLenum face, GLenum pname, GLint * params)
3215 {
3216     __GLXcontext * const gc = __glXGetCurrentContext();
3217     Display * const dpy = gc->currentDpy;
3218     const GLuint cmdlen = 8;
3219     if (__builtin_expect(dpy != NULL, 1)) {
3220         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMaterialiv, cmdlen);
3221         (void) memcpy((void *)(pc + 0), (void *)(&face), 4);
3222         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3223         (void) read_reply(dpy, 4, params, GL_FALSE);
3224         UnlockDisplay(dpy); SyncHandle();
3225     }
3226     return;
3227 }
3228
3229 #define X_GLsop_GetPixelMapfv 125
3230 void
3231 __indirect_glGetPixelMapfv(GLenum map, GLfloat * values)
3232 {
3233     __GLXcontext * const gc = __glXGetCurrentContext();
3234     Display * const dpy = gc->currentDpy;
3235     const GLuint cmdlen = 4;
3236     if (__builtin_expect(dpy != NULL, 1)) {
3237         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetPixelMapfv, cmdlen);
3238         (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
3239         (void) read_reply(dpy, 4, values, GL_FALSE);
3240         UnlockDisplay(dpy); SyncHandle();
3241     }
3242     return;
3243 }
3244
3245 #define X_GLsop_GetPixelMapuiv 126
3246 void
3247 __indirect_glGetPixelMapuiv(GLenum map, GLuint * values)
3248 {
3249     __GLXcontext * const gc = __glXGetCurrentContext();
3250     Display * const dpy = gc->currentDpy;
3251     const GLuint cmdlen = 4;
3252     if (__builtin_expect(dpy != NULL, 1)) {
3253         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetPixelMapuiv, cmdlen);
3254         (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
3255         (void) read_reply(dpy, 4, values, GL_FALSE);
3256         UnlockDisplay(dpy); SyncHandle();
3257     }
3258     return;
3259 }
3260
3261 #define X_GLsop_GetPixelMapusv 127
3262 void
3263 __indirect_glGetPixelMapusv(GLenum map, GLushort * values)
3264 {
3265     __GLXcontext * const gc = __glXGetCurrentContext();
3266     Display * const dpy = gc->currentDpy;
3267     const GLuint cmdlen = 4;
3268     if (__builtin_expect(dpy != NULL, 1)) {
3269         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetPixelMapusv, cmdlen);
3270         (void) memcpy((void *)(pc + 0), (void *)(&map), 4);
3271         (void) read_reply(dpy, 2, values, GL_FALSE);
3272         UnlockDisplay(dpy); SyncHandle();
3273     }
3274     return;
3275 }
3276
3277 #define X_GLsop_GetTexEnvfv 130
3278 void
3279 __indirect_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat * params)
3280 {
3281     __GLXcontext * const gc = __glXGetCurrentContext();
3282     Display * const dpy = gc->currentDpy;
3283     const GLuint cmdlen = 8;
3284     if (__builtin_expect(dpy != NULL, 1)) {
3285         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexEnvfv, cmdlen);
3286         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3287         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3288         (void) read_reply(dpy, 4, params, GL_FALSE);
3289         UnlockDisplay(dpy); SyncHandle();
3290     }
3291     return;
3292 }
3293
3294 #define X_GLsop_GetTexEnviv 131
3295 void
3296 __indirect_glGetTexEnviv(GLenum target, GLenum pname, GLint * params)
3297 {
3298     __GLXcontext * const gc = __glXGetCurrentContext();
3299     Display * const dpy = gc->currentDpy;
3300     const GLuint cmdlen = 8;
3301     if (__builtin_expect(dpy != NULL, 1)) {
3302         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexEnviv, cmdlen);
3303         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3304         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3305         (void) read_reply(dpy, 4, params, GL_FALSE);
3306         UnlockDisplay(dpy); SyncHandle();
3307     }
3308     return;
3309 }
3310
3311 #define X_GLsop_GetTexGendv 132
3312 void
3313 __indirect_glGetTexGendv(GLenum coord, GLenum pname, GLdouble * params)
3314 {
3315     __GLXcontext * const gc = __glXGetCurrentContext();
3316     Display * const dpy = gc->currentDpy;
3317     const GLuint cmdlen = 8;
3318     if (__builtin_expect(dpy != NULL, 1)) {
3319         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexGendv, cmdlen);
3320         (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
3321         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3322         (void) read_reply(dpy, 8, params, GL_FALSE);
3323         UnlockDisplay(dpy); SyncHandle();
3324     }
3325     return;
3326 }
3327
3328 #define X_GLsop_GetTexGenfv 133
3329 void
3330 __indirect_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat * params)
3331 {
3332     __GLXcontext * const gc = __glXGetCurrentContext();
3333     Display * const dpy = gc->currentDpy;
3334     const GLuint cmdlen = 8;
3335     if (__builtin_expect(dpy != NULL, 1)) {
3336         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexGenfv, cmdlen);
3337         (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
3338         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3339         (void) read_reply(dpy, 4, params, GL_FALSE);
3340         UnlockDisplay(dpy); SyncHandle();
3341     }
3342     return;
3343 }
3344
3345 #define X_GLsop_GetTexGeniv 134
3346 void
3347 __indirect_glGetTexGeniv(GLenum coord, GLenum pname, GLint * params)
3348 {
3349     __GLXcontext * const gc = __glXGetCurrentContext();
3350     Display * const dpy = gc->currentDpy;
3351     const GLuint cmdlen = 8;
3352     if (__builtin_expect(dpy != NULL, 1)) {
3353         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexGeniv, cmdlen);
3354         (void) memcpy((void *)(pc + 0), (void *)(&coord), 4);
3355         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3356         (void) read_reply(dpy, 4, params, GL_FALSE);
3357         UnlockDisplay(dpy); SyncHandle();
3358     }
3359     return;
3360 }
3361
3362 #define X_GLsop_GetTexParameterfv 136
3363 void
3364 __indirect_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat * params)
3365 {
3366     __GLXcontext * const gc = __glXGetCurrentContext();
3367     Display * const dpy = gc->currentDpy;
3368     const GLuint cmdlen = 8;
3369     if (__builtin_expect(dpy != NULL, 1)) {
3370         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexParameterfv, cmdlen);
3371         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3372         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3373         (void) read_reply(dpy, 4, params, GL_FALSE);
3374         UnlockDisplay(dpy); SyncHandle();
3375     }
3376     return;
3377 }
3378
3379 #define X_GLsop_GetTexParameteriv 137
3380 void
3381 __indirect_glGetTexParameteriv(GLenum target, GLenum pname, GLint * params)
3382 {
3383     __GLXcontext * const gc = __glXGetCurrentContext();
3384     Display * const dpy = gc->currentDpy;
3385     const GLuint cmdlen = 8;
3386     if (__builtin_expect(dpy != NULL, 1)) {
3387         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexParameteriv, cmdlen);
3388         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3389         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3390         (void) read_reply(dpy, 4, params, GL_FALSE);
3391         UnlockDisplay(dpy); SyncHandle();
3392     }
3393     return;
3394 }
3395
3396 #define X_GLsop_GetTexLevelParameterfv 138
3397 void
3398 __indirect_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat * params)
3399 {
3400     __GLXcontext * const gc = __glXGetCurrentContext();
3401     Display * const dpy = gc->currentDpy;
3402     const GLuint cmdlen = 12;
3403     if (__builtin_expect(dpy != NULL, 1)) {
3404         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexLevelParameterfv, cmdlen);
3405         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3406         (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
3407         (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
3408         (void) read_reply(dpy, 4, params, GL_FALSE);
3409         UnlockDisplay(dpy); SyncHandle();
3410     }
3411     return;
3412 }
3413
3414 #define X_GLsop_GetTexLevelParameteriv 139
3415 void
3416 __indirect_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint * params)
3417 {
3418     __GLXcontext * const gc = __glXGetCurrentContext();
3419     Display * const dpy = gc->currentDpy;
3420     const GLuint cmdlen = 12;
3421     if (__builtin_expect(dpy != NULL, 1)) {
3422         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetTexLevelParameteriv, cmdlen);
3423         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3424         (void) memcpy((void *)(pc + 4), (void *)(&level), 4);
3425         (void) memcpy((void *)(pc + 8), (void *)(&pname), 4);
3426         (void) read_reply(dpy, 4, params, GL_FALSE);
3427         UnlockDisplay(dpy); SyncHandle();
3428     }
3429     return;
3430 }
3431
3432 #define X_GLsop_IsList 141
3433 GLboolean
3434 __indirect_glIsList(GLuint list)
3435 {
3436     __GLXcontext * const gc = __glXGetCurrentContext();
3437     Display * const dpy = gc->currentDpy;
3438     GLboolean retval = (GLboolean) 0;
3439     const GLuint cmdlen = 4;
3440     if (__builtin_expect(dpy != NULL, 1)) {
3441         GLubyte const * pc = setup_single_request(gc, X_GLsop_IsList, cmdlen);
3442         (void) memcpy((void *)(pc + 0), (void *)(&list), 4);
3443         retval = (GLboolean) read_reply(dpy, 0, NULL, GL_FALSE);
3444         UnlockDisplay(dpy); SyncHandle();
3445     }
3446     return retval;
3447 }
3448
3449 #define X_GLrop_DepthRange 174
3450 void
3451 __indirect_glDepthRange(GLclampd zNear, GLclampd zFar)
3452 {
3453     __GLXcontext * const gc = __glXGetCurrentContext();
3454     const GLuint cmdlen = 20;
3455     emit_header(gc->pc, X_GLrop_DepthRange, cmdlen);
3456     (void) memcpy((void *)(gc->pc + 4), (void *)(&zNear), 8);
3457     (void) memcpy((void *)(gc->pc + 12), (void *)(&zFar), 8);
3458     gc->pc += cmdlen;
3459     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3460 }
3461
3462 #define X_GLrop_Frustum 175
3463 void
3464 __indirect_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
3465 {
3466     __GLXcontext * const gc = __glXGetCurrentContext();
3467     const GLuint cmdlen = 52;
3468     emit_header(gc->pc, X_GLrop_Frustum, cmdlen);
3469     (void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8);
3470     (void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8);
3471     (void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8);
3472     (void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8);
3473     (void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8);
3474     (void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8);
3475     gc->pc += cmdlen;
3476     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3477 }
3478
3479 #define X_GLrop_LoadIdentity 176
3480 void
3481 __indirect_glLoadIdentity(void)
3482 {
3483     __GLXcontext * const gc = __glXGetCurrentContext();
3484     const GLuint cmdlen = 4;
3485     emit_header(gc->pc, X_GLrop_LoadIdentity, cmdlen);
3486     gc->pc += cmdlen;
3487     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3488 }
3489
3490 #define X_GLrop_LoadMatrixf 177
3491 void
3492 __indirect_glLoadMatrixf(const GLfloat * m)
3493 {
3494     __GLXcontext * const gc = __glXGetCurrentContext();
3495     const GLuint cmdlen = 68;
3496     emit_header(gc->pc, X_GLrop_LoadMatrixf, cmdlen);
3497     (void) memcpy((void *)(gc->pc + 4), (void *)(m), 64);
3498     gc->pc += cmdlen;
3499     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3500 }
3501
3502 #define X_GLrop_LoadMatrixd 178
3503 void
3504 __indirect_glLoadMatrixd(const GLdouble * m)
3505 {
3506     __GLXcontext * const gc = __glXGetCurrentContext();
3507     const GLuint cmdlen = 132;
3508     emit_header(gc->pc, X_GLrop_LoadMatrixd, cmdlen);
3509     (void) memcpy((void *)(gc->pc + 4), (void *)(m), 128);
3510     gc->pc += cmdlen;
3511     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3512 }
3513
3514 #define X_GLrop_MatrixMode 179
3515 void
3516 __indirect_glMatrixMode(GLenum mode)
3517 {
3518     __GLXcontext * const gc = __glXGetCurrentContext();
3519     const GLuint cmdlen = 8;
3520     emit_header(gc->pc, X_GLrop_MatrixMode, cmdlen);
3521     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
3522     gc->pc += cmdlen;
3523     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3524 }
3525
3526 #define X_GLrop_MultMatrixf 180
3527 void
3528 __indirect_glMultMatrixf(const GLfloat * m)
3529 {
3530     __GLXcontext * const gc = __glXGetCurrentContext();
3531     const GLuint cmdlen = 68;
3532     emit_header(gc->pc, X_GLrop_MultMatrixf, cmdlen);
3533     (void) memcpy((void *)(gc->pc + 4), (void *)(m), 64);
3534     gc->pc += cmdlen;
3535     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3536 }
3537
3538 #define X_GLrop_MultMatrixd 181
3539 void
3540 __indirect_glMultMatrixd(const GLdouble * m)
3541 {
3542     __GLXcontext * const gc = __glXGetCurrentContext();
3543     const GLuint cmdlen = 132;
3544     emit_header(gc->pc, X_GLrop_MultMatrixd, cmdlen);
3545     (void) memcpy((void *)(gc->pc + 4), (void *)(m), 128);
3546     gc->pc += cmdlen;
3547     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3548 }
3549
3550 #define X_GLrop_Ortho 182
3551 void
3552 __indirect_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
3553 {
3554     __GLXcontext * const gc = __glXGetCurrentContext();
3555     const GLuint cmdlen = 52;
3556     emit_header(gc->pc, X_GLrop_Ortho, cmdlen);
3557     (void) memcpy((void *)(gc->pc + 4), (void *)(&left), 8);
3558     (void) memcpy((void *)(gc->pc + 12), (void *)(&right), 8);
3559     (void) memcpy((void *)(gc->pc + 20), (void *)(&bottom), 8);
3560     (void) memcpy((void *)(gc->pc + 28), (void *)(&top), 8);
3561     (void) memcpy((void *)(gc->pc + 36), (void *)(&zNear), 8);
3562     (void) memcpy((void *)(gc->pc + 44), (void *)(&zFar), 8);
3563     gc->pc += cmdlen;
3564     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3565 }
3566
3567 #define X_GLrop_PopMatrix 183
3568 void
3569 __indirect_glPopMatrix(void)
3570 {
3571     __GLXcontext * const gc = __glXGetCurrentContext();
3572     const GLuint cmdlen = 4;
3573     emit_header(gc->pc, X_GLrop_PopMatrix, cmdlen);
3574     gc->pc += cmdlen;
3575     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3576 }
3577
3578 #define X_GLrop_PushMatrix 184
3579 void
3580 __indirect_glPushMatrix(void)
3581 {
3582     __GLXcontext * const gc = __glXGetCurrentContext();
3583     const GLuint cmdlen = 4;
3584     emit_header(gc->pc, X_GLrop_PushMatrix, cmdlen);
3585     gc->pc += cmdlen;
3586     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3587 }
3588
3589 #define X_GLrop_Rotated 185
3590 void
3591 __indirect_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
3592 {
3593     __GLXcontext * const gc = __glXGetCurrentContext();
3594     const GLuint cmdlen = 36;
3595     emit_header(gc->pc, X_GLrop_Rotated, cmdlen);
3596     (void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 8);
3597     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 8);
3598     (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 8);
3599     (void) memcpy((void *)(gc->pc + 28), (void *)(&z), 8);
3600     gc->pc += cmdlen;
3601     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3602 }
3603
3604 #define X_GLrop_Rotatef 186
3605 void
3606 __indirect_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
3607 {
3608     __GLXcontext * const gc = __glXGetCurrentContext();
3609     const GLuint cmdlen = 20;
3610     emit_header(gc->pc, X_GLrop_Rotatef, cmdlen);
3611     (void) memcpy((void *)(gc->pc + 4), (void *)(&angle), 4);
3612     (void) memcpy((void *)(gc->pc + 8), (void *)(&x), 4);
3613     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 4);
3614     (void) memcpy((void *)(gc->pc + 16), (void *)(&z), 4);
3615     gc->pc += cmdlen;
3616     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3617 }
3618
3619 #define X_GLrop_Scaled 187
3620 void
3621 __indirect_glScaled(GLdouble x, GLdouble y, GLdouble z)
3622 {
3623     __GLXcontext * const gc = __glXGetCurrentContext();
3624     const GLuint cmdlen = 28;
3625     emit_header(gc->pc, X_GLrop_Scaled, cmdlen);
3626     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
3627     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
3628     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
3629     gc->pc += cmdlen;
3630     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3631 }
3632
3633 #define X_GLrop_Scalef 188
3634 void
3635 __indirect_glScalef(GLfloat x, GLfloat y, GLfloat z)
3636 {
3637     __GLXcontext * const gc = __glXGetCurrentContext();
3638     const GLuint cmdlen = 16;
3639     emit_header(gc->pc, X_GLrop_Scalef, cmdlen);
3640     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
3641     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
3642     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
3643     gc->pc += cmdlen;
3644     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3645 }
3646
3647 #define X_GLrop_Translated 189
3648 void
3649 __indirect_glTranslated(GLdouble x, GLdouble y, GLdouble z)
3650 {
3651     __GLXcontext * const gc = __glXGetCurrentContext();
3652     const GLuint cmdlen = 28;
3653     emit_header(gc->pc, X_GLrop_Translated, cmdlen);
3654     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 8);
3655     (void) memcpy((void *)(gc->pc + 12), (void *)(&y), 8);
3656     (void) memcpy((void *)(gc->pc + 20), (void *)(&z), 8);
3657     gc->pc += cmdlen;
3658     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3659 }
3660
3661 #define X_GLrop_Translatef 190
3662 void
3663 __indirect_glTranslatef(GLfloat x, GLfloat y, GLfloat z)
3664 {
3665     __GLXcontext * const gc = __glXGetCurrentContext();
3666     const GLuint cmdlen = 16;
3667     emit_header(gc->pc, X_GLrop_Translatef, cmdlen);
3668     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
3669     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
3670     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
3671     gc->pc += cmdlen;
3672     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3673 }
3674
3675 #define X_GLrop_Viewport 191
3676 void
3677 __indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
3678 {
3679     __GLXcontext * const gc = __glXGetCurrentContext();
3680     const GLuint cmdlen = 20;
3681     emit_header(gc->pc, X_GLrop_Viewport, cmdlen);
3682     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
3683     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
3684     (void) memcpy((void *)(gc->pc + 12), (void *)(&width), 4);
3685     (void) memcpy((void *)(gc->pc + 16), (void *)(&height), 4);
3686     gc->pc += cmdlen;
3687     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3688 }
3689
3690 #define X_GLrop_BindTexture 4117
3691 void
3692 __indirect_glBindTexture(GLenum target, GLuint texture)
3693 {
3694     __GLXcontext * const gc = __glXGetCurrentContext();
3695     const GLuint cmdlen = 12;
3696     emit_header(gc->pc, X_GLrop_BindTexture, cmdlen);
3697     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
3698     (void) memcpy((void *)(gc->pc + 8), (void *)(&texture), 4);
3699     gc->pc += cmdlen;
3700     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3701 }
3702
3703 #define X_GLrop_Indexubv 194
3704 void
3705 __indirect_glIndexub(GLubyte c)
3706 {
3707     __GLXcontext * const gc = __glXGetCurrentContext();
3708     const GLuint cmdlen = 8;
3709     emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
3710     (void) memcpy((void *)(gc->pc + 4), (void *)(&c), 1);
3711     gc->pc += cmdlen;
3712     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3713 }
3714
3715 #define X_GLrop_Indexubv 194
3716 void
3717 __indirect_glIndexubv(const GLubyte * c)
3718 {
3719     __GLXcontext * const gc = __glXGetCurrentContext();
3720     const GLuint cmdlen = 8;
3721     emit_header(gc->pc, X_GLrop_Indexubv, cmdlen);
3722     (void) memcpy((void *)(gc->pc + 4), (void *)(c), 1);
3723     gc->pc += cmdlen;
3724     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3725 }
3726
3727 #define X_GLrop_PolygonOffset 192
3728 void
3729 __indirect_glPolygonOffset(GLfloat factor, GLfloat units)
3730 {
3731     __GLXcontext * const gc = __glXGetCurrentContext();
3732     const GLuint cmdlen = 12;
3733     emit_header(gc->pc, X_GLrop_PolygonOffset, cmdlen);
3734     (void) memcpy((void *)(gc->pc + 4), (void *)(&factor), 4);
3735     (void) memcpy((void *)(gc->pc + 8), (void *)(&units), 4);
3736     gc->pc += cmdlen;
3737     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3738 }
3739
3740 #define X_GLsop_AreTexturesResident 143
3741 GLboolean
3742 __indirect_glAreTexturesResident(GLsizei n, const GLuint * textures, GLboolean * residences)
3743 {
3744     __GLXcontext * const gc = __glXGetCurrentContext();
3745     Display * const dpy = gc->currentDpy;
3746     GLboolean retval = (GLboolean) 0;
3747     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
3748     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
3749         GLubyte const * pc = setup_single_request(gc, X_GLsop_AreTexturesResident, cmdlen);
3750         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
3751         (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
3752         retval = (GLboolean) read_reply(dpy, 1, residences, GL_TRUE);
3753         UnlockDisplay(dpy); SyncHandle();
3754     }
3755     return retval;
3756 }
3757
3758 #define X_GLrop_CopyTexImage1D 4119
3759 void
3760 __indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
3761 {
3762     __GLXcontext * const gc = __glXGetCurrentContext();
3763     const GLuint cmdlen = 32;
3764     emit_header(gc->pc, X_GLrop_CopyTexImage1D, cmdlen);
3765     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
3766     (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
3767     (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
3768     (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
3769     (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
3770     (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
3771     (void) memcpy((void *)(gc->pc + 28), (void *)(&border), 4);
3772     gc->pc += cmdlen;
3773     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3774 }
3775
3776 #define X_GLrop_CopyTexImage2D 4120
3777 void
3778 __indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
3779 {
3780     __GLXcontext * const gc = __glXGetCurrentContext();
3781     const GLuint cmdlen = 36;
3782     emit_header(gc->pc, X_GLrop_CopyTexImage2D, cmdlen);
3783     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
3784     (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
3785     (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
3786     (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
3787     (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
3788     (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
3789     (void) memcpy((void *)(gc->pc + 28), (void *)(&height), 4);
3790     (void) memcpy((void *)(gc->pc + 32), (void *)(&border), 4);
3791     gc->pc += cmdlen;
3792     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3793 }
3794
3795 #define X_GLrop_CopyTexSubImage1D 4121
3796 void
3797 __indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
3798 {
3799     __GLXcontext * const gc = __glXGetCurrentContext();
3800     const GLuint cmdlen = 28;
3801     emit_header(gc->pc, X_GLrop_CopyTexSubImage1D, cmdlen);
3802     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
3803     (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
3804     (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
3805     (void) memcpy((void *)(gc->pc + 16), (void *)(&x), 4);
3806     (void) memcpy((void *)(gc->pc + 20), (void *)(&y), 4);
3807     (void) memcpy((void *)(gc->pc + 24), (void *)(&width), 4);
3808     gc->pc += cmdlen;
3809     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3810 }
3811
3812 #define X_GLrop_CopyTexSubImage2D 4122
3813 void
3814 __indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
3815 {
3816     __GLXcontext * const gc = __glXGetCurrentContext();
3817     const GLuint cmdlen = 36;
3818     emit_header(gc->pc, X_GLrop_CopyTexSubImage2D, cmdlen);
3819     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
3820     (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
3821     (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
3822     (void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4);
3823     (void) memcpy((void *)(gc->pc + 20), (void *)(&x), 4);
3824     (void) memcpy((void *)(gc->pc + 24), (void *)(&y), 4);
3825     (void) memcpy((void *)(gc->pc + 28), (void *)(&width), 4);
3826     (void) memcpy((void *)(gc->pc + 32), (void *)(&height), 4);
3827     gc->pc += cmdlen;
3828     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3829 }
3830
3831 #define X_GLsop_DeleteTextures 144
3832 void
3833 __indirect_glDeleteTextures(GLsizei n, const GLuint * textures)
3834 {
3835     __GLXcontext * const gc = __glXGetCurrentContext();
3836     Display * const dpy = gc->currentDpy;
3837     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
3838     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
3839         GLubyte const * pc = setup_single_request(gc, X_GLsop_DeleteTextures, cmdlen);
3840         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
3841         (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
3842         UnlockDisplay(dpy); SyncHandle();
3843     }
3844     return;
3845 }
3846
3847 #define X_GLsop_GenTextures 145
3848 void
3849 __indirect_glGenTextures(GLsizei n, GLuint * textures)
3850 {
3851     __GLXcontext * const gc = __glXGetCurrentContext();
3852     Display * const dpy = gc->currentDpy;
3853     const GLuint cmdlen = 4;
3854     if (__builtin_expect(dpy != NULL, 1)) {
3855         GLubyte const * pc = setup_single_request(gc, X_GLsop_GenTextures, cmdlen);
3856         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
3857         (void) read_reply(dpy, 4, textures, GL_TRUE);
3858         UnlockDisplay(dpy); SyncHandle();
3859     }
3860     return;
3861 }
3862
3863 #define X_GLsop_IsTexture 146
3864 GLboolean
3865 __indirect_glIsTexture(GLuint texture)
3866 {
3867     __GLXcontext * const gc = __glXGetCurrentContext();
3868     Display * const dpy = gc->currentDpy;
3869     GLboolean retval = (GLboolean) 0;
3870     const GLuint cmdlen = 4;
3871     if (__builtin_expect(dpy != NULL, 1)) {
3872         GLubyte const * pc = setup_single_request(gc, X_GLsop_IsTexture, cmdlen);
3873         (void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
3874         retval = (GLboolean) read_reply(dpy, 0, NULL, GL_FALSE);
3875         UnlockDisplay(dpy); SyncHandle();
3876     }
3877     return retval;
3878 }
3879
3880 #define X_GLrop_PrioritizeTextures 4118
3881 void
3882 __indirect_glPrioritizeTextures(GLsizei n, const GLuint * textures, const GLclampf * priorities)
3883 {
3884     __GLXcontext * const gc = __glXGetCurrentContext();
3885     const GLuint cmdlen = 8 + __GLX_PAD((n * 4)) + __GLX_PAD((n * 4));
3886     if (__builtin_expect(n >= 0, 1)) {
3887         emit_header(gc->pc, X_GLrop_PrioritizeTextures, cmdlen);
3888         (void) memcpy((void *)(gc->pc + 4), (void *)(&n), 4);
3889         (void) memcpy((void *)(gc->pc + 8), (void *)(textures), (n * 4));
3890         (void) memcpy((void *)(gc->pc + 8), (void *)(priorities), (n * 4));
3891         gc->pc += cmdlen;
3892         if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3893     }
3894 }
3895
3896 #define X_GLrop_BlendColor 4096
3897 void
3898 __indirect_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
3899 {
3900     __GLXcontext * const gc = __glXGetCurrentContext();
3901     const GLuint cmdlen = 20;
3902     emit_header(gc->pc, X_GLrop_BlendColor, cmdlen);
3903     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
3904     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
3905     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
3906     (void) memcpy((void *)(gc->pc + 16), (void *)(&alpha), 4);
3907     gc->pc += cmdlen;
3908     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3909 }
3910
3911 #define X_GLrop_BlendEquation 4097
3912 void
3913 __indirect_glBlendEquation(GLenum mode)
3914 {
3915     __GLXcontext * const gc = __glXGetCurrentContext();
3916     const GLuint cmdlen = 8;
3917     emit_header(gc->pc, X_GLrop_BlendEquation, cmdlen);
3918     (void) memcpy((void *)(gc->pc + 4), (void *)(&mode), 4);
3919     gc->pc += cmdlen;
3920     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3921 }
3922
3923 #define X_GLrop_ColorTableParameterfv 2054
3924 void
3925 __indirect_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat * params)
3926 {
3927     __GLXcontext * const gc = __glXGetCurrentContext();
3928     const GLuint compsize = __glColorTableParameterfv_size(pname);
3929     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
3930     emit_header(gc->pc, X_GLrop_ColorTableParameterfv, cmdlen);
3931     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
3932     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
3933     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
3934     gc->pc += cmdlen;
3935     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3936 }
3937
3938 #define X_GLrop_ColorTableParameteriv 2055
3939 void
3940 __indirect_glColorTableParameteriv(GLenum target, GLenum pname, const GLint * params)
3941 {
3942     __GLXcontext * const gc = __glXGetCurrentContext();
3943     const GLuint compsize = __glColorTableParameteriv_size(pname);
3944     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
3945     emit_header(gc->pc, X_GLrop_ColorTableParameteriv, cmdlen);
3946     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
3947     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
3948     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
3949     gc->pc += cmdlen;
3950     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3951 }
3952
3953 #define X_GLrop_CopyColorTable 2056
3954 void
3955 __indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
3956 {
3957     __GLXcontext * const gc = __glXGetCurrentContext();
3958     const GLuint cmdlen = 24;
3959     emit_header(gc->pc, X_GLrop_CopyColorTable, cmdlen);
3960     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
3961     (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
3962     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
3963     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
3964     (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
3965     gc->pc += cmdlen;
3966     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
3967 }
3968
3969 #define X_GLsop_GetColorTableParameterfv 148
3970 void
3971 __indirect_glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params)
3972 {
3973     __GLXcontext * const gc = __glXGetCurrentContext();
3974     Display * const dpy = gc->currentDpy;
3975     const GLuint cmdlen = 8;
3976     if (__builtin_expect(dpy != NULL, 1)) {
3977         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetColorTableParameterfv, cmdlen);
3978         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3979         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3980         (void) read_reply(dpy, 4, params, GL_FALSE);
3981         UnlockDisplay(dpy); SyncHandle();
3982     }
3983     return;
3984 }
3985
3986 #define X_GLsop_GetColorTableParameteriv 149
3987 void
3988 __indirect_glGetColorTableParameteriv(GLenum target, GLenum pname, GLint * params)
3989 {
3990     __GLXcontext * const gc = __glXGetCurrentContext();
3991     Display * const dpy = gc->currentDpy;
3992     const GLuint cmdlen = 8;
3993     if (__builtin_expect(dpy != NULL, 1)) {
3994         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetColorTableParameteriv, cmdlen);
3995         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
3996         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
3997         (void) read_reply(dpy, 4, params, GL_FALSE);
3998         UnlockDisplay(dpy); SyncHandle();
3999     }
4000     return;
4001 }
4002
4003 #define X_GLrop_CopyColorSubTable 196
4004 void
4005 __indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
4006 {
4007     __GLXcontext * const gc = __glXGetCurrentContext();
4008     const GLuint cmdlen = 24;
4009     emit_header(gc->pc, X_GLrop_CopyColorSubTable, cmdlen);
4010     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4011     (void) memcpy((void *)(gc->pc + 8), (void *)(&start), 4);
4012     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4013     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4014     (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4015     gc->pc += cmdlen;
4016     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4017 }
4018
4019 #define X_GLrop_ConvolutionParameterf 4103
4020 void
4021 __indirect_glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
4022 {
4023     __GLXcontext * const gc = __glXGetCurrentContext();
4024     const GLuint cmdlen = 16;
4025     emit_header(gc->pc, X_GLrop_ConvolutionParameterf, cmdlen);
4026     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4027     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4028     (void) memcpy((void *)(gc->pc + 12), (void *)(&params), 4);
4029     gc->pc += cmdlen;
4030     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4031 }
4032
4033 #define X_GLrop_ConvolutionParameterfv 4104
4034 void
4035 __indirect_glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat * params)
4036 {
4037     __GLXcontext * const gc = __glXGetCurrentContext();
4038     const GLuint compsize = __glConvolutionParameterfv_size(pname);
4039     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4040     emit_header(gc->pc, X_GLrop_ConvolutionParameterfv, cmdlen);
4041     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4042     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4043     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4044     gc->pc += cmdlen;
4045     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4046 }
4047
4048 #define X_GLrop_ConvolutionParameteri 4105
4049 void
4050 __indirect_glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
4051 {
4052     __GLXcontext * const gc = __glXGetCurrentContext();
4053     const GLuint cmdlen = 16;
4054     emit_header(gc->pc, X_GLrop_ConvolutionParameteri, cmdlen);
4055     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4056     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4057     (void) memcpy((void *)(gc->pc + 12), (void *)(&params), 4);
4058     gc->pc += cmdlen;
4059     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4060 }
4061
4062 #define X_GLrop_ConvolutionParameteriv 4106
4063 void
4064 __indirect_glConvolutionParameteriv(GLenum target, GLenum pname, const GLint * params)
4065 {
4066     __GLXcontext * const gc = __glXGetCurrentContext();
4067     const GLuint compsize = __glConvolutionParameteriv_size(pname);
4068     const GLuint cmdlen = 12 + __GLX_PAD((compsize * 4));
4069     emit_header(gc->pc, X_GLrop_ConvolutionParameteriv, cmdlen);
4070     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4071     (void) memcpy((void *)(gc->pc + 8), (void *)(&pname), 4);
4072     (void) memcpy((void *)(gc->pc + 12), (void *)(params), (compsize * 4));
4073     gc->pc += cmdlen;
4074     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4075 }
4076
4077 #define X_GLrop_CopyConvolutionFilter1D 4107
4078 void
4079 __indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
4080 {
4081     __GLXcontext * const gc = __glXGetCurrentContext();
4082     const GLuint cmdlen = 24;
4083     emit_header(gc->pc, X_GLrop_CopyConvolutionFilter1D, cmdlen);
4084     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4085     (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4086     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4087     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4088     (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4089     gc->pc += cmdlen;
4090     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4091 }
4092
4093 #define X_GLrop_CopyConvolutionFilter2D 4108
4094 void
4095 __indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
4096 {
4097     __GLXcontext * const gc = __glXGetCurrentContext();
4098     const GLuint cmdlen = 28;
4099     emit_header(gc->pc, X_GLrop_CopyConvolutionFilter2D, cmdlen);
4100     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4101     (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4102     (void) memcpy((void *)(gc->pc + 12), (void *)(&x), 4);
4103     (void) memcpy((void *)(gc->pc + 16), (void *)(&y), 4);
4104     (void) memcpy((void *)(gc->pc + 20), (void *)(&width), 4);
4105     (void) memcpy((void *)(gc->pc + 24), (void *)(&height), 4);
4106     gc->pc += cmdlen;
4107     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4108 }
4109
4110 #define X_GLsop_GetConvolutionParameterfv 151
4111 void
4112 __indirect_glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params)
4113 {
4114     __GLXcontext * const gc = __glXGetCurrentContext();
4115     Display * const dpy = gc->currentDpy;
4116     const GLuint cmdlen = 8;
4117     if (__builtin_expect(dpy != NULL, 1)) {
4118         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetConvolutionParameterfv, cmdlen);
4119         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4120         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4121         (void) read_reply(dpy, 4, params, GL_FALSE);
4122         UnlockDisplay(dpy); SyncHandle();
4123     }
4124     return;
4125 }
4126
4127 #define X_GLsop_GetConvolutionParameteriv 152
4128 void
4129 __indirect_glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint * params)
4130 {
4131     __GLXcontext * const gc = __glXGetCurrentContext();
4132     Display * const dpy = gc->currentDpy;
4133     const GLuint cmdlen = 8;
4134     if (__builtin_expect(dpy != NULL, 1)) {
4135         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetConvolutionParameteriv, cmdlen);
4136         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4137         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4138         (void) read_reply(dpy, 4, params, GL_FALSE);
4139         UnlockDisplay(dpy); SyncHandle();
4140     }
4141     return;
4142 }
4143
4144 #define X_GLsop_GetHistogramParameterfv 155
4145 void
4146 __indirect_glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params)
4147 {
4148     __GLXcontext * const gc = __glXGetCurrentContext();
4149     Display * const dpy = gc->currentDpy;
4150     const GLuint cmdlen = 8;
4151     if (__builtin_expect(dpy != NULL, 1)) {
4152         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetHistogramParameterfv, cmdlen);
4153         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4154         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4155         (void) read_reply(dpy, 4, params, GL_FALSE);
4156         UnlockDisplay(dpy); SyncHandle();
4157     }
4158     return;
4159 }
4160
4161 #define X_GLsop_GetHistogramParameteriv 156
4162 void
4163 __indirect_glGetHistogramParameteriv(GLenum target, GLenum pname, GLint * params)
4164 {
4165     __GLXcontext * const gc = __glXGetCurrentContext();
4166     Display * const dpy = gc->currentDpy;
4167     const GLuint cmdlen = 8;
4168     if (__builtin_expect(dpy != NULL, 1)) {
4169         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetHistogramParameteriv, cmdlen);
4170         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4171         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4172         (void) read_reply(dpy, 4, params, GL_FALSE);
4173         UnlockDisplay(dpy); SyncHandle();
4174     }
4175     return;
4176 }
4177
4178 #define X_GLsop_GetMinmaxParameterfv 158
4179 void
4180 __indirect_glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * params)
4181 {
4182     __GLXcontext * const gc = __glXGetCurrentContext();
4183     Display * const dpy = gc->currentDpy;
4184     const GLuint cmdlen = 8;
4185     if (__builtin_expect(dpy != NULL, 1)) {
4186         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMinmaxParameterfv, cmdlen);
4187         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4188         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4189         (void) read_reply(dpy, 4, params, GL_FALSE);
4190         UnlockDisplay(dpy); SyncHandle();
4191     }
4192     return;
4193 }
4194
4195 #define X_GLsop_GetMinmaxParameteriv 159
4196 void
4197 __indirect_glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params)
4198 {
4199     __GLXcontext * const gc = __glXGetCurrentContext();
4200     Display * const dpy = gc->currentDpy;
4201     const GLuint cmdlen = 8;
4202     if (__builtin_expect(dpy != NULL, 1)) {
4203         GLubyte const * pc = setup_single_request(gc, X_GLsop_GetMinmaxParameteriv, cmdlen);
4204         (void) memcpy((void *)(pc + 0), (void *)(&target), 4);
4205         (void) memcpy((void *)(pc + 4), (void *)(&pname), 4);
4206         (void) read_reply(dpy, 4, params, GL_FALSE);
4207         UnlockDisplay(dpy); SyncHandle();
4208     }
4209     return;
4210 }
4211
4212 #define X_GLrop_Histogram 4110
4213 void
4214 __indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
4215 {
4216     __GLXcontext * const gc = __glXGetCurrentContext();
4217     const GLuint cmdlen = 20;
4218     emit_header(gc->pc, X_GLrop_Histogram, cmdlen);
4219     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4220     (void) memcpy((void *)(gc->pc + 8), (void *)(&width), 4);
4221     (void) memcpy((void *)(gc->pc + 12), (void *)(&internalformat), 4);
4222     (void) memcpy((void *)(gc->pc + 16), (void *)(&sink), 1);
4223     gc->pc += cmdlen;
4224     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4225 }
4226
4227 #define X_GLrop_Minmax 4111
4228 void
4229 __indirect_glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
4230 {
4231     __GLXcontext * const gc = __glXGetCurrentContext();
4232     const GLuint cmdlen = 16;
4233     emit_header(gc->pc, X_GLrop_Minmax, cmdlen);
4234     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4235     (void) memcpy((void *)(gc->pc + 8), (void *)(&internalformat), 4);
4236     (void) memcpy((void *)(gc->pc + 12), (void *)(&sink), 1);
4237     gc->pc += cmdlen;
4238     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4239 }
4240
4241 #define X_GLrop_ResetHistogram 4112
4242 void
4243 __indirect_glResetHistogram(GLenum target)
4244 {
4245     __GLXcontext * const gc = __glXGetCurrentContext();
4246     const GLuint cmdlen = 8;
4247     emit_header(gc->pc, X_GLrop_ResetHistogram, cmdlen);
4248     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4249     gc->pc += cmdlen;
4250     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4251 }
4252
4253 #define X_GLrop_ResetMinmax 4113
4254 void
4255 __indirect_glResetMinmax(GLenum target)
4256 {
4257     __GLXcontext * const gc = __glXGetCurrentContext();
4258     const GLuint cmdlen = 8;
4259     emit_header(gc->pc, X_GLrop_ResetMinmax, cmdlen);
4260     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4261     gc->pc += cmdlen;
4262     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4263 }
4264
4265 #define X_GLrop_CopyTexSubImage3D 4123
4266 void
4267 __indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
4268 {
4269     __GLXcontext * const gc = __glXGetCurrentContext();
4270     const GLuint cmdlen = 40;
4271     emit_header(gc->pc, X_GLrop_CopyTexSubImage3D, cmdlen);
4272     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4273     (void) memcpy((void *)(gc->pc + 8), (void *)(&level), 4);
4274     (void) memcpy((void *)(gc->pc + 12), (void *)(&xoffset), 4);
4275     (void) memcpy((void *)(gc->pc + 16), (void *)(&yoffset), 4);
4276     (void) memcpy((void *)(gc->pc + 20), (void *)(&zoffset), 4);
4277     (void) memcpy((void *)(gc->pc + 24), (void *)(&x), 4);
4278     (void) memcpy((void *)(gc->pc + 28), (void *)(&y), 4);
4279     (void) memcpy((void *)(gc->pc + 32), (void *)(&width), 4);
4280     (void) memcpy((void *)(gc->pc + 36), (void *)(&height), 4);
4281     gc->pc += cmdlen;
4282     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4283 }
4284
4285 #define X_GLrop_ActiveTextureARB 197
4286 void
4287 __indirect_glActiveTextureARB(GLenum texture)
4288 {
4289     __GLXcontext * const gc = __glXGetCurrentContext();
4290     const GLuint cmdlen = 8;
4291     emit_header(gc->pc, X_GLrop_ActiveTextureARB, cmdlen);
4292     (void) memcpy((void *)(gc->pc + 4), (void *)(&texture), 4);
4293     gc->pc += cmdlen;
4294     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4295 }
4296
4297 #define X_GLrop_MultiTexCoord1dvARB 198
4298 void
4299 __indirect_glMultiTexCoord1dARB(GLenum target, GLdouble s)
4300 {
4301     __GLXcontext * const gc = __glXGetCurrentContext();
4302     const GLuint cmdlen = 16;
4303     emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
4304     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
4305     (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
4306     gc->pc += cmdlen;
4307     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4308 }
4309
4310 #define X_GLrop_MultiTexCoord1dvARB 198
4311 void
4312 __indirect_glMultiTexCoord1dvARB(GLenum target, const GLdouble * v)
4313 {
4314     __GLXcontext * const gc = __glXGetCurrentContext();
4315     const GLuint cmdlen = 16;
4316     emit_header(gc->pc, X_GLrop_MultiTexCoord1dvARB, cmdlen);
4317     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 8);
4318     (void) memcpy((void *)(gc->pc + 12), (void *)(&target), 4);
4319     gc->pc += cmdlen;
4320     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4321 }
4322
4323 #define X_GLrop_MultiTexCoord1fvARB 199
4324 void
4325 __indirect_glMultiTexCoord1fARB(GLenum target, GLfloat s)
4326 {
4327     __GLXcontext * const gc = __glXGetCurrentContext();
4328     const GLuint cmdlen = 12;
4329     emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
4330     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4331     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
4332     gc->pc += cmdlen;
4333     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4334 }
4335
4336 #define X_GLrop_MultiTexCoord1fvARB 199
4337 void
4338 __indirect_glMultiTexCoord1fvARB(GLenum target, const GLfloat * v)
4339 {
4340     __GLXcontext * const gc = __glXGetCurrentContext();
4341     const GLuint cmdlen = 12;
4342     emit_header(gc->pc, X_GLrop_MultiTexCoord1fvARB, cmdlen);
4343     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4344     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
4345     gc->pc += cmdlen;
4346     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4347 }
4348
4349 #define X_GLrop_MultiTexCoord1ivARB 200
4350 void
4351 __indirect_glMultiTexCoord1iARB(GLenum target, GLint s)
4352 {
4353     __GLXcontext * const gc = __glXGetCurrentContext();
4354     const GLuint cmdlen = 12;
4355     emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
4356     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4357     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
4358     gc->pc += cmdlen;
4359     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4360 }
4361
4362 #define X_GLrop_MultiTexCoord1ivARB 200
4363 void
4364 __indirect_glMultiTexCoord1ivARB(GLenum target, const GLint * v)
4365 {
4366     __GLXcontext * const gc = __glXGetCurrentContext();
4367     const GLuint cmdlen = 12;
4368     emit_header(gc->pc, X_GLrop_MultiTexCoord1ivARB, cmdlen);
4369     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4370     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
4371     gc->pc += cmdlen;
4372     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4373 }
4374
4375 #define X_GLrop_MultiTexCoord1svARB 201
4376 void
4377 __indirect_glMultiTexCoord1sARB(GLenum target, GLshort s)
4378 {
4379     __GLXcontext * const gc = __glXGetCurrentContext();
4380     const GLuint cmdlen = 12;
4381     emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
4382     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4383     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
4384     gc->pc += cmdlen;
4385     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4386 }
4387
4388 #define X_GLrop_MultiTexCoord1svARB 201
4389 void
4390 __indirect_glMultiTexCoord1svARB(GLenum target, const GLshort * v)
4391 {
4392     __GLXcontext * const gc = __glXGetCurrentContext();
4393     const GLuint cmdlen = 12;
4394     emit_header(gc->pc, X_GLrop_MultiTexCoord1svARB, cmdlen);
4395     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4396     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 2);
4397     gc->pc += cmdlen;
4398     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4399 }
4400
4401 #define X_GLrop_MultiTexCoord2dvARB 202
4402 void
4403 __indirect_glMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
4404 {
4405     __GLXcontext * const gc = __glXGetCurrentContext();
4406     const GLuint cmdlen = 24;
4407     emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
4408     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
4409     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
4410     (void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4);
4411     gc->pc += cmdlen;
4412     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4413 }
4414
4415 #define X_GLrop_MultiTexCoord2dvARB 202
4416 void
4417 __indirect_glMultiTexCoord2dvARB(GLenum target, const GLdouble * v)
4418 {
4419     __GLXcontext * const gc = __glXGetCurrentContext();
4420     const GLuint cmdlen = 24;
4421     emit_header(gc->pc, X_GLrop_MultiTexCoord2dvARB, cmdlen);
4422     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 16);
4423     (void) memcpy((void *)(gc->pc + 20), (void *)(&target), 4);
4424     gc->pc += cmdlen;
4425     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4426 }
4427
4428 #define X_GLrop_MultiTexCoord2fvARB 203
4429 void
4430 __indirect_glMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
4431 {
4432     __GLXcontext * const gc = __glXGetCurrentContext();
4433     const GLuint cmdlen = 16;
4434     emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
4435     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4436     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
4437     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
4438     gc->pc += cmdlen;
4439     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4440 }
4441
4442 #define X_GLrop_MultiTexCoord2fvARB 203
4443 void
4444 __indirect_glMultiTexCoord2fvARB(GLenum target, const GLfloat * v)
4445 {
4446     __GLXcontext * const gc = __glXGetCurrentContext();
4447     const GLuint cmdlen = 16;
4448     emit_header(gc->pc, X_GLrop_MultiTexCoord2fvARB, cmdlen);
4449     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4450     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
4451     gc->pc += cmdlen;
4452     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4453 }
4454
4455 #define X_GLrop_MultiTexCoord2ivARB 204
4456 void
4457 __indirect_glMultiTexCoord2iARB(GLenum target, GLint s, GLint t)
4458 {
4459     __GLXcontext * const gc = __glXGetCurrentContext();
4460     const GLuint cmdlen = 16;
4461     emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
4462     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4463     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
4464     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
4465     gc->pc += cmdlen;
4466     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4467 }
4468
4469 #define X_GLrop_MultiTexCoord2ivARB 204
4470 void
4471 __indirect_glMultiTexCoord2ivARB(GLenum target, const GLint * v)
4472 {
4473     __GLXcontext * const gc = __glXGetCurrentContext();
4474     const GLuint cmdlen = 16;
4475     emit_header(gc->pc, X_GLrop_MultiTexCoord2ivARB, cmdlen);
4476     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4477     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
4478     gc->pc += cmdlen;
4479     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4480 }
4481
4482 #define X_GLrop_MultiTexCoord2svARB 205
4483 void
4484 __indirect_glMultiTexCoord2sARB(GLenum target, GLshort s, GLshort t)
4485 {
4486     __GLXcontext * const gc = __glXGetCurrentContext();
4487     const GLuint cmdlen = 12;
4488     emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
4489     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4490     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
4491     (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
4492     gc->pc += cmdlen;
4493     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4494 }
4495
4496 #define X_GLrop_MultiTexCoord2svARB 205
4497 void
4498 __indirect_glMultiTexCoord2svARB(GLenum target, const GLshort * v)
4499 {
4500     __GLXcontext * const gc = __glXGetCurrentContext();
4501     const GLuint cmdlen = 12;
4502     emit_header(gc->pc, X_GLrop_MultiTexCoord2svARB, cmdlen);
4503     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4504     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 4);
4505     gc->pc += cmdlen;
4506     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4507 }
4508
4509 #define X_GLrop_MultiTexCoord3dvARB 206
4510 void
4511 __indirect_glMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r)
4512 {
4513     __GLXcontext * const gc = __glXGetCurrentContext();
4514     const GLuint cmdlen = 32;
4515     emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
4516     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
4517     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
4518     (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
4519     (void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4);
4520     gc->pc += cmdlen;
4521     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4522 }
4523
4524 #define X_GLrop_MultiTexCoord3dvARB 206
4525 void
4526 __indirect_glMultiTexCoord3dvARB(GLenum target, const GLdouble * v)
4527 {
4528     __GLXcontext * const gc = __glXGetCurrentContext();
4529     const GLuint cmdlen = 32;
4530     emit_header(gc->pc, X_GLrop_MultiTexCoord3dvARB, cmdlen);
4531     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 24);
4532     (void) memcpy((void *)(gc->pc + 28), (void *)(&target), 4);
4533     gc->pc += cmdlen;
4534     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4535 }
4536
4537 #define X_GLrop_MultiTexCoord3fvARB 207
4538 void
4539 __indirect_glMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)
4540 {
4541     __GLXcontext * const gc = __glXGetCurrentContext();
4542     const GLuint cmdlen = 20;
4543     emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
4544     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4545     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
4546     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
4547     (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
4548     gc->pc += cmdlen;
4549     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4550 }
4551
4552 #define X_GLrop_MultiTexCoord3fvARB 207
4553 void
4554 __indirect_glMultiTexCoord3fvARB(GLenum target, const GLfloat * v)
4555 {
4556     __GLXcontext * const gc = __glXGetCurrentContext();
4557     const GLuint cmdlen = 20;
4558     emit_header(gc->pc, X_GLrop_MultiTexCoord3fvARB, cmdlen);
4559     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4560     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
4561     gc->pc += cmdlen;
4562     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4563 }
4564
4565 #define X_GLrop_MultiTexCoord3ivARB 208
4566 void
4567 __indirect_glMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)
4568 {
4569     __GLXcontext * const gc = __glXGetCurrentContext();
4570     const GLuint cmdlen = 20;
4571     emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
4572     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4573     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
4574     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
4575     (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
4576     gc->pc += cmdlen;
4577     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4578 }
4579
4580 #define X_GLrop_MultiTexCoord3ivARB 208
4581 void
4582 __indirect_glMultiTexCoord3ivARB(GLenum target, const GLint * v)
4583 {
4584     __GLXcontext * const gc = __glXGetCurrentContext();
4585     const GLuint cmdlen = 20;
4586     emit_header(gc->pc, X_GLrop_MultiTexCoord3ivARB, cmdlen);
4587     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4588     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 12);
4589     gc->pc += cmdlen;
4590     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4591 }
4592
4593 #define X_GLrop_MultiTexCoord3svARB 209
4594 void
4595 __indirect_glMultiTexCoord3sARB(GLenum target, GLshort s, GLshort t, GLshort r)
4596 {
4597     __GLXcontext * const gc = __glXGetCurrentContext();
4598     const GLuint cmdlen = 16;
4599     emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
4600     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4601     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
4602     (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
4603     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2);
4604     gc->pc += cmdlen;
4605     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4606 }
4607
4608 #define X_GLrop_MultiTexCoord3svARB 209
4609 void
4610 __indirect_glMultiTexCoord3svARB(GLenum target, const GLshort * v)
4611 {
4612     __GLXcontext * const gc = __glXGetCurrentContext();
4613     const GLuint cmdlen = 16;
4614     emit_header(gc->pc, X_GLrop_MultiTexCoord3svARB, cmdlen);
4615     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4616     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 6);
4617     gc->pc += cmdlen;
4618     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4619 }
4620
4621 #define X_GLrop_MultiTexCoord4dvARB 210
4622 void
4623 __indirect_glMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
4624 {
4625     __GLXcontext * const gc = __glXGetCurrentContext();
4626     const GLuint cmdlen = 40;
4627     emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
4628     (void) memcpy((void *)(gc->pc + 4), (void *)(&s), 8);
4629     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 8);
4630     (void) memcpy((void *)(gc->pc + 20), (void *)(&r), 8);
4631     (void) memcpy((void *)(gc->pc + 28), (void *)(&q), 8);
4632     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
4633     gc->pc += cmdlen;
4634     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4635 }
4636
4637 #define X_GLrop_MultiTexCoord4dvARB 210
4638 void
4639 __indirect_glMultiTexCoord4dvARB(GLenum target, const GLdouble * v)
4640 {
4641     __GLXcontext * const gc = __glXGetCurrentContext();
4642     const GLuint cmdlen = 40;
4643     emit_header(gc->pc, X_GLrop_MultiTexCoord4dvARB, cmdlen);
4644     (void) memcpy((void *)(gc->pc + 4), (void *)(v), 32);
4645     (void) memcpy((void *)(gc->pc + 36), (void *)(&target), 4);
4646     gc->pc += cmdlen;
4647     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4648 }
4649
4650 #define X_GLrop_MultiTexCoord4fvARB 211
4651 void
4652 __indirect_glMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
4653 {
4654     __GLXcontext * const gc = __glXGetCurrentContext();
4655     const GLuint cmdlen = 24;
4656     emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
4657     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4658     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
4659     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
4660     (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
4661     (void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4);
4662     gc->pc += cmdlen;
4663     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4664 }
4665
4666 #define X_GLrop_MultiTexCoord4fvARB 211
4667 void
4668 __indirect_glMultiTexCoord4fvARB(GLenum target, const GLfloat * v)
4669 {
4670     __GLXcontext * const gc = __glXGetCurrentContext();
4671     const GLuint cmdlen = 24;
4672     emit_header(gc->pc, X_GLrop_MultiTexCoord4fvARB, cmdlen);
4673     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4674     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
4675     gc->pc += cmdlen;
4676     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4677 }
4678
4679 #define X_GLrop_MultiTexCoord4ivARB 212
4680 void
4681 __indirect_glMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q)
4682 {
4683     __GLXcontext * const gc = __glXGetCurrentContext();
4684     const GLuint cmdlen = 24;
4685     emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
4686     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4687     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 4);
4688     (void) memcpy((void *)(gc->pc + 12), (void *)(&t), 4);
4689     (void) memcpy((void *)(gc->pc + 16), (void *)(&r), 4);
4690     (void) memcpy((void *)(gc->pc + 20), (void *)(&q), 4);
4691     gc->pc += cmdlen;
4692     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4693 }
4694
4695 #define X_GLrop_MultiTexCoord4ivARB 212
4696 void
4697 __indirect_glMultiTexCoord4ivARB(GLenum target, const GLint * v)
4698 {
4699     __GLXcontext * const gc = __glXGetCurrentContext();
4700     const GLuint cmdlen = 24;
4701     emit_header(gc->pc, X_GLrop_MultiTexCoord4ivARB, cmdlen);
4702     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4703     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 16);
4704     gc->pc += cmdlen;
4705     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4706 }
4707
4708 #define X_GLrop_MultiTexCoord4svARB 213
4709 void
4710 __indirect_glMultiTexCoord4sARB(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
4711 {
4712     __GLXcontext * const gc = __glXGetCurrentContext();
4713     const GLuint cmdlen = 16;
4714     emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
4715     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4716     (void) memcpy((void *)(gc->pc + 8), (void *)(&s), 2);
4717     (void) memcpy((void *)(gc->pc + 10), (void *)(&t), 2);
4718     (void) memcpy((void *)(gc->pc + 12), (void *)(&r), 2);
4719     (void) memcpy((void *)(gc->pc + 14), (void *)(&q), 2);
4720     gc->pc += cmdlen;
4721     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4722 }
4723
4724 #define X_GLrop_MultiTexCoord4svARB 213
4725 void
4726 __indirect_glMultiTexCoord4svARB(GLenum target, const GLshort * v)
4727 {
4728     __GLXcontext * const gc = __glXGetCurrentContext();
4729     const GLuint cmdlen = 16;
4730     emit_header(gc->pc, X_GLrop_MultiTexCoord4svARB, cmdlen);
4731     (void) memcpy((void *)(gc->pc + 4), (void *)(&target), 4);
4732     (void) memcpy((void *)(gc->pc + 8), (void *)(v), 8);
4733     gc->pc += cmdlen;
4734     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4735 }
4736
4737 #define X_GLrop_SampleCoverageARB 229
4738 void
4739 __indirect_glSampleCoverageARB(GLclampf value, GLboolean invert)
4740 {
4741     __GLXcontext * const gc = __glXGetCurrentContext();
4742     const GLuint cmdlen = 12;
4743     emit_header(gc->pc, X_GLrop_SampleCoverageARB, cmdlen);
4744     (void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4);
4745     (void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1);
4746     gc->pc += cmdlen;
4747     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4748 }
4749
4750 #define X_GLvop_AreTexturesResidentEXT 11
4751 GLboolean
4752 __indirect_glAreTexturesResidentEXT(GLsizei n, const GLuint * textures, GLboolean * residences)
4753 {
4754     __GLXcontext * const gc = __glXGetCurrentContext();
4755     Display * const dpy = gc->currentDpy;
4756     GLboolean retval = (GLboolean) 0;
4757     const GLuint cmdlen = 4 + __GLX_PAD((n * 4));
4758     if (__builtin_expect((n >= 0) && (dpy != NULL), 1)) {
4759         GLubyte const * pc = setup_vendor_request(gc, X_GLXVendorPrivateWithReply, X_GLvop_AreTexturesResidentEXT, cmdlen);
4760         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
4761         (void) memcpy((void *)(pc + 4), (void *)(textures), (n * 4));
4762         retval = (GLboolean) read_reply(dpy, 1, residences, GL_TRUE);
4763         UnlockDisplay(dpy); SyncHandle();
4764     }
4765     return retval;
4766 }
4767
4768 #define X_GLvop_GenTexturesEXT 13
4769 void
4770 __indirect_glGenTexturesEXT(GLsizei n, GLuint * textures)
4771 {
4772     __GLXcontext * const gc = __glXGetCurrentContext();
4773     Display * const dpy = gc->currentDpy;
4774     const GLuint cmdlen = 4;
4775     if (__builtin_expect(dpy != NULL, 1)) {
4776         GLubyte const * pc = setup_vendor_request(gc, X_GLXVendorPrivateWithReply, X_GLvop_GenTexturesEXT, cmdlen);
4777         (void) memcpy((void *)(pc + 0), (void *)(&n), 4);
4778         (void) read_reply(dpy, 4, textures, GL_TRUE);
4779         UnlockDisplay(dpy); SyncHandle();
4780     }
4781     return;
4782 }
4783
4784 #define X_GLvop_IsTextureEXT 14
4785 GLboolean
4786 __indirect_glIsTextureEXT(GLuint texture)
4787 {
4788     __GLXcontext * const gc = __glXGetCurrentContext();
4789     Display * const dpy = gc->currentDpy;
4790     GLboolean retval = (GLboolean) 0;
4791     const GLuint cmdlen = 4;
4792     if (__builtin_expect(dpy != NULL, 1)) {
4793         GLubyte const * pc = setup_vendor_request(gc, X_GLXVendorPrivateWithReply, X_GLvop_IsTextureEXT, cmdlen);
4794         (void) memcpy((void *)(pc + 0), (void *)(&texture), 4);
4795         retval = (GLboolean) read_reply(dpy, 0, NULL, GL_FALSE);
4796         UnlockDisplay(dpy); SyncHandle();
4797     }
4798     return retval;
4799 }
4800
4801 #define X_GLrop_SampleMaskSGIS 2048
4802 void
4803 __indirect_glSampleMaskSGIS(GLclampf value, GLboolean invert)
4804 {
4805     __GLXcontext * const gc = __glXGetCurrentContext();
4806     const GLuint cmdlen = 12;
4807     emit_header(gc->pc, X_GLrop_SampleMaskSGIS, cmdlen);
4808     (void) memcpy((void *)(gc->pc + 4), (void *)(&value), 4);
4809     (void) memcpy((void *)(gc->pc + 8), (void *)(&invert), 1);
4810     gc->pc += cmdlen;
4811     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4812 }
4813
4814 #define X_GLrop_SamplePatternSGIS 2049
4815 void
4816 __indirect_glSamplePatternSGIS(GLenum pattern)
4817 {
4818     __GLXcontext * const gc = __glXGetCurrentContext();
4819     const GLuint cmdlen = 8;
4820     emit_header(gc->pc, X_GLrop_SamplePatternSGIS, cmdlen);
4821     (void) memcpy((void *)(gc->pc + 4), (void *)(&pattern), 4);
4822     gc->pc += cmdlen;
4823     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4824 }
4825
4826 #define X_GLrop_PointParameterfEXT 2065
4827 void
4828 __indirect_glPointParameterfEXT(GLenum pname, GLfloat param)
4829 {
4830     __GLXcontext * const gc = __glXGetCurrentContext();
4831     const GLuint cmdlen = 12;
4832     emit_header(gc->pc, X_GLrop_PointParameterfEXT, cmdlen);
4833     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
4834     (void) memcpy((void *)(gc->pc + 8), (void *)(&param), 4);
4835     gc->pc += cmdlen;
4836     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4837 }
4838
4839 #define X_GLrop_PointParameterfvEXT 2066
4840 void
4841 __indirect_glPointParameterfvEXT(GLenum pname, const GLfloat * params)
4842 {
4843     __GLXcontext * const gc = __glXGetCurrentContext();
4844     const GLuint compsize = __glPointParameterfvEXT_size(pname);
4845     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
4846     emit_header(gc->pc, X_GLrop_PointParameterfvEXT, cmdlen);
4847     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
4848     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
4849     gc->pc += cmdlen;
4850     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4851 }
4852
4853 #define X_GLrop_WindowPos3fvMESA 230
4854 void
4855 __indirect_glWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
4856 {
4857     __GLXcontext * const gc = __glXGetCurrentContext();
4858     const GLuint cmdlen = 16;
4859     emit_header(gc->pc, X_GLrop_WindowPos3fvMESA, cmdlen);
4860     (void) memcpy((void *)(gc->pc + 4), (void *)(&x), 4);
4861     (void) memcpy((void *)(gc->pc + 8), (void *)(&y), 4);
4862     (void) memcpy((void *)(gc->pc + 12), (void *)(&z), 4);
4863     gc->pc += cmdlen;
4864     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4865 }
4866
4867 #define X_GLrop_WindowPos3fvMESA 230
4868 void
4869 __indirect_glWindowPos3fvMESA(const GLfloat * v)
4870 {
4871     generic_12_byte( X_GLrop_WindowPos3fvMESA, v );
4872 }
4873
4874 #define X_GLrop_BlendFuncSeparateEXT 4134
4875 void
4876 __indirect_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
4877 {
4878     __GLXcontext * const gc = __glXGetCurrentContext();
4879     const GLuint cmdlen = 20;
4880     emit_header(gc->pc, X_GLrop_BlendFuncSeparateEXT, cmdlen);
4881     (void) memcpy((void *)(gc->pc + 4), (void *)(&sfactorRGB), 4);
4882     (void) memcpy((void *)(gc->pc + 8), (void *)(&dfactorRGB), 4);
4883     (void) memcpy((void *)(gc->pc + 12), (void *)(&sfactorAlpha), 4);
4884     (void) memcpy((void *)(gc->pc + 16), (void *)(&dfactorAlpha), 4);
4885     gc->pc += cmdlen;
4886     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4887 }
4888
4889 #define X_GLrop_FogCoordfvEXT 4124
4890 void
4891 __indirect_glFogCoordfEXT(GLfloat coord)
4892 {
4893     __GLXcontext * const gc = __glXGetCurrentContext();
4894     const GLuint cmdlen = 8;
4895     emit_header(gc->pc, X_GLrop_FogCoordfvEXT, cmdlen);
4896     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 4);
4897     gc->pc += cmdlen;
4898     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4899 }
4900
4901 #define X_GLrop_FogCoordfvEXT 4124
4902 void
4903 __indirect_glFogCoordfvEXT(const GLfloat * coord)
4904 {
4905     generic_4_byte( X_GLrop_FogCoordfvEXT, coord );
4906 }
4907
4908 #define X_GLrop_FogCoorddvEXT 4125
4909 void
4910 __indirect_glFogCoorddEXT(GLdouble coord)
4911 {
4912     __GLXcontext * const gc = __glXGetCurrentContext();
4913     const GLuint cmdlen = 12;
4914     emit_header(gc->pc, X_GLrop_FogCoorddvEXT, cmdlen);
4915     (void) memcpy((void *)(gc->pc + 4), (void *)(&coord), 8);
4916     gc->pc += cmdlen;
4917     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4918 }
4919
4920 #define X_GLrop_FogCoorddvEXT 4125
4921 void
4922 __indirect_glFogCoorddvEXT(const GLdouble * coord)
4923 {
4924     generic_8_byte( X_GLrop_FogCoorddvEXT, coord );
4925 }
4926
4927 #define X_GLrop_SecondaryColor3bvEXT 4126
4928 void
4929 __indirect_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue)
4930 {
4931     __GLXcontext * const gc = __glXGetCurrentContext();
4932     const GLuint cmdlen = 8;
4933     emit_header(gc->pc, X_GLrop_SecondaryColor3bvEXT, cmdlen);
4934     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
4935     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
4936     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
4937     gc->pc += cmdlen;
4938     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4939 }
4940
4941 #define X_GLrop_SecondaryColor3bvEXT 4126
4942 void
4943 __indirect_glSecondaryColor3bvEXT(const GLbyte * v)
4944 {
4945     generic_3_byte( X_GLrop_SecondaryColor3bvEXT, v );
4946 }
4947
4948 #define X_GLrop_SecondaryColor3dvEXT 4130
4949 void
4950 __indirect_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue)
4951 {
4952     __GLXcontext * const gc = __glXGetCurrentContext();
4953     const GLuint cmdlen = 28;
4954     emit_header(gc->pc, X_GLrop_SecondaryColor3dvEXT, cmdlen);
4955     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 8);
4956     (void) memcpy((void *)(gc->pc + 12), (void *)(&green), 8);
4957     (void) memcpy((void *)(gc->pc + 20), (void *)(&blue), 8);
4958     gc->pc += cmdlen;
4959     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4960 }
4961
4962 #define X_GLrop_SecondaryColor3dvEXT 4130
4963 void
4964 __indirect_glSecondaryColor3dvEXT(const GLdouble * v)
4965 {
4966     generic_24_byte( X_GLrop_SecondaryColor3dvEXT, v );
4967 }
4968
4969 #define X_GLrop_SecondaryColor3fvEXT 4129
4970 void
4971 __indirect_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)
4972 {
4973     __GLXcontext * const gc = __glXGetCurrentContext();
4974     const GLuint cmdlen = 16;
4975     emit_header(gc->pc, X_GLrop_SecondaryColor3fvEXT, cmdlen);
4976     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
4977     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
4978     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
4979     gc->pc += cmdlen;
4980     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
4981 }
4982
4983 #define X_GLrop_SecondaryColor3fvEXT 4129
4984 void
4985 __indirect_glSecondaryColor3fvEXT(const GLfloat * v)
4986 {
4987     generic_12_byte( X_GLrop_SecondaryColor3fvEXT, v );
4988 }
4989
4990 #define X_GLrop_SecondaryColor3ivEXT 4128
4991 void
4992 __indirect_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue)
4993 {
4994     __GLXcontext * const gc = __glXGetCurrentContext();
4995     const GLuint cmdlen = 16;
4996     emit_header(gc->pc, X_GLrop_SecondaryColor3ivEXT, cmdlen);
4997     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
4998     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
4999     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
5000     gc->pc += cmdlen;
5001     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5002 }
5003
5004 #define X_GLrop_SecondaryColor3ivEXT 4128
5005 void
5006 __indirect_glSecondaryColor3ivEXT(const GLint * v)
5007 {
5008     generic_12_byte( X_GLrop_SecondaryColor3ivEXT, v );
5009 }
5010
5011 #define X_GLrop_SecondaryColor3svEXT 4128
5012 void
5013 __indirect_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue)
5014 {
5015     __GLXcontext * const gc = __glXGetCurrentContext();
5016     const GLuint cmdlen = 12;
5017     emit_header(gc->pc, X_GLrop_SecondaryColor3svEXT, cmdlen);
5018     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
5019     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
5020     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
5021     gc->pc += cmdlen;
5022     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5023 }
5024
5025 #define X_GLrop_SecondaryColor3svEXT 4128
5026 void
5027 __indirect_glSecondaryColor3svEXT(const GLshort * v)
5028 {
5029     generic_6_byte( X_GLrop_SecondaryColor3svEXT, v );
5030 }
5031
5032 #define X_GLrop_SecondaryColor3ubvEXT 4131
5033 void
5034 __indirect_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue)
5035 {
5036     __GLXcontext * const gc = __glXGetCurrentContext();
5037     const GLuint cmdlen = 8;
5038     emit_header(gc->pc, X_GLrop_SecondaryColor3ubvEXT, cmdlen);
5039     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 1);
5040     (void) memcpy((void *)(gc->pc + 5), (void *)(&green), 1);
5041     (void) memcpy((void *)(gc->pc + 6), (void *)(&blue), 1);
5042     gc->pc += cmdlen;
5043     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5044 }
5045
5046 #define X_GLrop_SecondaryColor3ubvEXT 4131
5047 void
5048 __indirect_glSecondaryColor3ubvEXT(const GLubyte * v)
5049 {
5050     generic_3_byte( X_GLrop_SecondaryColor3ubvEXT, v );
5051 }
5052
5053 #define X_GLrop_SecondaryColor3uivEXT 4133
5054 void
5055 __indirect_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue)
5056 {
5057     __GLXcontext * const gc = __glXGetCurrentContext();
5058     const GLuint cmdlen = 16;
5059     emit_header(gc->pc, X_GLrop_SecondaryColor3uivEXT, cmdlen);
5060     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 4);
5061     (void) memcpy((void *)(gc->pc + 8), (void *)(&green), 4);
5062     (void) memcpy((void *)(gc->pc + 12), (void *)(&blue), 4);
5063     gc->pc += cmdlen;
5064     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5065 }
5066
5067 #define X_GLrop_SecondaryColor3uivEXT 4133
5068 void
5069 __indirect_glSecondaryColor3uivEXT(const GLuint * v)
5070 {
5071     generic_12_byte( X_GLrop_SecondaryColor3uivEXT, v );
5072 }
5073
5074 #define X_GLrop_SecondaryColor3usvEXT 4132
5075 void
5076 __indirect_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue)
5077 {
5078     __GLXcontext * const gc = __glXGetCurrentContext();
5079     const GLuint cmdlen = 12;
5080     emit_header(gc->pc, X_GLrop_SecondaryColor3usvEXT, cmdlen);
5081     (void) memcpy((void *)(gc->pc + 4), (void *)(&red), 2);
5082     (void) memcpy((void *)(gc->pc + 6), (void *)(&green), 2);
5083     (void) memcpy((void *)(gc->pc + 8), (void *)(&blue), 2);
5084     gc->pc += cmdlen;
5085     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5086 }
5087
5088 #define X_GLrop_SecondaryColor3usvEXT 4132
5089 void
5090 __indirect_glSecondaryColor3usvEXT(const GLushort * v)
5091 {
5092     generic_6_byte( X_GLrop_SecondaryColor3usvEXT, v );
5093 }
5094
5095 #define X_GLrop_PointParameteriNV 4221
5096 void
5097 __indirect_glPointParameteriNV(GLenum pname, GLint params)
5098 {
5099     __GLXcontext * const gc = __glXGetCurrentContext();
5100     const GLuint cmdlen = 12;
5101     emit_header(gc->pc, X_GLrop_PointParameteriNV, cmdlen);
5102     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
5103     (void) memcpy((void *)(gc->pc + 8), (void *)(&params), 4);
5104     gc->pc += cmdlen;
5105     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5106 }
5107
5108 #define X_GLrop_PointParameterivNV 4222
5109 void
5110 __indirect_glPointParameterivNV(GLenum pname, const GLint * params)
5111 {
5112     __GLXcontext * const gc = __glXGetCurrentContext();
5113     const GLuint compsize = __glPointParameterivNV_size(pname);
5114     const GLuint cmdlen = 8 + __GLX_PAD((compsize * 4));
5115     emit_header(gc->pc, X_GLrop_PointParameterivNV, cmdlen);
5116     (void) memcpy((void *)(gc->pc + 4), (void *)(&pname), 4);
5117     (void) memcpy((void *)(gc->pc + 8), (void *)(params), (compsize * 4));
5118     gc->pc += cmdlen;
5119     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5120 }
5121
5122 #define X_GLrop_ActiveStencilFaceEXT 4220
5123 void
5124 __indirect_glActiveStencilFaceEXT(GLenum face)
5125 {
5126     __GLXcontext * const gc = __glXGetCurrentContext();
5127     const GLuint cmdlen = 8;
5128     emit_header(gc->pc, X_GLrop_ActiveStencilFaceEXT, cmdlen);
5129     (void) memcpy((void *)(gc->pc + 4), (void *)(&face), 4);
5130     gc->pc += cmdlen;
5131     if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
5132 }
5133