/* DO NOT EDIT - This file generated automatically by gl_marshal.py script */

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


#include "api_exec.h"
#include "context.h"
#include "dispatch.h"
#include "glthread.h"
#include "marshal.h"
#include "marshal_generated.h"

static inline int safe_mul(int a, int b)
{
    if (a < 0 || b < 0) return -1;
    if (a == 0 || b == 0) return 0;
    if (a > INT_MAX / b) return -1;
    return a * b;
}

/* MapGrid1d: marshalled asynchronously */
struct marshal_cmd_MapGrid1d
{
   struct marshal_cmd_base cmd_base;
   GLint un;
   GLdouble u1;
   GLdouble u2;
};
static inline void
_mesa_unmarshal_MapGrid1d(struct gl_context *ctx, const struct marshal_cmd_MapGrid1d *cmd)
{
   const GLint un = cmd->un;
   const GLdouble u1 = cmd->u1;
   const GLdouble u2 = cmd->u2;
   CALL_MapGrid1d(ctx->CurrentServerDispatch, (un, u1, u2));
}
static void GLAPIENTRY
_mesa_marshal_MapGrid1d(GLint un, GLdouble u1, GLdouble u2)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MapGrid1d);
   struct marshal_cmd_MapGrid1d *cmd;
   debug_print_marshal("MapGrid1d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MapGrid1d, cmd_size);
      cmd->un = un;
      cmd->u1 = u1;
      cmd->u2 = u2;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MapGrid1d");
   CALL_MapGrid1d(ctx->CurrentServerDispatch, (un, u1, u2));
}


/* MapGrid1f: marshalled asynchronously */
struct marshal_cmd_MapGrid1f
{
   struct marshal_cmd_base cmd_base;
   GLint un;
   GLfloat u1;
   GLfloat u2;
};
static inline void
_mesa_unmarshal_MapGrid1f(struct gl_context *ctx, const struct marshal_cmd_MapGrid1f *cmd)
{
   const GLint un = cmd->un;
   const GLfloat u1 = cmd->u1;
   const GLfloat u2 = cmd->u2;
   CALL_MapGrid1f(ctx->CurrentServerDispatch, (un, u1, u2));
}
static void GLAPIENTRY
_mesa_marshal_MapGrid1f(GLint un, GLfloat u1, GLfloat u2)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MapGrid1f);
   struct marshal_cmd_MapGrid1f *cmd;
   debug_print_marshal("MapGrid1f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MapGrid1f, cmd_size);
      cmd->un = un;
      cmd->u1 = u1;
      cmd->u2 = u2;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MapGrid1f");
   CALL_MapGrid1f(ctx->CurrentServerDispatch, (un, u1, u2));
}


/* ProgramUniform3i64vARB: marshalled asynchronously */
struct marshal_cmd_ProgramUniform3i64vARB
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 24) bytes are GLint64 value[count][3] */
};
static inline void
_mesa_unmarshal_ProgramUniform3i64vARB(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform3i64vARB *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLint64 * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLint64 *) variable_data;
   variable_data += count * 24;
   CALL_ProgramUniform3i64vARB(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform3i64vARB(GLuint program, GLint location, GLsizei count, const GLint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform3i64vARB) + safe_mul(count, 24);
   struct marshal_cmd_ProgramUniform3i64vARB *cmd;
   debug_print_marshal("ProgramUniform3i64vARB");
   if (unlikely(safe_mul(count, 24) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform3i64vARB, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 24);
      variable_data += count * 24;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform3i64vARB");
   CALL_ProgramUniform3i64vARB(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* GetProgramResourceLocationIndex: marshalled synchronously */
static GLint GLAPIENTRY
_mesa_marshal_GetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramResourceLocationIndex");
   return CALL_GetProgramResourceLocationIndex(ctx->CurrentServerDispatch, (program, programInterface, name));
}


/* TexCoordP1ui: marshalled asynchronously */
struct marshal_cmd_TexCoordP1ui
{
   struct marshal_cmd_base cmd_base;
   GLenum type;
   GLuint coords;
};
static inline void
_mesa_unmarshal_TexCoordP1ui(struct gl_context *ctx, const struct marshal_cmd_TexCoordP1ui *cmd)
{
   const GLenum type = cmd->type;
   const GLuint coords = cmd->coords;
   CALL_TexCoordP1ui(ctx->CurrentServerDispatch, (type, coords));
}
static void GLAPIENTRY
_mesa_marshal_TexCoordP1ui(GLenum type, GLuint coords)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoordP1ui);
   struct marshal_cmd_TexCoordP1ui *cmd;
   debug_print_marshal("TexCoordP1ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoordP1ui, cmd_size);
      cmd->type = type;
      cmd->coords = coords;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoordP1ui");
   CALL_TexCoordP1ui(ctx->CurrentServerDispatch, (type, coords));
}


/* PolygonStipple: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_PolygonStipple(const GLubyte * mask)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("PolygonStipple");
   CALL_PolygonStipple(ctx->CurrentServerDispatch, (mask));
}


/* MultiTexCoord1dv: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord1dv
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLdouble v[1];
};
static inline void
_mesa_unmarshal_MultiTexCoord1dv(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord1dv *cmd)
{
   const GLenum target = cmd->target;
   const GLdouble * v = cmd->v;
   CALL_MultiTexCoord1dv(ctx->CurrentServerDispatch, (target, v));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord1dv(GLenum target, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord1dv);
   struct marshal_cmd_MultiTexCoord1dv *cmd;
   debug_print_marshal("MultiTexCoord1dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord1dv, cmd_size);
      cmd->target = target;
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord1dv");
   CALL_MultiTexCoord1dv(ctx->CurrentServerDispatch, (target, v));
}


/* IsEnabled: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsEnabled(GLenum cap)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsEnabled");
   return CALL_IsEnabled(ctx->CurrentServerDispatch, (cap));
}


/* AttachShader: marshalled asynchronously */
struct marshal_cmd_AttachShader
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLuint shader;
};
static inline void
_mesa_unmarshal_AttachShader(struct gl_context *ctx, const struct marshal_cmd_AttachShader *cmd)
{
   const GLuint program = cmd->program;
   const GLuint shader = cmd->shader;
   CALL_AttachShader(ctx->CurrentServerDispatch, (program, shader));
}
static void GLAPIENTRY
_mesa_marshal_AttachShader(GLuint program, GLuint shader)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_AttachShader);
   struct marshal_cmd_AttachShader *cmd;
   debug_print_marshal("AttachShader");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_AttachShader, cmd_size);
      cmd->program = program;
      cmd->shader = shader;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("AttachShader");
   CALL_AttachShader(ctx->CurrentServerDispatch, (program, shader));
}


/* VertexAttrib3fARB: marshalled asynchronously */
struct marshal_cmd_VertexAttrib3fARB
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat x;
   GLfloat y;
   GLfloat z;
};
static inline void
_mesa_unmarshal_VertexAttrib3fARB(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib3fARB *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   CALL_VertexAttrib3fARB(ctx->CurrentServerDispatch, (index, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib3fARB);
   struct marshal_cmd_VertexAttrib3fARB *cmd;
   debug_print_marshal("VertexAttrib3fARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib3fARB, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib3fARB");
   CALL_VertexAttrib3fARB(ctx->CurrentServerDispatch, (index, x, y, z));
}


/* Indexubv: marshalled asynchronously */
struct marshal_cmd_Indexubv
{
   struct marshal_cmd_base cmd_base;
   GLubyte c[1];
};
static inline void
_mesa_unmarshal_Indexubv(struct gl_context *ctx, const struct marshal_cmd_Indexubv *cmd)
{
   const GLubyte * c = cmd->c;
   CALL_Indexubv(ctx->CurrentServerDispatch, (c));
}
static void GLAPIENTRY
_mesa_marshal_Indexubv(const GLubyte * c)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Indexubv);
   struct marshal_cmd_Indexubv *cmd;
   debug_print_marshal("Indexubv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Indexubv, cmd_size);
      memcpy(cmd->c, c, 1);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Indexubv");
   CALL_Indexubv(ctx->CurrentServerDispatch, (c));
}


/* GetCompressedTextureImage: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetCompressedTextureImage(GLuint texture, GLint level, GLsizei bufSize, GLvoid * pixels)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetCompressedTextureImage");
   CALL_GetCompressedTextureImage(ctx->CurrentServerDispatch, (texture, level, bufSize, pixels));
}


/* MultiTexCoordP3uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_MultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint * coords)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MultiTexCoordP3uiv");
   CALL_MultiTexCoordP3uiv(ctx->CurrentServerDispatch, (texture, type, coords));
}


/* VertexAttribI4usv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribI4usv(GLuint index, const GLushort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribI4usv");
   CALL_VertexAttribI4usv(ctx->CurrentServerDispatch, (index, v));
}


/* Color3ubv: marshalled asynchronously */
struct marshal_cmd_Color3ubv
{
   struct marshal_cmd_base cmd_base;
   GLubyte v[3];
};
static inline void
_mesa_unmarshal_Color3ubv(struct gl_context *ctx, const struct marshal_cmd_Color3ubv *cmd)
{
   const GLubyte * v = cmd->v;
   CALL_Color3ubv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Color3ubv(const GLubyte * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color3ubv);
   struct marshal_cmd_Color3ubv *cmd;
   debug_print_marshal("Color3ubv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color3ubv, cmd_size);
      memcpy(cmd->v, v, 3);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color3ubv");
   CALL_Color3ubv(ctx->CurrentServerDispatch, (v));
}


/* GetClipPlanex: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetClipPlanex(GLenum plane, GLfixed * equation)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetClipPlanex");
   CALL_GetClipPlanex(ctx->CurrentServerDispatch, (plane, equation));
}


/* ProgramUniform2ui: marshalled asynchronously */
struct marshal_cmd_ProgramUniform2ui
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLuint x;
   GLuint y;
};
static inline void
_mesa_unmarshal_ProgramUniform2ui(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform2ui *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLuint x = cmd->x;
   const GLuint y = cmd->y;
   CALL_ProgramUniform2ui(ctx->CurrentServerDispatch, (program, location, x, y));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform2ui(GLuint program, GLint location, GLuint x, GLuint y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform2ui);
   struct marshal_cmd_ProgramUniform2ui *cmd;
   debug_print_marshal("ProgramUniform2ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform2ui, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform2ui");
   CALL_ProgramUniform2ui(ctx->CurrentServerDispatch, (program, location, x, y));
}


/* TexCoordP1uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexCoordP1uiv(GLenum type, const GLuint * coords)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexCoordP1uiv");
   CALL_TexCoordP1uiv(ctx->CurrentServerDispatch, (type, coords));
}


/* RenderbufferStorage: marshalled asynchronously */
struct marshal_cmd_RenderbufferStorage
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum internalformat;
   GLsizei width;
   GLsizei height;
};
static inline void
_mesa_unmarshal_RenderbufferStorage(struct gl_context *ctx, const struct marshal_cmd_RenderbufferStorage *cmd)
{
   const GLenum target = cmd->target;
   const GLenum internalformat = cmd->internalformat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   CALL_RenderbufferStorage(ctx->CurrentServerDispatch, (target, internalformat, width, height));
}
static void GLAPIENTRY
_mesa_marshal_RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RenderbufferStorage);
   struct marshal_cmd_RenderbufferStorage *cmd;
   debug_print_marshal("RenderbufferStorage");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RenderbufferStorage, cmd_size);
      cmd->target = target;
      cmd->internalformat = internalformat;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RenderbufferStorage");
   CALL_RenderbufferStorage(ctx->CurrentServerDispatch, (target, internalformat, width, height));
}


/* GetClipPlanef: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetClipPlanef(GLenum plane, GLfloat * equation)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetClipPlanef");
   CALL_GetClipPlanef(ctx->CurrentServerDispatch, (plane, equation));
}


/* GetPerfQueryDataINTEL: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetPerfQueryDataINTEL(GLuint queryHandle, GLuint flags, GLsizei dataSize, GLvoid * data, GLuint * bytesWritten)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetPerfQueryDataINTEL");
   CALL_GetPerfQueryDataINTEL(ctx->CurrentServerDispatch, (queryHandle, flags, dataSize, data, bytesWritten));
}


/* DrawArraysIndirect: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_DrawArraysIndirect(GLenum mode, const GLvoid * indirect)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("DrawArraysIndirect");
   CALL_DrawArraysIndirect(ctx->CurrentServerDispatch, (mode, indirect));
}


/* Uniform3i: marshalled asynchronously */
struct marshal_cmd_Uniform3i
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLint v0;
   GLint v1;
   GLint v2;
};
static inline void
_mesa_unmarshal_Uniform3i(struct gl_context *ctx, const struct marshal_cmd_Uniform3i *cmd)
{
   const GLint location = cmd->location;
   const GLint v0 = cmd->v0;
   const GLint v1 = cmd->v1;
   const GLint v2 = cmd->v2;
   CALL_Uniform3i(ctx->CurrentServerDispatch, (location, v0, v1, v2));
}
static void GLAPIENTRY
_mesa_marshal_Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform3i);
   struct marshal_cmd_Uniform3i *cmd;
   debug_print_marshal("Uniform3i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform3i, cmd_size);
      cmd->location = location;
      cmd->v0 = v0;
      cmd->v1 = v1;
      cmd->v2 = v2;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform3i");
   CALL_Uniform3i(ctx->CurrentServerDispatch, (location, v0, v1, v2));
}


/* VDPAUGetSurfaceivNV: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VDPAUGetSurfaceivNV(GLintptr surface, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VDPAUGetSurfaceivNV");
   CALL_VDPAUGetSurfaceivNV(ctx->CurrentServerDispatch, (surface, pname, bufSize, length, values));
}


/* Uniform3d: marshalled asynchronously */
struct marshal_cmd_Uniform3d
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLdouble x;
   GLdouble y;
   GLdouble z;
};
static inline void
_mesa_unmarshal_Uniform3d(struct gl_context *ctx, const struct marshal_cmd_Uniform3d *cmd)
{
   const GLint location = cmd->location;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   CALL_Uniform3d(ctx->CurrentServerDispatch, (location, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_Uniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform3d);
   struct marshal_cmd_Uniform3d *cmd;
   debug_print_marshal("Uniform3d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform3d, cmd_size);
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform3d");
   CALL_Uniform3d(ctx->CurrentServerDispatch, (location, x, y, z));
}


/* Uniform3f: marshalled asynchronously */
struct marshal_cmd_Uniform3f
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLfloat v0;
   GLfloat v1;
   GLfloat v2;
};
static inline void
_mesa_unmarshal_Uniform3f(struct gl_context *ctx, const struct marshal_cmd_Uniform3f *cmd)
{
   const GLint location = cmd->location;
   const GLfloat v0 = cmd->v0;
   const GLfloat v1 = cmd->v1;
   const GLfloat v2 = cmd->v2;
   CALL_Uniform3f(ctx->CurrentServerDispatch, (location, v0, v1, v2));
}
static void GLAPIENTRY
_mesa_marshal_Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform3f);
   struct marshal_cmd_Uniform3f *cmd;
   debug_print_marshal("Uniform3f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform3f, cmd_size);
      cmd->location = location;
      cmd->v0 = v0;
      cmd->v1 = v1;
      cmd->v2 = v2;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform3f");
   CALL_Uniform3f(ctx->CurrentServerDispatch, (location, v0, v1, v2));
}


/* UniformMatrix2x4fv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix2x4fv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 32) bytes are GLfloat value[count][8] */
};
static inline void
_mesa_unmarshal_UniformMatrix2x4fv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix2x4fv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 32;
   CALL_UniformMatrix2x4fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix2x4fv) + safe_mul(count, 32);
   struct marshal_cmd_UniformMatrix2x4fv *cmd;
   debug_print_marshal("UniformMatrix2x4fv");
   if (unlikely(safe_mul(count, 32) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix2x4fv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 32);
      variable_data += count * 32;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix2x4fv");
   CALL_UniformMatrix2x4fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* QueryMatrixxOES: marshalled synchronously */
static GLbitfield GLAPIENTRY
_mesa_marshal_QueryMatrixxOES(GLfixed * mantissa, GLint * exponent)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("QueryMatrixxOES");
   return CALL_QueryMatrixxOES(ctx->CurrentServerDispatch, (mantissa, exponent));
}


/* Normal3iv: marshalled asynchronously */
struct marshal_cmd_Normal3iv
{
   struct marshal_cmd_base cmd_base;
   GLint v[3];
};
static inline void
_mesa_unmarshal_Normal3iv(struct gl_context *ctx, const struct marshal_cmd_Normal3iv *cmd)
{
   const GLint * v = cmd->v;
   CALL_Normal3iv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Normal3iv(const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Normal3iv);
   struct marshal_cmd_Normal3iv *cmd;
   debug_print_marshal("Normal3iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Normal3iv, cmd_size);
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Normal3iv");
   CALL_Normal3iv(ctx->CurrentServerDispatch, (v));
}


/* DrawTexiOES: marshalled asynchronously */
struct marshal_cmd_DrawTexiOES
{
   struct marshal_cmd_base cmd_base;
   GLint x;
   GLint y;
   GLint z;
   GLint width;
   GLint height;
};
static inline void
_mesa_unmarshal_DrawTexiOES(struct gl_context *ctx, const struct marshal_cmd_DrawTexiOES *cmd)
{
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLint z = cmd->z;
   const GLint width = cmd->width;
   const GLint height = cmd->height;
   CALL_DrawTexiOES(ctx->CurrentServerDispatch, (x, y, z, width, height));
}
static void GLAPIENTRY
_mesa_marshal_DrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawTexiOES);
   struct marshal_cmd_DrawTexiOES *cmd;
   debug_print_marshal("DrawTexiOES");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawTexiOES, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawTexiOES");
   CALL_DrawTexiOES(ctx->CurrentServerDispatch, (x, y, z, width, height));
}


/* Viewport: marshalled asynchronously */
struct marshal_cmd_Viewport
{
   struct marshal_cmd_base cmd_base;
   GLint x;
   GLint y;
   GLsizei width;
   GLsizei height;
};
static inline void
_mesa_unmarshal_Viewport(struct gl_context *ctx, const struct marshal_cmd_Viewport *cmd)
{
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   CALL_Viewport(ctx->CurrentServerDispatch, (x, y, width, height));
}
static void GLAPIENTRY
_mesa_marshal_Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Viewport);
   struct marshal_cmd_Viewport *cmd;
   debug_print_marshal("Viewport");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Viewport, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Viewport");
   CALL_Viewport(ctx->CurrentServerDispatch, (x, y, width, height));
}


/* CreateProgramPipelines: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CreateProgramPipelines(GLsizei n, GLuint * pipelines)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CreateProgramPipelines");
   CALL_CreateProgramPipelines(ctx->CurrentServerDispatch, (n, pipelines));
}


/* DeleteVertexArrays: marshalled asynchronously */
struct marshal_cmd_DeleteVertexArrays
{
   struct marshal_cmd_base cmd_base;
   GLsizei n;
   /* Next safe_mul(n, 4) bytes are GLuint arrays[n] */
};
static inline void
_mesa_unmarshal_DeleteVertexArrays(struct gl_context *ctx, const struct marshal_cmd_DeleteVertexArrays *cmd)
{
   const GLsizei n = cmd->n;
   const GLuint * arrays;
   const char *variable_data = (const char *) (cmd + 1);
   arrays = (const GLuint *) variable_data;
   variable_data += n * 4;
   CALL_DeleteVertexArrays(ctx->CurrentServerDispatch, (n, arrays));
}
static void GLAPIENTRY
_mesa_marshal_DeleteVertexArrays(GLsizei n, const GLuint * arrays)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DeleteVertexArrays) + safe_mul(n, 4);
   struct marshal_cmd_DeleteVertexArrays *cmd;
   debug_print_marshal("DeleteVertexArrays");
   if (unlikely(safe_mul(n, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DeleteVertexArrays, cmd_size);
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, arrays, n * 4);
      variable_data += n * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DeleteVertexArrays");
   CALL_DeleteVertexArrays(ctx->CurrentServerDispatch, (n, arrays));
}


/* ClearColorIuiEXT: marshalled asynchronously */
struct marshal_cmd_ClearColorIuiEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint r;
   GLuint g;
   GLuint b;
   GLuint a;
};
static inline void
_mesa_unmarshal_ClearColorIuiEXT(struct gl_context *ctx, const struct marshal_cmd_ClearColorIuiEXT *cmd)
{
   const GLuint r = cmd->r;
   const GLuint g = cmd->g;
   const GLuint b = cmd->b;
   const GLuint a = cmd->a;
   CALL_ClearColorIuiEXT(ctx->CurrentServerDispatch, (r, g, b, a));
}
static void GLAPIENTRY
_mesa_marshal_ClearColorIuiEXT(GLuint r, GLuint g, GLuint b, GLuint a)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ClearColorIuiEXT);
   struct marshal_cmd_ClearColorIuiEXT *cmd;
   debug_print_marshal("ClearColorIuiEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ClearColorIuiEXT, cmd_size);
      cmd->r = r;
      cmd->g = g;
      cmd->b = b;
      cmd->a = a;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ClearColorIuiEXT");
   CALL_ClearColorIuiEXT(ctx->CurrentServerDispatch, (r, g, b, a));
}


/* GetnConvolutionFilterARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnConvolutionFilterARB(GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid * image)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnConvolutionFilterARB");
   CALL_GetnConvolutionFilterARB(ctx->CurrentServerDispatch, (target, format, type, bufSize, image));
}


/* PolygonOffsetx: marshalled asynchronously */
struct marshal_cmd_PolygonOffsetx
{
   struct marshal_cmd_base cmd_base;
   GLfixed factor;
   GLfixed units;
};
static inline void
_mesa_unmarshal_PolygonOffsetx(struct gl_context *ctx, const struct marshal_cmd_PolygonOffsetx *cmd)
{
   const GLfixed factor = cmd->factor;
   const GLfixed units = cmd->units;
   CALL_PolygonOffsetx(ctx->CurrentServerDispatch, (factor, units));
}
static void GLAPIENTRY
_mesa_marshal_PolygonOffsetx(GLfixed factor, GLfixed units)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PolygonOffsetx);
   struct marshal_cmd_PolygonOffsetx *cmd;
   debug_print_marshal("PolygonOffsetx");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PolygonOffsetx, cmd_size);
      cmd->factor = factor;
      cmd->units = units;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PolygonOffsetx");
   CALL_PolygonOffsetx(ctx->CurrentServerDispatch, (factor, units));
}


/* GetLightxv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetLightxv(GLenum light, GLenum pname, GLfixed * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetLightxv");
   CALL_GetLightxv(ctx->CurrentServerDispatch, (light, pname, params));
}


/* GetConvolutionParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetConvolutionParameteriv(GLenum target, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetConvolutionParameteriv");
   CALL_GetConvolutionParameteriv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* DepthRangeIndexedfOES: marshalled asynchronously */
struct marshal_cmd_DepthRangeIndexedfOES
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat n;
   GLfloat f;
};
static inline void
_mesa_unmarshal_DepthRangeIndexedfOES(struct gl_context *ctx, const struct marshal_cmd_DepthRangeIndexedfOES *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat n = cmd->n;
   const GLfloat f = cmd->f;
   CALL_DepthRangeIndexedfOES(ctx->CurrentServerDispatch, (index, n, f));
}
static void GLAPIENTRY
_mesa_marshal_DepthRangeIndexedfOES(GLuint index, GLfloat n, GLfloat f)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DepthRangeIndexedfOES);
   struct marshal_cmd_DepthRangeIndexedfOES *cmd;
   debug_print_marshal("DepthRangeIndexedfOES");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DepthRangeIndexedfOES, cmd_size);
      cmd->index = index;
      cmd->n = n;
      cmd->f = f;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DepthRangeIndexedfOES");
   CALL_DepthRangeIndexedfOES(ctx->CurrentServerDispatch, (index, n, f));
}


/* GetProgramResourceLocation: marshalled synchronously */
static GLint GLAPIENTRY
_mesa_marshal_GetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramResourceLocation");
   return CALL_GetProgramResourceLocation(ctx->CurrentServerDispatch, (program, programInterface, name));
}


/* GetSubroutineUniformLocation: marshalled synchronously */
static GLint GLAPIENTRY
_mesa_marshal_GetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetSubroutineUniformLocation");
   return CALL_GetSubroutineUniformLocation(ctx->CurrentServerDispatch, (program, shadertype, name));
}


/* VertexAttrib4usv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4usv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLushort v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4usv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4usv *cmd)
{
   const GLuint index = cmd->index;
   const GLushort * v = cmd->v;
   CALL_VertexAttrib4usv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4usv(GLuint index, const GLushort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4usv);
   struct marshal_cmd_VertexAttrib4usv *cmd;
   debug_print_marshal("VertexAttrib4usv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4usv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4usv");
   CALL_VertexAttrib4usv(ctx->CurrentServerDispatch, (index, v));
}


/* TextureStorage1DEXT: marshalled asynchronously */
struct marshal_cmd_TextureStorage1DEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLenum target;
   GLsizei levels;
   GLenum internalFormat;
   GLsizei width;
};
static inline void
_mesa_unmarshal_TextureStorage1DEXT(struct gl_context *ctx, const struct marshal_cmd_TextureStorage1DEXT *cmd)
{
   const GLuint texture = cmd->texture;
   const GLenum target = cmd->target;
   const GLsizei levels = cmd->levels;
   const GLenum internalFormat = cmd->internalFormat;
   const GLsizei width = cmd->width;
   CALL_TextureStorage1DEXT(ctx->CurrentServerDispatch, (texture, target, levels, internalFormat, width));
}
static void GLAPIENTRY
_mesa_marshal_TextureStorage1DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureStorage1DEXT);
   struct marshal_cmd_TextureStorage1DEXT *cmd;
   debug_print_marshal("TextureStorage1DEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureStorage1DEXT, cmd_size);
      cmd->texture = texture;
      cmd->target = target;
      cmd->levels = levels;
      cmd->internalFormat = internalFormat;
      cmd->width = width;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureStorage1DEXT");
   CALL_TextureStorage1DEXT(ctx->CurrentServerDispatch, (texture, target, levels, internalFormat, width));
}


/* VertexAttrib4Nub: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4Nub
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLubyte x;
   GLubyte y;
   GLubyte z;
   GLubyte w;
};
static inline void
_mesa_unmarshal_VertexAttrib4Nub(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4Nub *cmd)
{
   const GLuint index = cmd->index;
   const GLubyte x = cmd->x;
   const GLubyte y = cmd->y;
   const GLubyte z = cmd->z;
   const GLubyte w = cmd->w;
   CALL_VertexAttrib4Nub(ctx->CurrentServerDispatch, (index, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4Nub);
   struct marshal_cmd_VertexAttrib4Nub *cmd;
   debug_print_marshal("VertexAttrib4Nub");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4Nub, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4Nub");
   CALL_VertexAttrib4Nub(ctx->CurrentServerDispatch, (index, x, y, z, w));
}


/* VertexAttribP3ui: marshalled asynchronously */
struct marshal_cmd_VertexAttribP3ui
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLenum type;
   GLboolean normalized;
   GLuint value;
};
static inline void
_mesa_unmarshal_VertexAttribP3ui(struct gl_context *ctx, const struct marshal_cmd_VertexAttribP3ui *cmd)
{
   const GLuint index = cmd->index;
   const GLenum type = cmd->type;
   const GLboolean normalized = cmd->normalized;
   const GLuint value = cmd->value;
   CALL_VertexAttribP3ui(ctx->CurrentServerDispatch, (index, type, normalized, value));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribP3ui);
   struct marshal_cmd_VertexAttribP3ui *cmd;
   debug_print_marshal("VertexAttribP3ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribP3ui, cmd_size);
      cmd->index = index;
      cmd->type = type;
      cmd->normalized = normalized;
      cmd->value = value;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribP3ui");
   CALL_VertexAttribP3ui(ctx->CurrentServerDispatch, (index, type, normalized, value));
}


/* PointSize: marshalled asynchronously */
struct marshal_cmd_PointSize
{
   struct marshal_cmd_base cmd_base;
   GLfloat size;
};
static inline void
_mesa_unmarshal_PointSize(struct gl_context *ctx, const struct marshal_cmd_PointSize *cmd)
{
   const GLfloat size = cmd->size;
   CALL_PointSize(ctx->CurrentServerDispatch, (size));
}
static void GLAPIENTRY
_mesa_marshal_PointSize(GLfloat size)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PointSize);
   struct marshal_cmd_PointSize *cmd;
   debug_print_marshal("PointSize");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PointSize, cmd_size);
      cmd->size = size;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PointSize");
   CALL_PointSize(ctx->CurrentServerDispatch, (size));
}


/* PopName: marshalled asynchronously */
struct marshal_cmd_PopName
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_PopName(struct gl_context *ctx, const struct marshal_cmd_PopName *cmd)
{
   CALL_PopName(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_PopName(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PopName);
   struct marshal_cmd_PopName *cmd;
   debug_print_marshal("PopName");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PopName, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PopName");
   CALL_PopName(ctx->CurrentServerDispatch, ());
}


/* FramebufferTexture: marshalled asynchronously */
struct marshal_cmd_FramebufferTexture
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum attachment;
   GLuint texture;
   GLint level;
};
static inline void
_mesa_unmarshal_FramebufferTexture(struct gl_context *ctx, const struct marshal_cmd_FramebufferTexture *cmd)
{
   const GLenum target = cmd->target;
   const GLenum attachment = cmd->attachment;
   const GLuint texture = cmd->texture;
   const GLint level = cmd->level;
   CALL_FramebufferTexture(ctx->CurrentServerDispatch, (target, attachment, texture, level));
}
static void GLAPIENTRY
_mesa_marshal_FramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_FramebufferTexture);
   struct marshal_cmd_FramebufferTexture *cmd;
   debug_print_marshal("FramebufferTexture");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_FramebufferTexture, cmd_size);
      cmd->target = target;
      cmd->attachment = attachment;
      cmd->texture = texture;
      cmd->level = level;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("FramebufferTexture");
   CALL_FramebufferTexture(ctx->CurrentServerDispatch, (target, attachment, texture, level));
}


/* CreateTransformFeedbacks: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CreateTransformFeedbacks(GLsizei n, GLuint * ids)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CreateTransformFeedbacks");
   CALL_CreateTransformFeedbacks(ctx->CurrentServerDispatch, (n, ids));
}


/* VertexAttrib4ubNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4ubNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLubyte x;
   GLubyte y;
   GLubyte z;
   GLubyte w;
};
static inline void
_mesa_unmarshal_VertexAttrib4ubNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4ubNV *cmd)
{
   const GLuint index = cmd->index;
   const GLubyte x = cmd->x;
   const GLubyte y = cmd->y;
   const GLubyte z = cmd->z;
   const GLubyte w = cmd->w;
   CALL_VertexAttrib4ubNV(ctx->CurrentServerDispatch, (index, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4ubNV(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4ubNV);
   struct marshal_cmd_VertexAttrib4ubNV *cmd;
   debug_print_marshal("VertexAttrib4ubNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4ubNV, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4ubNV");
   CALL_VertexAttrib4ubNV(ctx->CurrentServerDispatch, (index, x, y, z, w));
}


/* ValidateProgramPipeline: marshalled asynchronously */
struct marshal_cmd_ValidateProgramPipeline
{
   struct marshal_cmd_base cmd_base;
   GLuint pipeline;
};
static inline void
_mesa_unmarshal_ValidateProgramPipeline(struct gl_context *ctx, const struct marshal_cmd_ValidateProgramPipeline *cmd)
{
   const GLuint pipeline = cmd->pipeline;
   CALL_ValidateProgramPipeline(ctx->CurrentServerDispatch, (pipeline));
}
static void GLAPIENTRY
_mesa_marshal_ValidateProgramPipeline(GLuint pipeline)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ValidateProgramPipeline);
   struct marshal_cmd_ValidateProgramPipeline *cmd;
   debug_print_marshal("ValidateProgramPipeline");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ValidateProgramPipeline, cmd_size);
      cmd->pipeline = pipeline;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ValidateProgramPipeline");
   CALL_ValidateProgramPipeline(ctx->CurrentServerDispatch, (pipeline));
}


/* BindFragDataLocationIndexed: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_BindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("BindFragDataLocationIndexed");
   CALL_BindFragDataLocationIndexed(ctx->CurrentServerDispatch, (program, colorNumber, index, name));
}


/* GetClipPlane: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetClipPlane(GLenum plane, GLdouble * equation)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetClipPlane");
   CALL_GetClipPlane(ctx->CurrentServerDispatch, (plane, equation));
}


/* DeleteSemaphoresEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_DeleteSemaphoresEXT(GLsizei n, const GLuint * semaphores)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("DeleteSemaphoresEXT");
   CALL_DeleteSemaphoresEXT(ctx->CurrentServerDispatch, (n, semaphores));
}


/* TexCoordP4uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexCoordP4uiv(GLenum type, const GLuint * coords)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexCoordP4uiv");
   CALL_TexCoordP4uiv(ctx->CurrentServerDispatch, (type, coords));
}


/* VertexAttribs3dvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttribs3dvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLsizei n;
   /* Next safe_mul(n, 24) bytes are GLdouble v[n][3] */
};
static inline void
_mesa_unmarshal_VertexAttribs3dvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttribs3dvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLsizei n = cmd->n;
   const GLdouble * v;
   const char *variable_data = (const char *) (cmd + 1);
   v = (const GLdouble *) variable_data;
   variable_data += n * 24;
   CALL_VertexAttribs3dvNV(ctx->CurrentServerDispatch, (index, n, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribs3dvNV(GLuint index, GLsizei n, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribs3dvNV) + safe_mul(n, 24);
   struct marshal_cmd_VertexAttribs3dvNV *cmd;
   debug_print_marshal("VertexAttribs3dvNV");
   if (unlikely(safe_mul(n, 24) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribs3dvNV, cmd_size);
      cmd->index = index;
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, v, n * 24);
      variable_data += n * 24;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribs3dvNV");
   CALL_VertexAttribs3dvNV(ctx->CurrentServerDispatch, (index, n, v));
}


/* ProgramUniformMatrix2x4dv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix2x4dv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 64) bytes are GLdouble value[count][8] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix2x4dv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix2x4dv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 64;
   CALL_ProgramUniformMatrix2x4dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix2x4dv) + safe_mul(count, 64);
   struct marshal_cmd_ProgramUniformMatrix2x4dv *cmd;
   debug_print_marshal("ProgramUniformMatrix2x4dv");
   if (unlikely(safe_mul(count, 64) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix2x4dv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 64);
      variable_data += count * 64;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix2x4dv");
   CALL_ProgramUniformMatrix2x4dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* GenQueries: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GenQueries(GLsizei n, GLuint * ids)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GenQueries");
   CALL_GenQueries(ctx->CurrentServerDispatch, (n, ids));
}


/* ProgramUniform4iv: marshalled asynchronously */
struct marshal_cmd_ProgramUniform4iv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 16) bytes are GLint value[count][4] */
};
static inline void
_mesa_unmarshal_ProgramUniform4iv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform4iv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLint * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLint *) variable_data;
   variable_data += count * 16;
   CALL_ProgramUniform4iv(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform4iv) + safe_mul(count, 16);
   struct marshal_cmd_ProgramUniform4iv *cmd;
   debug_print_marshal("ProgramUniform4iv");
   if (unlikely(safe_mul(count, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform4iv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 16);
      variable_data += count * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform4iv");
   CALL_ProgramUniform4iv(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* ObjectUnpurgeableAPPLE: marshalled synchronously */
static GLenum GLAPIENTRY
_mesa_marshal_ObjectUnpurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ObjectUnpurgeableAPPLE");
   return CALL_ObjectUnpurgeableAPPLE(ctx->CurrentServerDispatch, (objectType, name, option));
}


/* GetCompressedTextureSubImage: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetCompressedTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, GLvoid * pixels)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetCompressedTextureSubImage");
   CALL_GetCompressedTextureSubImage(ctx->CurrentServerDispatch, (texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels));
}


/* TexCoord2iv: marshalled asynchronously */
struct marshal_cmd_TexCoord2iv
{
   struct marshal_cmd_base cmd_base;
   GLint v[2];
};
static inline void
_mesa_unmarshal_TexCoord2iv(struct gl_context *ctx, const struct marshal_cmd_TexCoord2iv *cmd)
{
   const GLint * v = cmd->v;
   CALL_TexCoord2iv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord2iv(const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord2iv);
   struct marshal_cmd_TexCoord2iv *cmd;
   debug_print_marshal("TexCoord2iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord2iv, cmd_size);
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord2iv");
   CALL_TexCoord2iv(ctx->CurrentServerDispatch, (v));
}


/* TexImage2DMultisample: marshalled asynchronously */
struct marshal_cmd_TexImage2DMultisample
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei samples;
   GLenum internalformat;
   GLsizei width;
   GLsizei height;
   GLboolean fixedsamplelocations;
};
static inline void
_mesa_unmarshal_TexImage2DMultisample(struct gl_context *ctx, const struct marshal_cmd_TexImage2DMultisample *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei samples = cmd->samples;
   const GLenum internalformat = cmd->internalformat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLboolean fixedsamplelocations = cmd->fixedsamplelocations;
   CALL_TexImage2DMultisample(ctx->CurrentServerDispatch, (target, samples, internalformat, width, height, fixedsamplelocations));
}
static void GLAPIENTRY
_mesa_marshal_TexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexImage2DMultisample);
   struct marshal_cmd_TexImage2DMultisample *cmd;
   debug_print_marshal("TexImage2DMultisample");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexImage2DMultisample, cmd_size);
      cmd->target = target;
      cmd->samples = samples;
      cmd->internalformat = internalformat;
      cmd->width = width;
      cmd->height = height;
      cmd->fixedsamplelocations = fixedsamplelocations;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexImage2DMultisample");
   CALL_TexImage2DMultisample(ctx->CurrentServerDispatch, (target, samples, internalformat, width, height, fixedsamplelocations));
}


/* TexParameterx: marshalled asynchronously */
struct marshal_cmd_TexParameterx
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum pname;
   GLfixed param;
};
static inline void
_mesa_unmarshal_TexParameterx(struct gl_context *ctx, const struct marshal_cmd_TexParameterx *cmd)
{
   const GLenum target = cmd->target;
   const GLenum pname = cmd->pname;
   const GLfixed param = cmd->param;
   CALL_TexParameterx(ctx->CurrentServerDispatch, (target, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_TexParameterx(GLenum target, GLenum pname, GLfixed param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexParameterx);
   struct marshal_cmd_TexParameterx *cmd;
   debug_print_marshal("TexParameterx");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexParameterx, cmd_size);
      cmd->target = target;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexParameterx");
   CALL_TexParameterx(ctx->CurrentServerDispatch, (target, pname, param));
}


/* Rotatef: marshalled asynchronously */
struct marshal_cmd_Rotatef
{
   struct marshal_cmd_base cmd_base;
   GLfloat angle;
   GLfloat x;
   GLfloat y;
   GLfloat z;
};
static inline void
_mesa_unmarshal_Rotatef(struct gl_context *ctx, const struct marshal_cmd_Rotatef *cmd)
{
   const GLfloat angle = cmd->angle;
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   CALL_Rotatef(ctx->CurrentServerDispatch, (angle, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Rotatef);
   struct marshal_cmd_Rotatef *cmd;
   debug_print_marshal("Rotatef");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Rotatef, cmd_size);
      cmd->angle = angle;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Rotatef");
   CALL_Rotatef(ctx->CurrentServerDispatch, (angle, x, y, z));
}


/* TexParameterf: marshalled asynchronously */
struct marshal_cmd_TexParameterf
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum pname;
   GLfloat param;
};
static inline void
_mesa_unmarshal_TexParameterf(struct gl_context *ctx, const struct marshal_cmd_TexParameterf *cmd)
{
   const GLenum target = cmd->target;
   const GLenum pname = cmd->pname;
   const GLfloat param = cmd->param;
   CALL_TexParameterf(ctx->CurrentServerDispatch, (target, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_TexParameterf(GLenum target, GLenum pname, GLfloat param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexParameterf);
   struct marshal_cmd_TexParameterf *cmd;
   debug_print_marshal("TexParameterf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexParameterf, cmd_size);
      cmd->target = target;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexParameterf");
   CALL_TexParameterf(ctx->CurrentServerDispatch, (target, pname, param));
}


/* TexParameteri: marshalled asynchronously */
struct marshal_cmd_TexParameteri
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum pname;
   GLint param;
};
static inline void
_mesa_unmarshal_TexParameteri(struct gl_context *ctx, const struct marshal_cmd_TexParameteri *cmd)
{
   const GLenum target = cmd->target;
   const GLenum pname = cmd->pname;
   const GLint param = cmd->param;
   CALL_TexParameteri(ctx->CurrentServerDispatch, (target, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_TexParameteri(GLenum target, GLenum pname, GLint param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexParameteri);
   struct marshal_cmd_TexParameteri *cmd;
   debug_print_marshal("TexParameteri");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexParameteri, cmd_size);
      cmd->target = target;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexParameteri");
   CALL_TexParameteri(ctx->CurrentServerDispatch, (target, pname, param));
}


/* GetUniformiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetUniformiv(GLuint program, GLint location, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetUniformiv");
   CALL_GetUniformiv(ctx->CurrentServerDispatch, (program, location, params));
}


/* ClearBufferSubData: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ClearBufferSubData");
   CALL_ClearBufferSubData(ctx->CurrentServerDispatch, (target, internalformat, offset, size, format, type, data));
}


/* TextureParameterfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TextureParameterfv(GLuint texture, GLenum pname, const GLfloat * param)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TextureParameterfv");
   CALL_TextureParameterfv(ctx->CurrentServerDispatch, (texture, pname, param));
}


/* VDPAUFiniNV: marshalled asynchronously */
struct marshal_cmd_VDPAUFiniNV
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_VDPAUFiniNV(struct gl_context *ctx, const struct marshal_cmd_VDPAUFiniNV *cmd)
{
   CALL_VDPAUFiniNV(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_VDPAUFiniNV(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VDPAUFiniNV);
   struct marshal_cmd_VDPAUFiniNV *cmd;
   debug_print_marshal("VDPAUFiniNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VDPAUFiniNV, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VDPAUFiniNV");
   CALL_VDPAUFiniNV(ctx->CurrentServerDispatch, ());
}


/* ProgramUniformMatrix4x2fv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix4x2fv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 32) bytes are GLfloat value[count][8] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix4x2fv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix4x2fv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 32;
   CALL_ProgramUniformMatrix4x2fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix4x2fv) + safe_mul(count, 32);
   struct marshal_cmd_ProgramUniformMatrix4x2fv *cmd;
   debug_print_marshal("ProgramUniformMatrix4x2fv");
   if (unlikely(safe_mul(count, 32) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix4x2fv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 32);
      variable_data += count * 32;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix4x2fv");
   CALL_ProgramUniformMatrix4x2fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* ProgramUniform2f: marshalled asynchronously */
struct marshal_cmd_ProgramUniform2f
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLfloat x;
   GLfloat y;
};
static inline void
_mesa_unmarshal_ProgramUniform2f(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform2f *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   CALL_ProgramUniform2f(ctx->CurrentServerDispatch, (program, location, x, y));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform2f(GLuint program, GLint location, GLfloat x, GLfloat y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform2f);
   struct marshal_cmd_ProgramUniform2f *cmd;
   debug_print_marshal("ProgramUniform2f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform2f, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform2f");
   CALL_ProgramUniform2f(ctx->CurrentServerDispatch, (program, location, x, y));
}


/* ProgramUniform2d: marshalled asynchronously */
struct marshal_cmd_ProgramUniform2d
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLdouble x;
   GLdouble y;
};
static inline void
_mesa_unmarshal_ProgramUniform2d(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform2d *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   CALL_ProgramUniform2d(ctx->CurrentServerDispatch, (program, location, x, y));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform2d(GLuint program, GLint location, GLdouble x, GLdouble y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform2d);
   struct marshal_cmd_ProgramUniform2d *cmd;
   debug_print_marshal("ProgramUniform2d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform2d, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform2d");
   CALL_ProgramUniform2d(ctx->CurrentServerDispatch, (program, location, x, y));
}


/* ProgramUniform2i: marshalled asynchronously */
struct marshal_cmd_ProgramUniform2i
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLint x;
   GLint y;
};
static inline void
_mesa_unmarshal_ProgramUniform2i(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform2i *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   CALL_ProgramUniform2i(ctx->CurrentServerDispatch, (program, location, x, y));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform2i(GLuint program, GLint location, GLint x, GLint y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform2i);
   struct marshal_cmd_ProgramUniform2i *cmd;
   debug_print_marshal("ProgramUniform2i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform2i, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform2i");
   CALL_ProgramUniform2i(ctx->CurrentServerDispatch, (program, location, x, y));
}


/* Fogx: marshalled asynchronously */
struct marshal_cmd_Fogx
{
   struct marshal_cmd_base cmd_base;
   GLenum pname;
   GLfixed param;
};
static inline void
_mesa_unmarshal_Fogx(struct gl_context *ctx, const struct marshal_cmd_Fogx *cmd)
{
   const GLenum pname = cmd->pname;
   const GLfixed param = cmd->param;
   CALL_Fogx(ctx->CurrentServerDispatch, (pname, param));
}
static void GLAPIENTRY
_mesa_marshal_Fogx(GLenum pname, GLfixed param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Fogx);
   struct marshal_cmd_Fogx *cmd;
   debug_print_marshal("Fogx");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Fogx, cmd_size);
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Fogx");
   CALL_Fogx(ctx->CurrentServerDispatch, (pname, param));
}


/* Uniform3ui64ARB: marshalled asynchronously */
struct marshal_cmd_Uniform3ui64ARB
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLuint64 x;
   GLuint64 y;
   GLuint64 z;
};
static inline void
_mesa_unmarshal_Uniform3ui64ARB(struct gl_context *ctx, const struct marshal_cmd_Uniform3ui64ARB *cmd)
{
   const GLint location = cmd->location;
   const GLuint64 x = cmd->x;
   const GLuint64 y = cmd->y;
   const GLuint64 z = cmd->z;
   CALL_Uniform3ui64ARB(ctx->CurrentServerDispatch, (location, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_Uniform3ui64ARB(GLint location, GLuint64 x, GLuint64 y, GLuint64 z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform3ui64ARB);
   struct marshal_cmd_Uniform3ui64ARB *cmd;
   debug_print_marshal("Uniform3ui64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform3ui64ARB, cmd_size);
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform3ui64ARB");
   CALL_Uniform3ui64ARB(ctx->CurrentServerDispatch, (location, x, y, z));
}


/* Fogf: marshalled asynchronously */
struct marshal_cmd_Fogf
{
   struct marshal_cmd_base cmd_base;
   GLenum pname;
   GLfloat param;
};
static inline void
_mesa_unmarshal_Fogf(struct gl_context *ctx, const struct marshal_cmd_Fogf *cmd)
{
   const GLenum pname = cmd->pname;
   const GLfloat param = cmd->param;
   CALL_Fogf(ctx->CurrentServerDispatch, (pname, param));
}
static void GLAPIENTRY
_mesa_marshal_Fogf(GLenum pname, GLfloat param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Fogf);
   struct marshal_cmd_Fogf *cmd;
   debug_print_marshal("Fogf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Fogf, cmd_size);
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Fogf");
   CALL_Fogf(ctx->CurrentServerDispatch, (pname, param));
}


/* TexSubImage1D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexSubImage1D");
   CALL_TexSubImage1D(ctx->CurrentServerDispatch, (target, level, xoffset, width, format, type, pixels));
}


/* ProgramUniform3ui64vARB: marshalled asynchronously */
struct marshal_cmd_ProgramUniform3ui64vARB
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 24) bytes are GLuint64 value[count][3] */
};
static inline void
_mesa_unmarshal_ProgramUniform3ui64vARB(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform3ui64vARB *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLuint64 * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLuint64 *) variable_data;
   variable_data += count * 24;
   CALL_ProgramUniform3ui64vARB(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform3ui64vARB(GLuint program, GLint location, GLsizei count, const GLuint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform3ui64vARB) + safe_mul(count, 24);
   struct marshal_cmd_ProgramUniform3ui64vARB *cmd;
   debug_print_marshal("ProgramUniform3ui64vARB");
   if (unlikely(safe_mul(count, 24) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform3ui64vARB, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 24);
      variable_data += count * 24;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform3ui64vARB");
   CALL_ProgramUniform3ui64vARB(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* Color4usv: marshalled asynchronously */
struct marshal_cmd_Color4usv
{
   struct marshal_cmd_base cmd_base;
   GLushort v[4];
};
static inline void
_mesa_unmarshal_Color4usv(struct gl_context *ctx, const struct marshal_cmd_Color4usv *cmd)
{
   const GLushort * v = cmd->v;
   CALL_Color4usv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Color4usv(const GLushort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color4usv);
   struct marshal_cmd_Color4usv *cmd;
   debug_print_marshal("Color4usv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color4usv, cmd_size);
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color4usv");
   CALL_Color4usv(ctx->CurrentServerDispatch, (v));
}


/* Fogi: marshalled asynchronously */
struct marshal_cmd_Fogi
{
   struct marshal_cmd_base cmd_base;
   GLenum pname;
   GLint param;
};
static inline void
_mesa_unmarshal_Fogi(struct gl_context *ctx, const struct marshal_cmd_Fogi *cmd)
{
   const GLenum pname = cmd->pname;
   const GLint param = cmd->param;
   CALL_Fogi(ctx->CurrentServerDispatch, (pname, param));
}
static void GLAPIENTRY
_mesa_marshal_Fogi(GLenum pname, GLint param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Fogi);
   struct marshal_cmd_Fogi *cmd;
   debug_print_marshal("Fogi");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Fogi, cmd_size);
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Fogi");
   CALL_Fogi(ctx->CurrentServerDispatch, (pname, param));
}


/* DepthFunc: marshalled asynchronously */
struct marshal_cmd_DepthFunc
{
   struct marshal_cmd_base cmd_base;
   GLenum func;
};
static inline void
_mesa_unmarshal_DepthFunc(struct gl_context *ctx, const struct marshal_cmd_DepthFunc *cmd)
{
   const GLenum func = cmd->func;
   CALL_DepthFunc(ctx->CurrentServerDispatch, (func));
}
static void GLAPIENTRY
_mesa_marshal_DepthFunc(GLenum func)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DepthFunc);
   struct marshal_cmd_DepthFunc *cmd;
   debug_print_marshal("DepthFunc");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DepthFunc, cmd_size);
      cmd->func = func;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DepthFunc");
   CALL_DepthFunc(ctx->CurrentServerDispatch, (func));
}


/* GetSamplerParameterIiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetSamplerParameterIiv");
   CALL_GetSamplerParameterIiv(ctx->CurrentServerDispatch, (sampler, pname, params));
}


/* VertexArrayAttribLFormat: marshalled asynchronously */
struct marshal_cmd_VertexArrayAttribLFormat
{
   struct marshal_cmd_base cmd_base;
   GLuint vaobj;
   GLuint attribindex;
   GLint size;
   GLenum type;
   GLuint relativeoffset;
};
static inline void
_mesa_unmarshal_VertexArrayAttribLFormat(struct gl_context *ctx, const struct marshal_cmd_VertexArrayAttribLFormat *cmd)
{
   const GLuint vaobj = cmd->vaobj;
   const GLuint attribindex = cmd->attribindex;
   const GLint size = cmd->size;
   const GLenum type = cmd->type;
   const GLuint relativeoffset = cmd->relativeoffset;
   CALL_VertexArrayAttribLFormat(ctx->CurrentServerDispatch, (vaobj, attribindex, size, type, relativeoffset));
}
static void GLAPIENTRY
_mesa_marshal_VertexArrayAttribLFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexArrayAttribLFormat);
   struct marshal_cmd_VertexArrayAttribLFormat *cmd;
   debug_print_marshal("VertexArrayAttribLFormat");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexArrayAttribLFormat, cmd_size);
      cmd->vaobj = vaobj;
      cmd->attribindex = attribindex;
      cmd->size = size;
      cmd->type = type;
      cmd->relativeoffset = relativeoffset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexArrayAttribLFormat");
   CALL_VertexArrayAttribLFormat(ctx->CurrentServerDispatch, (vaobj, attribindex, size, type, relativeoffset));
}


/* VertexAttribI4uiEXT: marshalled asynchronously */
struct marshal_cmd_VertexAttribI4uiEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLuint x;
   GLuint y;
   GLuint z;
   GLuint w;
};
static inline void
_mesa_unmarshal_VertexAttribI4uiEXT(struct gl_context *ctx, const struct marshal_cmd_VertexAttribI4uiEXT *cmd)
{
   const GLuint index = cmd->index;
   const GLuint x = cmd->x;
   const GLuint y = cmd->y;
   const GLuint z = cmd->z;
   const GLuint w = cmd->w;
   CALL_VertexAttribI4uiEXT(ctx->CurrentServerDispatch, (index, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribI4uiEXT(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribI4uiEXT);
   struct marshal_cmd_VertexAttribI4uiEXT *cmd;
   debug_print_marshal("VertexAttribI4uiEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribI4uiEXT, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribI4uiEXT");
   CALL_VertexAttribI4uiEXT(ctx->CurrentServerDispatch, (index, x, y, z, w));
}


/* DrawElementsInstancedBaseVertexBaseInstance: marshalled asynchronously */
struct marshal_cmd_DrawElementsInstancedBaseVertexBaseInstance
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLsizei count;
   GLenum type;
   const GLvoid * indices;
   GLsizei primcount;
   GLint basevertex;
   GLuint baseinstance;
};
static inline void
_mesa_unmarshal_DrawElementsInstancedBaseVertexBaseInstance(struct gl_context *ctx, const struct marshal_cmd_DrawElementsInstancedBaseVertexBaseInstance *cmd)
{
   const GLenum mode = cmd->mode;
   const GLsizei count = cmd->count;
   const GLenum type = cmd->type;
   const GLvoid * indices = cmd->indices;
   const GLsizei primcount = cmd->primcount;
   const GLint basevertex = cmd->basevertex;
   const GLuint baseinstance = cmd->baseinstance;
   CALL_DrawElementsInstancedBaseVertexBaseInstance(ctx->CurrentServerDispatch, (mode, count, type, indices, primcount, basevertex, baseinstance));
}
static void GLAPIENTRY
_mesa_marshal_DrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei primcount, GLint basevertex, GLuint baseinstance)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawElementsInstancedBaseVertexBaseInstance);
   struct marshal_cmd_DrawElementsInstancedBaseVertexBaseInstance *cmd;
   debug_print_marshal("DrawElementsInstancedBaseVertexBaseInstance");
   if (_mesa_glthread_is_non_vbo_draw_elements(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("DrawElementsInstancedBaseVertexBaseInstance");
      CALL_DrawElementsInstancedBaseVertexBaseInstance(ctx->CurrentServerDispatch, (mode, count, type, indices, primcount, basevertex, baseinstance));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawElementsInstancedBaseVertexBaseInstance, cmd_size);
      cmd->mode = mode;
      cmd->count = count;
      cmd->type = type;
      cmd->indices = indices;
      cmd->primcount = primcount;
      cmd->basevertex = basevertex;
      cmd->baseinstance = baseinstance;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawElementsInstancedBaseVertexBaseInstance");
   CALL_DrawElementsInstancedBaseVertexBaseInstance(ctx->CurrentServerDispatch, (mode, count, type, indices, primcount, basevertex, baseinstance));
}


/* ProgramEnvParameter4dvARB: marshalled asynchronously */
struct marshal_cmd_ProgramEnvParameter4dvARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint index;
   GLdouble params[4];
};
static inline void
_mesa_unmarshal_ProgramEnvParameter4dvARB(struct gl_context *ctx, const struct marshal_cmd_ProgramEnvParameter4dvARB *cmd)
{
   const GLenum target = cmd->target;
   const GLuint index = cmd->index;
   const GLdouble * params = cmd->params;
   CALL_ProgramEnvParameter4dvARB(ctx->CurrentServerDispatch, (target, index, params));
}
static void GLAPIENTRY
_mesa_marshal_ProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramEnvParameter4dvARB);
   struct marshal_cmd_ProgramEnvParameter4dvARB *cmd;
   debug_print_marshal("ProgramEnvParameter4dvARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramEnvParameter4dvARB, cmd_size);
      cmd->target = target;
      cmd->index = index;
      memcpy(cmd->params, params, 32);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramEnvParameter4dvARB");
   CALL_ProgramEnvParameter4dvARB(ctx->CurrentServerDispatch, (target, index, params));
}


/* ColorTableParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ColorTableParameteriv(GLenum target, GLenum pname, const GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ColorTableParameteriv");
   CALL_ColorTableParameteriv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* BindSamplers: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_BindSamplers(GLuint first, GLsizei count, const GLuint * samplers)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("BindSamplers");
   CALL_BindSamplers(ctx->CurrentServerDispatch, (first, count, samplers));
}


/* GetnCompressedTexImageARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnCompressedTexImageARB(GLenum target, GLint lod, GLsizei bufSize, GLvoid * img)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnCompressedTexImageARB");
   CALL_GetnCompressedTexImageARB(ctx->CurrentServerDispatch, (target, lod, bufSize, img));
}


/* CopyNamedBufferSubData: marshalled asynchronously */
struct marshal_cmd_CopyNamedBufferSubData
{
   struct marshal_cmd_base cmd_base;
   GLuint readBuffer;
   GLuint writeBuffer;
   GLintptr readOffset;
   GLintptr writeOffset;
   GLsizeiptr size;
};
static inline void
_mesa_unmarshal_CopyNamedBufferSubData(struct gl_context *ctx, const struct marshal_cmd_CopyNamedBufferSubData *cmd)
{
   const GLuint readBuffer = cmd->readBuffer;
   const GLuint writeBuffer = cmd->writeBuffer;
   const GLintptr readOffset = cmd->readOffset;
   const GLintptr writeOffset = cmd->writeOffset;
   const GLsizeiptr size = cmd->size;
   CALL_CopyNamedBufferSubData(ctx->CurrentServerDispatch, (readBuffer, writeBuffer, readOffset, writeOffset, size));
}
static void GLAPIENTRY
_mesa_marshal_CopyNamedBufferSubData(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CopyNamedBufferSubData);
   struct marshal_cmd_CopyNamedBufferSubData *cmd;
   debug_print_marshal("CopyNamedBufferSubData");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CopyNamedBufferSubData, cmd_size);
      cmd->readBuffer = readBuffer;
      cmd->writeBuffer = writeBuffer;
      cmd->readOffset = readOffset;
      cmd->writeOffset = writeOffset;
      cmd->size = size;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CopyNamedBufferSubData");
   CALL_CopyNamedBufferSubData(ctx->CurrentServerDispatch, (readBuffer, writeBuffer, readOffset, writeOffset, size));
}


/* BindSampler: marshalled asynchronously */
struct marshal_cmd_BindSampler
{
   struct marshal_cmd_base cmd_base;
   GLuint unit;
   GLuint sampler;
};
static inline void
_mesa_unmarshal_BindSampler(struct gl_context *ctx, const struct marshal_cmd_BindSampler *cmd)
{
   const GLuint unit = cmd->unit;
   const GLuint sampler = cmd->sampler;
   CALL_BindSampler(ctx->CurrentServerDispatch, (unit, sampler));
}
static void GLAPIENTRY
_mesa_marshal_BindSampler(GLuint unit, GLuint sampler)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BindSampler);
   struct marshal_cmd_BindSampler *cmd;
   debug_print_marshal("BindSampler");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BindSampler, cmd_size);
      cmd->unit = unit;
      cmd->sampler = sampler;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BindSampler");
   CALL_BindSampler(ctx->CurrentServerDispatch, (unit, sampler));
}


/* GetUniformuiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetUniformuiv(GLuint program, GLint location, GLuint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetUniformuiv");
   CALL_GetUniformuiv(ctx->CurrentServerDispatch, (program, location, params));
}


/* GetQueryBufferObjectuiv: marshalled asynchronously */
struct marshal_cmd_GetQueryBufferObjectuiv
{
   struct marshal_cmd_base cmd_base;
   GLuint id;
   GLuint buffer;
   GLenum pname;
   GLintptr offset;
};
static inline void
_mesa_unmarshal_GetQueryBufferObjectuiv(struct gl_context *ctx, const struct marshal_cmd_GetQueryBufferObjectuiv *cmd)
{
   const GLuint id = cmd->id;
   const GLuint buffer = cmd->buffer;
   const GLenum pname = cmd->pname;
   const GLintptr offset = cmd->offset;
   CALL_GetQueryBufferObjectuiv(ctx->CurrentServerDispatch, (id, buffer, pname, offset));
}
static void GLAPIENTRY
_mesa_marshal_GetQueryBufferObjectuiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_GetQueryBufferObjectuiv);
   struct marshal_cmd_GetQueryBufferObjectuiv *cmd;
   debug_print_marshal("GetQueryBufferObjectuiv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_GetQueryBufferObjectuiv, cmd_size);
      cmd->id = id;
      cmd->buffer = buffer;
      cmd->pname = pname;
      cmd->offset = offset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("GetQueryBufferObjectuiv");
   CALL_GetQueryBufferObjectuiv(ctx->CurrentServerDispatch, (id, buffer, pname, offset));
}


/* MultiTexCoord2fARB: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord2fARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLfloat s;
   GLfloat t;
};
static inline void
_mesa_unmarshal_MultiTexCoord2fARB(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord2fARB *cmd)
{
   const GLenum target = cmd->target;
   const GLfloat s = cmd->s;
   const GLfloat t = cmd->t;
   CALL_MultiTexCoord2fARB(ctx->CurrentServerDispatch, (target, s, t));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord2fARB);
   struct marshal_cmd_MultiTexCoord2fARB *cmd;
   debug_print_marshal("MultiTexCoord2fARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord2fARB, cmd_size);
      cmd->target = target;
      cmd->s = s;
      cmd->t = t;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord2fARB");
   CALL_MultiTexCoord2fARB(ctx->CurrentServerDispatch, (target, s, t));
}


/* Uniform1ui64ARB: marshalled asynchronously */
struct marshal_cmd_Uniform1ui64ARB
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLuint64 x;
};
static inline void
_mesa_unmarshal_Uniform1ui64ARB(struct gl_context *ctx, const struct marshal_cmd_Uniform1ui64ARB *cmd)
{
   const GLint location = cmd->location;
   const GLuint64 x = cmd->x;
   CALL_Uniform1ui64ARB(ctx->CurrentServerDispatch, (location, x));
}
static void GLAPIENTRY
_mesa_marshal_Uniform1ui64ARB(GLint location, GLuint64 x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform1ui64ARB);
   struct marshal_cmd_Uniform1ui64ARB *cmd;
   debug_print_marshal("Uniform1ui64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform1ui64ARB, cmd_size);
      cmd->location = location;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform1ui64ARB");
   CALL_Uniform1ui64ARB(ctx->CurrentServerDispatch, (location, x));
}


/* IndexPointer: marshalled asynchronously */
struct marshal_cmd_IndexPointer
{
   struct marshal_cmd_base cmd_base;
   GLenum type;
   GLsizei stride;
   const GLvoid * pointer;
};
static inline void
_mesa_unmarshal_IndexPointer(struct gl_context *ctx, const struct marshal_cmd_IndexPointer *cmd)
{
   const GLenum type = cmd->type;
   const GLsizei stride = cmd->stride;
   const GLvoid * pointer = cmd->pointer;
   CALL_IndexPointer(ctx->CurrentServerDispatch, (type, stride, pointer));
}
static void GLAPIENTRY
_mesa_marshal_IndexPointer(GLenum type, GLsizei stride, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_IndexPointer);
   struct marshal_cmd_IndexPointer *cmd;
   debug_print_marshal("IndexPointer");
   if (_mesa_glthread_is_non_vbo_vertex_attrib_pointer(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("IndexPointer");
      CALL_IndexPointer(ctx->CurrentServerDispatch, (type, stride, pointer));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_IndexPointer, cmd_size);
      cmd->type = type;
      cmd->stride = stride;
      cmd->pointer = pointer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("IndexPointer");
   CALL_IndexPointer(ctx->CurrentServerDispatch, (type, stride, pointer));
}


/* MultiTexCoord3iv: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord3iv
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLint v[3];
};
static inline void
_mesa_unmarshal_MultiTexCoord3iv(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord3iv *cmd)
{
   const GLenum target = cmd->target;
   const GLint * v = cmd->v;
   CALL_MultiTexCoord3iv(ctx->CurrentServerDispatch, (target, v));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord3iv(GLenum target, const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord3iv);
   struct marshal_cmd_MultiTexCoord3iv *cmd;
   debug_print_marshal("MultiTexCoord3iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord3iv, cmd_size);
      cmd->target = target;
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord3iv");
   CALL_MultiTexCoord3iv(ctx->CurrentServerDispatch, (target, v));
}


/* Finish: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_Finish(void)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("Finish");
   CALL_Finish(ctx->CurrentServerDispatch, ());
}


/* ClearStencil: marshalled asynchronously */
struct marshal_cmd_ClearStencil
{
   struct marshal_cmd_base cmd_base;
   GLint s;
};
static inline void
_mesa_unmarshal_ClearStencil(struct gl_context *ctx, const struct marshal_cmd_ClearStencil *cmd)
{
   const GLint s = cmd->s;
   CALL_ClearStencil(ctx->CurrentServerDispatch, (s));
}
static void GLAPIENTRY
_mesa_marshal_ClearStencil(GLint s)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ClearStencil);
   struct marshal_cmd_ClearStencil *cmd;
   debug_print_marshal("ClearStencil");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ClearStencil, cmd_size);
      cmd->s = s;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ClearStencil");
   CALL_ClearStencil(ctx->CurrentServerDispatch, (s));
}


/* ClearColorIiEXT: marshalled asynchronously */
struct marshal_cmd_ClearColorIiEXT
{
   struct marshal_cmd_base cmd_base;
   GLint r;
   GLint g;
   GLint b;
   GLint a;
};
static inline void
_mesa_unmarshal_ClearColorIiEXT(struct gl_context *ctx, const struct marshal_cmd_ClearColorIiEXT *cmd)
{
   const GLint r = cmd->r;
   const GLint g = cmd->g;
   const GLint b = cmd->b;
   const GLint a = cmd->a;
   CALL_ClearColorIiEXT(ctx->CurrentServerDispatch, (r, g, b, a));
}
static void GLAPIENTRY
_mesa_marshal_ClearColorIiEXT(GLint r, GLint g, GLint b, GLint a)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ClearColorIiEXT);
   struct marshal_cmd_ClearColorIiEXT *cmd;
   debug_print_marshal("ClearColorIiEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ClearColorIiEXT, cmd_size);
      cmd->r = r;
      cmd->g = g;
      cmd->b = b;
      cmd->a = a;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ClearColorIiEXT");
   CALL_ClearColorIiEXT(ctx->CurrentServerDispatch, (r, g, b, a));
}


/* LoadMatrixd: marshalled asynchronously */
struct marshal_cmd_LoadMatrixd
{
   struct marshal_cmd_base cmd_base;
   GLdouble m[16];
};
static inline void
_mesa_unmarshal_LoadMatrixd(struct gl_context *ctx, const struct marshal_cmd_LoadMatrixd *cmd)
{
   const GLdouble * m = cmd->m;
   CALL_LoadMatrixd(ctx->CurrentServerDispatch, (m));
}
static void GLAPIENTRY
_mesa_marshal_LoadMatrixd(const GLdouble * m)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_LoadMatrixd);
   struct marshal_cmd_LoadMatrixd *cmd;
   debug_print_marshal("LoadMatrixd");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_LoadMatrixd, cmd_size);
      memcpy(cmd->m, m, 128);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("LoadMatrixd");
   CALL_LoadMatrixd(ctx->CurrentServerDispatch, (m));
}


/* VDPAURegisterOutputSurfaceNV: marshalled synchronously */
static GLintptr GLAPIENTRY
_mesa_marshal_VDPAURegisterOutputSurfaceNV(const GLvoid * vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint * textureNames)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VDPAURegisterOutputSurfaceNV");
   return CALL_VDPAURegisterOutputSurfaceNV(ctx->CurrentServerDispatch, (vdpSurface, target, numTextureNames, textureNames));
}


/* VertexP4ui: marshalled asynchronously */
struct marshal_cmd_VertexP4ui
{
   struct marshal_cmd_base cmd_base;
   GLenum type;
   GLuint value;
};
static inline void
_mesa_unmarshal_VertexP4ui(struct gl_context *ctx, const struct marshal_cmd_VertexP4ui *cmd)
{
   const GLenum type = cmd->type;
   const GLuint value = cmd->value;
   CALL_VertexP4ui(ctx->CurrentServerDispatch, (type, value));
}
static void GLAPIENTRY
_mesa_marshal_VertexP4ui(GLenum type, GLuint value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexP4ui);
   struct marshal_cmd_VertexP4ui *cmd;
   debug_print_marshal("VertexP4ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexP4ui, cmd_size);
      cmd->type = type;
      cmd->value = value;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexP4ui");
   CALL_VertexP4ui(ctx->CurrentServerDispatch, (type, value));
}


/* GetProgramResourceIndex: marshalled synchronously */
static GLuint GLAPIENTRY
_mesa_marshal_GetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramResourceIndex");
   return CALL_GetProgramResourceIndex(ctx->CurrentServerDispatch, (program, programInterface, name));
}


/* TextureStorage3DMultisample: marshalled asynchronously */
struct marshal_cmd_TextureStorage3DMultisample
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLsizei samples;
   GLenum internalformat;
   GLsizei width;
   GLsizei height;
   GLsizei depth;
   GLboolean fixedsamplelocations;
};
static inline void
_mesa_unmarshal_TextureStorage3DMultisample(struct gl_context *ctx, const struct marshal_cmd_TextureStorage3DMultisample *cmd)
{
   const GLuint texture = cmd->texture;
   const GLsizei samples = cmd->samples;
   const GLenum internalformat = cmd->internalformat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLsizei depth = cmd->depth;
   const GLboolean fixedsamplelocations = cmd->fixedsamplelocations;
   CALL_TextureStorage3DMultisample(ctx->CurrentServerDispatch, (texture, samples, internalformat, width, height, depth, fixedsamplelocations));
}
static void GLAPIENTRY
_mesa_marshal_TextureStorage3DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureStorage3DMultisample);
   struct marshal_cmd_TextureStorage3DMultisample *cmd;
   debug_print_marshal("TextureStorage3DMultisample");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureStorage3DMultisample, cmd_size);
      cmd->texture = texture;
      cmd->samples = samples;
      cmd->internalformat = internalformat;
      cmd->width = width;
      cmd->height = height;
      cmd->depth = depth;
      cmd->fixedsamplelocations = fixedsamplelocations;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureStorage3DMultisample");
   CALL_TextureStorage3DMultisample(ctx->CurrentServerDispatch, (texture, samples, internalformat, width, height, depth, fixedsamplelocations));
}


/* GetnUniformivARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnUniformivARB(GLuint program, GLint location, GLsizei bufSize, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnUniformivARB");
   CALL_GetnUniformivARB(ctx->CurrentServerDispatch, (program, location, bufSize, params));
}


/* ReleaseShaderCompiler: marshalled asynchronously */
struct marshal_cmd_ReleaseShaderCompiler
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_ReleaseShaderCompiler(struct gl_context *ctx, const struct marshal_cmd_ReleaseShaderCompiler *cmd)
{
   CALL_ReleaseShaderCompiler(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_ReleaseShaderCompiler(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ReleaseShaderCompiler);
   struct marshal_cmd_ReleaseShaderCompiler *cmd;
   debug_print_marshal("ReleaseShaderCompiler");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ReleaseShaderCompiler, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ReleaseShaderCompiler");
   CALL_ReleaseShaderCompiler(ctx->CurrentServerDispatch, ());
}


/* BlendFuncSeparate: marshalled asynchronously */
struct marshal_cmd_BlendFuncSeparate
{
   struct marshal_cmd_base cmd_base;
   GLenum sfactorRGB;
   GLenum dfactorRGB;
   GLenum sfactorAlpha;
   GLenum dfactorAlpha;
};
static inline void
_mesa_unmarshal_BlendFuncSeparate(struct gl_context *ctx, const struct marshal_cmd_BlendFuncSeparate *cmd)
{
   const GLenum sfactorRGB = cmd->sfactorRGB;
   const GLenum dfactorRGB = cmd->dfactorRGB;
   const GLenum sfactorAlpha = cmd->sfactorAlpha;
   const GLenum dfactorAlpha = cmd->dfactorAlpha;
   CALL_BlendFuncSeparate(ctx->CurrentServerDispatch, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha));
}
static void GLAPIENTRY
_mesa_marshal_BlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BlendFuncSeparate);
   struct marshal_cmd_BlendFuncSeparate *cmd;
   debug_print_marshal("BlendFuncSeparate");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BlendFuncSeparate, cmd_size);
      cmd->sfactorRGB = sfactorRGB;
      cmd->dfactorRGB = dfactorRGB;
      cmd->sfactorAlpha = sfactorAlpha;
      cmd->dfactorAlpha = dfactorAlpha;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BlendFuncSeparate");
   CALL_BlendFuncSeparate(ctx->CurrentServerDispatch, (sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha));
}


/* Color3us: marshalled asynchronously */
struct marshal_cmd_Color3us
{
   struct marshal_cmd_base cmd_base;
   GLushort red;
   GLushort green;
   GLushort blue;
};
static inline void
_mesa_unmarshal_Color3us(struct gl_context *ctx, const struct marshal_cmd_Color3us *cmd)
{
   const GLushort red = cmd->red;
   const GLushort green = cmd->green;
   const GLushort blue = cmd->blue;
   CALL_Color3us(ctx->CurrentServerDispatch, (red, green, blue));
}
static void GLAPIENTRY
_mesa_marshal_Color3us(GLushort red, GLushort green, GLushort blue)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color3us);
   struct marshal_cmd_Color3us *cmd;
   debug_print_marshal("Color3us");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color3us, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color3us");
   CALL_Color3us(ctx->CurrentServerDispatch, (red, green, blue));
}


/* LoadMatrixx: marshalled asynchronously */
struct marshal_cmd_LoadMatrixx
{
   struct marshal_cmd_base cmd_base;
   GLfixed m[16];
};
static inline void
_mesa_unmarshal_LoadMatrixx(struct gl_context *ctx, const struct marshal_cmd_LoadMatrixx *cmd)
{
   const GLfixed * m = cmd->m;
   CALL_LoadMatrixx(ctx->CurrentServerDispatch, (m));
}
static void GLAPIENTRY
_mesa_marshal_LoadMatrixx(const GLfixed * m)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_LoadMatrixx);
   struct marshal_cmd_LoadMatrixx *cmd;
   debug_print_marshal("LoadMatrixx");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_LoadMatrixx, cmd_size);
      memcpy(cmd->m, m, 64);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("LoadMatrixx");
   CALL_LoadMatrixx(ctx->CurrentServerDispatch, (m));
}


/* BufferStorage: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_BufferStorage(GLenum target, GLsizeiptr size, const GLvoid * data, GLbitfield flags)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("BufferStorage");
   CALL_BufferStorage(ctx->CurrentServerDispatch, (target, size, data, flags));
}


/* Color3ub: marshalled asynchronously */
struct marshal_cmd_Color3ub
{
   struct marshal_cmd_base cmd_base;
   GLubyte red;
   GLubyte green;
   GLubyte blue;
};
static inline void
_mesa_unmarshal_Color3ub(struct gl_context *ctx, const struct marshal_cmd_Color3ub *cmd)
{
   const GLubyte red = cmd->red;
   const GLubyte green = cmd->green;
   const GLubyte blue = cmd->blue;
   CALL_Color3ub(ctx->CurrentServerDispatch, (red, green, blue));
}
static void GLAPIENTRY
_mesa_marshal_Color3ub(GLubyte red, GLubyte green, GLubyte blue)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color3ub);
   struct marshal_cmd_Color3ub *cmd;
   debug_print_marshal("Color3ub");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color3ub, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color3ub");
   CALL_Color3ub(ctx->CurrentServerDispatch, (red, green, blue));
}


/* Color3ui: marshalled asynchronously */
struct marshal_cmd_Color3ui
{
   struct marshal_cmd_base cmd_base;
   GLuint red;
   GLuint green;
   GLuint blue;
};
static inline void
_mesa_unmarshal_Color3ui(struct gl_context *ctx, const struct marshal_cmd_Color3ui *cmd)
{
   const GLuint red = cmd->red;
   const GLuint green = cmd->green;
   const GLuint blue = cmd->blue;
   CALL_Color3ui(ctx->CurrentServerDispatch, (red, green, blue));
}
static void GLAPIENTRY
_mesa_marshal_Color3ui(GLuint red, GLuint green, GLuint blue)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color3ui);
   struct marshal_cmd_Color3ui *cmd;
   debug_print_marshal("Color3ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color3ui, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color3ui");
   CALL_Color3ui(ctx->CurrentServerDispatch, (red, green, blue));
}


/* VertexAttrib4dvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4dvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4dvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4dvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble * v = cmd->v;
   CALL_VertexAttrib4dvNV(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4dvNV(GLuint index, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4dvNV);
   struct marshal_cmd_VertexAttrib4dvNV *cmd;
   debug_print_marshal("VertexAttrib4dvNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4dvNV, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 32);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4dvNV");
   CALL_VertexAttrib4dvNV(ctx->CurrentServerDispatch, (index, v));
}


/* AlphaFragmentOp2ATI: marshalled asynchronously */
struct marshal_cmd_AlphaFragmentOp2ATI
{
   struct marshal_cmd_base cmd_base;
   GLenum op;
   GLuint dst;
   GLuint dstMod;
   GLuint arg1;
   GLuint arg1Rep;
   GLuint arg1Mod;
   GLuint arg2;
   GLuint arg2Rep;
   GLuint arg2Mod;
};
static inline void
_mesa_unmarshal_AlphaFragmentOp2ATI(struct gl_context *ctx, const struct marshal_cmd_AlphaFragmentOp2ATI *cmd)
{
   const GLenum op = cmd->op;
   const GLuint dst = cmd->dst;
   const GLuint dstMod = cmd->dstMod;
   const GLuint arg1 = cmd->arg1;
   const GLuint arg1Rep = cmd->arg1Rep;
   const GLuint arg1Mod = cmd->arg1Mod;
   const GLuint arg2 = cmd->arg2;
   const GLuint arg2Rep = cmd->arg2Rep;
   const GLuint arg2Mod = cmd->arg2Mod;
   CALL_AlphaFragmentOp2ATI(ctx->CurrentServerDispatch, (op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod));
}
static void GLAPIENTRY
_mesa_marshal_AlphaFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_AlphaFragmentOp2ATI);
   struct marshal_cmd_AlphaFragmentOp2ATI *cmd;
   debug_print_marshal("AlphaFragmentOp2ATI");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_AlphaFragmentOp2ATI, cmd_size);
      cmd->op = op;
      cmd->dst = dst;
      cmd->dstMod = dstMod;
      cmd->arg1 = arg1;
      cmd->arg1Rep = arg1Rep;
      cmd->arg1Mod = arg1Mod;
      cmd->arg2 = arg2;
      cmd->arg2Rep = arg2Rep;
      cmd->arg2Mod = arg2Mod;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("AlphaFragmentOp2ATI");
   CALL_AlphaFragmentOp2ATI(ctx->CurrentServerDispatch, (op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod));
}


/* RasterPos4dv: marshalled asynchronously */
struct marshal_cmd_RasterPos4dv
{
   struct marshal_cmd_base cmd_base;
   GLdouble v[4];
};
static inline void
_mesa_unmarshal_RasterPos4dv(struct gl_context *ctx, const struct marshal_cmd_RasterPos4dv *cmd)
{
   const GLdouble * v = cmd->v;
   CALL_RasterPos4dv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos4dv(const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos4dv);
   struct marshal_cmd_RasterPos4dv *cmd;
   debug_print_marshal("RasterPos4dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos4dv, cmd_size);
      memcpy(cmd->v, v, 32);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos4dv");
   CALL_RasterPos4dv(ctx->CurrentServerDispatch, (v));
}


/* DeleteProgramPipelines: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_DeleteProgramPipelines(GLsizei n, const GLuint * pipelines)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("DeleteProgramPipelines");
   CALL_DeleteProgramPipelines(ctx->CurrentServerDispatch, (n, pipelines));
}


/* LineWidthx: marshalled asynchronously */
struct marshal_cmd_LineWidthx
{
   struct marshal_cmd_base cmd_base;
   GLfixed width;
};
static inline void
_mesa_unmarshal_LineWidthx(struct gl_context *ctx, const struct marshal_cmd_LineWidthx *cmd)
{
   const GLfixed width = cmd->width;
   CALL_LineWidthx(ctx->CurrentServerDispatch, (width));
}
static void GLAPIENTRY
_mesa_marshal_LineWidthx(GLfixed width)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_LineWidthx);
   struct marshal_cmd_LineWidthx *cmd;
   debug_print_marshal("LineWidthx");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_LineWidthx, cmd_size);
      cmd->width = width;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("LineWidthx");
   CALL_LineWidthx(ctx->CurrentServerDispatch, (width));
}


/* GetTransformFeedbacki_v: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index, GLint * param)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTransformFeedbacki_v");
   CALL_GetTransformFeedbacki_v(ctx->CurrentServerDispatch, (xfb, pname, index, param));
}


/* Indexdv: marshalled asynchronously */
struct marshal_cmd_Indexdv
{
   struct marshal_cmd_base cmd_base;
   GLdouble c[1];
};
static inline void
_mesa_unmarshal_Indexdv(struct gl_context *ctx, const struct marshal_cmd_Indexdv *cmd)
{
   const GLdouble * c = cmd->c;
   CALL_Indexdv(ctx->CurrentServerDispatch, (c));
}
static void GLAPIENTRY
_mesa_marshal_Indexdv(const GLdouble * c)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Indexdv);
   struct marshal_cmd_Indexdv *cmd;
   debug_print_marshal("Indexdv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Indexdv, cmd_size);
      memcpy(cmd->c, c, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Indexdv");
   CALL_Indexdv(ctx->CurrentServerDispatch, (c));
}


/* GetnPixelMapfvARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnPixelMapfvARB(GLenum map, GLsizei bufSize, GLfloat * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnPixelMapfvARB");
   CALL_GetnPixelMapfvARB(ctx->CurrentServerDispatch, (map, bufSize, values));
}


/* EGLImageTargetTexture2DOES: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_EGLImageTargetTexture2DOES(GLenum target, GLvoid * writeOffset)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("EGLImageTargetTexture2DOES");
   CALL_EGLImageTargetTexture2DOES(ctx->CurrentServerDispatch, (target, writeOffset));
}


/* DepthMask: marshalled asynchronously */
struct marshal_cmd_DepthMask
{
   struct marshal_cmd_base cmd_base;
   GLboolean flag;
};
static inline void
_mesa_unmarshal_DepthMask(struct gl_context *ctx, const struct marshal_cmd_DepthMask *cmd)
{
   const GLboolean flag = cmd->flag;
   CALL_DepthMask(ctx->CurrentServerDispatch, (flag));
}
static void GLAPIENTRY
_mesa_marshal_DepthMask(GLboolean flag)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DepthMask);
   struct marshal_cmd_DepthMask *cmd;
   debug_print_marshal("DepthMask");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DepthMask, cmd_size);
      cmd->flag = flag;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DepthMask");
   CALL_DepthMask(ctx->CurrentServerDispatch, (flag));
}


/* WindowPos4ivMESA: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_WindowPos4ivMESA(const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("WindowPos4ivMESA");
   CALL_WindowPos4ivMESA(ctx->CurrentServerDispatch, (v));
}


/* GetShaderInfoLog: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetShaderInfoLog");
   CALL_GetShaderInfoLog(ctx->CurrentServerDispatch, (shader, bufSize, length, infoLog));
}


/* BindFragmentShaderATI: marshalled asynchronously */
struct marshal_cmd_BindFragmentShaderATI
{
   struct marshal_cmd_base cmd_base;
   GLuint id;
};
static inline void
_mesa_unmarshal_BindFragmentShaderATI(struct gl_context *ctx, const struct marshal_cmd_BindFragmentShaderATI *cmd)
{
   const GLuint id = cmd->id;
   CALL_BindFragmentShaderATI(ctx->CurrentServerDispatch, (id));
}
static void GLAPIENTRY
_mesa_marshal_BindFragmentShaderATI(GLuint id)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BindFragmentShaderATI);
   struct marshal_cmd_BindFragmentShaderATI *cmd;
   debug_print_marshal("BindFragmentShaderATI");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BindFragmentShaderATI, cmd_size);
      cmd->id = id;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BindFragmentShaderATI");
   CALL_BindFragmentShaderATI(ctx->CurrentServerDispatch, (id));
}


/* BlendFuncSeparateiARB: marshalled asynchronously */
struct marshal_cmd_BlendFuncSeparateiARB
{
   struct marshal_cmd_base cmd_base;
   GLuint buf;
   GLenum srcRGB;
   GLenum dstRGB;
   GLenum srcA;
   GLenum dstA;
};
static inline void
_mesa_unmarshal_BlendFuncSeparateiARB(struct gl_context *ctx, const struct marshal_cmd_BlendFuncSeparateiARB *cmd)
{
   const GLuint buf = cmd->buf;
   const GLenum srcRGB = cmd->srcRGB;
   const GLenum dstRGB = cmd->dstRGB;
   const GLenum srcA = cmd->srcA;
   const GLenum dstA = cmd->dstA;
   CALL_BlendFuncSeparateiARB(ctx->CurrentServerDispatch, (buf, srcRGB, dstRGB, srcA, dstA));
}
static void GLAPIENTRY
_mesa_marshal_BlendFuncSeparateiARB(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcA, GLenum dstA)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BlendFuncSeparateiARB);
   struct marshal_cmd_BlendFuncSeparateiARB *cmd;
   debug_print_marshal("BlendFuncSeparateiARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BlendFuncSeparateiARB, cmd_size);
      cmd->buf = buf;
      cmd->srcRGB = srcRGB;
      cmd->dstRGB = dstRGB;
      cmd->srcA = srcA;
      cmd->dstA = dstA;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BlendFuncSeparateiARB");
   CALL_BlendFuncSeparateiARB(ctx->CurrentServerDispatch, (buf, srcRGB, dstRGB, srcA, dstA));
}


/* EGLImageTargetRenderbufferStorageOES: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_EGLImageTargetRenderbufferStorageOES(GLenum target, GLvoid * writeOffset)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("EGLImageTargetRenderbufferStorageOES");
   CALL_EGLImageTargetRenderbufferStorageOES(ctx->CurrentServerDispatch, (target, writeOffset));
}


/* GenTransformFeedbacks: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GenTransformFeedbacks(GLsizei n, GLuint * ids)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GenTransformFeedbacks");
   CALL_GenTransformFeedbacks(ctx->CurrentServerDispatch, (n, ids));
}


/* VertexPointer: marshalled asynchronously */
struct marshal_cmd_VertexPointer
{
   struct marshal_cmd_base cmd_base;
   GLint size;
   GLenum type;
   GLsizei stride;
   const GLvoid * pointer;
};
static inline void
_mesa_unmarshal_VertexPointer(struct gl_context *ctx, const struct marshal_cmd_VertexPointer *cmd)
{
   const GLint size = cmd->size;
   const GLenum type = cmd->type;
   const GLsizei stride = cmd->stride;
   const GLvoid * pointer = cmd->pointer;
   CALL_VertexPointer(ctx->CurrentServerDispatch, (size, type, stride, pointer));
}
static void GLAPIENTRY
_mesa_marshal_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexPointer);
   struct marshal_cmd_VertexPointer *cmd;
   debug_print_marshal("VertexPointer");
   if (_mesa_glthread_is_non_vbo_vertex_attrib_pointer(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("VertexPointer");
      CALL_VertexPointer(ctx->CurrentServerDispatch, (size, type, stride, pointer));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexPointer, cmd_size);
      cmd->size = size;
      cmd->type = type;
      cmd->stride = stride;
      cmd->pointer = pointer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexPointer");
   CALL_VertexPointer(ctx->CurrentServerDispatch, (size, type, stride, pointer));
}


/* GetCompressedTexImage: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetCompressedTexImage(GLenum target, GLint level, GLvoid * img)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetCompressedTexImage");
   CALL_GetCompressedTexImage(ctx->CurrentServerDispatch, (target, level, img));
}


/* ProgramLocalParameter4dvARB: marshalled asynchronously */
struct marshal_cmd_ProgramLocalParameter4dvARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint index;
   GLdouble params[4];
};
static inline void
_mesa_unmarshal_ProgramLocalParameter4dvARB(struct gl_context *ctx, const struct marshal_cmd_ProgramLocalParameter4dvARB *cmd)
{
   const GLenum target = cmd->target;
   const GLuint index = cmd->index;
   const GLdouble * params = cmd->params;
   CALL_ProgramLocalParameter4dvARB(ctx->CurrentServerDispatch, (target, index, params));
}
static void GLAPIENTRY
_mesa_marshal_ProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble * params)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramLocalParameter4dvARB);
   struct marshal_cmd_ProgramLocalParameter4dvARB *cmd;
   debug_print_marshal("ProgramLocalParameter4dvARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramLocalParameter4dvARB, cmd_size);
      cmd->target = target;
      cmd->index = index;
      memcpy(cmd->params, params, 32);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramLocalParameter4dvARB");
   CALL_ProgramLocalParameter4dvARB(ctx->CurrentServerDispatch, (target, index, params));
}


/* UniformMatrix2dv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix2dv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 32) bytes are GLdouble value[count][4] */
};
static inline void
_mesa_unmarshal_UniformMatrix2dv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix2dv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 32;
   CALL_UniformMatrix2dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix2dv) + safe_mul(count, 32);
   struct marshal_cmd_UniformMatrix2dv *cmd;
   debug_print_marshal("UniformMatrix2dv");
   if (unlikely(safe_mul(count, 32) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix2dv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 32);
      variable_data += count * 32;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix2dv");
   CALL_UniformMatrix2dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* GetQueryObjectui64v: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetQueryObjectui64v");
   CALL_GetQueryObjectui64v(ctx->CurrentServerDispatch, (id, pname, params));
}


/* VertexAttribP1uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribP1uiv");
   CALL_VertexAttribP1uiv(ctx->CurrentServerDispatch, (index, type, normalized, value));
}


/* IsProgram: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsProgram(GLuint program)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsProgram");
   return CALL_IsProgram(ctx->CurrentServerDispatch, (program));
}


/* BindBuffersBase: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_BindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint * buffers)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("BindBuffersBase");
   CALL_BindBuffersBase(ctx->CurrentServerDispatch, (target, first, count, buffers));
}


/* GenTextures: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GenTextures(GLsizei n, GLuint * textures)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GenTextures");
   CALL_GenTextures(ctx->CurrentServerDispatch, (n, textures));
}


/* UnmapNamedBuffer: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_UnmapNamedBuffer(GLuint buffer)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("UnmapNamedBuffer");
   return CALL_UnmapNamedBuffer(ctx->CurrentServerDispatch, (buffer));
}


/* UniformMatrix3x2dv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix3x2dv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 48) bytes are GLdouble value[count][6] */
};
static inline void
_mesa_unmarshal_UniformMatrix3x2dv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix3x2dv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 48;
   CALL_UniformMatrix3x2dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix3x2dv) + safe_mul(count, 48);
   struct marshal_cmd_UniformMatrix3x2dv *cmd;
   debug_print_marshal("UniformMatrix3x2dv");
   if (unlikely(safe_mul(count, 48) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix3x2dv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 48);
      variable_data += count * 48;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix3x2dv");
   CALL_UniformMatrix3x2dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* WindowPos4fMESA: marshalled asynchronously */
struct marshal_cmd_WindowPos4fMESA
{
   struct marshal_cmd_base cmd_base;
   GLfloat x;
   GLfloat y;
   GLfloat z;
   GLfloat w;
};
static inline void
_mesa_unmarshal_WindowPos4fMESA(struct gl_context *ctx, const struct marshal_cmd_WindowPos4fMESA *cmd)
{
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   const GLfloat w = cmd->w;
   CALL_WindowPos4fMESA(ctx->CurrentServerDispatch, (x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_WindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_WindowPos4fMESA);
   struct marshal_cmd_WindowPos4fMESA *cmd;
   debug_print_marshal("WindowPos4fMESA");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_WindowPos4fMESA, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("WindowPos4fMESA");
   CALL_WindowPos4fMESA(ctx->CurrentServerDispatch, (x, y, z, w));
}


/* VertexAttribs2fvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttribs2fvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLsizei n;
   /* Next safe_mul(n, 8) bytes are GLfloat v[n][2] */
};
static inline void
_mesa_unmarshal_VertexAttribs2fvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttribs2fvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLsizei n = cmd->n;
   const GLfloat * v;
   const char *variable_data = (const char *) (cmd + 1);
   v = (const GLfloat *) variable_data;
   variable_data += n * 8;
   CALL_VertexAttribs2fvNV(ctx->CurrentServerDispatch, (index, n, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribs2fvNV(GLuint index, GLsizei n, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribs2fvNV) + safe_mul(n, 8);
   struct marshal_cmd_VertexAttribs2fvNV *cmd;
   debug_print_marshal("VertexAttribs2fvNV");
   if (unlikely(safe_mul(n, 8) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribs2fvNV, cmd_size);
      cmd->index = index;
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, v, n * 8);
      variable_data += n * 8;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribs2fvNV");
   CALL_VertexAttribs2fvNV(ctx->CurrentServerDispatch, (index, n, v));
}


/* VertexAttribP4ui: marshalled asynchronously */
struct marshal_cmd_VertexAttribP4ui
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLenum type;
   GLboolean normalized;
   GLuint value;
};
static inline void
_mesa_unmarshal_VertexAttribP4ui(struct gl_context *ctx, const struct marshal_cmd_VertexAttribP4ui *cmd)
{
   const GLuint index = cmd->index;
   const GLenum type = cmd->type;
   const GLboolean normalized = cmd->normalized;
   const GLuint value = cmd->value;
   CALL_VertexAttribP4ui(ctx->CurrentServerDispatch, (index, type, normalized, value));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribP4ui);
   struct marshal_cmd_VertexAttribP4ui *cmd;
   debug_print_marshal("VertexAttribP4ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribP4ui, cmd_size);
      cmd->index = index;
      cmd->type = type;
      cmd->normalized = normalized;
      cmd->value = value;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribP4ui");
   CALL_VertexAttribP4ui(ctx->CurrentServerDispatch, (index, type, normalized, value));
}


/* StringMarkerGREMEDY: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_StringMarkerGREMEDY(GLsizei len, const GLvoid * string)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("StringMarkerGREMEDY");
   CALL_StringMarkerGREMEDY(ctx->CurrentServerDispatch, (len, string));
}


/* Uniform4i: marshalled asynchronously */
struct marshal_cmd_Uniform4i
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLint v0;
   GLint v1;
   GLint v2;
   GLint v3;
};
static inline void
_mesa_unmarshal_Uniform4i(struct gl_context *ctx, const struct marshal_cmd_Uniform4i *cmd)
{
   const GLint location = cmd->location;
   const GLint v0 = cmd->v0;
   const GLint v1 = cmd->v1;
   const GLint v2 = cmd->v2;
   const GLint v3 = cmd->v3;
   CALL_Uniform4i(ctx->CurrentServerDispatch, (location, v0, v1, v2, v3));
}
static void GLAPIENTRY
_mesa_marshal_Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform4i);
   struct marshal_cmd_Uniform4i *cmd;
   debug_print_marshal("Uniform4i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform4i, cmd_size);
      cmd->location = location;
      cmd->v0 = v0;
      cmd->v1 = v1;
      cmd->v2 = v2;
      cmd->v3 = v3;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform4i");
   CALL_Uniform4i(ctx->CurrentServerDispatch, (location, v0, v1, v2, v3));
}


/* Uniform4d: marshalled asynchronously */
struct marshal_cmd_Uniform4d
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLdouble x;
   GLdouble y;
   GLdouble z;
   GLdouble w;
};
static inline void
_mesa_unmarshal_Uniform4d(struct gl_context *ctx, const struct marshal_cmd_Uniform4d *cmd)
{
   const GLint location = cmd->location;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   const GLdouble w = cmd->w;
   CALL_Uniform4d(ctx->CurrentServerDispatch, (location, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_Uniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform4d);
   struct marshal_cmd_Uniform4d *cmd;
   debug_print_marshal("Uniform4d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform4d, cmd_size);
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform4d");
   CALL_Uniform4d(ctx->CurrentServerDispatch, (location, x, y, z, w));
}


/* Uniform4f: marshalled asynchronously */
struct marshal_cmd_Uniform4f
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLfloat v0;
   GLfloat v1;
   GLfloat v2;
   GLfloat v3;
};
static inline void
_mesa_unmarshal_Uniform4f(struct gl_context *ctx, const struct marshal_cmd_Uniform4f *cmd)
{
   const GLint location = cmd->location;
   const GLfloat v0 = cmd->v0;
   const GLfloat v1 = cmd->v1;
   const GLfloat v2 = cmd->v2;
   const GLfloat v3 = cmd->v3;
   CALL_Uniform4f(ctx->CurrentServerDispatch, (location, v0, v1, v2, v3));
}
static void GLAPIENTRY
_mesa_marshal_Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform4f);
   struct marshal_cmd_Uniform4f *cmd;
   debug_print_marshal("Uniform4f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform4f, cmd_size);
      cmd->location = location;
      cmd->v0 = v0;
      cmd->v1 = v1;
      cmd->v2 = v2;
      cmd->v3 = v3;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform4f");
   CALL_Uniform4f(ctx->CurrentServerDispatch, (location, v0, v1, v2, v3));
}


/* ProgramUniform3dv: marshalled asynchronously */
struct marshal_cmd_ProgramUniform3dv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 24) bytes are GLdouble value[count][3] */
};
static inline void
_mesa_unmarshal_ProgramUniform3dv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform3dv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 24;
   CALL_ProgramUniform3dv(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform3dv) + safe_mul(count, 24);
   struct marshal_cmd_ProgramUniform3dv *cmd;
   debug_print_marshal("ProgramUniform3dv");
   if (unlikely(safe_mul(count, 24) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform3dv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 24);
      variable_data += count * 24;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform3dv");
   CALL_ProgramUniform3dv(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* GetNamedBufferParameteri64v: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetNamedBufferParameteri64v(GLuint buffer, GLenum pname, GLint64 * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetNamedBufferParameteri64v");
   CALL_GetNamedBufferParameteri64v(ctx->CurrentServerDispatch, (buffer, pname, params));
}


/* NamedFramebufferTexture: marshalled asynchronously */
struct marshal_cmd_NamedFramebufferTexture
{
   struct marshal_cmd_base cmd_base;
   GLuint framebuffer;
   GLenum attachment;
   GLuint texture;
   GLint level;
};
static inline void
_mesa_unmarshal_NamedFramebufferTexture(struct gl_context *ctx, const struct marshal_cmd_NamedFramebufferTexture *cmd)
{
   const GLuint framebuffer = cmd->framebuffer;
   const GLenum attachment = cmd->attachment;
   const GLuint texture = cmd->texture;
   const GLint level = cmd->level;
   CALL_NamedFramebufferTexture(ctx->CurrentServerDispatch, (framebuffer, attachment, texture, level));
}
static void GLAPIENTRY
_mesa_marshal_NamedFramebufferTexture(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_NamedFramebufferTexture);
   struct marshal_cmd_NamedFramebufferTexture *cmd;
   debug_print_marshal("NamedFramebufferTexture");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_NamedFramebufferTexture, cmd_size);
      cmd->framebuffer = framebuffer;
      cmd->attachment = attachment;
      cmd->texture = texture;
      cmd->level = level;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("NamedFramebufferTexture");
   CALL_NamedFramebufferTexture(ctx->CurrentServerDispatch, (framebuffer, attachment, texture, level));
}


/* ProgramUniform3d: marshalled asynchronously */
struct marshal_cmd_ProgramUniform3d
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLdouble x;
   GLdouble y;
   GLdouble z;
};
static inline void
_mesa_unmarshal_ProgramUniform3d(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform3d *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   CALL_ProgramUniform3d(ctx->CurrentServerDispatch, (program, location, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform3d(GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform3d);
   struct marshal_cmd_ProgramUniform3d *cmd;
   debug_print_marshal("ProgramUniform3d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform3d, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform3d");
   CALL_ProgramUniform3d(ctx->CurrentServerDispatch, (program, location, x, y, z));
}


/* ProgramUniform3f: marshalled asynchronously */
struct marshal_cmd_ProgramUniform3f
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLfloat x;
   GLfloat y;
   GLfloat z;
};
static inline void
_mesa_unmarshal_ProgramUniform3f(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform3f *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   CALL_ProgramUniform3f(ctx->CurrentServerDispatch, (program, location, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform3f(GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform3f);
   struct marshal_cmd_ProgramUniform3f *cmd;
   debug_print_marshal("ProgramUniform3f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform3f, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform3f");
   CALL_ProgramUniform3f(ctx->CurrentServerDispatch, (program, location, x, y, z));
}


/* ProgramUniform3i: marshalled asynchronously */
struct marshal_cmd_ProgramUniform3i
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLint x;
   GLint y;
   GLint z;
};
static inline void
_mesa_unmarshal_ProgramUniform3i(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform3i *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLint z = cmd->z;
   CALL_ProgramUniform3i(ctx->CurrentServerDispatch, (program, location, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform3i(GLuint program, GLint location, GLint x, GLint y, GLint z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform3i);
   struct marshal_cmd_ProgramUniform3i *cmd;
   debug_print_marshal("ProgramUniform3i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform3i, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform3i");
   CALL_ProgramUniform3i(ctx->CurrentServerDispatch, (program, location, x, y, z));
}


/* PointParameterfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_PointParameterfv(GLenum pname, const GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("PointParameterfv");
   CALL_PointParameterfv(ctx->CurrentServerDispatch, (pname, params));
}


/* GetHistogramParameterfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetHistogramParameterfv(GLenum target, GLenum pname, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetHistogramParameterfv");
   CALL_GetHistogramParameterfv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* GetString: marshalled synchronously */
static const GLubyte * GLAPIENTRY
_mesa_marshal_GetString(GLenum name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetString");
   return CALL_GetString(ctx->CurrentServerDispatch, (name));
}


/* VDPAUUnmapSurfacesNV: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VDPAUUnmapSurfacesNV(GLsizei numSurfaces, const GLintptr * surfaces)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VDPAUUnmapSurfacesNV");
   CALL_VDPAUUnmapSurfacesNV(ctx->CurrentServerDispatch, (numSurfaces, surfaces));
}


/* GetnHistogramARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnHistogramARB(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnHistogramARB");
   CALL_GetnHistogramARB(ctx->CurrentServerDispatch, (target, reset, format, type, bufSize, values));
}


/* SecondaryColor3s: marshalled asynchronously */
struct marshal_cmd_SecondaryColor3s
{
   struct marshal_cmd_base cmd_base;
   GLshort red;
   GLshort green;
   GLshort blue;
};
static inline void
_mesa_unmarshal_SecondaryColor3s(struct gl_context *ctx, const struct marshal_cmd_SecondaryColor3s *cmd)
{
   const GLshort red = cmd->red;
   const GLshort green = cmd->green;
   const GLshort blue = cmd->blue;
   CALL_SecondaryColor3s(ctx->CurrentServerDispatch, (red, green, blue));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColor3s(GLshort red, GLshort green, GLshort blue)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColor3s);
   struct marshal_cmd_SecondaryColor3s *cmd;
   debug_print_marshal("SecondaryColor3s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColor3s, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColor3s");
   CALL_SecondaryColor3s(ctx->CurrentServerDispatch, (red, green, blue));
}


/* TexStorageMem2DEXT: marshalled asynchronously */
struct marshal_cmd_TexStorageMem2DEXT
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei levels;
   GLenum internalFormat;
   GLsizei width;
   GLsizei height;
   GLuint memory;
   GLuint64 offset;
};
static inline void
_mesa_unmarshal_TexStorageMem2DEXT(struct gl_context *ctx, const struct marshal_cmd_TexStorageMem2DEXT *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei levels = cmd->levels;
   const GLenum internalFormat = cmd->internalFormat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLuint memory = cmd->memory;
   const GLuint64 offset = cmd->offset;
   CALL_TexStorageMem2DEXT(ctx->CurrentServerDispatch, (target, levels, internalFormat, width, height, memory, offset));
}
static void GLAPIENTRY
_mesa_marshal_TexStorageMem2DEXT(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLuint memory, GLuint64 offset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexStorageMem2DEXT);
   struct marshal_cmd_TexStorageMem2DEXT *cmd;
   debug_print_marshal("TexStorageMem2DEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexStorageMem2DEXT, cmd_size);
      cmd->target = target;
      cmd->levels = levels;
      cmd->internalFormat = internalFormat;
      cmd->width = width;
      cmd->height = height;
      cmd->memory = memory;
      cmd->offset = offset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexStorageMem2DEXT");
   CALL_TexStorageMem2DEXT(ctx->CurrentServerDispatch, (target, levels, internalFormat, width, height, memory, offset));
}


/* VertexAttribP2uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribP2uiv");
   CALL_VertexAttribP2uiv(ctx->CurrentServerDispatch, (index, type, normalized, value));
}


/* UniformMatrix3x4dv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix3x4dv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 96) bytes are GLdouble value[count][12] */
};
static inline void
_mesa_unmarshal_UniformMatrix3x4dv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix3x4dv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 96;
   CALL_UniformMatrix3x4dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix3x4dv) + safe_mul(count, 96);
   struct marshal_cmd_UniformMatrix3x4dv *cmd;
   debug_print_marshal("UniformMatrix3x4dv");
   if (unlikely(safe_mul(count, 96) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix3x4dv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 96);
      variable_data += count * 96;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix3x4dv");
   CALL_UniformMatrix3x4dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* VertexAttrib3fNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib3fNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat x;
   GLfloat y;
   GLfloat z;
};
static inline void
_mesa_unmarshal_VertexAttrib3fNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib3fNV *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   CALL_VertexAttrib3fNV(ctx->CurrentServerDispatch, (index, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib3fNV);
   struct marshal_cmd_VertexAttrib3fNV *cmd;
   debug_print_marshal("VertexAttrib3fNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib3fNV, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib3fNV");
   CALL_VertexAttrib3fNV(ctx->CurrentServerDispatch, (index, x, y, z));
}


/* SecondaryColor3b: marshalled asynchronously */
struct marshal_cmd_SecondaryColor3b
{
   struct marshal_cmd_base cmd_base;
   GLbyte red;
   GLbyte green;
   GLbyte blue;
};
static inline void
_mesa_unmarshal_SecondaryColor3b(struct gl_context *ctx, const struct marshal_cmd_SecondaryColor3b *cmd)
{
   const GLbyte red = cmd->red;
   const GLbyte green = cmd->green;
   const GLbyte blue = cmd->blue;
   CALL_SecondaryColor3b(ctx->CurrentServerDispatch, (red, green, blue));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColor3b);
   struct marshal_cmd_SecondaryColor3b *cmd;
   debug_print_marshal("SecondaryColor3b");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColor3b, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColor3b");
   CALL_SecondaryColor3b(ctx->CurrentServerDispatch, (red, green, blue));
}


/* EnableClientState: marshalled asynchronously */
struct marshal_cmd_EnableClientState
{
   struct marshal_cmd_base cmd_base;
   GLenum array;
};
static inline void
_mesa_unmarshal_EnableClientState(struct gl_context *ctx, const struct marshal_cmd_EnableClientState *cmd)
{
   const GLenum array = cmd->array;
   CALL_EnableClientState(ctx->CurrentServerDispatch, (array));
}
static void GLAPIENTRY
_mesa_marshal_EnableClientState(GLenum array)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EnableClientState);
   struct marshal_cmd_EnableClientState *cmd;
   debug_print_marshal("EnableClientState");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EnableClientState, cmd_size);
      cmd->array = array;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EnableClientState");
   CALL_EnableClientState(ctx->CurrentServerDispatch, (array));
}


/* GetActiveSubroutineName: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei * length, GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetActiveSubroutineName");
   CALL_GetActiveSubroutineName(ctx->CurrentServerDispatch, (program, shadertype, index, bufsize, length, name));
}


/* SecondaryColor3i: marshalled asynchronously */
struct marshal_cmd_SecondaryColor3i
{
   struct marshal_cmd_base cmd_base;
   GLint red;
   GLint green;
   GLint blue;
};
static inline void
_mesa_unmarshal_SecondaryColor3i(struct gl_context *ctx, const struct marshal_cmd_SecondaryColor3i *cmd)
{
   const GLint red = cmd->red;
   const GLint green = cmd->green;
   const GLint blue = cmd->blue;
   CALL_SecondaryColor3i(ctx->CurrentServerDispatch, (red, green, blue));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColor3i(GLint red, GLint green, GLint blue)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColor3i);
   struct marshal_cmd_SecondaryColor3i *cmd;
   debug_print_marshal("SecondaryColor3i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColor3i, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColor3i");
   CALL_SecondaryColor3i(ctx->CurrentServerDispatch, (red, green, blue));
}


/* FlushMappedBufferRange: marshalled asynchronously */
struct marshal_cmd_FlushMappedBufferRange
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLintptr offset;
   GLsizeiptr length;
};
static inline void
_mesa_unmarshal_FlushMappedBufferRange(struct gl_context *ctx, const struct marshal_cmd_FlushMappedBufferRange *cmd)
{
   const GLenum target = cmd->target;
   const GLintptr offset = cmd->offset;
   const GLsizeiptr length = cmd->length;
   CALL_FlushMappedBufferRange(ctx->CurrentServerDispatch, (target, offset, length));
}
static void GLAPIENTRY
_mesa_marshal_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_FlushMappedBufferRange);
   struct marshal_cmd_FlushMappedBufferRange *cmd;
   debug_print_marshal("FlushMappedBufferRange");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_FlushMappedBufferRange, cmd_size);
      cmd->target = target;
      cmd->offset = offset;
      cmd->length = length;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("FlushMappedBufferRange");
   CALL_FlushMappedBufferRange(ctx->CurrentServerDispatch, (target, offset, length));
}


/* TexStorageMem3DEXT: marshalled asynchronously */
struct marshal_cmd_TexStorageMem3DEXT
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei levels;
   GLenum internalFormat;
   GLsizei width;
   GLsizei height;
   GLsizei depth;
   GLuint memory;
   GLuint64 offset;
};
static inline void
_mesa_unmarshal_TexStorageMem3DEXT(struct gl_context *ctx, const struct marshal_cmd_TexStorageMem3DEXT *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei levels = cmd->levels;
   const GLenum internalFormat = cmd->internalFormat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLsizei depth = cmd->depth;
   const GLuint memory = cmd->memory;
   const GLuint64 offset = cmd->offset;
   CALL_TexStorageMem3DEXT(ctx->CurrentServerDispatch, (target, levels, internalFormat, width, height, depth, memory, offset));
}
static void GLAPIENTRY
_mesa_marshal_TexStorageMem3DEXT(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexStorageMem3DEXT);
   struct marshal_cmd_TexStorageMem3DEXT *cmd;
   debug_print_marshal("TexStorageMem3DEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexStorageMem3DEXT, cmd_size);
      cmd->target = target;
      cmd->levels = levels;
      cmd->internalFormat = internalFormat;
      cmd->width = width;
      cmd->height = height;
      cmd->depth = depth;
      cmd->memory = memory;
      cmd->offset = offset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexStorageMem3DEXT");
   CALL_TexStorageMem3DEXT(ctx->CurrentServerDispatch, (target, levels, internalFormat, width, height, depth, memory, offset));
}


/* Lightfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_Lightfv(GLenum light, GLenum pname, const GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("Lightfv");
   CALL_Lightfv(ctx->CurrentServerDispatch, (light, pname, params));
}


/* GetFramebufferAttachmentParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetFramebufferAttachmentParameteriv");
   CALL_GetFramebufferAttachmentParameteriv(ctx->CurrentServerDispatch, (target, attachment, pname, params));
}


/* ColorSubTable: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ColorSubTable");
   CALL_ColorSubTable(ctx->CurrentServerDispatch, (target, start, count, format, type, data));
}


/* GetVertexArrayIndexed64iv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetVertexArrayIndexed64iv(GLuint vaobj, GLuint index, GLenum pname, GLint64 * param)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetVertexArrayIndexed64iv");
   CALL_GetVertexArrayIndexed64iv(ctx->CurrentServerDispatch, (vaobj, index, pname, param));
}


/* EndPerfMonitorAMD: marshalled asynchronously */
struct marshal_cmd_EndPerfMonitorAMD
{
   struct marshal_cmd_base cmd_base;
   GLuint monitor;
};
static inline void
_mesa_unmarshal_EndPerfMonitorAMD(struct gl_context *ctx, const struct marshal_cmd_EndPerfMonitorAMD *cmd)
{
   const GLuint monitor = cmd->monitor;
   CALL_EndPerfMonitorAMD(ctx->CurrentServerDispatch, (monitor));
}
static void GLAPIENTRY
_mesa_marshal_EndPerfMonitorAMD(GLuint monitor)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EndPerfMonitorAMD);
   struct marshal_cmd_EndPerfMonitorAMD *cmd;
   debug_print_marshal("EndPerfMonitorAMD");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EndPerfMonitorAMD, cmd_size);
      cmd->monitor = monitor;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EndPerfMonitorAMD");
   CALL_EndPerfMonitorAMD(ctx->CurrentServerDispatch, (monitor));
}


/* CreateBuffers: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CreateBuffers(GLsizei n, GLuint * buffers)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CreateBuffers");
   CALL_CreateBuffers(ctx->CurrentServerDispatch, (n, buffers));
}


/* VertexAttribs4dvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttribs4dvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLsizei n;
   /* Next safe_mul(n, 32) bytes are GLdouble v[n][4] */
};
static inline void
_mesa_unmarshal_VertexAttribs4dvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttribs4dvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLsizei n = cmd->n;
   const GLdouble * v;
   const char *variable_data = (const char *) (cmd + 1);
   v = (const GLdouble *) variable_data;
   variable_data += n * 32;
   CALL_VertexAttribs4dvNV(ctx->CurrentServerDispatch, (index, n, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribs4dvNV(GLuint index, GLsizei n, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribs4dvNV) + safe_mul(n, 32);
   struct marshal_cmd_VertexAttribs4dvNV *cmd;
   debug_print_marshal("VertexAttribs4dvNV");
   if (unlikely(safe_mul(n, 32) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribs4dvNV, cmd_size);
      cmd->index = index;
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, v, n * 32);
      variable_data += n * 32;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribs4dvNV");
   CALL_VertexAttribs4dvNV(ctx->CurrentServerDispatch, (index, n, v));
}


/* Uniform2i64vARB: marshalled asynchronously */
struct marshal_cmd_Uniform2i64vARB
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 16) bytes are GLint64 value[count][2] */
};
static inline void
_mesa_unmarshal_Uniform2i64vARB(struct gl_context *ctx, const struct marshal_cmd_Uniform2i64vARB *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLint64 * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLint64 *) variable_data;
   variable_data += count * 16;
   CALL_Uniform2i64vARB(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform2i64vARB(GLint location, GLsizei count, const GLint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform2i64vARB) + safe_mul(count, 16);
   struct marshal_cmd_Uniform2i64vARB *cmd;
   debug_print_marshal("Uniform2i64vARB");
   if (unlikely(safe_mul(count, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform2i64vARB, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 16);
      variable_data += count * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform2i64vARB");
   CALL_Uniform2i64vARB(ctx->CurrentServerDispatch, (location, count, value));
}


/* GetMultisamplefv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetMultisamplefv(GLenum pname, GLuint index, GLfloat * val)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetMultisamplefv");
   CALL_GetMultisamplefv(ctx->CurrentServerDispatch, (pname, index, val));
}


/* GetActiveSubroutineUniformName: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei * length, GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetActiveSubroutineUniformName");
   CALL_GetActiveSubroutineUniformName(ctx->CurrentServerDispatch, (program, shadertype, index, bufsize, length, name));
}


/* Rectdv: marshalled asynchronously */
struct marshal_cmd_Rectdv
{
   struct marshal_cmd_base cmd_base;
   GLdouble v1[2];
   GLdouble v2[2];
};
static inline void
_mesa_unmarshal_Rectdv(struct gl_context *ctx, const struct marshal_cmd_Rectdv *cmd)
{
   const GLdouble * v1 = cmd->v1;
   const GLdouble * v2 = cmd->v2;
   CALL_Rectdv(ctx->CurrentServerDispatch, (v1, v2));
}
static void GLAPIENTRY
_mesa_marshal_Rectdv(const GLdouble * v1, const GLdouble * v2)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Rectdv);
   struct marshal_cmd_Rectdv *cmd;
   debug_print_marshal("Rectdv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Rectdv, cmd_size);
      memcpy(cmd->v1, v1, 16);
      memcpy(cmd->v2, v2, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Rectdv");
   CALL_Rectdv(ctx->CurrentServerDispatch, (v1, v2));
}


/* DrawArraysInstancedARB: marshalled asynchronously */
struct marshal_cmd_DrawArraysInstancedARB
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLint first;
   GLsizei count;
   GLsizei primcount;
};
static inline void
_mesa_unmarshal_DrawArraysInstancedARB(struct gl_context *ctx, const struct marshal_cmd_DrawArraysInstancedARB *cmd)
{
   const GLenum mode = cmd->mode;
   const GLint first = cmd->first;
   const GLsizei count = cmd->count;
   const GLsizei primcount = cmd->primcount;
   CALL_DrawArraysInstancedARB(ctx->CurrentServerDispatch, (mode, first, count, primcount));
}
static void GLAPIENTRY
_mesa_marshal_DrawArraysInstancedARB(GLenum mode, GLint first, GLsizei count, GLsizei primcount)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawArraysInstancedARB);
   struct marshal_cmd_DrawArraysInstancedARB *cmd;
   debug_print_marshal("DrawArraysInstancedARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawArraysInstancedARB, cmd_size);
      cmd->mode = mode;
      cmd->first = first;
      cmd->count = count;
      cmd->primcount = primcount;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawArraysInstancedARB");
   CALL_DrawArraysInstancedARB(ctx->CurrentServerDispatch, (mode, first, count, primcount));
}


/* MakeImageHandleNonResidentARB: marshalled asynchronously */
struct marshal_cmd_MakeImageHandleNonResidentARB
{
   struct marshal_cmd_base cmd_base;
   GLuint64 handle;
};
static inline void
_mesa_unmarshal_MakeImageHandleNonResidentARB(struct gl_context *ctx, const struct marshal_cmd_MakeImageHandleNonResidentARB *cmd)
{
   const GLuint64 handle = cmd->handle;
   CALL_MakeImageHandleNonResidentARB(ctx->CurrentServerDispatch, (handle));
}
static void GLAPIENTRY
_mesa_marshal_MakeImageHandleNonResidentARB(GLuint64 handle)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MakeImageHandleNonResidentARB);
   struct marshal_cmd_MakeImageHandleNonResidentARB *cmd;
   debug_print_marshal("MakeImageHandleNonResidentARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MakeImageHandleNonResidentARB, cmd_size);
      cmd->handle = handle;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MakeImageHandleNonResidentARB");
   CALL_MakeImageHandleNonResidentARB(ctx->CurrentServerDispatch, (handle));
}


/* ImportMemoryFdEXT: marshalled asynchronously */
struct marshal_cmd_ImportMemoryFdEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint memory;
   GLuint64 size;
   GLenum handleType;
   GLint fd;
};
static inline void
_mesa_unmarshal_ImportMemoryFdEXT(struct gl_context *ctx, const struct marshal_cmd_ImportMemoryFdEXT *cmd)
{
   const GLuint memory = cmd->memory;
   const GLuint64 size = cmd->size;
   const GLenum handleType = cmd->handleType;
   const GLint fd = cmd->fd;
   CALL_ImportMemoryFdEXT(ctx->CurrentServerDispatch, (memory, size, handleType, fd));
}
static void GLAPIENTRY
_mesa_marshal_ImportMemoryFdEXT(GLuint memory, GLuint64 size, GLenum handleType, GLint fd)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ImportMemoryFdEXT);
   struct marshal_cmd_ImportMemoryFdEXT *cmd;
   debug_print_marshal("ImportMemoryFdEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ImportMemoryFdEXT, cmd_size);
      cmd->memory = memory;
      cmd->size = size;
      cmd->handleType = handleType;
      cmd->fd = fd;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ImportMemoryFdEXT");
   CALL_ImportMemoryFdEXT(ctx->CurrentServerDispatch, (memory, size, handleType, fd));
}


/* ProgramEnvParameters4fvEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, const GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ProgramEnvParameters4fvEXT");
   CALL_ProgramEnvParameters4fvEXT(ctx->CurrentServerDispatch, (target, index, count, params));
}


/* TexStorageMem1DEXT: marshalled asynchronously */
struct marshal_cmd_TexStorageMem1DEXT
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei levels;
   GLenum internalFormat;
   GLsizei width;
   GLuint memory;
   GLuint64 offset;
};
static inline void
_mesa_unmarshal_TexStorageMem1DEXT(struct gl_context *ctx, const struct marshal_cmd_TexStorageMem1DEXT *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei levels = cmd->levels;
   const GLenum internalFormat = cmd->internalFormat;
   const GLsizei width = cmd->width;
   const GLuint memory = cmd->memory;
   const GLuint64 offset = cmd->offset;
   CALL_TexStorageMem1DEXT(ctx->CurrentServerDispatch, (target, levels, internalFormat, width, memory, offset));
}
static void GLAPIENTRY
_mesa_marshal_TexStorageMem1DEXT(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLuint memory, GLuint64 offset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexStorageMem1DEXT);
   struct marshal_cmd_TexStorageMem1DEXT *cmd;
   debug_print_marshal("TexStorageMem1DEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexStorageMem1DEXT, cmd_size);
      cmd->target = target;
      cmd->levels = levels;
      cmd->internalFormat = internalFormat;
      cmd->width = width;
      cmd->memory = memory;
      cmd->offset = offset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexStorageMem1DEXT");
   CALL_TexStorageMem1DEXT(ctx->CurrentServerDispatch, (target, levels, internalFormat, width, memory, offset));
}


/* BlendBarrier: marshalled asynchronously */
struct marshal_cmd_BlendBarrier
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_BlendBarrier(struct gl_context *ctx, const struct marshal_cmd_BlendBarrier *cmd)
{
   CALL_BlendBarrier(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_BlendBarrier(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BlendBarrier);
   struct marshal_cmd_BlendBarrier *cmd;
   debug_print_marshal("BlendBarrier");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BlendBarrier, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BlendBarrier");
   CALL_BlendBarrier(ctx->CurrentServerDispatch, ());
}


/* VertexAttrib2svNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib2svNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLshort v[2];
};
static inline void
_mesa_unmarshal_VertexAttrib2svNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib2svNV *cmd)
{
   const GLuint index = cmd->index;
   const GLshort * v = cmd->v;
   CALL_VertexAttrib2svNV(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib2svNV(GLuint index, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib2svNV);
   struct marshal_cmd_VertexAttrib2svNV *cmd;
   debug_print_marshal("VertexAttrib2svNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib2svNV, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib2svNV");
   CALL_VertexAttrib2svNV(ctx->CurrentServerDispatch, (index, v));
}


/* SecondaryColorP3uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_SecondaryColorP3uiv(GLenum type, const GLuint * color)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("SecondaryColorP3uiv");
   CALL_SecondaryColorP3uiv(ctx->CurrentServerDispatch, (type, color));
}


/* GetnPixelMapuivARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnPixelMapuivARB(GLenum map, GLsizei bufSize, GLuint * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnPixelMapuivARB");
   CALL_GetnPixelMapuivARB(ctx->CurrentServerDispatch, (map, bufSize, values));
}


/* GetSamplerParameterIuiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetSamplerParameterIuiv");
   CALL_GetSamplerParameterIuiv(ctx->CurrentServerDispatch, (sampler, pname, params));
}


/* Disablei: marshalled asynchronously */
struct marshal_cmd_Disablei
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint index;
};
static inline void
_mesa_unmarshal_Disablei(struct gl_context *ctx, const struct marshal_cmd_Disablei *cmd)
{
   const GLenum target = cmd->target;
   const GLuint index = cmd->index;
   CALL_Disablei(ctx->CurrentServerDispatch, (target, index));
}
static void GLAPIENTRY
_mesa_marshal_Disablei(GLenum target, GLuint index)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Disablei);
   struct marshal_cmd_Disablei *cmd;
   debug_print_marshal("Disablei");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Disablei, cmd_size);
      cmd->target = target;
      cmd->index = index;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Disablei");
   CALL_Disablei(ctx->CurrentServerDispatch, (target, index));
}


/* CompressedTexSubImage3D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CompressedTexSubImage3D");
   CALL_CompressedTexSubImage3D(ctx->CurrentServerDispatch, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data));
}


/* WindowPos4svMESA: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_WindowPos4svMESA(const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("WindowPos4svMESA");
   CALL_WindowPos4svMESA(ctx->CurrentServerDispatch, (v));
}


/* ObjectLabel: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar * label)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ObjectLabel");
   CALL_ObjectLabel(ctx->CurrentServerDispatch, (identifier, name, length, label));
}


/* Color3dv: marshalled asynchronously */
struct marshal_cmd_Color3dv
{
   struct marshal_cmd_base cmd_base;
   GLdouble v[3];
};
static inline void
_mesa_unmarshal_Color3dv(struct gl_context *ctx, const struct marshal_cmd_Color3dv *cmd)
{
   const GLdouble * v = cmd->v;
   CALL_Color3dv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Color3dv(const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color3dv);
   struct marshal_cmd_Color3dv *cmd;
   debug_print_marshal("Color3dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color3dv, cmd_size);
      memcpy(cmd->v, v, 24);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color3dv");
   CALL_Color3dv(ctx->CurrentServerDispatch, (v));
}


/* ProgramUniform1ui64ARB: marshalled asynchronously */
struct marshal_cmd_ProgramUniform1ui64ARB
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLuint64 x;
};
static inline void
_mesa_unmarshal_ProgramUniform1ui64ARB(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform1ui64ARB *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLuint64 x = cmd->x;
   CALL_ProgramUniform1ui64ARB(ctx->CurrentServerDispatch, (program, location, x));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform1ui64ARB(GLuint program, GLint location, GLuint64 x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform1ui64ARB);
   struct marshal_cmd_ProgramUniform1ui64ARB *cmd;
   debug_print_marshal("ProgramUniform1ui64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform1ui64ARB, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform1ui64ARB");
   CALL_ProgramUniform1ui64ARB(ctx->CurrentServerDispatch, (program, location, x));
}


/* BeginQuery: marshalled asynchronously */
struct marshal_cmd_BeginQuery
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint id;
};
static inline void
_mesa_unmarshal_BeginQuery(struct gl_context *ctx, const struct marshal_cmd_BeginQuery *cmd)
{
   const GLenum target = cmd->target;
   const GLuint id = cmd->id;
   CALL_BeginQuery(ctx->CurrentServerDispatch, (target, id));
}
static void GLAPIENTRY
_mesa_marshal_BeginQuery(GLenum target, GLuint id)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BeginQuery);
   struct marshal_cmd_BeginQuery *cmd;
   debug_print_marshal("BeginQuery");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BeginQuery, cmd_size);
      cmd->target = target;
      cmd->id = id;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BeginQuery");
   CALL_BeginQuery(ctx->CurrentServerDispatch, (target, id));
}


/* VertexP3uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexP3uiv(GLenum type, const GLuint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexP3uiv");
   CALL_VertexP3uiv(ctx->CurrentServerDispatch, (type, value));
}


/* GetUniformLocation: marshalled synchronously */
static GLint GLAPIENTRY
_mesa_marshal_GetUniformLocation(GLuint program, const GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetUniformLocation");
   return CALL_GetUniformLocation(ctx->CurrentServerDispatch, (program, name));
}


/* PixelStoref: marshalled asynchronously */
struct marshal_cmd_PixelStoref
{
   struct marshal_cmd_base cmd_base;
   GLenum pname;
   GLfloat param;
};
static inline void
_mesa_unmarshal_PixelStoref(struct gl_context *ctx, const struct marshal_cmd_PixelStoref *cmd)
{
   const GLenum pname = cmd->pname;
   const GLfloat param = cmd->param;
   CALL_PixelStoref(ctx->CurrentServerDispatch, (pname, param));
}
static void GLAPIENTRY
_mesa_marshal_PixelStoref(GLenum pname, GLfloat param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PixelStoref);
   struct marshal_cmd_PixelStoref *cmd;
   debug_print_marshal("PixelStoref");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PixelStoref, cmd_size);
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PixelStoref");
   CALL_PixelStoref(ctx->CurrentServerDispatch, (pname, param));
}


/* WindowPos2iv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_WindowPos2iv(const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("WindowPos2iv");
   CALL_WindowPos2iv(ctx->CurrentServerDispatch, (v));
}


/* PixelStorei: marshalled asynchronously */
struct marshal_cmd_PixelStorei
{
   struct marshal_cmd_base cmd_base;
   GLenum pname;
   GLint param;
};
static inline void
_mesa_unmarshal_PixelStorei(struct gl_context *ctx, const struct marshal_cmd_PixelStorei *cmd)
{
   const GLenum pname = cmd->pname;
   const GLint param = cmd->param;
   CALL_PixelStorei(ctx->CurrentServerDispatch, (pname, param));
}
static void GLAPIENTRY
_mesa_marshal_PixelStorei(GLenum pname, GLint param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PixelStorei);
   struct marshal_cmd_PixelStorei *cmd;
   debug_print_marshal("PixelStorei");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PixelStorei, cmd_size);
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PixelStorei");
   CALL_PixelStorei(ctx->CurrentServerDispatch, (pname, param));
}


/* VertexAttribs1svNV: marshalled asynchronously */
struct marshal_cmd_VertexAttribs1svNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLsizei n;
   /* Next safe_mul(n, 2) bytes are GLshort v[n] */
};
static inline void
_mesa_unmarshal_VertexAttribs1svNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttribs1svNV *cmd)
{
   const GLuint index = cmd->index;
   const GLsizei n = cmd->n;
   const GLshort * v;
   const char *variable_data = (const char *) (cmd + 1);
   v = (const GLshort *) variable_data;
   variable_data += n * 2;
   CALL_VertexAttribs1svNV(ctx->CurrentServerDispatch, (index, n, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribs1svNV(GLuint index, GLsizei n, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribs1svNV) + safe_mul(n, 2);
   struct marshal_cmd_VertexAttribs1svNV *cmd;
   debug_print_marshal("VertexAttribs1svNV");
   if (unlikely(safe_mul(n, 2) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribs1svNV, cmd_size);
      cmd->index = index;
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, v, n * 2);
      variable_data += n * 2;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribs1svNV");
   CALL_VertexAttribs1svNV(ctx->CurrentServerDispatch, (index, n, v));
}


/* CheckNamedFramebufferStatus: marshalled synchronously */
static GLenum GLAPIENTRY
_mesa_marshal_CheckNamedFramebufferStatus(GLuint framebuffer, GLenum target)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CheckNamedFramebufferStatus");
   return CALL_CheckNamedFramebufferStatus(ctx->CurrentServerDispatch, (framebuffer, target));
}


/* UniformSubroutinesuiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_UniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint * indices)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("UniformSubroutinesuiv");
   CALL_UniformSubroutinesuiv(ctx->CurrentServerDispatch, (shadertype, count, indices));
}


/* CheckFramebufferStatus: marshalled synchronously */
static GLenum GLAPIENTRY
_mesa_marshal_CheckFramebufferStatus(GLenum target)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CheckFramebufferStatus");
   return CALL_CheckFramebufferStatus(ctx->CurrentServerDispatch, (target));
}


/* DispatchComputeIndirect: marshalled asynchronously */
struct marshal_cmd_DispatchComputeIndirect
{
   struct marshal_cmd_base cmd_base;
   GLintptr indirect;
};
static inline void
_mesa_unmarshal_DispatchComputeIndirect(struct gl_context *ctx, const struct marshal_cmd_DispatchComputeIndirect *cmd)
{
   const GLintptr indirect = cmd->indirect;
   CALL_DispatchComputeIndirect(ctx->CurrentServerDispatch, (indirect));
}
static void GLAPIENTRY
_mesa_marshal_DispatchComputeIndirect(GLintptr indirect)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DispatchComputeIndirect);
   struct marshal_cmd_DispatchComputeIndirect *cmd;
   debug_print_marshal("DispatchComputeIndirect");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DispatchComputeIndirect, cmd_size);
      cmd->indirect = indirect;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DispatchComputeIndirect");
   CALL_DispatchComputeIndirect(ctx->CurrentServerDispatch, (indirect));
}


/* InvalidateBufferData: marshalled asynchronously */
struct marshal_cmd_InvalidateBufferData
{
   struct marshal_cmd_base cmd_base;
   GLuint buffer;
};
static inline void
_mesa_unmarshal_InvalidateBufferData(struct gl_context *ctx, const struct marshal_cmd_InvalidateBufferData *cmd)
{
   const GLuint buffer = cmd->buffer;
   CALL_InvalidateBufferData(ctx->CurrentServerDispatch, (buffer));
}
static void GLAPIENTRY
_mesa_marshal_InvalidateBufferData(GLuint buffer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_InvalidateBufferData);
   struct marshal_cmd_InvalidateBufferData *cmd;
   debug_print_marshal("InvalidateBufferData");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_InvalidateBufferData, cmd_size);
      cmd->buffer = buffer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("InvalidateBufferData");
   CALL_InvalidateBufferData(ctx->CurrentServerDispatch, (buffer));
}


/* GetUniformdv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetUniformdv(GLuint program, GLint location, GLdouble * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetUniformdv");
   CALL_GetUniformdv(ctx->CurrentServerDispatch, (program, location, params));
}


/* ProgramLocalParameters4fvEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, const GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ProgramLocalParameters4fvEXT");
   CALL_ProgramLocalParameters4fvEXT(ctx->CurrentServerDispatch, (target, index, count, params));
}


/* VertexAttribL1dv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribL1dv(GLuint index, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribL1dv");
   CALL_VertexAttribL1dv(ctx->CurrentServerDispatch, (index, v));
}


/* Uniform1ui64vARB: marshalled asynchronously */
struct marshal_cmd_Uniform1ui64vARB
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 8) bytes are GLuint64 value[count] */
};
static inline void
_mesa_unmarshal_Uniform1ui64vARB(struct gl_context *ctx, const struct marshal_cmd_Uniform1ui64vARB *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLuint64 * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLuint64 *) variable_data;
   variable_data += count * 8;
   CALL_Uniform1ui64vARB(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform1ui64vARB(GLint location, GLsizei count, const GLuint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform1ui64vARB) + safe_mul(count, 8);
   struct marshal_cmd_Uniform1ui64vARB *cmd;
   debug_print_marshal("Uniform1ui64vARB");
   if (unlikely(safe_mul(count, 8) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform1ui64vARB, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 8);
      variable_data += count * 8;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform1ui64vARB");
   CALL_Uniform1ui64vARB(ctx->CurrentServerDispatch, (location, count, value));
}


/* IsFramebuffer: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsFramebuffer(GLuint framebuffer)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsFramebuffer");
   return CALL_IsFramebuffer(ctx->CurrentServerDispatch, (framebuffer));
}


/* GetDoublev: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetDoublev(GLenum pname, GLdouble * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetDoublev");
   CALL_GetDoublev(ctx->CurrentServerDispatch, (pname, params));
}


/* GetObjectLabel: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei * length, GLchar * label)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetObjectLabel");
   CALL_GetObjectLabel(ctx->CurrentServerDispatch, (identifier, name, bufSize, length, label));
}


/* ColorP3uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ColorP3uiv(GLenum type, const GLuint * color)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ColorP3uiv");
   CALL_ColorP3uiv(ctx->CurrentServerDispatch, (type, color));
}


/* GetTextureSubImage: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, GLvoid * pixels)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTextureSubImage");
   CALL_GetTextureSubImage(ctx->CurrentServerDispatch, (texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels));
}


/* VertexAttribI4ivEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribI4ivEXT(GLuint index, const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribI4ivEXT");
   CALL_VertexAttribI4ivEXT(ctx->CurrentServerDispatch, (index, v));
}


/* VertexAttrib1svNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib1svNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLshort v[1];
};
static inline void
_mesa_unmarshal_VertexAttrib1svNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib1svNV *cmd)
{
   const GLuint index = cmd->index;
   const GLshort * v = cmd->v;
   CALL_VertexAttrib1svNV(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib1svNV(GLuint index, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib1svNV);
   struct marshal_cmd_VertexAttrib1svNV *cmd;
   debug_print_marshal("VertexAttrib1svNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib1svNV, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 2);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib1svNV");
   CALL_VertexAttrib1svNV(ctx->CurrentServerDispatch, (index, v));
}


/* SecondaryColor3ubv: marshalled asynchronously */
struct marshal_cmd_SecondaryColor3ubv
{
   struct marshal_cmd_base cmd_base;
   GLubyte v[3];
};
static inline void
_mesa_unmarshal_SecondaryColor3ubv(struct gl_context *ctx, const struct marshal_cmd_SecondaryColor3ubv *cmd)
{
   const GLubyte * v = cmd->v;
   CALL_SecondaryColor3ubv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColor3ubv(const GLubyte * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColor3ubv);
   struct marshal_cmd_SecondaryColor3ubv *cmd;
   debug_print_marshal("SecondaryColor3ubv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColor3ubv, cmd_size);
      memcpy(cmd->v, v, 3);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColor3ubv");
   CALL_SecondaryColor3ubv(ctx->CurrentServerDispatch, (v));
}


/* GetDebugMessageLog: marshalled synchronously */
static GLuint GLAPIENTRY
_mesa_marshal_GetDebugMessageLog(GLuint count, GLsizei bufsize, GLenum * sources, GLenum * types, GLuint * ids, GLenum * severities, GLsizei * lengths, GLchar * messageLog)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetDebugMessageLog");
   return CALL_GetDebugMessageLog(ctx->CurrentServerDispatch, (count, bufsize, sources, types, ids, severities, lengths, messageLog));
}


/* Uniform4ui64ARB: marshalled asynchronously */
struct marshal_cmd_Uniform4ui64ARB
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLuint64 x;
   GLuint64 y;
   GLuint64 z;
   GLuint64 w;
};
static inline void
_mesa_unmarshal_Uniform4ui64ARB(struct gl_context *ctx, const struct marshal_cmd_Uniform4ui64ARB *cmd)
{
   const GLint location = cmd->location;
   const GLuint64 x = cmd->x;
   const GLuint64 y = cmd->y;
   const GLuint64 z = cmd->z;
   const GLuint64 w = cmd->w;
   CALL_Uniform4ui64ARB(ctx->CurrentServerDispatch, (location, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_Uniform4ui64ARB(GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform4ui64ARB);
   struct marshal_cmd_Uniform4ui64ARB *cmd;
   debug_print_marshal("Uniform4ui64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform4ui64ARB, cmd_size);
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform4ui64ARB");
   CALL_Uniform4ui64ARB(ctx->CurrentServerDispatch, (location, x, y, z, w));
}


/* RasterPos3fv: marshalled asynchronously */
struct marshal_cmd_RasterPos3fv
{
   struct marshal_cmd_base cmd_base;
   GLfloat v[3];
};
static inline void
_mesa_unmarshal_RasterPos3fv(struct gl_context *ctx, const struct marshal_cmd_RasterPos3fv *cmd)
{
   const GLfloat * v = cmd->v;
   CALL_RasterPos3fv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos3fv(const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos3fv);
   struct marshal_cmd_RasterPos3fv *cmd;
   debug_print_marshal("RasterPos3fv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos3fv, cmd_size);
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos3fv");
   CALL_RasterPos3fv(ctx->CurrentServerDispatch, (v));
}


/* GetShaderSource: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetShaderSource");
   CALL_GetShaderSource(ctx->CurrentServerDispatch, (shader, bufSize, length, source));
}


/* BindProgramARB: marshalled asynchronously */
struct marshal_cmd_BindProgramARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint program;
};
static inline void
_mesa_unmarshal_BindProgramARB(struct gl_context *ctx, const struct marshal_cmd_BindProgramARB *cmd)
{
   const GLenum target = cmd->target;
   const GLuint program = cmd->program;
   CALL_BindProgramARB(ctx->CurrentServerDispatch, (target, program));
}
static void GLAPIENTRY
_mesa_marshal_BindProgramARB(GLenum target, GLuint program)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BindProgramARB);
   struct marshal_cmd_BindProgramARB *cmd;
   debug_print_marshal("BindProgramARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BindProgramARB, cmd_size);
      cmd->target = target;
      cmd->program = program;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BindProgramARB");
   CALL_BindProgramARB(ctx->CurrentServerDispatch, (target, program));
}


/* VertexAttrib3sNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib3sNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLshort x;
   GLshort y;
   GLshort z;
};
static inline void
_mesa_unmarshal_VertexAttrib3sNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib3sNV *cmd)
{
   const GLuint index = cmd->index;
   const GLshort x = cmd->x;
   const GLshort y = cmd->y;
   const GLshort z = cmd->z;
   CALL_VertexAttrib3sNV(ctx->CurrentServerDispatch, (index, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib3sNV);
   struct marshal_cmd_VertexAttrib3sNV *cmd;
   debug_print_marshal("VertexAttrib3sNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib3sNV, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib3sNV");
   CALL_VertexAttrib3sNV(ctx->CurrentServerDispatch, (index, x, y, z));
}


/* ColorFragmentOp1ATI: marshalled asynchronously */
struct marshal_cmd_ColorFragmentOp1ATI
{
   struct marshal_cmd_base cmd_base;
   GLenum op;
   GLuint dst;
   GLuint dstMask;
   GLuint dstMod;
   GLuint arg1;
   GLuint arg1Rep;
   GLuint arg1Mod;
};
static inline void
_mesa_unmarshal_ColorFragmentOp1ATI(struct gl_context *ctx, const struct marshal_cmd_ColorFragmentOp1ATI *cmd)
{
   const GLenum op = cmd->op;
   const GLuint dst = cmd->dst;
   const GLuint dstMask = cmd->dstMask;
   const GLuint dstMod = cmd->dstMod;
   const GLuint arg1 = cmd->arg1;
   const GLuint arg1Rep = cmd->arg1Rep;
   const GLuint arg1Mod = cmd->arg1Mod;
   CALL_ColorFragmentOp1ATI(ctx->CurrentServerDispatch, (op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod));
}
static void GLAPIENTRY
_mesa_marshal_ColorFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ColorFragmentOp1ATI);
   struct marshal_cmd_ColorFragmentOp1ATI *cmd;
   debug_print_marshal("ColorFragmentOp1ATI");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ColorFragmentOp1ATI, cmd_size);
      cmd->op = op;
      cmd->dst = dst;
      cmd->dstMask = dstMask;
      cmd->dstMod = dstMod;
      cmd->arg1 = arg1;
      cmd->arg1Rep = arg1Rep;
      cmd->arg1Mod = arg1Mod;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ColorFragmentOp1ATI");
   CALL_ColorFragmentOp1ATI(ctx->CurrentServerDispatch, (op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod));
}


/* ProgramUniformMatrix4x3fv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix4x3fv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 48) bytes are GLfloat value[count][12] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix4x3fv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix4x3fv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 48;
   CALL_ProgramUniformMatrix4x3fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix4x3fv) + safe_mul(count, 48);
   struct marshal_cmd_ProgramUniformMatrix4x3fv *cmd;
   debug_print_marshal("ProgramUniformMatrix4x3fv");
   if (unlikely(safe_mul(count, 48) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix4x3fv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 48);
      variable_data += count * 48;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix4x3fv");
   CALL_ProgramUniformMatrix4x3fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* PopClientAttrib: marshalled asynchronously */
struct marshal_cmd_PopClientAttrib
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_PopClientAttrib(struct gl_context *ctx, const struct marshal_cmd_PopClientAttrib *cmd)
{
   CALL_PopClientAttrib(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_PopClientAttrib(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PopClientAttrib);
   struct marshal_cmd_PopClientAttrib *cmd;
   debug_print_marshal("PopClientAttrib");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PopClientAttrib, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PopClientAttrib");
   CALL_PopClientAttrib(ctx->CurrentServerDispatch, ());
}


/* DrawElementsInstancedARB: marshalled asynchronously */
struct marshal_cmd_DrawElementsInstancedARB
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLsizei count;
   GLenum type;
   const GLvoid * indices;
   GLsizei primcount;
};
static inline void
_mesa_unmarshal_DrawElementsInstancedARB(struct gl_context *ctx, const struct marshal_cmd_DrawElementsInstancedARB *cmd)
{
   const GLenum mode = cmd->mode;
   const GLsizei count = cmd->count;
   const GLenum type = cmd->type;
   const GLvoid * indices = cmd->indices;
   const GLsizei primcount = cmd->primcount;
   CALL_DrawElementsInstancedARB(ctx->CurrentServerDispatch, (mode, count, type, indices, primcount));
}
static void GLAPIENTRY
_mesa_marshal_DrawElementsInstancedARB(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei primcount)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawElementsInstancedARB);
   struct marshal_cmd_DrawElementsInstancedARB *cmd;
   debug_print_marshal("DrawElementsInstancedARB");
   if (_mesa_glthread_is_non_vbo_draw_elements(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("DrawElementsInstancedARB");
      CALL_DrawElementsInstancedARB(ctx->CurrentServerDispatch, (mode, count, type, indices, primcount));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawElementsInstancedARB, cmd_size);
      cmd->mode = mode;
      cmd->count = count;
      cmd->type = type;
      cmd->indices = indices;
      cmd->primcount = primcount;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawElementsInstancedARB");
   CALL_DrawElementsInstancedARB(ctx->CurrentServerDispatch, (mode, count, type, indices, primcount));
}


/* GetQueryObjectuiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetQueryObjectuiv(GLuint id, GLenum pname, GLuint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetQueryObjectuiv");
   CALL_GetQueryObjectuiv(ctx->CurrentServerDispatch, (id, pname, params));
}


/* VertexAttribI4bv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribI4bv(GLuint index, const GLbyte * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribI4bv");
   CALL_VertexAttribI4bv(ctx->CurrentServerDispatch, (index, v));
}


/* DisableVertexArrayAttrib: marshalled asynchronously */
struct marshal_cmd_DisableVertexArrayAttrib
{
   struct marshal_cmd_base cmd_base;
   GLuint vaobj;
   GLuint index;
};
static inline void
_mesa_unmarshal_DisableVertexArrayAttrib(struct gl_context *ctx, const struct marshal_cmd_DisableVertexArrayAttrib *cmd)
{
   const GLuint vaobj = cmd->vaobj;
   const GLuint index = cmd->index;
   CALL_DisableVertexArrayAttrib(ctx->CurrentServerDispatch, (vaobj, index));
}
static void GLAPIENTRY
_mesa_marshal_DisableVertexArrayAttrib(GLuint vaobj, GLuint index)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DisableVertexArrayAttrib);
   struct marshal_cmd_DisableVertexArrayAttrib *cmd;
   debug_print_marshal("DisableVertexArrayAttrib");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DisableVertexArrayAttrib, cmd_size);
      cmd->vaobj = vaobj;
      cmd->index = index;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DisableVertexArrayAttrib");
   CALL_DisableVertexArrayAttrib(ctx->CurrentServerDispatch, (vaobj, index));
}


/* VertexAttribL4d: marshalled asynchronously */
struct marshal_cmd_VertexAttribL4d
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble x;
   GLdouble y;
   GLdouble z;
   GLdouble w;
};
static inline void
_mesa_unmarshal_VertexAttribL4d(struct gl_context *ctx, const struct marshal_cmd_VertexAttribL4d *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   const GLdouble w = cmd->w;
   CALL_VertexAttribL4d(ctx->CurrentServerDispatch, (index, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribL4d);
   struct marshal_cmd_VertexAttribL4d *cmd;
   debug_print_marshal("VertexAttribL4d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribL4d, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribL4d");
   CALL_VertexAttribL4d(ctx->CurrentServerDispatch, (index, x, y, z, w));
}


/* ListBase: marshalled asynchronously */
struct marshal_cmd_ListBase
{
   struct marshal_cmd_base cmd_base;
   GLuint base;
};
static inline void
_mesa_unmarshal_ListBase(struct gl_context *ctx, const struct marshal_cmd_ListBase *cmd)
{
   const GLuint base = cmd->base;
   CALL_ListBase(ctx->CurrentServerDispatch, (base));
}
static void GLAPIENTRY
_mesa_marshal_ListBase(GLuint base)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ListBase);
   struct marshal_cmd_ListBase *cmd;
   debug_print_marshal("ListBase");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ListBase, cmd_size);
      cmd->base = base;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ListBase");
   CALL_ListBase(ctx->CurrentServerDispatch, (base));
}


/* GenerateMipmap: marshalled asynchronously */
struct marshal_cmd_GenerateMipmap
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
};
static inline void
_mesa_unmarshal_GenerateMipmap(struct gl_context *ctx, const struct marshal_cmd_GenerateMipmap *cmd)
{
   const GLenum target = cmd->target;
   CALL_GenerateMipmap(ctx->CurrentServerDispatch, (target));
}
static void GLAPIENTRY
_mesa_marshal_GenerateMipmap(GLenum target)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_GenerateMipmap);
   struct marshal_cmd_GenerateMipmap *cmd;
   debug_print_marshal("GenerateMipmap");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_GenerateMipmap, cmd_size);
      cmd->target = target;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("GenerateMipmap");
   CALL_GenerateMipmap(ctx->CurrentServerDispatch, (target));
}


/* BindBufferRange: marshalled asynchronously */
struct marshal_cmd_BindBufferRange
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint index;
   GLuint buffer;
   GLintptr offset;
   GLsizeiptr size;
};
static inline void
_mesa_unmarshal_BindBufferRange(struct gl_context *ctx, const struct marshal_cmd_BindBufferRange *cmd)
{
   const GLenum target = cmd->target;
   const GLuint index = cmd->index;
   const GLuint buffer = cmd->buffer;
   const GLintptr offset = cmd->offset;
   const GLsizeiptr size = cmd->size;
   CALL_BindBufferRange(ctx->CurrentServerDispatch, (target, index, buffer, offset, size));
}
static void GLAPIENTRY
_mesa_marshal_BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BindBufferRange);
   struct marshal_cmd_BindBufferRange *cmd;
   debug_print_marshal("BindBufferRange");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BindBufferRange, cmd_size);
      cmd->target = target;
      cmd->index = index;
      cmd->buffer = buffer;
      cmd->offset = offset;
      cmd->size = size;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BindBufferRange");
   CALL_BindBufferRange(ctx->CurrentServerDispatch, (target, index, buffer, offset, size));
}


/* ProgramUniformMatrix2x4fv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix2x4fv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 32) bytes are GLfloat value[count][8] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix2x4fv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix2x4fv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 32;
   CALL_ProgramUniformMatrix2x4fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix2x4fv) + safe_mul(count, 32);
   struct marshal_cmd_ProgramUniformMatrix2x4fv *cmd;
   debug_print_marshal("ProgramUniformMatrix2x4fv");
   if (unlikely(safe_mul(count, 32) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix2x4fv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 32);
      variable_data += count * 32;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix2x4fv");
   CALL_ProgramUniformMatrix2x4fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* BindBufferBase: marshalled asynchronously */
struct marshal_cmd_BindBufferBase
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint index;
   GLuint buffer;
};
static inline void
_mesa_unmarshal_BindBufferBase(struct gl_context *ctx, const struct marshal_cmd_BindBufferBase *cmd)
{
   const GLenum target = cmd->target;
   const GLuint index = cmd->index;
   const GLuint buffer = cmd->buffer;
   CALL_BindBufferBase(ctx->CurrentServerDispatch, (target, index, buffer));
}
static void GLAPIENTRY
_mesa_marshal_BindBufferBase(GLenum target, GLuint index, GLuint buffer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BindBufferBase);
   struct marshal_cmd_BindBufferBase *cmd;
   debug_print_marshal("BindBufferBase");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BindBufferBase, cmd_size);
      cmd->target = target;
      cmd->index = index;
      cmd->buffer = buffer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BindBufferBase");
   CALL_BindBufferBase(ctx->CurrentServerDispatch, (target, index, buffer));
}


/* GetQueryObjectiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetQueryObjectiv(GLuint id, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetQueryObjectiv");
   CALL_GetQueryObjectiv(ctx->CurrentServerDispatch, (id, pname, params));
}


/* VertexAttrib2s: marshalled asynchronously */
struct marshal_cmd_VertexAttrib2s
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLshort x;
   GLshort y;
};
static inline void
_mesa_unmarshal_VertexAttrib2s(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib2s *cmd)
{
   const GLuint index = cmd->index;
   const GLshort x = cmd->x;
   const GLshort y = cmd->y;
   CALL_VertexAttrib2s(ctx->CurrentServerDispatch, (index, x, y));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib2s(GLuint index, GLshort x, GLshort y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib2s);
   struct marshal_cmd_VertexAttrib2s *cmd;
   debug_print_marshal("VertexAttrib2s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib2s, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib2s");
   CALL_VertexAttrib2s(ctx->CurrentServerDispatch, (index, x, y));
}


/* SecondaryColor3fvEXT: marshalled asynchronously */
struct marshal_cmd_SecondaryColor3fvEXT
{
   struct marshal_cmd_base cmd_base;
   GLfloat v[3];
};
static inline void
_mesa_unmarshal_SecondaryColor3fvEXT(struct gl_context *ctx, const struct marshal_cmd_SecondaryColor3fvEXT *cmd)
{
   const GLfloat * v = cmd->v;
   CALL_SecondaryColor3fvEXT(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColor3fvEXT(const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColor3fvEXT);
   struct marshal_cmd_SecondaryColor3fvEXT *cmd;
   debug_print_marshal("SecondaryColor3fvEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColor3fvEXT, cmd_size);
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColor3fvEXT");
   CALL_SecondaryColor3fvEXT(ctx->CurrentServerDispatch, (v));
}


/* VertexAttrib2d: marshalled asynchronously */
struct marshal_cmd_VertexAttrib2d
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble x;
   GLdouble y;
};
static inline void
_mesa_unmarshal_VertexAttrib2d(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib2d *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   CALL_VertexAttrib2d(ctx->CurrentServerDispatch, (index, x, y));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib2d);
   struct marshal_cmd_VertexAttrib2d *cmd;
   debug_print_marshal("VertexAttrib2d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib2d, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib2d");
   CALL_VertexAttrib2d(ctx->CurrentServerDispatch, (index, x, y));
}


/* ClearNamedFramebufferiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ClearNamedFramebufferiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ClearNamedFramebufferiv");
   CALL_ClearNamedFramebufferiv(ctx->CurrentServerDispatch, (framebuffer, buffer, drawbuffer, value));
}


/* Uniform1fv: marshalled asynchronously */
struct marshal_cmd_Uniform1fv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 4) bytes are GLfloat value[count] */
};
static inline void
_mesa_unmarshal_Uniform1fv(struct gl_context *ctx, const struct marshal_cmd_Uniform1fv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 4;
   CALL_Uniform1fv(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform1fv(GLint location, GLsizei count, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform1fv) + safe_mul(count, 4);
   struct marshal_cmd_Uniform1fv *cmd;
   debug_print_marshal("Uniform1fv");
   if (unlikely(safe_mul(count, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform1fv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 4);
      variable_data += count * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform1fv");
   CALL_Uniform1fv(ctx->CurrentServerDispatch, (location, count, value));
}


/* GetProgramPipelineInfoLog: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei * length, GLchar * infoLog)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramPipelineInfoLog");
   CALL_GetProgramPipelineInfoLog(ctx->CurrentServerDispatch, (pipeline, bufSize, length, infoLog));
}


/* DepthBoundsEXT: marshalled asynchronously */
struct marshal_cmd_DepthBoundsEXT
{
   struct marshal_cmd_base cmd_base;
   GLclampd zmin;
   GLclampd zmax;
};
static inline void
_mesa_unmarshal_DepthBoundsEXT(struct gl_context *ctx, const struct marshal_cmd_DepthBoundsEXT *cmd)
{
   const GLclampd zmin = cmd->zmin;
   const GLclampd zmax = cmd->zmax;
   CALL_DepthBoundsEXT(ctx->CurrentServerDispatch, (zmin, zmax));
}
static void GLAPIENTRY
_mesa_marshal_DepthBoundsEXT(GLclampd zmin, GLclampd zmax)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DepthBoundsEXT);
   struct marshal_cmd_DepthBoundsEXT *cmd;
   debug_print_marshal("DepthBoundsEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DepthBoundsEXT, cmd_size);
      cmd->zmin = zmin;
      cmd->zmax = zmax;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DepthBoundsEXT");
   CALL_DepthBoundsEXT(ctx->CurrentServerDispatch, (zmin, zmax));
}


/* BufferStorageMemEXT: marshalled asynchronously */
struct marshal_cmd_BufferStorageMemEXT
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizeiptr size;
   GLuint memory;
   GLuint64 offset;
};
static inline void
_mesa_unmarshal_BufferStorageMemEXT(struct gl_context *ctx, const struct marshal_cmd_BufferStorageMemEXT *cmd)
{
   const GLenum target = cmd->target;
   const GLsizeiptr size = cmd->size;
   const GLuint memory = cmd->memory;
   const GLuint64 offset = cmd->offset;
   CALL_BufferStorageMemEXT(ctx->CurrentServerDispatch, (target, size, memory, offset));
}
static void GLAPIENTRY
_mesa_marshal_BufferStorageMemEXT(GLenum target, GLsizeiptr size, GLuint memory, GLuint64 offset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BufferStorageMemEXT);
   struct marshal_cmd_BufferStorageMemEXT *cmd;
   debug_print_marshal("BufferStorageMemEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BufferStorageMemEXT, cmd_size);
      cmd->target = target;
      cmd->size = size;
      cmd->memory = memory;
      cmd->offset = offset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BufferStorageMemEXT");
   CALL_BufferStorageMemEXT(ctx->CurrentServerDispatch, (target, size, memory, offset));
}


/* WindowPos3fv: marshalled asynchronously */
struct marshal_cmd_WindowPos3fv
{
   struct marshal_cmd_base cmd_base;
   GLfloat v[3];
};
static inline void
_mesa_unmarshal_WindowPos3fv(struct gl_context *ctx, const struct marshal_cmd_WindowPos3fv *cmd)
{
   const GLfloat * v = cmd->v;
   CALL_WindowPos3fv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_WindowPos3fv(const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_WindowPos3fv);
   struct marshal_cmd_WindowPos3fv *cmd;
   debug_print_marshal("WindowPos3fv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_WindowPos3fv, cmd_size);
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("WindowPos3fv");
   CALL_WindowPos3fv(ctx->CurrentServerDispatch, (v));
}


/* GetHistogramParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetHistogramParameteriv(GLenum target, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetHistogramParameteriv");
   CALL_GetHistogramParameteriv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* PointParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_PointParameteriv(GLenum pname, const GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("PointParameteriv");
   CALL_PointParameteriv(ctx->CurrentServerDispatch, (pname, params));
}


/* NamedRenderbufferStorage: marshalled asynchronously */
struct marshal_cmd_NamedRenderbufferStorage
{
   struct marshal_cmd_base cmd_base;
   GLuint renderbuffer;
   GLenum internalformat;
   GLsizei width;
   GLsizei height;
};
static inline void
_mesa_unmarshal_NamedRenderbufferStorage(struct gl_context *ctx, const struct marshal_cmd_NamedRenderbufferStorage *cmd)
{
   const GLuint renderbuffer = cmd->renderbuffer;
   const GLenum internalformat = cmd->internalformat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   CALL_NamedRenderbufferStorage(ctx->CurrentServerDispatch, (renderbuffer, internalformat, width, height));
}
static void GLAPIENTRY
_mesa_marshal_NamedRenderbufferStorage(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_NamedRenderbufferStorage);
   struct marshal_cmd_NamedRenderbufferStorage *cmd;
   debug_print_marshal("NamedRenderbufferStorage");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_NamedRenderbufferStorage, cmd_size);
      cmd->renderbuffer = renderbuffer;
      cmd->internalformat = internalformat;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("NamedRenderbufferStorage");
   CALL_NamedRenderbufferStorage(ctx->CurrentServerDispatch, (renderbuffer, internalformat, width, height));
}


/* GetProgramivARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetProgramivARB(GLenum target, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramivARB");
   CALL_GetProgramivARB(ctx->CurrentServerDispatch, (target, pname, params));
}


/* BindRenderbuffer: marshalled asynchronously */
struct marshal_cmd_BindRenderbuffer
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint renderbuffer;
};
static inline void
_mesa_unmarshal_BindRenderbuffer(struct gl_context *ctx, const struct marshal_cmd_BindRenderbuffer *cmd)
{
   const GLenum target = cmd->target;
   const GLuint renderbuffer = cmd->renderbuffer;
   CALL_BindRenderbuffer(ctx->CurrentServerDispatch, (target, renderbuffer));
}
static void GLAPIENTRY
_mesa_marshal_BindRenderbuffer(GLenum target, GLuint renderbuffer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BindRenderbuffer);
   struct marshal_cmd_BindRenderbuffer *cmd;
   debug_print_marshal("BindRenderbuffer");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BindRenderbuffer, cmd_size);
      cmd->target = target;
      cmd->renderbuffer = renderbuffer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BindRenderbuffer");
   CALL_BindRenderbuffer(ctx->CurrentServerDispatch, (target, renderbuffer));
}


/* SecondaryColor3fEXT: marshalled asynchronously */
struct marshal_cmd_SecondaryColor3fEXT
{
   struct marshal_cmd_base cmd_base;
   GLfloat red;
   GLfloat green;
   GLfloat blue;
};
static inline void
_mesa_unmarshal_SecondaryColor3fEXT(struct gl_context *ctx, const struct marshal_cmd_SecondaryColor3fEXT *cmd)
{
   const GLfloat red = cmd->red;
   const GLfloat green = cmd->green;
   const GLfloat blue = cmd->blue;
   CALL_SecondaryColor3fEXT(ctx->CurrentServerDispatch, (red, green, blue));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColor3fEXT);
   struct marshal_cmd_SecondaryColor3fEXT *cmd;
   debug_print_marshal("SecondaryColor3fEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColor3fEXT, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColor3fEXT");
   CALL_SecondaryColor3fEXT(ctx->CurrentServerDispatch, (red, green, blue));
}


/* PrimitiveRestartIndex: marshalled asynchronously */
struct marshal_cmd_PrimitiveRestartIndex
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
};
static inline void
_mesa_unmarshal_PrimitiveRestartIndex(struct gl_context *ctx, const struct marshal_cmd_PrimitiveRestartIndex *cmd)
{
   const GLuint index = cmd->index;
   CALL_PrimitiveRestartIndex(ctx->CurrentServerDispatch, (index));
}
static void GLAPIENTRY
_mesa_marshal_PrimitiveRestartIndex(GLuint index)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PrimitiveRestartIndex);
   struct marshal_cmd_PrimitiveRestartIndex *cmd;
   debug_print_marshal("PrimitiveRestartIndex");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PrimitiveRestartIndex, cmd_size);
      cmd->index = index;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PrimitiveRestartIndex");
   CALL_PrimitiveRestartIndex(ctx->CurrentServerDispatch, (index));
}


/* TextureStorageMem3DEXT: marshalled asynchronously */
struct marshal_cmd_TextureStorageMem3DEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLsizei levels;
   GLenum internalFormat;
   GLsizei width;
   GLsizei height;
   GLsizei depth;
   GLuint memory;
   GLuint64 offset;
};
static inline void
_mesa_unmarshal_TextureStorageMem3DEXT(struct gl_context *ctx, const struct marshal_cmd_TextureStorageMem3DEXT *cmd)
{
   const GLuint texture = cmd->texture;
   const GLsizei levels = cmd->levels;
   const GLenum internalFormat = cmd->internalFormat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLsizei depth = cmd->depth;
   const GLuint memory = cmd->memory;
   const GLuint64 offset = cmd->offset;
   CALL_TextureStorageMem3DEXT(ctx->CurrentServerDispatch, (texture, levels, internalFormat, width, height, depth, memory, offset));
}
static void GLAPIENTRY
_mesa_marshal_TextureStorageMem3DEXT(GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureStorageMem3DEXT);
   struct marshal_cmd_TextureStorageMem3DEXT *cmd;
   debug_print_marshal("TextureStorageMem3DEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureStorageMem3DEXT, cmd_size);
      cmd->texture = texture;
      cmd->levels = levels;
      cmd->internalFormat = internalFormat;
      cmd->width = width;
      cmd->height = height;
      cmd->depth = depth;
      cmd->memory = memory;
      cmd->offset = offset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureStorageMem3DEXT");
   CALL_TextureStorageMem3DEXT(ctx->CurrentServerDispatch, (texture, levels, internalFormat, width, height, depth, memory, offset));
}


/* VertexAttribI4ubv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribI4ubv(GLuint index, const GLubyte * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribI4ubv");
   CALL_VertexAttribI4ubv(ctx->CurrentServerDispatch, (index, v));
}


/* GetGraphicsResetStatusARB: marshalled synchronously */
static GLenum GLAPIENTRY
_mesa_marshal_GetGraphicsResetStatusARB(void)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetGraphicsResetStatusARB");
   return CALL_GetGraphicsResetStatusARB(ctx->CurrentServerDispatch, ());
}


/* CreateRenderbuffers: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CreateRenderbuffers(GLsizei n, GLuint * renderbuffers)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CreateRenderbuffers");
   CALL_CreateRenderbuffers(ctx->CurrentServerDispatch, (n, renderbuffers));
}


/* ActiveStencilFaceEXT: marshalled asynchronously */
struct marshal_cmd_ActiveStencilFaceEXT
{
   struct marshal_cmd_base cmd_base;
   GLenum face;
};
static inline void
_mesa_unmarshal_ActiveStencilFaceEXT(struct gl_context *ctx, const struct marshal_cmd_ActiveStencilFaceEXT *cmd)
{
   const GLenum face = cmd->face;
   CALL_ActiveStencilFaceEXT(ctx->CurrentServerDispatch, (face));
}
static void GLAPIENTRY
_mesa_marshal_ActiveStencilFaceEXT(GLenum face)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ActiveStencilFaceEXT);
   struct marshal_cmd_ActiveStencilFaceEXT *cmd;
   debug_print_marshal("ActiveStencilFaceEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ActiveStencilFaceEXT, cmd_size);
      cmd->face = face;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ActiveStencilFaceEXT");
   CALL_ActiveStencilFaceEXT(ctx->CurrentServerDispatch, (face));
}


/* VertexAttrib4dNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4dNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble x;
   GLdouble y;
   GLdouble z;
   GLdouble w;
};
static inline void
_mesa_unmarshal_VertexAttrib4dNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4dNV *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   const GLdouble w = cmd->w;
   CALL_VertexAttrib4dNV(ctx->CurrentServerDispatch, (index, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4dNV);
   struct marshal_cmd_VertexAttrib4dNV *cmd;
   debug_print_marshal("VertexAttrib4dNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4dNV, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4dNV");
   CALL_VertexAttrib4dNV(ctx->CurrentServerDispatch, (index, x, y, z, w));
}


/* DepthRange: marshalled asynchronously */
struct marshal_cmd_DepthRange
{
   struct marshal_cmd_base cmd_base;
   GLclampd zNear;
   GLclampd zFar;
};
static inline void
_mesa_unmarshal_DepthRange(struct gl_context *ctx, const struct marshal_cmd_DepthRange *cmd)
{
   const GLclampd zNear = cmd->zNear;
   const GLclampd zFar = cmd->zFar;
   CALL_DepthRange(ctx->CurrentServerDispatch, (zNear, zFar));
}
static void GLAPIENTRY
_mesa_marshal_DepthRange(GLclampd zNear, GLclampd zFar)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DepthRange);
   struct marshal_cmd_DepthRange *cmd;
   debug_print_marshal("DepthRange");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DepthRange, cmd_size);
      cmd->zNear = zNear;
      cmd->zFar = zFar;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DepthRange");
   CALL_DepthRange(ctx->CurrentServerDispatch, (zNear, zFar));
}


/* VertexAttrib4fNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4fNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat x;
   GLfloat y;
   GLfloat z;
   GLfloat w;
};
static inline void
_mesa_unmarshal_VertexAttrib4fNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4fNV *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   const GLfloat w = cmd->w;
   CALL_VertexAttrib4fNV(ctx->CurrentServerDispatch, (index, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4fNV);
   struct marshal_cmd_VertexAttrib4fNV *cmd;
   debug_print_marshal("VertexAttrib4fNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4fNV, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4fNV");
   CALL_VertexAttrib4fNV(ctx->CurrentServerDispatch, (index, x, y, z, w));
}


/* Uniform4fv: marshalled asynchronously */
struct marshal_cmd_Uniform4fv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 16) bytes are GLfloat value[count][4] */
};
static inline void
_mesa_unmarshal_Uniform4fv(struct gl_context *ctx, const struct marshal_cmd_Uniform4fv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 16;
   CALL_Uniform4fv(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform4fv(GLint location, GLsizei count, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform4fv) + safe_mul(count, 16);
   struct marshal_cmd_Uniform4fv *cmd;
   debug_print_marshal("Uniform4fv");
   if (unlikely(safe_mul(count, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform4fv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 16);
      variable_data += count * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform4fv");
   CALL_Uniform4fv(ctx->CurrentServerDispatch, (location, count, value));
}


/* SamplerParameterIiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_SamplerParameterIiv(GLuint sampler, GLenum pname, const GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("SamplerParameterIiv");
   CALL_SamplerParameterIiv(ctx->CurrentServerDispatch, (sampler, pname, params));
}


/* Frustumf: marshalled asynchronously */
struct marshal_cmd_Frustumf
{
   struct marshal_cmd_base cmd_base;
   GLfloat left;
   GLfloat right;
   GLfloat bottom;
   GLfloat top;
   GLfloat zNear;
   GLfloat zFar;
};
static inline void
_mesa_unmarshal_Frustumf(struct gl_context *ctx, const struct marshal_cmd_Frustumf *cmd)
{
   const GLfloat left = cmd->left;
   const GLfloat right = cmd->right;
   const GLfloat bottom = cmd->bottom;
   const GLfloat top = cmd->top;
   const GLfloat zNear = cmd->zNear;
   const GLfloat zFar = cmd->zFar;
   CALL_Frustumf(ctx->CurrentServerDispatch, (left, right, bottom, top, zNear, zFar));
}
static void GLAPIENTRY
_mesa_marshal_Frustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Frustumf);
   struct marshal_cmd_Frustumf *cmd;
   debug_print_marshal("Frustumf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Frustumf, cmd_size);
      cmd->left = left;
      cmd->right = right;
      cmd->bottom = bottom;
      cmd->top = top;
      cmd->zNear = zNear;
      cmd->zFar = zFar;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Frustumf");
   CALL_Frustumf(ctx->CurrentServerDispatch, (left, right, bottom, top, zNear, zFar));
}


/* GetQueryBufferObjectui64v: marshalled asynchronously */
struct marshal_cmd_GetQueryBufferObjectui64v
{
   struct marshal_cmd_base cmd_base;
   GLuint id;
   GLuint buffer;
   GLenum pname;
   GLintptr offset;
};
static inline void
_mesa_unmarshal_GetQueryBufferObjectui64v(struct gl_context *ctx, const struct marshal_cmd_GetQueryBufferObjectui64v *cmd)
{
   const GLuint id = cmd->id;
   const GLuint buffer = cmd->buffer;
   const GLenum pname = cmd->pname;
   const GLintptr offset = cmd->offset;
   CALL_GetQueryBufferObjectui64v(ctx->CurrentServerDispatch, (id, buffer, pname, offset));
}
static void GLAPIENTRY
_mesa_marshal_GetQueryBufferObjectui64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_GetQueryBufferObjectui64v);
   struct marshal_cmd_GetQueryBufferObjectui64v *cmd;
   debug_print_marshal("GetQueryBufferObjectui64v");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_GetQueryBufferObjectui64v, cmd_size);
      cmd->id = id;
      cmd->buffer = buffer;
      cmd->pname = pname;
      cmd->offset = offset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("GetQueryBufferObjectui64v");
   CALL_GetQueryBufferObjectui64v(ctx->CurrentServerDispatch, (id, buffer, pname, offset));
}


/* ProgramUniform2uiv: marshalled asynchronously */
struct marshal_cmd_ProgramUniform2uiv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 8) bytes are GLuint value[count][2] */
};
static inline void
_mesa_unmarshal_ProgramUniform2uiv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform2uiv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLuint * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLuint *) variable_data;
   variable_data += count * 8;
   CALL_ProgramUniform2uiv(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform2uiv) + safe_mul(count, 8);
   struct marshal_cmd_ProgramUniform2uiv *cmd;
   debug_print_marshal("ProgramUniform2uiv");
   if (unlikely(safe_mul(count, 8) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform2uiv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 8);
      variable_data += count * 8;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform2uiv");
   CALL_ProgramUniform2uiv(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* Rectsv: marshalled asynchronously */
struct marshal_cmd_Rectsv
{
   struct marshal_cmd_base cmd_base;
   GLshort v1[2];
   GLshort v2[2];
};
static inline void
_mesa_unmarshal_Rectsv(struct gl_context *ctx, const struct marshal_cmd_Rectsv *cmd)
{
   const GLshort * v1 = cmd->v1;
   const GLshort * v2 = cmd->v2;
   CALL_Rectsv(ctx->CurrentServerDispatch, (v1, v2));
}
static void GLAPIENTRY
_mesa_marshal_Rectsv(const GLshort * v1, const GLshort * v2)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Rectsv);
   struct marshal_cmd_Rectsv *cmd;
   debug_print_marshal("Rectsv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Rectsv, cmd_size);
      memcpy(cmd->v1, v1, 4);
      memcpy(cmd->v2, v2, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Rectsv");
   CALL_Rectsv(ctx->CurrentServerDispatch, (v1, v2));
}


/* Frustumx: marshalled asynchronously */
struct marshal_cmd_Frustumx
{
   struct marshal_cmd_base cmd_base;
   GLfixed left;
   GLfixed right;
   GLfixed bottom;
   GLfixed top;
   GLfixed zNear;
   GLfixed zFar;
};
static inline void
_mesa_unmarshal_Frustumx(struct gl_context *ctx, const struct marshal_cmd_Frustumx *cmd)
{
   const GLfixed left = cmd->left;
   const GLfixed right = cmd->right;
   const GLfixed bottom = cmd->bottom;
   const GLfixed top = cmd->top;
   const GLfixed zNear = cmd->zNear;
   const GLfixed zFar = cmd->zFar;
   CALL_Frustumx(ctx->CurrentServerDispatch, (left, right, bottom, top, zNear, zFar));
}
static void GLAPIENTRY
_mesa_marshal_Frustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Frustumx);
   struct marshal_cmd_Frustumx *cmd;
   debug_print_marshal("Frustumx");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Frustumx, cmd_size);
      cmd->left = left;
      cmd->right = right;
      cmd->bottom = bottom;
      cmd->top = top;
      cmd->zNear = zNear;
      cmd->zFar = zFar;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Frustumx");
   CALL_Frustumx(ctx->CurrentServerDispatch, (left, right, bottom, top, zNear, zFar));
}


/* CullFace: marshalled asynchronously */
struct marshal_cmd_CullFace
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
};
static inline void
_mesa_unmarshal_CullFace(struct gl_context *ctx, const struct marshal_cmd_CullFace *cmd)
{
   const GLenum mode = cmd->mode;
   CALL_CullFace(ctx->CurrentServerDispatch, (mode));
}
static void GLAPIENTRY
_mesa_marshal_CullFace(GLenum mode)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CullFace);
   struct marshal_cmd_CullFace *cmd;
   debug_print_marshal("CullFace");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CullFace, cmd_size);
      cmd->mode = mode;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CullFace");
   CALL_CullFace(ctx->CurrentServerDispatch, (mode));
}


/* BindTexture: marshalled asynchronously */
struct marshal_cmd_BindTexture
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint texture;
};
static inline void
_mesa_unmarshal_BindTexture(struct gl_context *ctx, const struct marshal_cmd_BindTexture *cmd)
{
   const GLenum target = cmd->target;
   const GLuint texture = cmd->texture;
   CALL_BindTexture(ctx->CurrentServerDispatch, (target, texture));
}
static void GLAPIENTRY
_mesa_marshal_BindTexture(GLenum target, GLuint texture)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BindTexture);
   struct marshal_cmd_BindTexture *cmd;
   debug_print_marshal("BindTexture");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BindTexture, cmd_size);
      cmd->target = target;
      cmd->texture = texture;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BindTexture");
   CALL_BindTexture(ctx->CurrentServerDispatch, (target, texture));
}


/* MultiTexCoord4fARB: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord4fARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLfloat s;
   GLfloat t;
   GLfloat r;
   GLfloat q;
};
static inline void
_mesa_unmarshal_MultiTexCoord4fARB(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord4fARB *cmd)
{
   const GLenum target = cmd->target;
   const GLfloat s = cmd->s;
   const GLfloat t = cmd->t;
   const GLfloat r = cmd->r;
   const GLfloat q = cmd->q;
   CALL_MultiTexCoord4fARB(ctx->CurrentServerDispatch, (target, s, t, r, q));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord4fARB);
   struct marshal_cmd_MultiTexCoord4fARB *cmd;
   debug_print_marshal("MultiTexCoord4fARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord4fARB, cmd_size);
      cmd->target = target;
      cmd->s = s;
      cmd->t = t;
      cmd->r = r;
      cmd->q = q;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord4fARB");
   CALL_MultiTexCoord4fARB(ctx->CurrentServerDispatch, (target, s, t, r, q));
}


/* Uniform2ui64ARB: marshalled asynchronously */
struct marshal_cmd_Uniform2ui64ARB
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLuint64 x;
   GLuint64 y;
};
static inline void
_mesa_unmarshal_Uniform2ui64ARB(struct gl_context *ctx, const struct marshal_cmd_Uniform2ui64ARB *cmd)
{
   const GLint location = cmd->location;
   const GLuint64 x = cmd->x;
   const GLuint64 y = cmd->y;
   CALL_Uniform2ui64ARB(ctx->CurrentServerDispatch, (location, x, y));
}
static void GLAPIENTRY
_mesa_marshal_Uniform2ui64ARB(GLint location, GLuint64 x, GLuint64 y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform2ui64ARB);
   struct marshal_cmd_Uniform2ui64ARB *cmd;
   debug_print_marshal("Uniform2ui64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform2ui64ARB, cmd_size);
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform2ui64ARB");
   CALL_Uniform2ui64ARB(ctx->CurrentServerDispatch, (location, x, y));
}


/* MultiTexCoordP2uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_MultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint * coords)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MultiTexCoordP2uiv");
   CALL_MultiTexCoordP2uiv(ctx->CurrentServerDispatch, (texture, type, coords));
}


/* BeginPerfQueryINTEL: marshalled asynchronously */
struct marshal_cmd_BeginPerfQueryINTEL
{
   struct marshal_cmd_base cmd_base;
   GLuint queryHandle;
};
static inline void
_mesa_unmarshal_BeginPerfQueryINTEL(struct gl_context *ctx, const struct marshal_cmd_BeginPerfQueryINTEL *cmd)
{
   const GLuint queryHandle = cmd->queryHandle;
   CALL_BeginPerfQueryINTEL(ctx->CurrentServerDispatch, (queryHandle));
}
static void GLAPIENTRY
_mesa_marshal_BeginPerfQueryINTEL(GLuint queryHandle)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BeginPerfQueryINTEL);
   struct marshal_cmd_BeginPerfQueryINTEL *cmd;
   debug_print_marshal("BeginPerfQueryINTEL");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BeginPerfQueryINTEL, cmd_size);
      cmd->queryHandle = queryHandle;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BeginPerfQueryINTEL");
   CALL_BeginPerfQueryINTEL(ctx->CurrentServerDispatch, (queryHandle));
}


/* NormalPointer: marshalled asynchronously */
struct marshal_cmd_NormalPointer
{
   struct marshal_cmd_base cmd_base;
   GLenum type;
   GLsizei stride;
   const GLvoid * pointer;
};
static inline void
_mesa_unmarshal_NormalPointer(struct gl_context *ctx, const struct marshal_cmd_NormalPointer *cmd)
{
   const GLenum type = cmd->type;
   const GLsizei stride = cmd->stride;
   const GLvoid * pointer = cmd->pointer;
   CALL_NormalPointer(ctx->CurrentServerDispatch, (type, stride, pointer));
}
static void GLAPIENTRY
_mesa_marshal_NormalPointer(GLenum type, GLsizei stride, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_NormalPointer);
   struct marshal_cmd_NormalPointer *cmd;
   debug_print_marshal("NormalPointer");
   if (_mesa_glthread_is_non_vbo_vertex_attrib_pointer(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("NormalPointer");
      CALL_NormalPointer(ctx->CurrentServerDispatch, (type, stride, pointer));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_NormalPointer, cmd_size);
      cmd->type = type;
      cmd->stride = stride;
      cmd->pointer = pointer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("NormalPointer");
   CALL_NormalPointer(ctx->CurrentServerDispatch, (type, stride, pointer));
}


/* WindowPos4iMESA: marshalled asynchronously */
struct marshal_cmd_WindowPos4iMESA
{
   struct marshal_cmd_base cmd_base;
   GLint x;
   GLint y;
   GLint z;
   GLint w;
};
static inline void
_mesa_unmarshal_WindowPos4iMESA(struct gl_context *ctx, const struct marshal_cmd_WindowPos4iMESA *cmd)
{
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLint z = cmd->z;
   const GLint w = cmd->w;
   CALL_WindowPos4iMESA(ctx->CurrentServerDispatch, (x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_WindowPos4iMESA(GLint x, GLint y, GLint z, GLint w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_WindowPos4iMESA);
   struct marshal_cmd_WindowPos4iMESA *cmd;
   debug_print_marshal("WindowPos4iMESA");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_WindowPos4iMESA, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("WindowPos4iMESA");
   CALL_WindowPos4iMESA(ctx->CurrentServerDispatch, (x, y, z, w));
}


/* VertexAttrib4bv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4bv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLbyte v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4bv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4bv *cmd)
{
   const GLuint index = cmd->index;
   const GLbyte * v = cmd->v;
   CALL_VertexAttrib4bv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4bv(GLuint index, const GLbyte * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4bv);
   struct marshal_cmd_VertexAttrib4bv *cmd;
   debug_print_marshal("VertexAttrib4bv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4bv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4bv");
   CALL_VertexAttrib4bv(ctx->CurrentServerDispatch, (index, v));
}


/* SecondaryColor3usv: marshalled asynchronously */
struct marshal_cmd_SecondaryColor3usv
{
   struct marshal_cmd_base cmd_base;
   GLushort v[3];
};
static inline void
_mesa_unmarshal_SecondaryColor3usv(struct gl_context *ctx, const struct marshal_cmd_SecondaryColor3usv *cmd)
{
   const GLushort * v = cmd->v;
   CALL_SecondaryColor3usv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColor3usv(const GLushort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColor3usv);
   struct marshal_cmd_SecondaryColor3usv *cmd;
   debug_print_marshal("SecondaryColor3usv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColor3usv, cmd_size);
      memcpy(cmd->v, v, 6);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColor3usv");
   CALL_SecondaryColor3usv(ctx->CurrentServerDispatch, (v));
}


/* GetPixelMapuiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetPixelMapuiv(GLenum map, GLuint * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetPixelMapuiv");
   CALL_GetPixelMapuiv(ctx->CurrentServerDispatch, (map, values));
}


/* MapNamedBuffer: marshalled synchronously */
static GLvoid * GLAPIENTRY
_mesa_marshal_MapNamedBuffer(GLuint buffer, GLenum access)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MapNamedBuffer");
   return CALL_MapNamedBuffer(ctx->CurrentServerDispatch, (buffer, access));
}


/* Indexfv: marshalled asynchronously */
struct marshal_cmd_Indexfv
{
   struct marshal_cmd_base cmd_base;
   GLfloat c[1];
};
static inline void
_mesa_unmarshal_Indexfv(struct gl_context *ctx, const struct marshal_cmd_Indexfv *cmd)
{
   const GLfloat * c = cmd->c;
   CALL_Indexfv(ctx->CurrentServerDispatch, (c));
}
static void GLAPIENTRY
_mesa_marshal_Indexfv(const GLfloat * c)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Indexfv);
   struct marshal_cmd_Indexfv *cmd;
   debug_print_marshal("Indexfv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Indexfv, cmd_size);
      memcpy(cmd->c, c, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Indexfv");
   CALL_Indexfv(ctx->CurrentServerDispatch, (c));
}


/* AlphaFragmentOp1ATI: marshalled asynchronously */
struct marshal_cmd_AlphaFragmentOp1ATI
{
   struct marshal_cmd_base cmd_base;
   GLenum op;
   GLuint dst;
   GLuint dstMod;
   GLuint arg1;
   GLuint arg1Rep;
   GLuint arg1Mod;
};
static inline void
_mesa_unmarshal_AlphaFragmentOp1ATI(struct gl_context *ctx, const struct marshal_cmd_AlphaFragmentOp1ATI *cmd)
{
   const GLenum op = cmd->op;
   const GLuint dst = cmd->dst;
   const GLuint dstMod = cmd->dstMod;
   const GLuint arg1 = cmd->arg1;
   const GLuint arg1Rep = cmd->arg1Rep;
   const GLuint arg1Mod = cmd->arg1Mod;
   CALL_AlphaFragmentOp1ATI(ctx->CurrentServerDispatch, (op, dst, dstMod, arg1, arg1Rep, arg1Mod));
}
static void GLAPIENTRY
_mesa_marshal_AlphaFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_AlphaFragmentOp1ATI);
   struct marshal_cmd_AlphaFragmentOp1ATI *cmd;
   debug_print_marshal("AlphaFragmentOp1ATI");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_AlphaFragmentOp1ATI, cmd_size);
      cmd->op = op;
      cmd->dst = dst;
      cmd->dstMod = dstMod;
      cmd->arg1 = arg1;
      cmd->arg1Rep = arg1Rep;
      cmd->arg1Mod = arg1Mod;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("AlphaFragmentOp1ATI");
   CALL_AlphaFragmentOp1ATI(ctx->CurrentServerDispatch, (op, dst, dstMod, arg1, arg1Rep, arg1Mod));
}


/* GetFloatv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetFloatv(GLenum pname, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetFloatv");
   CALL_GetFloatv(ctx->CurrentServerDispatch, (pname, params));
}


/* ProgramUniform2dv: marshalled asynchronously */
struct marshal_cmd_ProgramUniform2dv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 16) bytes are GLdouble value[count][2] */
};
static inline void
_mesa_unmarshal_ProgramUniform2dv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform2dv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 16;
   CALL_ProgramUniform2dv(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform2dv) + safe_mul(count, 16);
   struct marshal_cmd_ProgramUniform2dv *cmd;
   debug_print_marshal("ProgramUniform2dv");
   if (unlikely(safe_mul(count, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform2dv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 16);
      variable_data += count * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform2dv");
   CALL_ProgramUniform2dv(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* MultiTexCoord3i: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord3i
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLint s;
   GLint t;
   GLint r;
};
static inline void
_mesa_unmarshal_MultiTexCoord3i(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord3i *cmd)
{
   const GLenum target = cmd->target;
   const GLint s = cmd->s;
   const GLint t = cmd->t;
   const GLint r = cmd->r;
   CALL_MultiTexCoord3i(ctx->CurrentServerDispatch, (target, s, t, r));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord3i);
   struct marshal_cmd_MultiTexCoord3i *cmd;
   debug_print_marshal("MultiTexCoord3i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord3i, cmd_size);
      cmd->target = target;
      cmd->s = s;
      cmd->t = t;
      cmd->r = r;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord3i");
   CALL_MultiTexCoord3i(ctx->CurrentServerDispatch, (target, s, t, r));
}


/* ProgramUniform1fv: marshalled asynchronously */
struct marshal_cmd_ProgramUniform1fv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 4) bytes are GLfloat value[count] */
};
static inline void
_mesa_unmarshal_ProgramUniform1fv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform1fv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 4;
   CALL_ProgramUniform1fv(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform1fv) + safe_mul(count, 4);
   struct marshal_cmd_ProgramUniform1fv *cmd;
   debug_print_marshal("ProgramUniform1fv");
   if (unlikely(safe_mul(count, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform1fv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 4);
      variable_data += count * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform1fv");
   CALL_ProgramUniform1fv(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* MultiTexCoord3d: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord3d
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLdouble s;
   GLdouble t;
   GLdouble r;
};
static inline void
_mesa_unmarshal_MultiTexCoord3d(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord3d *cmd)
{
   const GLenum target = cmd->target;
   const GLdouble s = cmd->s;
   const GLdouble t = cmd->t;
   const GLdouble r = cmd->r;
   CALL_MultiTexCoord3d(ctx->CurrentServerDispatch, (target, s, t, r));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord3d);
   struct marshal_cmd_MultiTexCoord3d *cmd;
   debug_print_marshal("MultiTexCoord3d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord3d, cmd_size);
      cmd->target = target;
      cmd->s = s;
      cmd->t = t;
      cmd->r = r;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord3d");
   CALL_MultiTexCoord3d(ctx->CurrentServerDispatch, (target, s, t, r));
}


/* TexCoord3sv: marshalled asynchronously */
struct marshal_cmd_TexCoord3sv
{
   struct marshal_cmd_base cmd_base;
   GLshort v[3];
};
static inline void
_mesa_unmarshal_TexCoord3sv(struct gl_context *ctx, const struct marshal_cmd_TexCoord3sv *cmd)
{
   const GLshort * v = cmd->v;
   CALL_TexCoord3sv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord3sv(const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord3sv);
   struct marshal_cmd_TexCoord3sv *cmd;
   debug_print_marshal("TexCoord3sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord3sv, cmd_size);
      memcpy(cmd->v, v, 6);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord3sv");
   CALL_TexCoord3sv(ctx->CurrentServerDispatch, (v));
}


/* Fogfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_Fogfv(GLenum pname, const GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("Fogfv");
   CALL_Fogfv(ctx->CurrentServerDispatch, (pname, params));
}


/* Minmax: marshalled asynchronously */
struct marshal_cmd_Minmax
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum internalformat;
   GLboolean sink;
};
static inline void
_mesa_unmarshal_Minmax(struct gl_context *ctx, const struct marshal_cmd_Minmax *cmd)
{
   const GLenum target = cmd->target;
   const GLenum internalformat = cmd->internalformat;
   const GLboolean sink = cmd->sink;
   CALL_Minmax(ctx->CurrentServerDispatch, (target, internalformat, sink));
}
static void GLAPIENTRY
_mesa_marshal_Minmax(GLenum target, GLenum internalformat, GLboolean sink)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Minmax);
   struct marshal_cmd_Minmax *cmd;
   debug_print_marshal("Minmax");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Minmax, cmd_size);
      cmd->target = target;
      cmd->internalformat = internalformat;
      cmd->sink = sink;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Minmax");
   CALL_Minmax(ctx->CurrentServerDispatch, (target, internalformat, sink));
}


/* MultiTexCoord3s: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord3s
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLshort s;
   GLshort t;
   GLshort r;
};
static inline void
_mesa_unmarshal_MultiTexCoord3s(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord3s *cmd)
{
   const GLenum target = cmd->target;
   const GLshort s = cmd->s;
   const GLshort t = cmd->t;
   const GLshort r = cmd->r;
   CALL_MultiTexCoord3s(ctx->CurrentServerDispatch, (target, s, t, r));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord3s);
   struct marshal_cmd_MultiTexCoord3s *cmd;
   debug_print_marshal("MultiTexCoord3s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord3s, cmd_size);
      cmd->target = target;
      cmd->s = s;
      cmd->t = t;
      cmd->r = r;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord3s");
   CALL_MultiTexCoord3s(ctx->CurrentServerDispatch, (target, s, t, r));
}


/* Vertex4iv: marshalled asynchronously */
struct marshal_cmd_Vertex4iv
{
   struct marshal_cmd_base cmd_base;
   GLint v[4];
};
static inline void
_mesa_unmarshal_Vertex4iv(struct gl_context *ctx, const struct marshal_cmd_Vertex4iv *cmd)
{
   const GLint * v = cmd->v;
   CALL_Vertex4iv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Vertex4iv(const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex4iv);
   struct marshal_cmd_Vertex4iv *cmd;
   debug_print_marshal("Vertex4iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex4iv, cmd_size);
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex4iv");
   CALL_Vertex4iv(ctx->CurrentServerDispatch, (v));
}


/* TexCoord4dv: marshalled asynchronously */
struct marshal_cmd_TexCoord4dv
{
   struct marshal_cmd_base cmd_base;
   GLdouble v[4];
};
static inline void
_mesa_unmarshal_TexCoord4dv(struct gl_context *ctx, const struct marshal_cmd_TexCoord4dv *cmd)
{
   const GLdouble * v = cmd->v;
   CALL_TexCoord4dv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord4dv(const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord4dv);
   struct marshal_cmd_TexCoord4dv *cmd;
   debug_print_marshal("TexCoord4dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord4dv, cmd_size);
      memcpy(cmd->v, v, 32);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord4dv");
   CALL_TexCoord4dv(ctx->CurrentServerDispatch, (v));
}


/* Begin: marshalled asynchronously */
struct marshal_cmd_Begin
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
};
static inline void
_mesa_unmarshal_Begin(struct gl_context *ctx, const struct marshal_cmd_Begin *cmd)
{
   const GLenum mode = cmd->mode;
   CALL_Begin(ctx->CurrentServerDispatch, (mode));
}
static void GLAPIENTRY
_mesa_marshal_Begin(GLenum mode)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Begin);
   struct marshal_cmd_Begin *cmd;
   debug_print_marshal("Begin");
   if (true) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("Begin");
      CALL_Begin(ctx->CurrentServerDispatch, (mode));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Begin, cmd_size);
      cmd->mode = mode;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Begin");
   CALL_Begin(ctx->CurrentServerDispatch, (mode));
}


/* LightModeli: marshalled asynchronously */
struct marshal_cmd_LightModeli
{
   struct marshal_cmd_base cmd_base;
   GLenum pname;
   GLint param;
};
static inline void
_mesa_unmarshal_LightModeli(struct gl_context *ctx, const struct marshal_cmd_LightModeli *cmd)
{
   const GLenum pname = cmd->pname;
   const GLint param = cmd->param;
   CALL_LightModeli(ctx->CurrentServerDispatch, (pname, param));
}
static void GLAPIENTRY
_mesa_marshal_LightModeli(GLenum pname, GLint param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_LightModeli);
   struct marshal_cmd_LightModeli *cmd;
   debug_print_marshal("LightModeli");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_LightModeli, cmd_size);
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("LightModeli");
   CALL_LightModeli(ctx->CurrentServerDispatch, (pname, param));
}


/* UniformMatrix2fv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix2fv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 16) bytes are GLfloat value[count][4] */
};
static inline void
_mesa_unmarshal_UniformMatrix2fv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix2fv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 16;
   CALL_UniformMatrix2fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix2fv) + safe_mul(count, 16);
   struct marshal_cmd_UniformMatrix2fv *cmd;
   debug_print_marshal("UniformMatrix2fv");
   if (unlikely(safe_mul(count, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix2fv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 16);
      variable_data += count * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix2fv");
   CALL_UniformMatrix2fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* LightModelf: marshalled asynchronously */
struct marshal_cmd_LightModelf
{
   struct marshal_cmd_base cmd_base;
   GLenum pname;
   GLfloat param;
};
static inline void
_mesa_unmarshal_LightModelf(struct gl_context *ctx, const struct marshal_cmd_LightModelf *cmd)
{
   const GLenum pname = cmd->pname;
   const GLfloat param = cmd->param;
   CALL_LightModelf(ctx->CurrentServerDispatch, (pname, param));
}
static void GLAPIENTRY
_mesa_marshal_LightModelf(GLenum pname, GLfloat param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_LightModelf);
   struct marshal_cmd_LightModelf *cmd;
   debug_print_marshal("LightModelf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_LightModelf, cmd_size);
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("LightModelf");
   CALL_LightModelf(ctx->CurrentServerDispatch, (pname, param));
}


/* GetTexParameterfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTexParameterfv(GLenum target, GLenum pname, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTexParameterfv");
   CALL_GetTexParameterfv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* TextureStorage1D: marshalled asynchronously */
struct marshal_cmd_TextureStorage1D
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLsizei levels;
   GLenum internalformat;
   GLsizei width;
};
static inline void
_mesa_unmarshal_TextureStorage1D(struct gl_context *ctx, const struct marshal_cmd_TextureStorage1D *cmd)
{
   const GLuint texture = cmd->texture;
   const GLsizei levels = cmd->levels;
   const GLenum internalformat = cmd->internalformat;
   const GLsizei width = cmd->width;
   CALL_TextureStorage1D(ctx->CurrentServerDispatch, (texture, levels, internalformat, width));
}
static void GLAPIENTRY
_mesa_marshal_TextureStorage1D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureStorage1D);
   struct marshal_cmd_TextureStorage1D *cmd;
   debug_print_marshal("TextureStorage1D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureStorage1D, cmd_size);
      cmd->texture = texture;
      cmd->levels = levels;
      cmd->internalformat = internalformat;
      cmd->width = width;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureStorage1D");
   CALL_TextureStorage1D(ctx->CurrentServerDispatch, (texture, levels, internalformat, width));
}


/* MultiTexCoord2fvARB: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord2fvARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLfloat v[2];
};
static inline void
_mesa_unmarshal_MultiTexCoord2fvARB(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord2fvARB *cmd)
{
   const GLenum target = cmd->target;
   const GLfloat * v = cmd->v;
   CALL_MultiTexCoord2fvARB(ctx->CurrentServerDispatch, (target, v));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord2fvARB(GLenum target, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord2fvARB);
   struct marshal_cmd_MultiTexCoord2fvARB *cmd;
   debug_print_marshal("MultiTexCoord2fvARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord2fvARB, cmd_size);
      cmd->target = target;
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord2fvARB");
   CALL_MultiTexCoord2fvARB(ctx->CurrentServerDispatch, (target, v));
}


/* VertexAttrib4ubv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4ubv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLubyte v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4ubv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4ubv *cmd)
{
   const GLuint index = cmd->index;
   const GLubyte * v = cmd->v;
   CALL_VertexAttrib4ubv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4ubv(GLuint index, const GLubyte * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4ubv);
   struct marshal_cmd_VertexAttrib4ubv *cmd;
   debug_print_marshal("VertexAttrib4ubv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4ubv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4ubv");
   CALL_VertexAttrib4ubv(ctx->CurrentServerDispatch, (index, v));
}


/* GetnTexImageARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnTexImageARB(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, GLvoid * img)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnTexImageARB");
   CALL_GetnTexImageARB(ctx->CurrentServerDispatch, (target, level, format, type, bufSize, img));
}


/* ColorMask: marshalled asynchronously */
struct marshal_cmd_ColorMask
{
   struct marshal_cmd_base cmd_base;
   GLboolean red;
   GLboolean green;
   GLboolean blue;
   GLboolean alpha;
};
static inline void
_mesa_unmarshal_ColorMask(struct gl_context *ctx, const struct marshal_cmd_ColorMask *cmd)
{
   const GLboolean red = cmd->red;
   const GLboolean green = cmd->green;
   const GLboolean blue = cmd->blue;
   const GLboolean alpha = cmd->alpha;
   CALL_ColorMask(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}
static void GLAPIENTRY
_mesa_marshal_ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ColorMask);
   struct marshal_cmd_ColorMask *cmd;
   debug_print_marshal("ColorMask");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ColorMask, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      cmd->alpha = alpha;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ColorMask");
   CALL_ColorMask(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}


/* MultiTexCoord4x: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord4x
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLfixed s;
   GLfixed t;
   GLfixed r;
   GLfixed q;
};
static inline void
_mesa_unmarshal_MultiTexCoord4x(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord4x *cmd)
{
   const GLenum target = cmd->target;
   const GLfixed s = cmd->s;
   const GLfixed t = cmd->t;
   const GLfixed r = cmd->r;
   const GLfixed q = cmd->q;
   CALL_MultiTexCoord4x(ctx->CurrentServerDispatch, (target, s, t, r, q));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord4x);
   struct marshal_cmd_MultiTexCoord4x *cmd;
   debug_print_marshal("MultiTexCoord4x");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord4x, cmd_size);
      cmd->target = target;
      cmd->s = s;
      cmd->t = t;
      cmd->r = r;
      cmd->q = q;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord4x");
   CALL_MultiTexCoord4x(ctx->CurrentServerDispatch, (target, s, t, r, q));
}


/* UniformHandleui64ARB: marshalled asynchronously */
struct marshal_cmd_UniformHandleui64ARB
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLuint64 value;
};
static inline void
_mesa_unmarshal_UniformHandleui64ARB(struct gl_context *ctx, const struct marshal_cmd_UniformHandleui64ARB *cmd)
{
   const GLint location = cmd->location;
   const GLuint64 value = cmd->value;
   CALL_UniformHandleui64ARB(ctx->CurrentServerDispatch, (location, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformHandleui64ARB(GLint location, GLuint64 value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformHandleui64ARB);
   struct marshal_cmd_UniformHandleui64ARB *cmd;
   debug_print_marshal("UniformHandleui64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformHandleui64ARB, cmd_size);
      cmd->location = location;
      cmd->value = value;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformHandleui64ARB");
   CALL_UniformHandleui64ARB(ctx->CurrentServerDispatch, (location, value));
}


/* VertexAttribs4svNV: marshalled asynchronously */
struct marshal_cmd_VertexAttribs4svNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLsizei n;
   /* Next safe_mul(n, 8) bytes are GLshort v[n][4] */
};
static inline void
_mesa_unmarshal_VertexAttribs4svNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttribs4svNV *cmd)
{
   const GLuint index = cmd->index;
   const GLsizei n = cmd->n;
   const GLshort * v;
   const char *variable_data = (const char *) (cmd + 1);
   v = (const GLshort *) variable_data;
   variable_data += n * 8;
   CALL_VertexAttribs4svNV(ctx->CurrentServerDispatch, (index, n, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribs4svNV(GLuint index, GLsizei n, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribs4svNV) + safe_mul(n, 8);
   struct marshal_cmd_VertexAttribs4svNV *cmd;
   debug_print_marshal("VertexAttribs4svNV");
   if (unlikely(safe_mul(n, 8) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribs4svNV, cmd_size);
      cmd->index = index;
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, v, n * 8);
      variable_data += n * 8;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribs4svNV");
   CALL_VertexAttribs4svNV(ctx->CurrentServerDispatch, (index, n, v));
}


/* DrawElementsInstancedBaseInstance: marshalled asynchronously */
struct marshal_cmd_DrawElementsInstancedBaseInstance
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLsizei count;
   GLenum type;
   const GLvoid * indices;
   GLsizei primcount;
   GLuint baseinstance;
};
static inline void
_mesa_unmarshal_DrawElementsInstancedBaseInstance(struct gl_context *ctx, const struct marshal_cmd_DrawElementsInstancedBaseInstance *cmd)
{
   const GLenum mode = cmd->mode;
   const GLsizei count = cmd->count;
   const GLenum type = cmd->type;
   const GLvoid * indices = cmd->indices;
   const GLsizei primcount = cmd->primcount;
   const GLuint baseinstance = cmd->baseinstance;
   CALL_DrawElementsInstancedBaseInstance(ctx->CurrentServerDispatch, (mode, count, type, indices, primcount, baseinstance));
}
static void GLAPIENTRY
_mesa_marshal_DrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei primcount, GLuint baseinstance)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawElementsInstancedBaseInstance);
   struct marshal_cmd_DrawElementsInstancedBaseInstance *cmd;
   debug_print_marshal("DrawElementsInstancedBaseInstance");
   if (_mesa_glthread_is_non_vbo_draw_elements(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("DrawElementsInstancedBaseInstance");
      CALL_DrawElementsInstancedBaseInstance(ctx->CurrentServerDispatch, (mode, count, type, indices, primcount, baseinstance));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawElementsInstancedBaseInstance, cmd_size);
      cmd->mode = mode;
      cmd->count = count;
      cmd->type = type;
      cmd->indices = indices;
      cmd->primcount = primcount;
      cmd->baseinstance = baseinstance;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawElementsInstancedBaseInstance");
   CALL_DrawElementsInstancedBaseInstance(ctx->CurrentServerDispatch, (mode, count, type, indices, primcount, baseinstance));
}


/* UniformMatrix4fv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix4fv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 64) bytes are GLfloat value[count][16] */
};
static inline void
_mesa_unmarshal_UniformMatrix4fv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix4fv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 64;
   CALL_UniformMatrix4fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix4fv) + safe_mul(count, 64);
   struct marshal_cmd_UniformMatrix4fv *cmd;
   debug_print_marshal("UniformMatrix4fv");
   if (unlikely(safe_mul(count, 64) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix4fv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 64);
      variable_data += count * 64;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix4fv");
   CALL_UniformMatrix4fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* UniformMatrix3x2fv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix3x2fv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 24) bytes are GLfloat value[count][6] */
};
static inline void
_mesa_unmarshal_UniformMatrix3x2fv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix3x2fv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 24;
   CALL_UniformMatrix3x2fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix3x2fv) + safe_mul(count, 24);
   struct marshal_cmd_UniformMatrix3x2fv *cmd;
   debug_print_marshal("UniformMatrix3x2fv");
   if (unlikely(safe_mul(count, 24) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix3x2fv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 24);
      variable_data += count * 24;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix3x2fv");
   CALL_UniformMatrix3x2fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* VertexAttrib4Nuiv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4Nuiv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLuint v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4Nuiv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4Nuiv *cmd)
{
   const GLuint index = cmd->index;
   const GLuint * v = cmd->v;
   CALL_VertexAttrib4Nuiv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4Nuiv(GLuint index, const GLuint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4Nuiv);
   struct marshal_cmd_VertexAttrib4Nuiv *cmd;
   debug_print_marshal("VertexAttrib4Nuiv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4Nuiv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4Nuiv");
   CALL_VertexAttrib4Nuiv(ctx->CurrentServerDispatch, (index, v));
}


/* ClientActiveTexture: marshalled asynchronously */
struct marshal_cmd_ClientActiveTexture
{
   struct marshal_cmd_base cmd_base;
   GLenum texture;
};
static inline void
_mesa_unmarshal_ClientActiveTexture(struct gl_context *ctx, const struct marshal_cmd_ClientActiveTexture *cmd)
{
   const GLenum texture = cmd->texture;
   CALL_ClientActiveTexture(ctx->CurrentServerDispatch, (texture));
}
static void GLAPIENTRY
_mesa_marshal_ClientActiveTexture(GLenum texture)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ClientActiveTexture);
   struct marshal_cmd_ClientActiveTexture *cmd;
   debug_print_marshal("ClientActiveTexture");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ClientActiveTexture, cmd_size);
      cmd->texture = texture;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ClientActiveTexture");
   CALL_ClientActiveTexture(ctx->CurrentServerDispatch, (texture));
}


/* GetUniformIndices: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar * const * uniformNames, GLuint * uniformIndices)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetUniformIndices");
   CALL_GetUniformIndices(ctx->CurrentServerDispatch, (program, uniformCount, uniformNames, uniformIndices));
}


/* MultiTexCoord2sv: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord2sv
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLshort v[2];
};
static inline void
_mesa_unmarshal_MultiTexCoord2sv(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord2sv *cmd)
{
   const GLenum target = cmd->target;
   const GLshort * v = cmd->v;
   CALL_MultiTexCoord2sv(ctx->CurrentServerDispatch, (target, v));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord2sv(GLenum target, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord2sv);
   struct marshal_cmd_MultiTexCoord2sv *cmd;
   debug_print_marshal("MultiTexCoord2sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord2sv, cmd_size);
      cmd->target = target;
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord2sv");
   CALL_MultiTexCoord2sv(ctx->CurrentServerDispatch, (target, v));
}


/* NamedBufferStorage: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_NamedBufferStorage(GLuint buffer, GLsizeiptr size, const GLvoid * data, GLbitfield flags)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("NamedBufferStorage");
   CALL_NamedBufferStorage(ctx->CurrentServerDispatch, (buffer, size, data, flags));
}


/* NamedFramebufferDrawBuffer: marshalled asynchronously */
struct marshal_cmd_NamedFramebufferDrawBuffer
{
   struct marshal_cmd_base cmd_base;
   GLuint framebuffer;
   GLenum buf;
};
static inline void
_mesa_unmarshal_NamedFramebufferDrawBuffer(struct gl_context *ctx, const struct marshal_cmd_NamedFramebufferDrawBuffer *cmd)
{
   const GLuint framebuffer = cmd->framebuffer;
   const GLenum buf = cmd->buf;
   CALL_NamedFramebufferDrawBuffer(ctx->CurrentServerDispatch, (framebuffer, buf));
}
static void GLAPIENTRY
_mesa_marshal_NamedFramebufferDrawBuffer(GLuint framebuffer, GLenum buf)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_NamedFramebufferDrawBuffer);
   struct marshal_cmd_NamedFramebufferDrawBuffer *cmd;
   debug_print_marshal("NamedFramebufferDrawBuffer");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_NamedFramebufferDrawBuffer, cmd_size);
      cmd->framebuffer = framebuffer;
      cmd->buf = buf;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("NamedFramebufferDrawBuffer");
   CALL_NamedFramebufferDrawBuffer(ctx->CurrentServerDispatch, (framebuffer, buf));
}


/* NamedFramebufferTextureLayer: marshalled asynchronously */
struct marshal_cmd_NamedFramebufferTextureLayer
{
   struct marshal_cmd_base cmd_base;
   GLuint framebuffer;
   GLenum attachment;
   GLuint texture;
   GLint level;
   GLint layer;
};
static inline void
_mesa_unmarshal_NamedFramebufferTextureLayer(struct gl_context *ctx, const struct marshal_cmd_NamedFramebufferTextureLayer *cmd)
{
   const GLuint framebuffer = cmd->framebuffer;
   const GLenum attachment = cmd->attachment;
   const GLuint texture = cmd->texture;
   const GLint level = cmd->level;
   const GLint layer = cmd->layer;
   CALL_NamedFramebufferTextureLayer(ctx->CurrentServerDispatch, (framebuffer, attachment, texture, level, layer));
}
static void GLAPIENTRY
_mesa_marshal_NamedFramebufferTextureLayer(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_NamedFramebufferTextureLayer);
   struct marshal_cmd_NamedFramebufferTextureLayer *cmd;
   debug_print_marshal("NamedFramebufferTextureLayer");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_NamedFramebufferTextureLayer, cmd_size);
      cmd->framebuffer = framebuffer;
      cmd->attachment = attachment;
      cmd->texture = texture;
      cmd->level = level;
      cmd->layer = layer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("NamedFramebufferTextureLayer");
   CALL_NamedFramebufferTextureLayer(ctx->CurrentServerDispatch, (framebuffer, attachment, texture, level, layer));
}


/* LoadIdentity: marshalled asynchronously */
struct marshal_cmd_LoadIdentity
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_LoadIdentity(struct gl_context *ctx, const struct marshal_cmd_LoadIdentity *cmd)
{
   CALL_LoadIdentity(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_LoadIdentity(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_LoadIdentity);
   struct marshal_cmd_LoadIdentity *cmd;
   debug_print_marshal("LoadIdentity");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_LoadIdentity, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("LoadIdentity");
   CALL_LoadIdentity(ctx->CurrentServerDispatch, ());
}


/* ActiveShaderProgram: marshalled asynchronously */
struct marshal_cmd_ActiveShaderProgram
{
   struct marshal_cmd_base cmd_base;
   GLuint pipeline;
   GLuint program;
};
static inline void
_mesa_unmarshal_ActiveShaderProgram(struct gl_context *ctx, const struct marshal_cmd_ActiveShaderProgram *cmd)
{
   const GLuint pipeline = cmd->pipeline;
   const GLuint program = cmd->program;
   CALL_ActiveShaderProgram(ctx->CurrentServerDispatch, (pipeline, program));
}
static void GLAPIENTRY
_mesa_marshal_ActiveShaderProgram(GLuint pipeline, GLuint program)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ActiveShaderProgram);
   struct marshal_cmd_ActiveShaderProgram *cmd;
   debug_print_marshal("ActiveShaderProgram");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ActiveShaderProgram, cmd_size);
      cmd->pipeline = pipeline;
      cmd->program = program;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ActiveShaderProgram");
   CALL_ActiveShaderProgram(ctx->CurrentServerDispatch, (pipeline, program));
}


/* BindImageTextures: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_BindImageTextures(GLuint first, GLsizei count, const GLuint * textures)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("BindImageTextures");
   CALL_BindImageTextures(ctx->CurrentServerDispatch, (first, count, textures));
}


/* DeleteTransformFeedbacks: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_DeleteTransformFeedbacks(GLsizei n, const GLuint * ids)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("DeleteTransformFeedbacks");
   CALL_DeleteTransformFeedbacks(ctx->CurrentServerDispatch, (n, ids));
}


/* VertexAttrib4ubvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4ubvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLubyte v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4ubvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4ubvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLubyte * v = cmd->v;
   CALL_VertexAttrib4ubvNV(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4ubvNV(GLuint index, const GLubyte * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4ubvNV);
   struct marshal_cmd_VertexAttrib4ubvNV *cmd;
   debug_print_marshal("VertexAttrib4ubvNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4ubvNV, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4ubvNV");
   CALL_VertexAttrib4ubvNV(ctx->CurrentServerDispatch, (index, v));
}


/* FogCoordfEXT: marshalled asynchronously */
struct marshal_cmd_FogCoordfEXT
{
   struct marshal_cmd_base cmd_base;
   GLfloat coord;
};
static inline void
_mesa_unmarshal_FogCoordfEXT(struct gl_context *ctx, const struct marshal_cmd_FogCoordfEXT *cmd)
{
   const GLfloat coord = cmd->coord;
   CALL_FogCoordfEXT(ctx->CurrentServerDispatch, (coord));
}
static void GLAPIENTRY
_mesa_marshal_FogCoordfEXT(GLfloat coord)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_FogCoordfEXT);
   struct marshal_cmd_FogCoordfEXT *cmd;
   debug_print_marshal("FogCoordfEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_FogCoordfEXT, cmd_size);
      cmd->coord = coord;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("FogCoordfEXT");
   CALL_FogCoordfEXT(ctx->CurrentServerDispatch, (coord));
}


/* GetMapfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetMapfv(GLenum target, GLenum query, GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetMapfv");
   CALL_GetMapfv(ctx->CurrentServerDispatch, (target, query, v));
}


/* GetProgramInfoLog: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramInfoLog");
   CALL_GetProgramInfoLog(ctx->CurrentServerDispatch, (program, bufSize, length, infoLog));
}


/* BindTransformFeedback: marshalled asynchronously */
struct marshal_cmd_BindTransformFeedback
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint id;
};
static inline void
_mesa_unmarshal_BindTransformFeedback(struct gl_context *ctx, const struct marshal_cmd_BindTransformFeedback *cmd)
{
   const GLenum target = cmd->target;
   const GLuint id = cmd->id;
   CALL_BindTransformFeedback(ctx->CurrentServerDispatch, (target, id));
}
static void GLAPIENTRY
_mesa_marshal_BindTransformFeedback(GLenum target, GLuint id)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BindTransformFeedback);
   struct marshal_cmd_BindTransformFeedback *cmd;
   debug_print_marshal("BindTransformFeedback");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BindTransformFeedback, cmd_size);
      cmd->target = target;
      cmd->id = id;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BindTransformFeedback");
   CALL_BindTransformFeedback(ctx->CurrentServerDispatch, (target, id));
}


/* GetPixelMapfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetPixelMapfv(GLenum map, GLfloat * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetPixelMapfv");
   CALL_GetPixelMapfv(ctx->CurrentServerDispatch, (map, values));
}


/* TextureBufferRange: marshalled asynchronously */
struct marshal_cmd_TextureBufferRange
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLenum internalformat;
   GLuint buffer;
   GLintptr offset;
   GLsizeiptr size;
};
static inline void
_mesa_unmarshal_TextureBufferRange(struct gl_context *ctx, const struct marshal_cmd_TextureBufferRange *cmd)
{
   const GLuint texture = cmd->texture;
   const GLenum internalformat = cmd->internalformat;
   const GLuint buffer = cmd->buffer;
   const GLintptr offset = cmd->offset;
   const GLsizeiptr size = cmd->size;
   CALL_TextureBufferRange(ctx->CurrentServerDispatch, (texture, internalformat, buffer, offset, size));
}
static void GLAPIENTRY
_mesa_marshal_TextureBufferRange(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureBufferRange);
   struct marshal_cmd_TextureBufferRange *cmd;
   debug_print_marshal("TextureBufferRange");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureBufferRange, cmd_size);
      cmd->texture = texture;
      cmd->internalformat = internalformat;
      cmd->buffer = buffer;
      cmd->offset = offset;
      cmd->size = size;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureBufferRange");
   CALL_TextureBufferRange(ctx->CurrentServerDispatch, (texture, internalformat, buffer, offset, size));
}


/* VertexAttrib4svNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4svNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLshort v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4svNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4svNV *cmd)
{
   const GLuint index = cmd->index;
   const GLshort * v = cmd->v;
   CALL_VertexAttrib4svNV(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4svNV(GLuint index, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4svNV);
   struct marshal_cmd_VertexAttrib4svNV *cmd;
   debug_print_marshal("VertexAttrib4svNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4svNV, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4svNV");
   CALL_VertexAttrib4svNV(ctx->CurrentServerDispatch, (index, v));
}


/* PatchParameteri: marshalled asynchronously */
struct marshal_cmd_PatchParameteri
{
   struct marshal_cmd_base cmd_base;
   GLenum pname;
   GLint value;
};
static inline void
_mesa_unmarshal_PatchParameteri(struct gl_context *ctx, const struct marshal_cmd_PatchParameteri *cmd)
{
   const GLenum pname = cmd->pname;
   const GLint value = cmd->value;
   CALL_PatchParameteri(ctx->CurrentServerDispatch, (pname, value));
}
static void GLAPIENTRY
_mesa_marshal_PatchParameteri(GLenum pname, GLint value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PatchParameteri);
   struct marshal_cmd_PatchParameteri *cmd;
   debug_print_marshal("PatchParameteri");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PatchParameteri, cmd_size);
      cmd->pname = pname;
      cmd->value = value;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PatchParameteri");
   CALL_PatchParameteri(ctx->CurrentServerDispatch, (pname, value));
}


/* NamedFramebufferParameteri: marshalled asynchronously */
struct marshal_cmd_NamedFramebufferParameteri
{
   struct marshal_cmd_base cmd_base;
   GLuint framebuffer;
   GLenum pname;
   GLint param;
};
static inline void
_mesa_unmarshal_NamedFramebufferParameteri(struct gl_context *ctx, const struct marshal_cmd_NamedFramebufferParameteri *cmd)
{
   const GLuint framebuffer = cmd->framebuffer;
   const GLenum pname = cmd->pname;
   const GLint param = cmd->param;
   CALL_NamedFramebufferParameteri(ctx->CurrentServerDispatch, (framebuffer, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_NamedFramebufferParameteri(GLuint framebuffer, GLenum pname, GLint param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_NamedFramebufferParameteri);
   struct marshal_cmd_NamedFramebufferParameteri *cmd;
   debug_print_marshal("NamedFramebufferParameteri");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_NamedFramebufferParameteri, cmd_size);
      cmd->framebuffer = framebuffer;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("NamedFramebufferParameteri");
   CALL_NamedFramebufferParameteri(ctx->CurrentServerDispatch, (framebuffer, pname, param));
}


/* VDPAUSurfaceAccessNV: marshalled asynchronously */
struct marshal_cmd_VDPAUSurfaceAccessNV
{
   struct marshal_cmd_base cmd_base;
   GLintptr surface;
   GLenum access;
};
static inline void
_mesa_unmarshal_VDPAUSurfaceAccessNV(struct gl_context *ctx, const struct marshal_cmd_VDPAUSurfaceAccessNV *cmd)
{
   const GLintptr surface = cmd->surface;
   const GLenum access = cmd->access;
   CALL_VDPAUSurfaceAccessNV(ctx->CurrentServerDispatch, (surface, access));
}
static void GLAPIENTRY
_mesa_marshal_VDPAUSurfaceAccessNV(GLintptr surface, GLenum access)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VDPAUSurfaceAccessNV);
   struct marshal_cmd_VDPAUSurfaceAccessNV *cmd;
   debug_print_marshal("VDPAUSurfaceAccessNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VDPAUSurfaceAccessNV, cmd_size);
      cmd->surface = surface;
      cmd->access = access;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VDPAUSurfaceAccessNV");
   CALL_VDPAUSurfaceAccessNV(ctx->CurrentServerDispatch, (surface, access));
}


/* EdgeFlagPointer: marshalled asynchronously */
struct marshal_cmd_EdgeFlagPointer
{
   struct marshal_cmd_base cmd_base;
   GLsizei stride;
   const GLvoid * pointer;
};
static inline void
_mesa_unmarshal_EdgeFlagPointer(struct gl_context *ctx, const struct marshal_cmd_EdgeFlagPointer *cmd)
{
   const GLsizei stride = cmd->stride;
   const GLvoid * pointer = cmd->pointer;
   CALL_EdgeFlagPointer(ctx->CurrentServerDispatch, (stride, pointer));
}
static void GLAPIENTRY
_mesa_marshal_EdgeFlagPointer(GLsizei stride, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EdgeFlagPointer);
   struct marshal_cmd_EdgeFlagPointer *cmd;
   debug_print_marshal("EdgeFlagPointer");
   if (_mesa_glthread_is_non_vbo_vertex_attrib_pointer(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("EdgeFlagPointer");
      CALL_EdgeFlagPointer(ctx->CurrentServerDispatch, (stride, pointer));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EdgeFlagPointer, cmd_size);
      cmd->stride = stride;
      cmd->pointer = pointer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EdgeFlagPointer");
   CALL_EdgeFlagPointer(ctx->CurrentServerDispatch, (stride, pointer));
}


/* WindowPos2f: marshalled asynchronously */
struct marshal_cmd_WindowPos2f
{
   struct marshal_cmd_base cmd_base;
   GLfloat x;
   GLfloat y;
};
static inline void
_mesa_unmarshal_WindowPos2f(struct gl_context *ctx, const struct marshal_cmd_WindowPos2f *cmd)
{
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   CALL_WindowPos2f(ctx->CurrentServerDispatch, (x, y));
}
static void GLAPIENTRY
_mesa_marshal_WindowPos2f(GLfloat x, GLfloat y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_WindowPos2f);
   struct marshal_cmd_WindowPos2f *cmd;
   debug_print_marshal("WindowPos2f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_WindowPos2f, cmd_size);
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("WindowPos2f");
   CALL_WindowPos2f(ctx->CurrentServerDispatch, (x, y));
}


/* WindowPos2d: marshalled asynchronously */
struct marshal_cmd_WindowPos2d
{
   struct marshal_cmd_base cmd_base;
   GLdouble x;
   GLdouble y;
};
static inline void
_mesa_unmarshal_WindowPos2d(struct gl_context *ctx, const struct marshal_cmd_WindowPos2d *cmd)
{
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   CALL_WindowPos2d(ctx->CurrentServerDispatch, (x, y));
}
static void GLAPIENTRY
_mesa_marshal_WindowPos2d(GLdouble x, GLdouble y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_WindowPos2d);
   struct marshal_cmd_WindowPos2d *cmd;
   debug_print_marshal("WindowPos2d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_WindowPos2d, cmd_size);
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("WindowPos2d");
   CALL_WindowPos2d(ctx->CurrentServerDispatch, (x, y));
}


/* GetVertexAttribLdv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetVertexAttribLdv(GLuint index, GLenum pname, GLdouble * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetVertexAttribLdv");
   CALL_GetVertexAttribLdv(ctx->CurrentServerDispatch, (index, pname, params));
}


/* WindowPos2i: marshalled asynchronously */
struct marshal_cmd_WindowPos2i
{
   struct marshal_cmd_base cmd_base;
   GLint x;
   GLint y;
};
static inline void
_mesa_unmarshal_WindowPos2i(struct gl_context *ctx, const struct marshal_cmd_WindowPos2i *cmd)
{
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   CALL_WindowPos2i(ctx->CurrentServerDispatch, (x, y));
}
static void GLAPIENTRY
_mesa_marshal_WindowPos2i(GLint x, GLint y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_WindowPos2i);
   struct marshal_cmd_WindowPos2i *cmd;
   debug_print_marshal("WindowPos2i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_WindowPos2i, cmd_size);
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("WindowPos2i");
   CALL_WindowPos2i(ctx->CurrentServerDispatch, (x, y));
}


/* WindowPos2s: marshalled asynchronously */
struct marshal_cmd_WindowPos2s
{
   struct marshal_cmd_base cmd_base;
   GLshort x;
   GLshort y;
};
static inline void
_mesa_unmarshal_WindowPos2s(struct gl_context *ctx, const struct marshal_cmd_WindowPos2s *cmd)
{
   const GLshort x = cmd->x;
   const GLshort y = cmd->y;
   CALL_WindowPos2s(ctx->CurrentServerDispatch, (x, y));
}
static void GLAPIENTRY
_mesa_marshal_WindowPos2s(GLshort x, GLshort y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_WindowPos2s);
   struct marshal_cmd_WindowPos2s *cmd;
   debug_print_marshal("WindowPos2s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_WindowPos2s, cmd_size);
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("WindowPos2s");
   CALL_WindowPos2s(ctx->CurrentServerDispatch, (x, y));
}


/* VertexAttribI1uiEXT: marshalled asynchronously */
struct marshal_cmd_VertexAttribI1uiEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLuint x;
};
static inline void
_mesa_unmarshal_VertexAttribI1uiEXT(struct gl_context *ctx, const struct marshal_cmd_VertexAttribI1uiEXT *cmd)
{
   const GLuint index = cmd->index;
   const GLuint x = cmd->x;
   CALL_VertexAttribI1uiEXT(ctx->CurrentServerDispatch, (index, x));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribI1uiEXT(GLuint index, GLuint x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribI1uiEXT);
   struct marshal_cmd_VertexAttribI1uiEXT *cmd;
   debug_print_marshal("VertexAttribI1uiEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribI1uiEXT, cmd_size);
      cmd->index = index;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribI1uiEXT");
   CALL_VertexAttribI1uiEXT(ctx->CurrentServerDispatch, (index, x));
}


/* DeleteSync: marshalled asynchronously */
struct marshal_cmd_DeleteSync
{
   struct marshal_cmd_base cmd_base;
   GLsync sync;
};
static inline void
_mesa_unmarshal_DeleteSync(struct gl_context *ctx, const struct marshal_cmd_DeleteSync *cmd)
{
   const GLsync sync = cmd->sync;
   CALL_DeleteSync(ctx->CurrentServerDispatch, (sync));
}
static void GLAPIENTRY
_mesa_marshal_DeleteSync(GLsync sync)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DeleteSync);
   struct marshal_cmd_DeleteSync *cmd;
   debug_print_marshal("DeleteSync");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DeleteSync, cmd_size);
      cmd->sync = sync;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DeleteSync");
   CALL_DeleteSync(ctx->CurrentServerDispatch, (sync));
}


/* WindowPos4fvMESA: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_WindowPos4fvMESA(const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("WindowPos4fvMESA");
   CALL_WindowPos4fvMESA(ctx->CurrentServerDispatch, (v));
}


/* CompressedTexImage3D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CompressedTexImage3D");
   CALL_CompressedTexImage3D(ctx->CurrentServerDispatch, (target, level, internalformat, width, height, depth, border, imageSize, data));
}


/* GenSemaphoresEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GenSemaphoresEXT(GLsizei n, GLuint * semaphores)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GenSemaphoresEXT");
   CALL_GenSemaphoresEXT(ctx->CurrentServerDispatch, (n, semaphores));
}


/* VertexAttribI1uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribI1uiv(GLuint index, const GLuint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribI1uiv");
   CALL_VertexAttribI1uiv(ctx->CurrentServerDispatch, (index, v));
}


/* SecondaryColor3dv: marshalled asynchronously */
struct marshal_cmd_SecondaryColor3dv
{
   struct marshal_cmd_base cmd_base;
   GLdouble v[3];
};
static inline void
_mesa_unmarshal_SecondaryColor3dv(struct gl_context *ctx, const struct marshal_cmd_SecondaryColor3dv *cmd)
{
   const GLdouble * v = cmd->v;
   CALL_SecondaryColor3dv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColor3dv(const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColor3dv);
   struct marshal_cmd_SecondaryColor3dv *cmd;
   debug_print_marshal("SecondaryColor3dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColor3dv, cmd_size);
      memcpy(cmd->v, v, 24);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColor3dv");
   CALL_SecondaryColor3dv(ctx->CurrentServerDispatch, (v));
}


/* GetnPixelMapusvARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnPixelMapusvARB(GLenum map, GLsizei bufSize, GLushort * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnPixelMapusvARB");
   CALL_GetnPixelMapusvARB(ctx->CurrentServerDispatch, (map, bufSize, values));
}


/* VertexAttrib3s: marshalled asynchronously */
struct marshal_cmd_VertexAttrib3s
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLshort x;
   GLshort y;
   GLshort z;
};
static inline void
_mesa_unmarshal_VertexAttrib3s(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib3s *cmd)
{
   const GLuint index = cmd->index;
   const GLshort x = cmd->x;
   const GLshort y = cmd->y;
   const GLshort z = cmd->z;
   CALL_VertexAttrib3s(ctx->CurrentServerDispatch, (index, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib3s);
   struct marshal_cmd_VertexAttrib3s *cmd;
   debug_print_marshal("VertexAttrib3s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib3s, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib3s");
   CALL_VertexAttrib3s(ctx->CurrentServerDispatch, (index, x, y, z));
}


/* UniformMatrix4x3fv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix4x3fv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 48) bytes are GLfloat value[count][12] */
};
static inline void
_mesa_unmarshal_UniformMatrix4x3fv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix4x3fv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 48;
   CALL_UniformMatrix4x3fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix4x3fv) + safe_mul(count, 48);
   struct marshal_cmd_UniformMatrix4x3fv *cmd;
   debug_print_marshal("UniformMatrix4x3fv");
   if (unlikely(safe_mul(count, 48) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix4x3fv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 48);
      variable_data += count * 48;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix4x3fv");
   CALL_UniformMatrix4x3fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* GetQueryiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetQueryiv(GLenum target, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetQueryiv");
   CALL_GetQueryiv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* VertexAttrib3d: marshalled asynchronously */
struct marshal_cmd_VertexAttrib3d
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble x;
   GLdouble y;
   GLdouble z;
};
static inline void
_mesa_unmarshal_VertexAttrib3d(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib3d *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   CALL_VertexAttrib3d(ctx->CurrentServerDispatch, (index, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib3d);
   struct marshal_cmd_VertexAttrib3d *cmd;
   debug_print_marshal("VertexAttrib3d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib3d, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib3d");
   CALL_VertexAttrib3d(ctx->CurrentServerDispatch, (index, x, y, z));
}


/* MapNamedBufferRange: marshalled synchronously */
static GLvoid * GLAPIENTRY
_mesa_marshal_MapNamedBufferRange(GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MapNamedBufferRange");
   return CALL_MapNamedBufferRange(ctx->CurrentServerDispatch, (buffer, offset, length, access));
}


/* MapBuffer: marshalled synchronously */
static GLvoid * GLAPIENTRY
_mesa_marshal_MapBuffer(GLenum target, GLenum access)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MapBuffer");
   return CALL_MapBuffer(ctx->CurrentServerDispatch, (target, access));
}


/* GetProgramStageiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramStageiv");
   CALL_GetProgramStageiv(ctx->CurrentServerDispatch, (program, shadertype, pname, values));
}


/* VertexAttrib4Nbv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4Nbv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLbyte v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4Nbv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4Nbv *cmd)
{
   const GLuint index = cmd->index;
   const GLbyte * v = cmd->v;
   CALL_VertexAttrib4Nbv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4Nbv(GLuint index, const GLbyte * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4Nbv);
   struct marshal_cmd_VertexAttrib4Nbv *cmd;
   debug_print_marshal("VertexAttrib4Nbv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4Nbv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4Nbv");
   CALL_VertexAttrib4Nbv(ctx->CurrentServerDispatch, (index, v));
}


/* ProgramBinary: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid * binary, GLsizei length)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ProgramBinary");
   CALL_ProgramBinary(ctx->CurrentServerDispatch, (program, binaryFormat, binary, length));
}


/* InvalidateTexImage: marshalled asynchronously */
struct marshal_cmd_InvalidateTexImage
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLint level;
};
static inline void
_mesa_unmarshal_InvalidateTexImage(struct gl_context *ctx, const struct marshal_cmd_InvalidateTexImage *cmd)
{
   const GLuint texture = cmd->texture;
   const GLint level = cmd->level;
   CALL_InvalidateTexImage(ctx->CurrentServerDispatch, (texture, level));
}
static void GLAPIENTRY
_mesa_marshal_InvalidateTexImage(GLuint texture, GLint level)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_InvalidateTexImage);
   struct marshal_cmd_InvalidateTexImage *cmd;
   debug_print_marshal("InvalidateTexImage");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_InvalidateTexImage, cmd_size);
      cmd->texture = texture;
      cmd->level = level;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("InvalidateTexImage");
   CALL_InvalidateTexImage(ctx->CurrentServerDispatch, (texture, level));
}


/* Uniform4ui: marshalled asynchronously */
struct marshal_cmd_Uniform4ui
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLuint x;
   GLuint y;
   GLuint z;
   GLuint w;
};
static inline void
_mesa_unmarshal_Uniform4ui(struct gl_context *ctx, const struct marshal_cmd_Uniform4ui *cmd)
{
   const GLint location = cmd->location;
   const GLuint x = cmd->x;
   const GLuint y = cmd->y;
   const GLuint z = cmd->z;
   const GLuint w = cmd->w;
   CALL_Uniform4ui(ctx->CurrentServerDispatch, (location, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_Uniform4ui(GLint location, GLuint x, GLuint y, GLuint z, GLuint w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform4ui);
   struct marshal_cmd_Uniform4ui *cmd;
   debug_print_marshal("Uniform4ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform4ui, cmd_size);
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform4ui");
   CALL_Uniform4ui(ctx->CurrentServerDispatch, (location, x, y, z, w));
}


/* VertexArrayAttribFormat: marshalled asynchronously */
struct marshal_cmd_VertexArrayAttribFormat
{
   struct marshal_cmd_base cmd_base;
   GLuint vaobj;
   GLuint attribindex;
   GLint size;
   GLenum type;
   GLboolean normalized;
   GLuint relativeoffset;
};
static inline void
_mesa_unmarshal_VertexArrayAttribFormat(struct gl_context *ctx, const struct marshal_cmd_VertexArrayAttribFormat *cmd)
{
   const GLuint vaobj = cmd->vaobj;
   const GLuint attribindex = cmd->attribindex;
   const GLint size = cmd->size;
   const GLenum type = cmd->type;
   const GLboolean normalized = cmd->normalized;
   const GLuint relativeoffset = cmd->relativeoffset;
   CALL_VertexArrayAttribFormat(ctx->CurrentServerDispatch, (vaobj, attribindex, size, type, normalized, relativeoffset));
}
static void GLAPIENTRY
_mesa_marshal_VertexArrayAttribFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexArrayAttribFormat);
   struct marshal_cmd_VertexArrayAttribFormat *cmd;
   debug_print_marshal("VertexArrayAttribFormat");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexArrayAttribFormat, cmd_size);
      cmd->vaobj = vaobj;
      cmd->attribindex = attribindex;
      cmd->size = size;
      cmd->type = type;
      cmd->normalized = normalized;
      cmd->relativeoffset = relativeoffset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexArrayAttribFormat");
   CALL_VertexArrayAttribFormat(ctx->CurrentServerDispatch, (vaobj, attribindex, size, type, normalized, relativeoffset));
}


/* VertexAttrib1fARB: marshalled asynchronously */
struct marshal_cmd_VertexAttrib1fARB
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat x;
};
static inline void
_mesa_unmarshal_VertexAttrib1fARB(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib1fARB *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat x = cmd->x;
   CALL_VertexAttrib1fARB(ctx->CurrentServerDispatch, (index, x));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib1fARB(GLuint index, GLfloat x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib1fARB);
   struct marshal_cmd_VertexAttrib1fARB *cmd;
   debug_print_marshal("VertexAttrib1fARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib1fARB, cmd_size);
      cmd->index = index;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib1fARB");
   CALL_VertexAttrib1fARB(ctx->CurrentServerDispatch, (index, x));
}


/* GetBooleani_v: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetBooleani_v(GLenum value, GLuint index, GLboolean * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetBooleani_v");
   CALL_GetBooleani_v(ctx->CurrentServerDispatch, (value, index, data));
}


/* DrawTexsOES: marshalled asynchronously */
struct marshal_cmd_DrawTexsOES
{
   struct marshal_cmd_base cmd_base;
   GLshort x;
   GLshort y;
   GLshort z;
   GLshort width;
   GLshort height;
};
static inline void
_mesa_unmarshal_DrawTexsOES(struct gl_context *ctx, const struct marshal_cmd_DrawTexsOES *cmd)
{
   const GLshort x = cmd->x;
   const GLshort y = cmd->y;
   const GLshort z = cmd->z;
   const GLshort width = cmd->width;
   const GLshort height = cmd->height;
   CALL_DrawTexsOES(ctx->CurrentServerDispatch, (x, y, z, width, height));
}
static void GLAPIENTRY
_mesa_marshal_DrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawTexsOES);
   struct marshal_cmd_DrawTexsOES *cmd;
   debug_print_marshal("DrawTexsOES");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawTexsOES, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawTexsOES");
   CALL_DrawTexsOES(ctx->CurrentServerDispatch, (x, y, z, width, height));
}


/* GetObjectPtrLabel: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetObjectPtrLabel(const GLvoid * ptr, GLsizei bufSize, GLsizei * length, GLchar * label)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetObjectPtrLabel");
   CALL_GetObjectPtrLabel(ctx->CurrentServerDispatch, (ptr, bufSize, length, label));
}


/* ProgramParameteri: marshalled asynchronously */
struct marshal_cmd_ProgramParameteri
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLenum pname;
   GLint value;
};
static inline void
_mesa_unmarshal_ProgramParameteri(struct gl_context *ctx, const struct marshal_cmd_ProgramParameteri *cmd)
{
   const GLuint program = cmd->program;
   const GLenum pname = cmd->pname;
   const GLint value = cmd->value;
   CALL_ProgramParameteri(ctx->CurrentServerDispatch, (program, pname, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramParameteri(GLuint program, GLenum pname, GLint value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramParameteri);
   struct marshal_cmd_ProgramParameteri *cmd;
   debug_print_marshal("ProgramParameteri");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramParameteri, cmd_size);
      cmd->program = program;
      cmd->pname = pname;
      cmd->value = value;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramParameteri");
   CALL_ProgramParameteri(ctx->CurrentServerDispatch, (program, pname, value));
}


/* Color3fv: marshalled asynchronously */
struct marshal_cmd_Color3fv
{
   struct marshal_cmd_base cmd_base;
   GLfloat v[3];
};
static inline void
_mesa_unmarshal_Color3fv(struct gl_context *ctx, const struct marshal_cmd_Color3fv *cmd)
{
   const GLfloat * v = cmd->v;
   CALL_Color3fv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Color3fv(const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color3fv);
   struct marshal_cmd_Color3fv *cmd;
   debug_print_marshal("Color3fv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color3fv, cmd_size);
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color3fv");
   CALL_Color3fv(ctx->CurrentServerDispatch, (v));
}


/* GetnMapfvARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnMapfvARB(GLenum target, GLenum query, GLsizei bufSize, GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnMapfvARB");
   CALL_GetnMapfvARB(ctx->CurrentServerDispatch, (target, query, bufSize, v));
}


/* MultiTexCoord2i: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord2i
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLint s;
   GLint t;
};
static inline void
_mesa_unmarshal_MultiTexCoord2i(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord2i *cmd)
{
   const GLenum target = cmd->target;
   const GLint s = cmd->s;
   const GLint t = cmd->t;
   CALL_MultiTexCoord2i(ctx->CurrentServerDispatch, (target, s, t));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord2i(GLenum target, GLint s, GLint t)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord2i);
   struct marshal_cmd_MultiTexCoord2i *cmd;
   debug_print_marshal("MultiTexCoord2i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord2i, cmd_size);
      cmd->target = target;
      cmd->s = s;
      cmd->t = t;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord2i");
   CALL_MultiTexCoord2i(ctx->CurrentServerDispatch, (target, s, t));
}


/* MultiTexCoord2d: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord2d
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLdouble s;
   GLdouble t;
};
static inline void
_mesa_unmarshal_MultiTexCoord2d(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord2d *cmd)
{
   const GLenum target = cmd->target;
   const GLdouble s = cmd->s;
   const GLdouble t = cmd->t;
   CALL_MultiTexCoord2d(ctx->CurrentServerDispatch, (target, s, t));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord2d);
   struct marshal_cmd_MultiTexCoord2d *cmd;
   debug_print_marshal("MultiTexCoord2d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord2d, cmd_size);
      cmd->target = target;
      cmd->s = s;
      cmd->t = t;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord2d");
   CALL_MultiTexCoord2d(ctx->CurrentServerDispatch, (target, s, t));
}


/* SamplerParameterIuiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_SamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("SamplerParameterIuiv");
   CALL_SamplerParameterIuiv(ctx->CurrentServerDispatch, (sampler, pname, params));
}


/* MultiTexCoord2s: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord2s
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLshort s;
   GLshort t;
};
static inline void
_mesa_unmarshal_MultiTexCoord2s(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord2s *cmd)
{
   const GLenum target = cmd->target;
   const GLshort s = cmd->s;
   const GLshort t = cmd->t;
   CALL_MultiTexCoord2s(ctx->CurrentServerDispatch, (target, s, t));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord2s(GLenum target, GLshort s, GLshort t)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord2s);
   struct marshal_cmd_MultiTexCoord2s *cmd;
   debug_print_marshal("MultiTexCoord2s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord2s, cmd_size);
      cmd->target = target;
      cmd->s = s;
      cmd->t = t;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord2s");
   CALL_MultiTexCoord2s(ctx->CurrentServerDispatch, (target, s, t));
}


/* GetInternalformati64v: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetInternalformati64v");
   CALL_GetInternalformati64v(ctx->CurrentServerDispatch, (target, internalformat, pname, bufSize, params));
}


/* VDPAURegisterVideoSurfaceNV: marshalled synchronously */
static GLintptr GLAPIENTRY
_mesa_marshal_VDPAURegisterVideoSurfaceNV(const GLvoid * vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint * textureNames)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VDPAURegisterVideoSurfaceNV");
   return CALL_VDPAURegisterVideoSurfaceNV(ctx->CurrentServerDispatch, (vdpSurface, target, numTextureNames, textureNames));
}


/* Indexub: marshalled asynchronously */
struct marshal_cmd_Indexub
{
   struct marshal_cmd_base cmd_base;
   GLubyte c;
};
static inline void
_mesa_unmarshal_Indexub(struct gl_context *ctx, const struct marshal_cmd_Indexub *cmd)
{
   const GLubyte c = cmd->c;
   CALL_Indexub(ctx->CurrentServerDispatch, (c));
}
static void GLAPIENTRY
_mesa_marshal_Indexub(GLubyte c)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Indexub);
   struct marshal_cmd_Indexub *cmd;
   debug_print_marshal("Indexub");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Indexub, cmd_size);
      cmd->c = c;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Indexub");
   CALL_Indexub(ctx->CurrentServerDispatch, (c));
}


/* GetPerfMonitorCounterDataAMD: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint * data, GLint * bytesWritten)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetPerfMonitorCounterDataAMD");
   CALL_GetPerfMonitorCounterDataAMD(ctx->CurrentServerDispatch, (monitor, pname, dataSize, data, bytesWritten));
}


/* MultTransposeMatrixf: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_MultTransposeMatrixf(const GLfloat * m)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MultTransposeMatrixf");
   CALL_MultTransposeMatrixf(ctx->CurrentServerDispatch, (m));
}


/* PolygonOffsetEXT: marshalled asynchronously */
struct marshal_cmd_PolygonOffsetEXT
{
   struct marshal_cmd_base cmd_base;
   GLfloat factor;
   GLfloat bias;
};
static inline void
_mesa_unmarshal_PolygonOffsetEXT(struct gl_context *ctx, const struct marshal_cmd_PolygonOffsetEXT *cmd)
{
   const GLfloat factor = cmd->factor;
   const GLfloat bias = cmd->bias;
   CALL_PolygonOffsetEXT(ctx->CurrentServerDispatch, (factor, bias));
}
static void GLAPIENTRY
_mesa_marshal_PolygonOffsetEXT(GLfloat factor, GLfloat bias)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PolygonOffsetEXT);
   struct marshal_cmd_PolygonOffsetEXT *cmd;
   debug_print_marshal("PolygonOffsetEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PolygonOffsetEXT, cmd_size);
      cmd->factor = factor;
      cmd->bias = bias;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PolygonOffsetEXT");
   CALL_PolygonOffsetEXT(ctx->CurrentServerDispatch, (factor, bias));
}


/* Scalex: marshalled asynchronously */
struct marshal_cmd_Scalex
{
   struct marshal_cmd_base cmd_base;
   GLfixed x;
   GLfixed y;
   GLfixed z;
};
static inline void
_mesa_unmarshal_Scalex(struct gl_context *ctx, const struct marshal_cmd_Scalex *cmd)
{
   const GLfixed x = cmd->x;
   const GLfixed y = cmd->y;
   const GLfixed z = cmd->z;
   CALL_Scalex(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_Scalex(GLfixed x, GLfixed y, GLfixed z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Scalex);
   struct marshal_cmd_Scalex *cmd;
   debug_print_marshal("Scalex");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Scalex, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Scalex");
   CALL_Scalex(ctx->CurrentServerDispatch, (x, y, z));
}


/* Scaled: marshalled asynchronously */
struct marshal_cmd_Scaled
{
   struct marshal_cmd_base cmd_base;
   GLdouble x;
   GLdouble y;
   GLdouble z;
};
static inline void
_mesa_unmarshal_Scaled(struct gl_context *ctx, const struct marshal_cmd_Scaled *cmd)
{
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   CALL_Scaled(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_Scaled(GLdouble x, GLdouble y, GLdouble z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Scaled);
   struct marshal_cmd_Scaled *cmd;
   debug_print_marshal("Scaled");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Scaled, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Scaled");
   CALL_Scaled(ctx->CurrentServerDispatch, (x, y, z));
}


/* Scalef: marshalled asynchronously */
struct marshal_cmd_Scalef
{
   struct marshal_cmd_base cmd_base;
   GLfloat x;
   GLfloat y;
   GLfloat z;
};
static inline void
_mesa_unmarshal_Scalef(struct gl_context *ctx, const struct marshal_cmd_Scalef *cmd)
{
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   CALL_Scalef(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_Scalef(GLfloat x, GLfloat y, GLfloat z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Scalef);
   struct marshal_cmd_Scalef *cmd;
   debug_print_marshal("Scalef");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Scalef, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Scalef");
   CALL_Scalef(ctx->CurrentServerDispatch, (x, y, z));
}


/* IndexPointerEXT: marshalled asynchronously */
struct marshal_cmd_IndexPointerEXT
{
   struct marshal_cmd_base cmd_base;
   GLenum type;
   GLsizei stride;
   GLsizei count;
   const GLvoid * pointer;
};
static inline void
_mesa_unmarshal_IndexPointerEXT(struct gl_context *ctx, const struct marshal_cmd_IndexPointerEXT *cmd)
{
   const GLenum type = cmd->type;
   const GLsizei stride = cmd->stride;
   const GLsizei count = cmd->count;
   const GLvoid * pointer = cmd->pointer;
   CALL_IndexPointerEXT(ctx->CurrentServerDispatch, (type, stride, count, pointer));
}
static void GLAPIENTRY
_mesa_marshal_IndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_IndexPointerEXT);
   struct marshal_cmd_IndexPointerEXT *cmd;
   debug_print_marshal("IndexPointerEXT");
   if (_mesa_glthread_is_non_vbo_vertex_attrib_pointer(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("IndexPointerEXT");
      CALL_IndexPointerEXT(ctx->CurrentServerDispatch, (type, stride, count, pointer));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_IndexPointerEXT, cmd_size);
      cmd->type = type;
      cmd->stride = stride;
      cmd->count = count;
      cmd->pointer = pointer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("IndexPointerEXT");
   CALL_IndexPointerEXT(ctx->CurrentServerDispatch, (type, stride, count, pointer));
}


/* GetUniformfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetUniformfv(GLuint program, GLint location, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetUniformfv");
   CALL_GetUniformfv(ctx->CurrentServerDispatch, (program, location, params));
}


/* ColorFragmentOp2ATI: marshalled asynchronously */
struct marshal_cmd_ColorFragmentOp2ATI
{
   struct marshal_cmd_base cmd_base;
   GLenum op;
   GLuint dst;
   GLuint dstMask;
   GLuint dstMod;
   GLuint arg1;
   GLuint arg1Rep;
   GLuint arg1Mod;
   GLuint arg2;
   GLuint arg2Rep;
   GLuint arg2Mod;
};
static inline void
_mesa_unmarshal_ColorFragmentOp2ATI(struct gl_context *ctx, const struct marshal_cmd_ColorFragmentOp2ATI *cmd)
{
   const GLenum op = cmd->op;
   const GLuint dst = cmd->dst;
   const GLuint dstMask = cmd->dstMask;
   const GLuint dstMod = cmd->dstMod;
   const GLuint arg1 = cmd->arg1;
   const GLuint arg1Rep = cmd->arg1Rep;
   const GLuint arg1Mod = cmd->arg1Mod;
   const GLuint arg2 = cmd->arg2;
   const GLuint arg2Rep = cmd->arg2Rep;
   const GLuint arg2Mod = cmd->arg2Mod;
   CALL_ColorFragmentOp2ATI(ctx->CurrentServerDispatch, (op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod));
}
static void GLAPIENTRY
_mesa_marshal_ColorFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ColorFragmentOp2ATI);
   struct marshal_cmd_ColorFragmentOp2ATI *cmd;
   debug_print_marshal("ColorFragmentOp2ATI");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ColorFragmentOp2ATI, cmd_size);
      cmd->op = op;
      cmd->dst = dst;
      cmd->dstMask = dstMask;
      cmd->dstMod = dstMod;
      cmd->arg1 = arg1;
      cmd->arg1Rep = arg1Rep;
      cmd->arg1Mod = arg1Mod;
      cmd->arg2 = arg2;
      cmd->arg2Rep = arg2Rep;
      cmd->arg2Mod = arg2Mod;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ColorFragmentOp2ATI");
   CALL_ColorFragmentOp2ATI(ctx->CurrentServerDispatch, (op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod));
}


/* VertexAttrib2sNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib2sNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLshort x;
   GLshort y;
};
static inline void
_mesa_unmarshal_VertexAttrib2sNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib2sNV *cmd)
{
   const GLuint index = cmd->index;
   const GLshort x = cmd->x;
   const GLshort y = cmd->y;
   CALL_VertexAttrib2sNV(ctx->CurrentServerDispatch, (index, x, y));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib2sNV(GLuint index, GLshort x, GLshort y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib2sNV);
   struct marshal_cmd_VertexAttrib2sNV *cmd;
   debug_print_marshal("VertexAttrib2sNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib2sNV, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib2sNV");
   CALL_VertexAttrib2sNV(ctx->CurrentServerDispatch, (index, x, y));
}


/* ReadPixels: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * pixels)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ReadPixels");
   CALL_ReadPixels(ctx->CurrentServerDispatch, (x, y, width, height, format, type, pixels));
}


/* QueryCounter: marshalled asynchronously */
struct marshal_cmd_QueryCounter
{
   struct marshal_cmd_base cmd_base;
   GLuint id;
   GLenum target;
};
static inline void
_mesa_unmarshal_QueryCounter(struct gl_context *ctx, const struct marshal_cmd_QueryCounter *cmd)
{
   const GLuint id = cmd->id;
   const GLenum target = cmd->target;
   CALL_QueryCounter(ctx->CurrentServerDispatch, (id, target));
}
static void GLAPIENTRY
_mesa_marshal_QueryCounter(GLuint id, GLenum target)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_QueryCounter);
   struct marshal_cmd_QueryCounter *cmd;
   debug_print_marshal("QueryCounter");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_QueryCounter, cmd_size);
      cmd->id = id;
      cmd->target = target;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("QueryCounter");
   CALL_QueryCounter(ctx->CurrentServerDispatch, (id, target));
}


/* NormalPointerEXT: marshalled asynchronously */
struct marshal_cmd_NormalPointerEXT
{
   struct marshal_cmd_base cmd_base;
   GLenum type;
   GLsizei stride;
   GLsizei count;
   const GLvoid * pointer;
};
static inline void
_mesa_unmarshal_NormalPointerEXT(struct gl_context *ctx, const struct marshal_cmd_NormalPointerEXT *cmd)
{
   const GLenum type = cmd->type;
   const GLsizei stride = cmd->stride;
   const GLsizei count = cmd->count;
   const GLvoid * pointer = cmd->pointer;
   CALL_NormalPointerEXT(ctx->CurrentServerDispatch, (type, stride, count, pointer));
}
static void GLAPIENTRY
_mesa_marshal_NormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_NormalPointerEXT);
   struct marshal_cmd_NormalPointerEXT *cmd;
   debug_print_marshal("NormalPointerEXT");
   if (_mesa_glthread_is_non_vbo_vertex_attrib_pointer(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("NormalPointerEXT");
      CALL_NormalPointerEXT(ctx->CurrentServerDispatch, (type, stride, count, pointer));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_NormalPointerEXT, cmd_size);
      cmd->type = type;
      cmd->stride = stride;
      cmd->count = count;
      cmd->pointer = pointer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("NormalPointerEXT");
   CALL_NormalPointerEXT(ctx->CurrentServerDispatch, (type, stride, count, pointer));
}


/* GetSubroutineIndex: marshalled synchronously */
static GLuint GLAPIENTRY
_mesa_marshal_GetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetSubroutineIndex");
   return CALL_GetSubroutineIndex(ctx->CurrentServerDispatch, (program, shadertype, name));
}


/* ProgramUniform3iv: marshalled asynchronously */
struct marshal_cmd_ProgramUniform3iv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 12) bytes are GLint value[count][3] */
};
static inline void
_mesa_unmarshal_ProgramUniform3iv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform3iv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLint * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLint *) variable_data;
   variable_data += count * 12;
   CALL_ProgramUniform3iv(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform3iv) + safe_mul(count, 12);
   struct marshal_cmd_ProgramUniform3iv *cmd;
   debug_print_marshal("ProgramUniform3iv");
   if (unlikely(safe_mul(count, 12) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform3iv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 12);
      variable_data += count * 12;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform3iv");
   CALL_ProgramUniform3iv(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* ProgramUniformMatrix2dv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix2dv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 32) bytes are GLdouble value[count][4] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix2dv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix2dv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 32;
   CALL_ProgramUniformMatrix2dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix2dv) + safe_mul(count, 32);
   struct marshal_cmd_ProgramUniformMatrix2dv *cmd;
   debug_print_marshal("ProgramUniformMatrix2dv");
   if (unlikely(safe_mul(count, 32) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix2dv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 32);
      variable_data += count * 32;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix2dv");
   CALL_ProgramUniformMatrix2dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* ClearTexSubImage: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ClearTexSubImage");
   CALL_ClearTexSubImage(ctx->CurrentServerDispatch, (texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data));
}


/* GetActiveUniformBlockName: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetActiveUniformBlockName");
   CALL_GetActiveUniformBlockName(ctx->CurrentServerDispatch, (program, uniformBlockIndex, bufSize, length, uniformBlockName));
}


/* DrawElementsBaseVertex: marshalled asynchronously */
struct marshal_cmd_DrawElementsBaseVertex
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLsizei count;
   GLenum type;
   const GLvoid * indices;
   GLint basevertex;
};
static inline void
_mesa_unmarshal_DrawElementsBaseVertex(struct gl_context *ctx, const struct marshal_cmd_DrawElementsBaseVertex *cmd)
{
   const GLenum mode = cmd->mode;
   const GLsizei count = cmd->count;
   const GLenum type = cmd->type;
   const GLvoid * indices = cmd->indices;
   const GLint basevertex = cmd->basevertex;
   CALL_DrawElementsBaseVertex(ctx->CurrentServerDispatch, (mode, count, type, indices, basevertex));
}
static void GLAPIENTRY
_mesa_marshal_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLint basevertex)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawElementsBaseVertex);
   struct marshal_cmd_DrawElementsBaseVertex *cmd;
   debug_print_marshal("DrawElementsBaseVertex");
   if (_mesa_glthread_is_non_vbo_draw_elements(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("DrawElementsBaseVertex");
      CALL_DrawElementsBaseVertex(ctx->CurrentServerDispatch, (mode, count, type, indices, basevertex));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawElementsBaseVertex, cmd_size);
      cmd->mode = mode;
      cmd->count = count;
      cmd->type = type;
      cmd->indices = indices;
      cmd->basevertex = basevertex;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawElementsBaseVertex");
   CALL_DrawElementsBaseVertex(ctx->CurrentServerDispatch, (mode, count, type, indices, basevertex));
}


/* RasterPos3iv: marshalled asynchronously */
struct marshal_cmd_RasterPos3iv
{
   struct marshal_cmd_base cmd_base;
   GLint v[3];
};
static inline void
_mesa_unmarshal_RasterPos3iv(struct gl_context *ctx, const struct marshal_cmd_RasterPos3iv *cmd)
{
   const GLint * v = cmd->v;
   CALL_RasterPos3iv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos3iv(const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos3iv);
   struct marshal_cmd_RasterPos3iv *cmd;
   debug_print_marshal("RasterPos3iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos3iv, cmd_size);
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos3iv");
   CALL_RasterPos3iv(ctx->CurrentServerDispatch, (v));
}


/* ColorMaski: marshalled asynchronously */
struct marshal_cmd_ColorMaski
{
   struct marshal_cmd_base cmd_base;
   GLuint buf;
   GLboolean r;
   GLboolean g;
   GLboolean b;
   GLboolean a;
};
static inline void
_mesa_unmarshal_ColorMaski(struct gl_context *ctx, const struct marshal_cmd_ColorMaski *cmd)
{
   const GLuint buf = cmd->buf;
   const GLboolean r = cmd->r;
   const GLboolean g = cmd->g;
   const GLboolean b = cmd->b;
   const GLboolean a = cmd->a;
   CALL_ColorMaski(ctx->CurrentServerDispatch, (buf, r, g, b, a));
}
static void GLAPIENTRY
_mesa_marshal_ColorMaski(GLuint buf, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ColorMaski);
   struct marshal_cmd_ColorMaski *cmd;
   debug_print_marshal("ColorMaski");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ColorMaski, cmd_size);
      cmd->buf = buf;
      cmd->r = r;
      cmd->g = g;
      cmd->b = b;
      cmd->a = a;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ColorMaski");
   CALL_ColorMaski(ctx->CurrentServerDispatch, (buf, r, g, b, a));
}


/* Uniform2uiv: marshalled asynchronously */
struct marshal_cmd_Uniform2uiv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 8) bytes are GLuint value[count][2] */
};
static inline void
_mesa_unmarshal_Uniform2uiv(struct gl_context *ctx, const struct marshal_cmd_Uniform2uiv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLuint * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLuint *) variable_data;
   variable_data += count * 8;
   CALL_Uniform2uiv(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform2uiv(GLint location, GLsizei count, const GLuint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform2uiv) + safe_mul(count, 8);
   struct marshal_cmd_Uniform2uiv *cmd;
   debug_print_marshal("Uniform2uiv");
   if (unlikely(safe_mul(count, 8) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform2uiv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 8);
      variable_data += count * 8;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform2uiv");
   CALL_Uniform2uiv(ctx->CurrentServerDispatch, (location, count, value));
}


/* RasterPos3s: marshalled asynchronously */
struct marshal_cmd_RasterPos3s
{
   struct marshal_cmd_base cmd_base;
   GLshort x;
   GLshort y;
   GLshort z;
};
static inline void
_mesa_unmarshal_RasterPos3s(struct gl_context *ctx, const struct marshal_cmd_RasterPos3s *cmd)
{
   const GLshort x = cmd->x;
   const GLshort y = cmd->y;
   const GLshort z = cmd->z;
   CALL_RasterPos3s(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos3s(GLshort x, GLshort y, GLshort z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos3s);
   struct marshal_cmd_RasterPos3s *cmd;
   debug_print_marshal("RasterPos3s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos3s, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos3s");
   CALL_RasterPos3s(ctx->CurrentServerDispatch, (x, y, z));
}


/* RasterPos3d: marshalled asynchronously */
struct marshal_cmd_RasterPos3d
{
   struct marshal_cmd_base cmd_base;
   GLdouble x;
   GLdouble y;
   GLdouble z;
};
static inline void
_mesa_unmarshal_RasterPos3d(struct gl_context *ctx, const struct marshal_cmd_RasterPos3d *cmd)
{
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   CALL_RasterPos3d(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos3d(GLdouble x, GLdouble y, GLdouble z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos3d);
   struct marshal_cmd_RasterPos3d *cmd;
   debug_print_marshal("RasterPos3d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos3d, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos3d");
   CALL_RasterPos3d(ctx->CurrentServerDispatch, (x, y, z));
}


/* RasterPos3f: marshalled asynchronously */
struct marshal_cmd_RasterPos3f
{
   struct marshal_cmd_base cmd_base;
   GLfloat x;
   GLfloat y;
   GLfloat z;
};
static inline void
_mesa_unmarshal_RasterPos3f(struct gl_context *ctx, const struct marshal_cmd_RasterPos3f *cmd)
{
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   CALL_RasterPos3f(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos3f(GLfloat x, GLfloat y, GLfloat z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos3f);
   struct marshal_cmd_RasterPos3f *cmd;
   debug_print_marshal("RasterPos3f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos3f, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos3f");
   CALL_RasterPos3f(ctx->CurrentServerDispatch, (x, y, z));
}


/* BindVertexArray: marshalled asynchronously */
struct marshal_cmd_BindVertexArray
{
   struct marshal_cmd_base cmd_base;
   GLuint array;
};
static inline void
_mesa_unmarshal_BindVertexArray(struct gl_context *ctx, const struct marshal_cmd_BindVertexArray *cmd)
{
   const GLuint array = cmd->array;
   CALL_BindVertexArray(ctx->CurrentServerDispatch, (array));
}
static void GLAPIENTRY
_mesa_marshal_BindVertexArray(GLuint array)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BindVertexArray);
   struct marshal_cmd_BindVertexArray *cmd;
   debug_print_marshal("BindVertexArray");
   if (_mesa_glthread_is_compat_bind_vertex_array(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("BindVertexArray");
      CALL_BindVertexArray(ctx->CurrentServerDispatch, (array));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BindVertexArray, cmd_size);
      cmd->array = array;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BindVertexArray");
   CALL_BindVertexArray(ctx->CurrentServerDispatch, (array));
}


/* RasterPos3i: marshalled asynchronously */
struct marshal_cmd_RasterPos3i
{
   struct marshal_cmd_base cmd_base;
   GLint x;
   GLint y;
   GLint z;
};
static inline void
_mesa_unmarshal_RasterPos3i(struct gl_context *ctx, const struct marshal_cmd_RasterPos3i *cmd)
{
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLint z = cmd->z;
   CALL_RasterPos3i(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos3i(GLint x, GLint y, GLint z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos3i);
   struct marshal_cmd_RasterPos3i *cmd;
   debug_print_marshal("RasterPos3i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos3i, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos3i");
   CALL_RasterPos3i(ctx->CurrentServerDispatch, (x, y, z));
}


/* VertexAttribL3dv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribL3dv(GLuint index, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribL3dv");
   CALL_VertexAttribL3dv(ctx->CurrentServerDispatch, (index, v));
}


/* GetTexParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTexParameteriv(GLenum target, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTexParameteriv");
   CALL_GetTexParameteriv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* DrawTransformFeedbackStreamInstanced: marshalled asynchronously */
struct marshal_cmd_DrawTransformFeedbackStreamInstanced
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLuint id;
   GLuint stream;
   GLsizei primcount;
};
static inline void
_mesa_unmarshal_DrawTransformFeedbackStreamInstanced(struct gl_context *ctx, const struct marshal_cmd_DrawTransformFeedbackStreamInstanced *cmd)
{
   const GLenum mode = cmd->mode;
   const GLuint id = cmd->id;
   const GLuint stream = cmd->stream;
   const GLsizei primcount = cmd->primcount;
   CALL_DrawTransformFeedbackStreamInstanced(ctx->CurrentServerDispatch, (mode, id, stream, primcount));
}
static void GLAPIENTRY
_mesa_marshal_DrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei primcount)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawTransformFeedbackStreamInstanced);
   struct marshal_cmd_DrawTransformFeedbackStreamInstanced *cmd;
   debug_print_marshal("DrawTransformFeedbackStreamInstanced");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawTransformFeedbackStreamInstanced, cmd_size);
      cmd->mode = mode;
      cmd->id = id;
      cmd->stream = stream;
      cmd->primcount = primcount;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawTransformFeedbackStreamInstanced");
   CALL_DrawTransformFeedbackStreamInstanced(ctx->CurrentServerDispatch, (mode, id, stream, primcount));
}


/* VertexAttrib2fvARB: marshalled asynchronously */
struct marshal_cmd_VertexAttrib2fvARB
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat v[2];
};
static inline void
_mesa_unmarshal_VertexAttrib2fvARB(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib2fvARB *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat * v = cmd->v;
   CALL_VertexAttrib2fvARB(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib2fvARB(GLuint index, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib2fvARB);
   struct marshal_cmd_VertexAttrib2fvARB *cmd;
   debug_print_marshal("VertexAttrib2fvARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib2fvARB, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib2fvARB");
   CALL_VertexAttrib2fvARB(ctx->CurrentServerDispatch, (index, v));
}


/* GetProgramResourceName: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei  bufSize, GLsizei * length, GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramResourceName");
   CALL_GetProgramResourceName(ctx->CurrentServerDispatch, (program, programInterface, index, bufSize, length, name));
}


/* ProgramUniformMatrix4x3dv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix4x3dv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 96) bytes are GLdouble value[count][12] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix4x3dv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix4x3dv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 96;
   CALL_ProgramUniformMatrix4x3dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix4x3dv) + safe_mul(count, 96);
   struct marshal_cmd_ProgramUniformMatrix4x3dv *cmd;
   debug_print_marshal("ProgramUniformMatrix4x3dv");
   if (unlikely(safe_mul(count, 96) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix4x3dv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 96);
      variable_data += count * 96;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix4x3dv");
   CALL_ProgramUniformMatrix4x3dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* ColorTable: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * table)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ColorTable");
   CALL_ColorTable(ctx->CurrentServerDispatch, (target, internalformat, width, format, type, table));
}


/* LoadName: marshalled asynchronously */
struct marshal_cmd_LoadName
{
   struct marshal_cmd_base cmd_base;
   GLuint name;
};
static inline void
_mesa_unmarshal_LoadName(struct gl_context *ctx, const struct marshal_cmd_LoadName *cmd)
{
   const GLuint name = cmd->name;
   CALL_LoadName(ctx->CurrentServerDispatch, (name));
}
static void GLAPIENTRY
_mesa_marshal_LoadName(GLuint name)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_LoadName);
   struct marshal_cmd_LoadName *cmd;
   debug_print_marshal("LoadName");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_LoadName, cmd_size);
      cmd->name = name;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("LoadName");
   CALL_LoadName(ctx->CurrentServerDispatch, (name));
}


/* GetnUniformuivARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnUniformuivARB(GLuint program, GLint location, GLsizei bufSize, GLuint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnUniformuivARB");
   CALL_GetnUniformuivARB(ctx->CurrentServerDispatch, (program, location, bufSize, params));
}


/* ClearIndex: marshalled asynchronously */
struct marshal_cmd_ClearIndex
{
   struct marshal_cmd_base cmd_base;
   GLfloat c;
};
static inline void
_mesa_unmarshal_ClearIndex(struct gl_context *ctx, const struct marshal_cmd_ClearIndex *cmd)
{
   const GLfloat c = cmd->c;
   CALL_ClearIndex(ctx->CurrentServerDispatch, (c));
}
static void GLAPIENTRY
_mesa_marshal_ClearIndex(GLfloat c)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ClearIndex);
   struct marshal_cmd_ClearIndex *cmd;
   debug_print_marshal("ClearIndex");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ClearIndex, cmd_size);
      cmd->c = c;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ClearIndex");
   CALL_ClearIndex(ctx->CurrentServerDispatch, (c));
}


/* ConvolutionParameterfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ConvolutionParameterfv");
   CALL_ConvolutionParameterfv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* GetTexGendv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTexGendv(GLenum coord, GLenum pname, GLdouble * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTexGendv");
   CALL_GetTexGendv(ctx->CurrentServerDispatch, (coord, pname, params));
}


/* FlushMappedNamedBufferRange: marshalled asynchronously */
struct marshal_cmd_FlushMappedNamedBufferRange
{
   struct marshal_cmd_base cmd_base;
   GLuint buffer;
   GLintptr offset;
   GLsizeiptr length;
};
static inline void
_mesa_unmarshal_FlushMappedNamedBufferRange(struct gl_context *ctx, const struct marshal_cmd_FlushMappedNamedBufferRange *cmd)
{
   const GLuint buffer = cmd->buffer;
   const GLintptr offset = cmd->offset;
   const GLsizeiptr length = cmd->length;
   CALL_FlushMappedNamedBufferRange(ctx->CurrentServerDispatch, (buffer, offset, length));
}
static void GLAPIENTRY
_mesa_marshal_FlushMappedNamedBufferRange(GLuint buffer, GLintptr offset, GLsizeiptr length)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_FlushMappedNamedBufferRange);
   struct marshal_cmd_FlushMappedNamedBufferRange *cmd;
   debug_print_marshal("FlushMappedNamedBufferRange");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_FlushMappedNamedBufferRange, cmd_size);
      cmd->buffer = buffer;
      cmd->offset = offset;
      cmd->length = length;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("FlushMappedNamedBufferRange");
   CALL_FlushMappedNamedBufferRange(ctx->CurrentServerDispatch, (buffer, offset, length));
}


/* MultiTexCoordP1ui: marshalled asynchronously */
struct marshal_cmd_MultiTexCoordP1ui
{
   struct marshal_cmd_base cmd_base;
   GLenum texture;
   GLenum type;
   GLuint coords;
};
static inline void
_mesa_unmarshal_MultiTexCoordP1ui(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoordP1ui *cmd)
{
   const GLenum texture = cmd->texture;
   const GLenum type = cmd->type;
   const GLuint coords = cmd->coords;
   CALL_MultiTexCoordP1ui(ctx->CurrentServerDispatch, (texture, type, coords));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoordP1ui);
   struct marshal_cmd_MultiTexCoordP1ui *cmd;
   debug_print_marshal("MultiTexCoordP1ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoordP1ui, cmd_size);
      cmd->texture = texture;
      cmd->type = type;
      cmd->coords = coords;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoordP1ui");
   CALL_MultiTexCoordP1ui(ctx->CurrentServerDispatch, (texture, type, coords));
}


/* EvalMesh2: marshalled asynchronously */
struct marshal_cmd_EvalMesh2
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLint i1;
   GLint i2;
   GLint j1;
   GLint j2;
};
static inline void
_mesa_unmarshal_EvalMesh2(struct gl_context *ctx, const struct marshal_cmd_EvalMesh2 *cmd)
{
   const GLenum mode = cmd->mode;
   const GLint i1 = cmd->i1;
   const GLint i2 = cmd->i2;
   const GLint j1 = cmd->j1;
   const GLint j2 = cmd->j2;
   CALL_EvalMesh2(ctx->CurrentServerDispatch, (mode, i1, i2, j1, j2));
}
static void GLAPIENTRY
_mesa_marshal_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EvalMesh2);
   struct marshal_cmd_EvalMesh2 *cmd;
   debug_print_marshal("EvalMesh2");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EvalMesh2, cmd_size);
      cmd->mode = mode;
      cmd->i1 = i1;
      cmd->i2 = i2;
      cmd->j1 = j1;
      cmd->j2 = j2;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EvalMesh2");
   CALL_EvalMesh2(ctx->CurrentServerDispatch, (mode, i1, i2, j1, j2));
}


/* Vertex4fv: marshalled asynchronously */
struct marshal_cmd_Vertex4fv
{
   struct marshal_cmd_base cmd_base;
   GLfloat v[4];
};
static inline void
_mesa_unmarshal_Vertex4fv(struct gl_context *ctx, const struct marshal_cmd_Vertex4fv *cmd)
{
   const GLfloat * v = cmd->v;
   CALL_Vertex4fv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Vertex4fv(const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex4fv);
   struct marshal_cmd_Vertex4fv *cmd;
   debug_print_marshal("Vertex4fv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex4fv, cmd_size);
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex4fv");
   CALL_Vertex4fv(ctx->CurrentServerDispatch, (v));
}


/* ProgramUniform4i64ARB: marshalled asynchronously */
struct marshal_cmd_ProgramUniform4i64ARB
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLint64 x;
   GLint64 y;
   GLint64 z;
   GLint64 w;
};
static inline void
_mesa_unmarshal_ProgramUniform4i64ARB(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform4i64ARB *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLint64 x = cmd->x;
   const GLint64 y = cmd->y;
   const GLint64 z = cmd->z;
   const GLint64 w = cmd->w;
   CALL_ProgramUniform4i64ARB(ctx->CurrentServerDispatch, (program, location, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform4i64ARB(GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform4i64ARB);
   struct marshal_cmd_ProgramUniform4i64ARB *cmd;
   debug_print_marshal("ProgramUniform4i64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform4i64ARB, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform4i64ARB");
   CALL_ProgramUniform4i64ARB(ctx->CurrentServerDispatch, (program, location, x, y, z, w));
}


/* SelectPerfMonitorCountersAMD: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_SelectPerfMonitorCountersAMD(GLuint monitor, GLboolean enable, GLuint group, GLint numCounters, GLuint * counterList)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("SelectPerfMonitorCountersAMD");
   CALL_SelectPerfMonitorCountersAMD(ctx->CurrentServerDispatch, (monitor, enable, group, numCounters, counterList));
}


/* TextureStorage2D: marshalled asynchronously */
struct marshal_cmd_TextureStorage2D
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLsizei levels;
   GLenum internalformat;
   GLsizei width;
   GLsizei height;
};
static inline void
_mesa_unmarshal_TextureStorage2D(struct gl_context *ctx, const struct marshal_cmd_TextureStorage2D *cmd)
{
   const GLuint texture = cmd->texture;
   const GLsizei levels = cmd->levels;
   const GLenum internalformat = cmd->internalformat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   CALL_TextureStorage2D(ctx->CurrentServerDispatch, (texture, levels, internalformat, width, height));
}
static void GLAPIENTRY
_mesa_marshal_TextureStorage2D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureStorage2D);
   struct marshal_cmd_TextureStorage2D *cmd;
   debug_print_marshal("TextureStorage2D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureStorage2D, cmd_size);
      cmd->texture = texture;
      cmd->levels = levels;
      cmd->internalformat = internalformat;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureStorage2D");
   CALL_TextureStorage2D(ctx->CurrentServerDispatch, (texture, levels, internalformat, width, height));
}


/* GetTextureParameterIiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTextureParameterIiv(GLuint texture, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTextureParameterIiv");
   CALL_GetTextureParameterIiv(ctx->CurrentServerDispatch, (texture, pname, params));
}


/* BindFramebuffer: marshalled asynchronously */
struct marshal_cmd_BindFramebuffer
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint framebuffer;
};
static inline void
_mesa_unmarshal_BindFramebuffer(struct gl_context *ctx, const struct marshal_cmd_BindFramebuffer *cmd)
{
   const GLenum target = cmd->target;
   const GLuint framebuffer = cmd->framebuffer;
   CALL_BindFramebuffer(ctx->CurrentServerDispatch, (target, framebuffer));
}
static void GLAPIENTRY
_mesa_marshal_BindFramebuffer(GLenum target, GLuint framebuffer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BindFramebuffer);
   struct marshal_cmd_BindFramebuffer *cmd;
   debug_print_marshal("BindFramebuffer");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BindFramebuffer, cmd_size);
      cmd->target = target;
      cmd->framebuffer = framebuffer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BindFramebuffer");
   CALL_BindFramebuffer(ctx->CurrentServerDispatch, (target, framebuffer));
}


/* GetMinmax: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetMinmax");
   CALL_GetMinmax(ctx->CurrentServerDispatch, (target, reset, format, type, values));
}


/* VertexAttribs3svNV: marshalled asynchronously */
struct marshal_cmd_VertexAttribs3svNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLsizei n;
   /* Next safe_mul(n, 6) bytes are GLshort v[n][3] */
};
static inline void
_mesa_unmarshal_VertexAttribs3svNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttribs3svNV *cmd)
{
   const GLuint index = cmd->index;
   const GLsizei n = cmd->n;
   const GLshort * v;
   const char *variable_data = (const char *) (cmd + 1);
   v = (const GLshort *) variable_data;
   variable_data += n * 6;
   CALL_VertexAttribs3svNV(ctx->CurrentServerDispatch, (index, n, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribs3svNV(GLuint index, GLsizei n, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribs3svNV) + safe_mul(n, 6);
   struct marshal_cmd_VertexAttribs3svNV *cmd;
   debug_print_marshal("VertexAttribs3svNV");
   if (unlikely(safe_mul(n, 6) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribs3svNV, cmd_size);
      cmd->index = index;
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, v, n * 6);
      variable_data += n * 6;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribs3svNV");
   CALL_VertexAttribs3svNV(ctx->CurrentServerDispatch, (index, n, v));
}


/* GetActiveUniformsiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetActiveUniformsiv");
   CALL_GetActiveUniformsiv(ctx->CurrentServerDispatch, (program, uniformCount, uniformIndices, pname, params));
}


/* VertexAttrib2sv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib2sv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLshort v[2];
};
static inline void
_mesa_unmarshal_VertexAttrib2sv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib2sv *cmd)
{
   const GLuint index = cmd->index;
   const GLshort * v = cmd->v;
   CALL_VertexAttrib2sv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib2sv(GLuint index, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib2sv);
   struct marshal_cmd_VertexAttrib2sv *cmd;
   debug_print_marshal("VertexAttrib2sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib2sv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib2sv");
   CALL_VertexAttrib2sv(ctx->CurrentServerDispatch, (index, v));
}


/* GetProgramEnvParameterdvARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramEnvParameterdvARB");
   CALL_GetProgramEnvParameterdvARB(ctx->CurrentServerDispatch, (target, index, params));
}


/* Uniform1dv: marshalled asynchronously */
struct marshal_cmd_Uniform1dv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 8) bytes are GLdouble value[count] */
};
static inline void
_mesa_unmarshal_Uniform1dv(struct gl_context *ctx, const struct marshal_cmd_Uniform1dv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 8;
   CALL_Uniform1dv(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform1dv(GLint location, GLsizei count, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform1dv) + safe_mul(count, 8);
   struct marshal_cmd_Uniform1dv *cmd;
   debug_print_marshal("Uniform1dv");
   if (unlikely(safe_mul(count, 8) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform1dv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 8);
      variable_data += count * 8;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform1dv");
   CALL_Uniform1dv(ctx->CurrentServerDispatch, (location, count, value));
}


/* TransformFeedbackBufferRange: marshalled asynchronously */
struct marshal_cmd_TransformFeedbackBufferRange
{
   struct marshal_cmd_base cmd_base;
   GLuint xfb;
   GLuint index;
   GLuint buffer;
   GLintptr offset;
   GLsizeiptr size;
};
static inline void
_mesa_unmarshal_TransformFeedbackBufferRange(struct gl_context *ctx, const struct marshal_cmd_TransformFeedbackBufferRange *cmd)
{
   const GLuint xfb = cmd->xfb;
   const GLuint index = cmd->index;
   const GLuint buffer = cmd->buffer;
   const GLintptr offset = cmd->offset;
   const GLsizeiptr size = cmd->size;
   CALL_TransformFeedbackBufferRange(ctx->CurrentServerDispatch, (xfb, index, buffer, offset, size));
}
static void GLAPIENTRY
_mesa_marshal_TransformFeedbackBufferRange(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TransformFeedbackBufferRange);
   struct marshal_cmd_TransformFeedbackBufferRange *cmd;
   debug_print_marshal("TransformFeedbackBufferRange");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TransformFeedbackBufferRange, cmd_size);
      cmd->xfb = xfb;
      cmd->index = index;
      cmd->buffer = buffer;
      cmd->offset = offset;
      cmd->size = size;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TransformFeedbackBufferRange");
   CALL_TransformFeedbackBufferRange(ctx->CurrentServerDispatch, (xfb, index, buffer, offset, size));
}


/* PushDebugGroup: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_PushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar * message)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("PushDebugGroup");
   CALL_PushDebugGroup(ctx->CurrentServerDispatch, (source, id, length, message));
}


/* GetPerfMonitorGroupStringAMD: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei * length, GLchar * groupString)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetPerfMonitorGroupStringAMD");
   CALL_GetPerfMonitorGroupStringAMD(ctx->CurrentServerDispatch, (group, bufSize, length, groupString));
}


/* GetError: marshalled synchronously */
static GLenum GLAPIENTRY
_mesa_marshal_GetError(void)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetError");
   return CALL_GetError(ctx->CurrentServerDispatch, ());
}


/* PassThrough: marshalled asynchronously */
struct marshal_cmd_PassThrough
{
   struct marshal_cmd_base cmd_base;
   GLfloat token;
};
static inline void
_mesa_unmarshal_PassThrough(struct gl_context *ctx, const struct marshal_cmd_PassThrough *cmd)
{
   const GLfloat token = cmd->token;
   CALL_PassThrough(ctx->CurrentServerDispatch, (token));
}
static void GLAPIENTRY
_mesa_marshal_PassThrough(GLfloat token)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PassThrough);
   struct marshal_cmd_PassThrough *cmd;
   debug_print_marshal("PassThrough");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PassThrough, cmd_size);
      cmd->token = token;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PassThrough");
   CALL_PassThrough(ctx->CurrentServerDispatch, (token));
}


/* PatchParameterfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_PatchParameterfv(GLenum pname, const GLfloat * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("PatchParameterfv");
   CALL_PatchParameterfv(ctx->CurrentServerDispatch, (pname, values));
}


/* GetObjectParameterivAPPLE: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetObjectParameterivAPPLE(GLenum objectType, GLuint name, GLenum pname, GLint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetObjectParameterivAPPLE");
   CALL_GetObjectParameterivAPPLE(ctx->CurrentServerDispatch, (objectType, name, pname, value));
}


/* BindBuffersRange: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_BindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizeiptr * sizes)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("BindBuffersRange");
   CALL_BindBuffersRange(ctx->CurrentServerDispatch, (target, first, count, buffers, offsets, sizes));
}


/* VertexAttrib4fvARB: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4fvARB
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4fvARB(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4fvARB *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat * v = cmd->v;
   CALL_VertexAttrib4fvARB(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4fvARB(GLuint index, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4fvARB);
   struct marshal_cmd_VertexAttrib4fvARB *cmd;
   debug_print_marshal("VertexAttrib4fvARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4fvARB, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4fvARB");
   CALL_VertexAttrib4fvARB(ctx->CurrentServerDispatch, (index, v));
}


/* Uniform3i64vARB: marshalled asynchronously */
struct marshal_cmd_Uniform3i64vARB
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 24) bytes are GLint64 value[count][3] */
};
static inline void
_mesa_unmarshal_Uniform3i64vARB(struct gl_context *ctx, const struct marshal_cmd_Uniform3i64vARB *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLint64 * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLint64 *) variable_data;
   variable_data += count * 24;
   CALL_Uniform3i64vARB(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform3i64vARB(GLint location, GLsizei count, const GLint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform3i64vARB) + safe_mul(count, 24);
   struct marshal_cmd_Uniform3i64vARB *cmd;
   debug_print_marshal("Uniform3i64vARB");
   if (unlikely(safe_mul(count, 24) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform3i64vARB, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 24);
      variable_data += count * 24;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform3i64vARB");
   CALL_Uniform3i64vARB(ctx->CurrentServerDispatch, (location, count, value));
}


/* WindowPos3dv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_WindowPos3dv(const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("WindowPos3dv");
   CALL_WindowPos3dv(ctx->CurrentServerDispatch, (v));
}


/* TexGenxOES: marshalled asynchronously */
struct marshal_cmd_TexGenxOES
{
   struct marshal_cmd_base cmd_base;
   GLenum coord;
   GLenum pname;
   GLint param;
};
static inline void
_mesa_unmarshal_TexGenxOES(struct gl_context *ctx, const struct marshal_cmd_TexGenxOES *cmd)
{
   const GLenum coord = cmd->coord;
   const GLenum pname = cmd->pname;
   const GLint param = cmd->param;
   CALL_TexGenxOES(ctx->CurrentServerDispatch, (coord, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_TexGenxOES(GLenum coord, GLenum pname, GLint param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexGenxOES);
   struct marshal_cmd_TexGenxOES *cmd;
   debug_print_marshal("TexGenxOES");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexGenxOES, cmd_size);
      cmd->coord = coord;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexGenxOES");
   CALL_TexGenxOES(ctx->CurrentServerDispatch, (coord, pname, param));
}


/* VertexArrayAttribIFormat: marshalled asynchronously */
struct marshal_cmd_VertexArrayAttribIFormat
{
   struct marshal_cmd_base cmd_base;
   GLuint vaobj;
   GLuint attribindex;
   GLint size;
   GLenum type;
   GLuint relativeoffset;
};
static inline void
_mesa_unmarshal_VertexArrayAttribIFormat(struct gl_context *ctx, const struct marshal_cmd_VertexArrayAttribIFormat *cmd)
{
   const GLuint vaobj = cmd->vaobj;
   const GLuint attribindex = cmd->attribindex;
   const GLint size = cmd->size;
   const GLenum type = cmd->type;
   const GLuint relativeoffset = cmd->relativeoffset;
   CALL_VertexArrayAttribIFormat(ctx->CurrentServerDispatch, (vaobj, attribindex, size, type, relativeoffset));
}
static void GLAPIENTRY
_mesa_marshal_VertexArrayAttribIFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexArrayAttribIFormat);
   struct marshal_cmd_VertexArrayAttribIFormat *cmd;
   debug_print_marshal("VertexArrayAttribIFormat");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexArrayAttribIFormat, cmd_size);
      cmd->vaobj = vaobj;
      cmd->attribindex = attribindex;
      cmd->size = size;
      cmd->type = type;
      cmd->relativeoffset = relativeoffset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexArrayAttribIFormat");
   CALL_VertexArrayAttribIFormat(ctx->CurrentServerDispatch, (vaobj, attribindex, size, type, relativeoffset));
}


/* StencilOp: marshalled asynchronously */
struct marshal_cmd_StencilOp
{
   struct marshal_cmd_base cmd_base;
   GLenum fail;
   GLenum zfail;
   GLenum zpass;
};
static inline void
_mesa_unmarshal_StencilOp(struct gl_context *ctx, const struct marshal_cmd_StencilOp *cmd)
{
   const GLenum fail = cmd->fail;
   const GLenum zfail = cmd->zfail;
   const GLenum zpass = cmd->zpass;
   CALL_StencilOp(ctx->CurrentServerDispatch, (fail, zfail, zpass));
}
static void GLAPIENTRY
_mesa_marshal_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_StencilOp);
   struct marshal_cmd_StencilOp *cmd;
   debug_print_marshal("StencilOp");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_StencilOp, cmd_size);
      cmd->fail = fail;
      cmd->zfail = zfail;
      cmd->zpass = zpass;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("StencilOp");
   CALL_StencilOp(ctx->CurrentServerDispatch, (fail, zfail, zpass));
}


/* ProgramUniform1iv: marshalled asynchronously */
struct marshal_cmd_ProgramUniform1iv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 4) bytes are GLint value[count] */
};
static inline void
_mesa_unmarshal_ProgramUniform1iv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform1iv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLint * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLint *) variable_data;
   variable_data += count * 4;
   CALL_ProgramUniform1iv(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform1iv) + safe_mul(count, 4);
   struct marshal_cmd_ProgramUniform1iv *cmd;
   debug_print_marshal("ProgramUniform1iv");
   if (unlikely(safe_mul(count, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform1iv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 4);
      variable_data += count * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform1iv");
   CALL_ProgramUniform1iv(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* ProgramUniform3ui: marshalled asynchronously */
struct marshal_cmd_ProgramUniform3ui
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLuint x;
   GLuint y;
   GLuint z;
};
static inline void
_mesa_unmarshal_ProgramUniform3ui(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform3ui *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLuint x = cmd->x;
   const GLuint y = cmd->y;
   const GLuint z = cmd->z;
   CALL_ProgramUniform3ui(ctx->CurrentServerDispatch, (program, location, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform3ui(GLuint program, GLint location, GLuint x, GLuint y, GLuint z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform3ui);
   struct marshal_cmd_ProgramUniform3ui *cmd;
   debug_print_marshal("ProgramUniform3ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform3ui, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform3ui");
   CALL_ProgramUniform3ui(ctx->CurrentServerDispatch, (program, location, x, y, z));
}


/* SecondaryColor3sv: marshalled asynchronously */
struct marshal_cmd_SecondaryColor3sv
{
   struct marshal_cmd_base cmd_base;
   GLshort v[3];
};
static inline void
_mesa_unmarshal_SecondaryColor3sv(struct gl_context *ctx, const struct marshal_cmd_SecondaryColor3sv *cmd)
{
   const GLshort * v = cmd->v;
   CALL_SecondaryColor3sv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColor3sv(const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColor3sv);
   struct marshal_cmd_SecondaryColor3sv *cmd;
   debug_print_marshal("SecondaryColor3sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColor3sv, cmd_size);
      memcpy(cmd->v, v, 6);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColor3sv");
   CALL_SecondaryColor3sv(ctx->CurrentServerDispatch, (v));
}


/* TexCoordP3ui: marshalled asynchronously */
struct marshal_cmd_TexCoordP3ui
{
   struct marshal_cmd_base cmd_base;
   GLenum type;
   GLuint coords;
};
static inline void
_mesa_unmarshal_TexCoordP3ui(struct gl_context *ctx, const struct marshal_cmd_TexCoordP3ui *cmd)
{
   const GLenum type = cmd->type;
   const GLuint coords = cmd->coords;
   CALL_TexCoordP3ui(ctx->CurrentServerDispatch, (type, coords));
}
static void GLAPIENTRY
_mesa_marshal_TexCoordP3ui(GLenum type, GLuint coords)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoordP3ui);
   struct marshal_cmd_TexCoordP3ui *cmd;
   debug_print_marshal("TexCoordP3ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoordP3ui, cmd_size);
      cmd->type = type;
      cmd->coords = coords;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoordP3ui");
   CALL_TexCoordP3ui(ctx->CurrentServerDispatch, (type, coords));
}


/* VertexArrayElementBuffer: marshalled asynchronously */
struct marshal_cmd_VertexArrayElementBuffer
{
   struct marshal_cmd_base cmd_base;
   GLuint vaobj;
   GLuint buffer;
};
static inline void
_mesa_unmarshal_VertexArrayElementBuffer(struct gl_context *ctx, const struct marshal_cmd_VertexArrayElementBuffer *cmd)
{
   const GLuint vaobj = cmd->vaobj;
   const GLuint buffer = cmd->buffer;
   CALL_VertexArrayElementBuffer(ctx->CurrentServerDispatch, (vaobj, buffer));
}
static void GLAPIENTRY
_mesa_marshal_VertexArrayElementBuffer(GLuint vaobj, GLuint buffer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexArrayElementBuffer);
   struct marshal_cmd_VertexArrayElementBuffer *cmd;
   debug_print_marshal("VertexArrayElementBuffer");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexArrayElementBuffer, cmd_size);
      cmd->vaobj = vaobj;
      cmd->buffer = buffer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexArrayElementBuffer");
   CALL_VertexArrayElementBuffer(ctx->CurrentServerDispatch, (vaobj, buffer));
}


/* Fogxv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_Fogxv(GLenum pname, const GLfixed * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("Fogxv");
   CALL_Fogxv(ctx->CurrentServerDispatch, (pname, params));
}


/* Uniform3i64ARB: marshalled asynchronously */
struct marshal_cmd_Uniform3i64ARB
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLint64 x;
   GLint64 y;
   GLint64 z;
};
static inline void
_mesa_unmarshal_Uniform3i64ARB(struct gl_context *ctx, const struct marshal_cmd_Uniform3i64ARB *cmd)
{
   const GLint location = cmd->location;
   const GLint64 x = cmd->x;
   const GLint64 y = cmd->y;
   const GLint64 z = cmd->z;
   CALL_Uniform3i64ARB(ctx->CurrentServerDispatch, (location, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_Uniform3i64ARB(GLint location, GLint64 x, GLint64 y, GLint64 z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform3i64ARB);
   struct marshal_cmd_Uniform3i64ARB *cmd;
   debug_print_marshal("Uniform3i64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform3i64ARB, cmd_size);
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform3i64ARB");
   CALL_Uniform3i64ARB(ctx->CurrentServerDispatch, (location, x, y, z));
}


/* VertexAttribP1ui: marshalled asynchronously */
struct marshal_cmd_VertexAttribP1ui
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLenum type;
   GLboolean normalized;
   GLuint value;
};
static inline void
_mesa_unmarshal_VertexAttribP1ui(struct gl_context *ctx, const struct marshal_cmd_VertexAttribP1ui *cmd)
{
   const GLuint index = cmd->index;
   const GLenum type = cmd->type;
   const GLboolean normalized = cmd->normalized;
   const GLuint value = cmd->value;
   CALL_VertexAttribP1ui(ctx->CurrentServerDispatch, (index, type, normalized, value));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribP1ui);
   struct marshal_cmd_VertexAttribP1ui *cmd;
   debug_print_marshal("VertexAttribP1ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribP1ui, cmd_size);
      cmd->index = index;
      cmd->type = type;
      cmd->normalized = normalized;
      cmd->value = value;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribP1ui");
   CALL_VertexAttribP1ui(ctx->CurrentServerDispatch, (index, type, normalized, value));
}


/* GetImageHandleARB: marshalled synchronously */
static GLuint64 GLAPIENTRY
_mesa_marshal_GetImageHandleARB(GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum format)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetImageHandleARB");
   return CALL_GetImageHandleARB(ctx->CurrentServerDispatch, (texture, level, layered, layer, format));
}


/* DeleteLists: marshalled asynchronously */
struct marshal_cmd_DeleteLists
{
   struct marshal_cmd_base cmd_base;
   GLuint list;
   GLsizei range;
};
static inline void
_mesa_unmarshal_DeleteLists(struct gl_context *ctx, const struct marshal_cmd_DeleteLists *cmd)
{
   const GLuint list = cmd->list;
   const GLsizei range = cmd->range;
   CALL_DeleteLists(ctx->CurrentServerDispatch, (list, range));
}
static void GLAPIENTRY
_mesa_marshal_DeleteLists(GLuint list, GLsizei range)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DeleteLists);
   struct marshal_cmd_DeleteLists *cmd;
   debug_print_marshal("DeleteLists");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DeleteLists, cmd_size);
      cmd->list = list;
      cmd->range = range;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DeleteLists");
   CALL_DeleteLists(ctx->CurrentServerDispatch, (list, range));
}


/* LogicOp: marshalled asynchronously */
struct marshal_cmd_LogicOp
{
   struct marshal_cmd_base cmd_base;
   GLenum opcode;
};
static inline void
_mesa_unmarshal_LogicOp(struct gl_context *ctx, const struct marshal_cmd_LogicOp *cmd)
{
   const GLenum opcode = cmd->opcode;
   CALL_LogicOp(ctx->CurrentServerDispatch, (opcode));
}
static void GLAPIENTRY
_mesa_marshal_LogicOp(GLenum opcode)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_LogicOp);
   struct marshal_cmd_LogicOp *cmd;
   debug_print_marshal("LogicOp");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_LogicOp, cmd_size);
      cmd->opcode = opcode;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("LogicOp");
   CALL_LogicOp(ctx->CurrentServerDispatch, (opcode));
}


/* RenderbufferStorageMultisample: marshalled asynchronously */
struct marshal_cmd_RenderbufferStorageMultisample
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei samples;
   GLenum internalformat;
   GLsizei width;
   GLsizei height;
};
static inline void
_mesa_unmarshal_RenderbufferStorageMultisample(struct gl_context *ctx, const struct marshal_cmd_RenderbufferStorageMultisample *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei samples = cmd->samples;
   const GLenum internalformat = cmd->internalformat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   CALL_RenderbufferStorageMultisample(ctx->CurrentServerDispatch, (target, samples, internalformat, width, height));
}
static void GLAPIENTRY
_mesa_marshal_RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RenderbufferStorageMultisample);
   struct marshal_cmd_RenderbufferStorageMultisample *cmd;
   debug_print_marshal("RenderbufferStorageMultisample");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RenderbufferStorageMultisample, cmd_size);
      cmd->target = target;
      cmd->samples = samples;
      cmd->internalformat = internalformat;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RenderbufferStorageMultisample");
   CALL_RenderbufferStorageMultisample(ctx->CurrentServerDispatch, (target, samples, internalformat, width, height));
}


/* GetTransformFeedbacki64_v: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index, GLint64 * param)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTransformFeedbacki64_v");
   CALL_GetTransformFeedbacki64_v(ctx->CurrentServerDispatch, (xfb, pname, index, param));
}


/* WindowPos3d: marshalled asynchronously */
struct marshal_cmd_WindowPos3d
{
   struct marshal_cmd_base cmd_base;
   GLdouble x;
   GLdouble y;
   GLdouble z;
};
static inline void
_mesa_unmarshal_WindowPos3d(struct gl_context *ctx, const struct marshal_cmd_WindowPos3d *cmd)
{
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   CALL_WindowPos3d(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_WindowPos3d(GLdouble x, GLdouble y, GLdouble z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_WindowPos3d);
   struct marshal_cmd_WindowPos3d *cmd;
   debug_print_marshal("WindowPos3d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_WindowPos3d, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("WindowPos3d");
   CALL_WindowPos3d(ctx->CurrentServerDispatch, (x, y, z));
}


/* Enablei: marshalled asynchronously */
struct marshal_cmd_Enablei
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint index;
};
static inline void
_mesa_unmarshal_Enablei(struct gl_context *ctx, const struct marshal_cmd_Enablei *cmd)
{
   const GLenum target = cmd->target;
   const GLuint index = cmd->index;
   CALL_Enablei(ctx->CurrentServerDispatch, (target, index));
}
static void GLAPIENTRY
_mesa_marshal_Enablei(GLenum target, GLuint index)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Enablei);
   struct marshal_cmd_Enablei *cmd;
   debug_print_marshal("Enablei");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Enablei, cmd_size);
      cmd->target = target;
      cmd->index = index;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Enablei");
   CALL_Enablei(ctx->CurrentServerDispatch, (target, index));
}


/* WindowPos3f: marshalled asynchronously */
struct marshal_cmd_WindowPos3f
{
   struct marshal_cmd_base cmd_base;
   GLfloat x;
   GLfloat y;
   GLfloat z;
};
static inline void
_mesa_unmarshal_WindowPos3f(struct gl_context *ctx, const struct marshal_cmd_WindowPos3f *cmd)
{
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   CALL_WindowPos3f(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_WindowPos3f(GLfloat x, GLfloat y, GLfloat z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_WindowPos3f);
   struct marshal_cmd_WindowPos3f *cmd;
   debug_print_marshal("WindowPos3f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_WindowPos3f, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("WindowPos3f");
   CALL_WindowPos3f(ctx->CurrentServerDispatch, (x, y, z));
}


/* GenProgramsARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GenProgramsARB(GLsizei n, GLuint * programs)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GenProgramsARB");
   CALL_GenProgramsARB(ctx->CurrentServerDispatch, (n, programs));
}


/* RasterPos2sv: marshalled asynchronously */
struct marshal_cmd_RasterPos2sv
{
   struct marshal_cmd_base cmd_base;
   GLshort v[2];
};
static inline void
_mesa_unmarshal_RasterPos2sv(struct gl_context *ctx, const struct marshal_cmd_RasterPos2sv *cmd)
{
   const GLshort * v = cmd->v;
   CALL_RasterPos2sv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos2sv(const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos2sv);
   struct marshal_cmd_RasterPos2sv *cmd;
   debug_print_marshal("RasterPos2sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos2sv, cmd_size);
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos2sv");
   CALL_RasterPos2sv(ctx->CurrentServerDispatch, (v));
}


/* WindowPos3i: marshalled asynchronously */
struct marshal_cmd_WindowPos3i
{
   struct marshal_cmd_base cmd_base;
   GLint x;
   GLint y;
   GLint z;
};
static inline void
_mesa_unmarshal_WindowPos3i(struct gl_context *ctx, const struct marshal_cmd_WindowPos3i *cmd)
{
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLint z = cmd->z;
   CALL_WindowPos3i(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_WindowPos3i(GLint x, GLint y, GLint z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_WindowPos3i);
   struct marshal_cmd_WindowPos3i *cmd;
   debug_print_marshal("WindowPos3i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_WindowPos3i, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("WindowPos3i");
   CALL_WindowPos3i(ctx->CurrentServerDispatch, (x, y, z));
}


/* MultiTexCoord4iv: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord4iv
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLint v[4];
};
static inline void
_mesa_unmarshal_MultiTexCoord4iv(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord4iv *cmd)
{
   const GLenum target = cmd->target;
   const GLint * v = cmd->v;
   CALL_MultiTexCoord4iv(ctx->CurrentServerDispatch, (target, v));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord4iv(GLenum target, const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord4iv);
   struct marshal_cmd_MultiTexCoord4iv *cmd;
   debug_print_marshal("MultiTexCoord4iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord4iv, cmd_size);
      cmd->target = target;
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord4iv");
   CALL_MultiTexCoord4iv(ctx->CurrentServerDispatch, (target, v));
}


/* TexCoord1sv: marshalled asynchronously */
struct marshal_cmd_TexCoord1sv
{
   struct marshal_cmd_base cmd_base;
   GLshort v[1];
};
static inline void
_mesa_unmarshal_TexCoord1sv(struct gl_context *ctx, const struct marshal_cmd_TexCoord1sv *cmd)
{
   const GLshort * v = cmd->v;
   CALL_TexCoord1sv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord1sv(const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord1sv);
   struct marshal_cmd_TexCoord1sv *cmd;
   debug_print_marshal("TexCoord1sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord1sv, cmd_size);
      memcpy(cmd->v, v, 2);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord1sv");
   CALL_TexCoord1sv(ctx->CurrentServerDispatch, (v));
}


/* WindowPos3s: marshalled asynchronously */
struct marshal_cmd_WindowPos3s
{
   struct marshal_cmd_base cmd_base;
   GLshort x;
   GLshort y;
   GLshort z;
};
static inline void
_mesa_unmarshal_WindowPos3s(struct gl_context *ctx, const struct marshal_cmd_WindowPos3s *cmd)
{
   const GLshort x = cmd->x;
   const GLshort y = cmd->y;
   const GLshort z = cmd->z;
   CALL_WindowPos3s(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_WindowPos3s(GLshort x, GLshort y, GLshort z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_WindowPos3s);
   struct marshal_cmd_WindowPos3s *cmd;
   debug_print_marshal("WindowPos3s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_WindowPos3s, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("WindowPos3s");
   CALL_WindowPos3s(ctx->CurrentServerDispatch, (x, y, z));
}


/* PixelMapusv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_PixelMapusv(GLenum map, GLsizei mapsize, const GLushort * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("PixelMapusv");
   CALL_PixelMapusv(ctx->CurrentServerDispatch, (map, mapsize, values));
}


/* DebugMessageInsert: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_DebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar * buf)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("DebugMessageInsert");
   CALL_DebugMessageInsert(ctx->CurrentServerDispatch, (source, type, id, severity, length, buf));
}


/* Orthof: marshalled asynchronously */
struct marshal_cmd_Orthof
{
   struct marshal_cmd_base cmd_base;
   GLfloat left;
   GLfloat right;
   GLfloat bottom;
   GLfloat top;
   GLfloat zNear;
   GLfloat zFar;
};
static inline void
_mesa_unmarshal_Orthof(struct gl_context *ctx, const struct marshal_cmd_Orthof *cmd)
{
   const GLfloat left = cmd->left;
   const GLfloat right = cmd->right;
   const GLfloat bottom = cmd->bottom;
   const GLfloat top = cmd->top;
   const GLfloat zNear = cmd->zNear;
   const GLfloat zFar = cmd->zFar;
   CALL_Orthof(ctx->CurrentServerDispatch, (left, right, bottom, top, zNear, zFar));
}
static void GLAPIENTRY
_mesa_marshal_Orthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Orthof);
   struct marshal_cmd_Orthof *cmd;
   debug_print_marshal("Orthof");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Orthof, cmd_size);
      cmd->left = left;
      cmd->right = right;
      cmd->bottom = bottom;
      cmd->top = top;
      cmd->zNear = zNear;
      cmd->zFar = zFar;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Orthof");
   CALL_Orthof(ctx->CurrentServerDispatch, (left, right, bottom, top, zNear, zFar));
}


/* CompressedTexImage2D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CompressedTexImage2D");
   CALL_CompressedTexImage2D(ctx->CurrentServerDispatch, (target, level, internalformat, width, height, border, imageSize, data));
}


/* DeleteObjectARB: marshalled asynchronously */
struct marshal_cmd_DeleteObjectARB
{
   struct marshal_cmd_base cmd_base;
   GLhandleARB obj;
};
static inline void
_mesa_unmarshal_DeleteObjectARB(struct gl_context *ctx, const struct marshal_cmd_DeleteObjectARB *cmd)
{
   const GLhandleARB obj = cmd->obj;
   CALL_DeleteObjectARB(ctx->CurrentServerDispatch, (obj));
}
static void GLAPIENTRY
_mesa_marshal_DeleteObjectARB(GLhandleARB obj)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DeleteObjectARB);
   struct marshal_cmd_DeleteObjectARB *cmd;
   debug_print_marshal("DeleteObjectARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DeleteObjectARB, cmd_size);
      cmd->obj = obj;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DeleteObjectARB");
   CALL_DeleteObjectARB(ctx->CurrentServerDispatch, (obj));
}


/* ProgramUniformMatrix2x3dv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix2x3dv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 48) bytes are GLdouble value[count][6] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix2x3dv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix2x3dv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 48;
   CALL_ProgramUniformMatrix2x3dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix2x3dv) + safe_mul(count, 48);
   struct marshal_cmd_ProgramUniformMatrix2x3dv *cmd;
   debug_print_marshal("ProgramUniformMatrix2x3dv");
   if (unlikely(safe_mul(count, 48) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix2x3dv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 48);
      variable_data += count * 48;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix2x3dv");
   CALL_ProgramUniformMatrix2x3dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* GetVertexArrayiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetVertexArrayiv(GLuint vaobj, GLenum pname, GLint * param)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetVertexArrayiv");
   CALL_GetVertexArrayiv(ctx->CurrentServerDispatch, (vaobj, pname, param));
}


/* IsSync: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsSync(GLsync sync)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsSync");
   return CALL_IsSync(ctx->CurrentServerDispatch, (sync));
}


/* Color4uiv: marshalled asynchronously */
struct marshal_cmd_Color4uiv
{
   struct marshal_cmd_base cmd_base;
   GLuint v[4];
};
static inline void
_mesa_unmarshal_Color4uiv(struct gl_context *ctx, const struct marshal_cmd_Color4uiv *cmd)
{
   const GLuint * v = cmd->v;
   CALL_Color4uiv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Color4uiv(const GLuint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color4uiv);
   struct marshal_cmd_Color4uiv *cmd;
   debug_print_marshal("Color4uiv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color4uiv, cmd_size);
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color4uiv");
   CALL_Color4uiv(ctx->CurrentServerDispatch, (v));
}


/* MultiTexCoord1sv: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord1sv
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLshort v[1];
};
static inline void
_mesa_unmarshal_MultiTexCoord1sv(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord1sv *cmd)
{
   const GLenum target = cmd->target;
   const GLshort * v = cmd->v;
   CALL_MultiTexCoord1sv(ctx->CurrentServerDispatch, (target, v));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord1sv(GLenum target, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord1sv);
   struct marshal_cmd_MultiTexCoord1sv *cmd;
   debug_print_marshal("MultiTexCoord1sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord1sv, cmd_size);
      cmd->target = target;
      memcpy(cmd->v, v, 2);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord1sv");
   CALL_MultiTexCoord1sv(ctx->CurrentServerDispatch, (target, v));
}


/* Orthox: marshalled asynchronously */
struct marshal_cmd_Orthox
{
   struct marshal_cmd_base cmd_base;
   GLfixed left;
   GLfixed right;
   GLfixed bottom;
   GLfixed top;
   GLfixed zNear;
   GLfixed zFar;
};
static inline void
_mesa_unmarshal_Orthox(struct gl_context *ctx, const struct marshal_cmd_Orthox *cmd)
{
   const GLfixed left = cmd->left;
   const GLfixed right = cmd->right;
   const GLfixed bottom = cmd->bottom;
   const GLfixed top = cmd->top;
   const GLfixed zNear = cmd->zNear;
   const GLfixed zFar = cmd->zFar;
   CALL_Orthox(ctx->CurrentServerDispatch, (left, right, bottom, top, zNear, zFar));
}
static void GLAPIENTRY
_mesa_marshal_Orthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Orthox);
   struct marshal_cmd_Orthox *cmd;
   debug_print_marshal("Orthox");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Orthox, cmd_size);
      cmd->left = left;
      cmd->right = right;
      cmd->bottom = bottom;
      cmd->top = top;
      cmd->zNear = zNear;
      cmd->zFar = zFar;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Orthox");
   CALL_Orthox(ctx->CurrentServerDispatch, (left, right, bottom, top, zNear, zFar));
}


/* PushAttrib: marshalled asynchronously */
struct marshal_cmd_PushAttrib
{
   struct marshal_cmd_base cmd_base;
   GLbitfield mask;
};
static inline void
_mesa_unmarshal_PushAttrib(struct gl_context *ctx, const struct marshal_cmd_PushAttrib *cmd)
{
   const GLbitfield mask = cmd->mask;
   CALL_PushAttrib(ctx->CurrentServerDispatch, (mask));
}
static void GLAPIENTRY
_mesa_marshal_PushAttrib(GLbitfield mask)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PushAttrib);
   struct marshal_cmd_PushAttrib *cmd;
   debug_print_marshal("PushAttrib");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PushAttrib, cmd_size);
      cmd->mask = mask;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PushAttrib");
   CALL_PushAttrib(ctx->CurrentServerDispatch, (mask));
}


/* RasterPos2i: marshalled asynchronously */
struct marshal_cmd_RasterPos2i
{
   struct marshal_cmd_base cmd_base;
   GLint x;
   GLint y;
};
static inline void
_mesa_unmarshal_RasterPos2i(struct gl_context *ctx, const struct marshal_cmd_RasterPos2i *cmd)
{
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   CALL_RasterPos2i(ctx->CurrentServerDispatch, (x, y));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos2i(GLint x, GLint y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos2i);
   struct marshal_cmd_RasterPos2i *cmd;
   debug_print_marshal("RasterPos2i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos2i, cmd_size);
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos2i");
   CALL_RasterPos2i(ctx->CurrentServerDispatch, (x, y));
}


/* ClipPlane: marshalled asynchronously */
struct marshal_cmd_ClipPlane
{
   struct marshal_cmd_base cmd_base;
   GLenum plane;
   GLdouble equation[4];
};
static inline void
_mesa_unmarshal_ClipPlane(struct gl_context *ctx, const struct marshal_cmd_ClipPlane *cmd)
{
   const GLenum plane = cmd->plane;
   const GLdouble * equation = cmd->equation;
   CALL_ClipPlane(ctx->CurrentServerDispatch, (plane, equation));
}
static void GLAPIENTRY
_mesa_marshal_ClipPlane(GLenum plane, const GLdouble * equation)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ClipPlane);
   struct marshal_cmd_ClipPlane *cmd;
   debug_print_marshal("ClipPlane");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ClipPlane, cmd_size);
      cmd->plane = plane;
      memcpy(cmd->equation, equation, 32);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ClipPlane");
   CALL_ClipPlane(ctx->CurrentServerDispatch, (plane, equation));
}


/* RasterPos2f: marshalled asynchronously */
struct marshal_cmd_RasterPos2f
{
   struct marshal_cmd_base cmd_base;
   GLfloat x;
   GLfloat y;
};
static inline void
_mesa_unmarshal_RasterPos2f(struct gl_context *ctx, const struct marshal_cmd_RasterPos2f *cmd)
{
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   CALL_RasterPos2f(ctx->CurrentServerDispatch, (x, y));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos2f(GLfloat x, GLfloat y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos2f);
   struct marshal_cmd_RasterPos2f *cmd;
   debug_print_marshal("RasterPos2f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos2f, cmd_size);
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos2f");
   CALL_RasterPos2f(ctx->CurrentServerDispatch, (x, y));
}


/* GetActiveSubroutineUniformiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetActiveSubroutineUniformiv");
   CALL_GetActiveSubroutineUniformiv(ctx->CurrentServerDispatch, (program, shadertype, index, pname, values));
}


/* RasterPos2d: marshalled asynchronously */
struct marshal_cmd_RasterPos2d
{
   struct marshal_cmd_base cmd_base;
   GLdouble x;
   GLdouble y;
};
static inline void
_mesa_unmarshal_RasterPos2d(struct gl_context *ctx, const struct marshal_cmd_RasterPos2d *cmd)
{
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   CALL_RasterPos2d(ctx->CurrentServerDispatch, (x, y));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos2d(GLdouble x, GLdouble y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos2d);
   struct marshal_cmd_RasterPos2d *cmd;
   debug_print_marshal("RasterPos2d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos2d, cmd_size);
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos2d");
   CALL_RasterPos2d(ctx->CurrentServerDispatch, (x, y));
}


/* MakeImageHandleResidentARB: marshalled asynchronously */
struct marshal_cmd_MakeImageHandleResidentARB
{
   struct marshal_cmd_base cmd_base;
   GLuint64 handle;
   GLenum access;
};
static inline void
_mesa_unmarshal_MakeImageHandleResidentARB(struct gl_context *ctx, const struct marshal_cmd_MakeImageHandleResidentARB *cmd)
{
   const GLuint64 handle = cmd->handle;
   const GLenum access = cmd->access;
   CALL_MakeImageHandleResidentARB(ctx->CurrentServerDispatch, (handle, access));
}
static void GLAPIENTRY
_mesa_marshal_MakeImageHandleResidentARB(GLuint64 handle, GLenum access)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MakeImageHandleResidentARB);
   struct marshal_cmd_MakeImageHandleResidentARB *cmd;
   debug_print_marshal("MakeImageHandleResidentARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MakeImageHandleResidentARB, cmd_size);
      cmd->handle = handle;
      cmd->access = access;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MakeImageHandleResidentARB");
   CALL_MakeImageHandleResidentARB(ctx->CurrentServerDispatch, (handle, access));
}


/* InvalidateSubFramebuffer: marshalled asynchronously */
struct marshal_cmd_InvalidateSubFramebuffer
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei numAttachments;
   GLint x;
   GLint y;
   GLsizei width;
   GLsizei height;
   /* Next safe_mul(numAttachments, 4) bytes are GLenum attachments[numAttachments] */
};
static inline void
_mesa_unmarshal_InvalidateSubFramebuffer(struct gl_context *ctx, const struct marshal_cmd_InvalidateSubFramebuffer *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei numAttachments = cmd->numAttachments;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLenum * attachments;
   const char *variable_data = (const char *) (cmd + 1);
   attachments = (const GLenum *) variable_data;
   variable_data += numAttachments * 4;
   CALL_InvalidateSubFramebuffer(ctx->CurrentServerDispatch, (target, numAttachments, attachments, x, y, width, height));
}
static void GLAPIENTRY
_mesa_marshal_InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_InvalidateSubFramebuffer) + safe_mul(numAttachments, 4);
   struct marshal_cmd_InvalidateSubFramebuffer *cmd;
   debug_print_marshal("InvalidateSubFramebuffer");
   if (unlikely(safe_mul(numAttachments, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_InvalidateSubFramebuffer, cmd_size);
      cmd->target = target;
      cmd->numAttachments = numAttachments;
      cmd->x = x;
      cmd->y = y;
      cmd->width = width;
      cmd->height = height;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, attachments, numAttachments * 4);
      variable_data += numAttachments * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("InvalidateSubFramebuffer");
   CALL_InvalidateSubFramebuffer(ctx->CurrentServerDispatch, (target, numAttachments, attachments, x, y, width, height));
}


/* Color4ub: marshalled asynchronously */
struct marshal_cmd_Color4ub
{
   struct marshal_cmd_base cmd_base;
   GLubyte red;
   GLubyte green;
   GLubyte blue;
   GLubyte alpha;
};
static inline void
_mesa_unmarshal_Color4ub(struct gl_context *ctx, const struct marshal_cmd_Color4ub *cmd)
{
   const GLubyte red = cmd->red;
   const GLubyte green = cmd->green;
   const GLubyte blue = cmd->blue;
   const GLubyte alpha = cmd->alpha;
   CALL_Color4ub(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}
static void GLAPIENTRY
_mesa_marshal_Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color4ub);
   struct marshal_cmd_Color4ub *cmd;
   debug_print_marshal("Color4ub");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color4ub, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      cmd->alpha = alpha;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color4ub");
   CALL_Color4ub(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}


/* UniformMatrix2x4dv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix2x4dv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 64) bytes are GLdouble value[count][8] */
};
static inline void
_mesa_unmarshal_UniformMatrix2x4dv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix2x4dv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 64;
   CALL_UniformMatrix2x4dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix2x4dv) + safe_mul(count, 64);
   struct marshal_cmd_UniformMatrix2x4dv *cmd;
   debug_print_marshal("UniformMatrix2x4dv");
   if (unlikely(safe_mul(count, 64) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix2x4dv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 64);
      variable_data += count * 64;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix2x4dv");
   CALL_UniformMatrix2x4dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* RasterPos2s: marshalled asynchronously */
struct marshal_cmd_RasterPos2s
{
   struct marshal_cmd_base cmd_base;
   GLshort x;
   GLshort y;
};
static inline void
_mesa_unmarshal_RasterPos2s(struct gl_context *ctx, const struct marshal_cmd_RasterPos2s *cmd)
{
   const GLshort x = cmd->x;
   const GLshort y = cmd->y;
   CALL_RasterPos2s(ctx->CurrentServerDispatch, (x, y));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos2s(GLshort x, GLshort y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos2s);
   struct marshal_cmd_RasterPos2s *cmd;
   debug_print_marshal("RasterPos2s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos2s, cmd_size);
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos2s");
   CALL_RasterPos2s(ctx->CurrentServerDispatch, (x, y));
}


/* DispatchComputeGroupSizeARB: marshalled asynchronously */
struct marshal_cmd_DispatchComputeGroupSizeARB
{
   struct marshal_cmd_base cmd_base;
   GLuint num_groups_x;
   GLuint num_groups_y;
   GLuint num_groups_z;
   GLuint group_size_x;
   GLuint group_size_y;
   GLuint group_size_z;
};
static inline void
_mesa_unmarshal_DispatchComputeGroupSizeARB(struct gl_context *ctx, const struct marshal_cmd_DispatchComputeGroupSizeARB *cmd)
{
   const GLuint num_groups_x = cmd->num_groups_x;
   const GLuint num_groups_y = cmd->num_groups_y;
   const GLuint num_groups_z = cmd->num_groups_z;
   const GLuint group_size_x = cmd->group_size_x;
   const GLuint group_size_y = cmd->group_size_y;
   const GLuint group_size_z = cmd->group_size_z;
   CALL_DispatchComputeGroupSizeARB(ctx->CurrentServerDispatch, (num_groups_x, num_groups_y, num_groups_z, group_size_x, group_size_y, group_size_z));
}
static void GLAPIENTRY
_mesa_marshal_DispatchComputeGroupSizeARB(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z, GLuint group_size_x, GLuint group_size_y, GLuint group_size_z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DispatchComputeGroupSizeARB);
   struct marshal_cmd_DispatchComputeGroupSizeARB *cmd;
   debug_print_marshal("DispatchComputeGroupSizeARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DispatchComputeGroupSizeARB, cmd_size);
      cmd->num_groups_x = num_groups_x;
      cmd->num_groups_y = num_groups_y;
      cmd->num_groups_z = num_groups_z;
      cmd->group_size_x = group_size_x;
      cmd->group_size_y = group_size_y;
      cmd->group_size_z = group_size_z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DispatchComputeGroupSizeARB");
   CALL_DispatchComputeGroupSizeARB(ctx->CurrentServerDispatch, (num_groups_x, num_groups_y, num_groups_z, group_size_x, group_size_y, group_size_z));
}


/* VertexP2uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexP2uiv(GLenum type, const GLuint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexP2uiv");
   CALL_VertexP2uiv(ctx->CurrentServerDispatch, (type, value));
}


/* VertexArrayBindingDivisor: marshalled asynchronously */
struct marshal_cmd_VertexArrayBindingDivisor
{
   struct marshal_cmd_base cmd_base;
   GLuint vaobj;
   GLuint bindingindex;
   GLuint divisor;
};
static inline void
_mesa_unmarshal_VertexArrayBindingDivisor(struct gl_context *ctx, const struct marshal_cmd_VertexArrayBindingDivisor *cmd)
{
   const GLuint vaobj = cmd->vaobj;
   const GLuint bindingindex = cmd->bindingindex;
   const GLuint divisor = cmd->divisor;
   CALL_VertexArrayBindingDivisor(ctx->CurrentServerDispatch, (vaobj, bindingindex, divisor));
}
static void GLAPIENTRY
_mesa_marshal_VertexArrayBindingDivisor(GLuint vaobj, GLuint bindingindex, GLuint divisor)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexArrayBindingDivisor);
   struct marshal_cmd_VertexArrayBindingDivisor *cmd;
   debug_print_marshal("VertexArrayBindingDivisor");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexArrayBindingDivisor, cmd_size);
      cmd->vaobj = vaobj;
      cmd->bindingindex = bindingindex;
      cmd->divisor = divisor;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexArrayBindingDivisor");
   CALL_VertexArrayBindingDivisor(ctx->CurrentServerDispatch, (vaobj, bindingindex, divisor));
}


/* MultiTexCoord3dv: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord3dv
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLdouble v[3];
};
static inline void
_mesa_unmarshal_MultiTexCoord3dv(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord3dv *cmd)
{
   const GLenum target = cmd->target;
   const GLdouble * v = cmd->v;
   CALL_MultiTexCoord3dv(ctx->CurrentServerDispatch, (target, v));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord3dv(GLenum target, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord3dv);
   struct marshal_cmd_MultiTexCoord3dv *cmd;
   debug_print_marshal("MultiTexCoord3dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord3dv, cmd_size);
      cmd->target = target;
      memcpy(cmd->v, v, 24);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord3dv");
   CALL_MultiTexCoord3dv(ctx->CurrentServerDispatch, (target, v));
}


/* BindProgramPipeline: marshalled asynchronously */
struct marshal_cmd_BindProgramPipeline
{
   struct marshal_cmd_base cmd_base;
   GLuint pipeline;
};
static inline void
_mesa_unmarshal_BindProgramPipeline(struct gl_context *ctx, const struct marshal_cmd_BindProgramPipeline *cmd)
{
   const GLuint pipeline = cmd->pipeline;
   CALL_BindProgramPipeline(ctx->CurrentServerDispatch, (pipeline));
}
static void GLAPIENTRY
_mesa_marshal_BindProgramPipeline(GLuint pipeline)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BindProgramPipeline);
   struct marshal_cmd_BindProgramPipeline *cmd;
   debug_print_marshal("BindProgramPipeline");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BindProgramPipeline, cmd_size);
      cmd->pipeline = pipeline;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BindProgramPipeline");
   CALL_BindProgramPipeline(ctx->CurrentServerDispatch, (pipeline));
}


/* VertexAttribP4uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribP4uiv");
   CALL_VertexAttribP4uiv(ctx->CurrentServerDispatch, (index, type, normalized, value));
}


/* DebugMessageCallback: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_DebugMessageCallback(GLDEBUGPROC callback, const GLvoid * userParam)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("DebugMessageCallback");
   CALL_DebugMessageCallback(ctx->CurrentServerDispatch, (callback, userParam));
}


/* MultiTexCoord1i: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord1i
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLint s;
};
static inline void
_mesa_unmarshal_MultiTexCoord1i(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord1i *cmd)
{
   const GLenum target = cmd->target;
   const GLint s = cmd->s;
   CALL_MultiTexCoord1i(ctx->CurrentServerDispatch, (target, s));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord1i(GLenum target, GLint s)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord1i);
   struct marshal_cmd_MultiTexCoord1i *cmd;
   debug_print_marshal("MultiTexCoord1i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord1i, cmd_size);
      cmd->target = target;
      cmd->s = s;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord1i");
   CALL_MultiTexCoord1i(ctx->CurrentServerDispatch, (target, s));
}


/* WindowPos2dv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_WindowPos2dv(const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("WindowPos2dv");
   CALL_WindowPos2dv(ctx->CurrentServerDispatch, (v));
}


/* TexParameterIuiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexParameterIuiv(GLenum target, GLenum pname, const GLuint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexParameterIuiv");
   CALL_TexParameterIuiv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* DeletePerfQueryINTEL: marshalled asynchronously */
struct marshal_cmd_DeletePerfQueryINTEL
{
   struct marshal_cmd_base cmd_base;
   GLuint queryHandle;
};
static inline void
_mesa_unmarshal_DeletePerfQueryINTEL(struct gl_context *ctx, const struct marshal_cmd_DeletePerfQueryINTEL *cmd)
{
   const GLuint queryHandle = cmd->queryHandle;
   CALL_DeletePerfQueryINTEL(ctx->CurrentServerDispatch, (queryHandle));
}
static void GLAPIENTRY
_mesa_marshal_DeletePerfQueryINTEL(GLuint queryHandle)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DeletePerfQueryINTEL);
   struct marshal_cmd_DeletePerfQueryINTEL *cmd;
   debug_print_marshal("DeletePerfQueryINTEL");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DeletePerfQueryINTEL, cmd_size);
      cmd->queryHandle = queryHandle;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DeletePerfQueryINTEL");
   CALL_DeletePerfQueryINTEL(ctx->CurrentServerDispatch, (queryHandle));
}


/* MultiTexCoord1d: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord1d
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLdouble s;
};
static inline void
_mesa_unmarshal_MultiTexCoord1d(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord1d *cmd)
{
   const GLenum target = cmd->target;
   const GLdouble s = cmd->s;
   CALL_MultiTexCoord1d(ctx->CurrentServerDispatch, (target, s));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord1d(GLenum target, GLdouble s)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord1d);
   struct marshal_cmd_MultiTexCoord1d *cmd;
   debug_print_marshal("MultiTexCoord1d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord1d, cmd_size);
      cmd->target = target;
      cmd->s = s;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord1d");
   CALL_MultiTexCoord1d(ctx->CurrentServerDispatch, (target, s));
}


/* MultiTexCoord1s: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord1s
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLshort s;
};
static inline void
_mesa_unmarshal_MultiTexCoord1s(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord1s *cmd)
{
   const GLenum target = cmd->target;
   const GLshort s = cmd->s;
   CALL_MultiTexCoord1s(ctx->CurrentServerDispatch, (target, s));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord1s(GLenum target, GLshort s)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord1s);
   struct marshal_cmd_MultiTexCoord1s *cmd;
   debug_print_marshal("MultiTexCoord1s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord1s, cmd_size);
      cmd->target = target;
      cmd->s = s;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord1s");
   CALL_MultiTexCoord1s(ctx->CurrentServerDispatch, (target, s));
}


/* BeginConditionalRender: marshalled asynchronously */
struct marshal_cmd_BeginConditionalRender
{
   struct marshal_cmd_base cmd_base;
   GLuint query;
   GLenum mode;
};
static inline void
_mesa_unmarshal_BeginConditionalRender(struct gl_context *ctx, const struct marshal_cmd_BeginConditionalRender *cmd)
{
   const GLuint query = cmd->query;
   const GLenum mode = cmd->mode;
   CALL_BeginConditionalRender(ctx->CurrentServerDispatch, (query, mode));
}
static void GLAPIENTRY
_mesa_marshal_BeginConditionalRender(GLuint query, GLenum mode)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BeginConditionalRender);
   struct marshal_cmd_BeginConditionalRender *cmd;
   debug_print_marshal("BeginConditionalRender");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BeginConditionalRender, cmd_size);
      cmd->query = query;
      cmd->mode = mode;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BeginConditionalRender");
   CALL_BeginConditionalRender(ctx->CurrentServerDispatch, (query, mode));
}


/* GetShaderiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetShaderiv(GLuint shader, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetShaderiv");
   CALL_GetShaderiv(ctx->CurrentServerDispatch, (shader, pname, params));
}


/* CopyConvolutionFilter1D: marshalled asynchronously */
struct marshal_cmd_CopyConvolutionFilter1D
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum internalformat;
   GLint x;
   GLint y;
   GLsizei width;
};
static inline void
_mesa_unmarshal_CopyConvolutionFilter1D(struct gl_context *ctx, const struct marshal_cmd_CopyConvolutionFilter1D *cmd)
{
   const GLenum target = cmd->target;
   const GLenum internalformat = cmd->internalformat;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLsizei width = cmd->width;
   CALL_CopyConvolutionFilter1D(ctx->CurrentServerDispatch, (target, internalformat, x, y, width));
}
static void GLAPIENTRY
_mesa_marshal_CopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CopyConvolutionFilter1D);
   struct marshal_cmd_CopyConvolutionFilter1D *cmd;
   debug_print_marshal("CopyConvolutionFilter1D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CopyConvolutionFilter1D, cmd_size);
      cmd->target = target;
      cmd->internalformat = internalformat;
      cmd->x = x;
      cmd->y = y;
      cmd->width = width;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CopyConvolutionFilter1D");
   CALL_CopyConvolutionFilter1D(ctx->CurrentServerDispatch, (target, internalformat, x, y, width));
}


/* UniformMatrix4dv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix4dv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 128) bytes are GLdouble value[count][16] */
};
static inline void
_mesa_unmarshal_UniformMatrix4dv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix4dv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 128;
   CALL_UniformMatrix4dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix4dv) + safe_mul(count, 128);
   struct marshal_cmd_UniformMatrix4dv *cmd;
   debug_print_marshal("UniformMatrix4dv");
   if (unlikely(safe_mul(count, 128) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix4dv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 128);
      variable_data += count * 128;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix4dv");
   CALL_UniformMatrix4dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* CreateShaderObjectARB: marshalled synchronously */
static GLhandleARB GLAPIENTRY
_mesa_marshal_CreateShaderObjectARB(GLenum shaderType)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CreateShaderObjectARB");
   return CALL_CreateShaderObjectARB(ctx->CurrentServerDispatch, (shaderType));
}


/* GetTexParameterxv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTexParameterxv(GLenum target, GLenum pname, GLfixed * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTexParameterxv");
   CALL_GetTexParameterxv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* GetAttachedShaders: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * obj)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetAttachedShaders");
   CALL_GetAttachedShaders(ctx->CurrentServerDispatch, (program, maxCount, count, obj));
}


/* Materialiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_Materialiv(GLenum face, GLenum pname, const GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("Materialiv");
   CALL_Materialiv(ctx->CurrentServerDispatch, (face, pname, params));
}


/* DeleteFragmentShaderATI: marshalled asynchronously */
struct marshal_cmd_DeleteFragmentShaderATI
{
   struct marshal_cmd_base cmd_base;
   GLuint id;
};
static inline void
_mesa_unmarshal_DeleteFragmentShaderATI(struct gl_context *ctx, const struct marshal_cmd_DeleteFragmentShaderATI *cmd)
{
   const GLuint id = cmd->id;
   CALL_DeleteFragmentShaderATI(ctx->CurrentServerDispatch, (id));
}
static void GLAPIENTRY
_mesa_marshal_DeleteFragmentShaderATI(GLuint id)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DeleteFragmentShaderATI);
   struct marshal_cmd_DeleteFragmentShaderATI *cmd;
   debug_print_marshal("DeleteFragmentShaderATI");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DeleteFragmentShaderATI, cmd_size);
      cmd->id = id;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DeleteFragmentShaderATI");
   CALL_DeleteFragmentShaderATI(ctx->CurrentServerDispatch, (id));
}


/* VertexArrayVertexBuffers: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexArrayVertexBuffers(GLuint vaobj, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizei * strides)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexArrayVertexBuffers");
   CALL_VertexArrayVertexBuffers(ctx->CurrentServerDispatch, (vaobj, first, count, buffers, offsets, strides));
}


/* DrawElementsInstancedBaseVertex: marshalled asynchronously */
struct marshal_cmd_DrawElementsInstancedBaseVertex
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLsizei count;
   GLenum type;
   const GLvoid * indices;
   GLsizei primcount;
   GLint basevertex;
};
static inline void
_mesa_unmarshal_DrawElementsInstancedBaseVertex(struct gl_context *ctx, const struct marshal_cmd_DrawElementsInstancedBaseVertex *cmd)
{
   const GLenum mode = cmd->mode;
   const GLsizei count = cmd->count;
   const GLenum type = cmd->type;
   const GLvoid * indices = cmd->indices;
   const GLsizei primcount = cmd->primcount;
   const GLint basevertex = cmd->basevertex;
   CALL_DrawElementsInstancedBaseVertex(ctx->CurrentServerDispatch, (mode, count, type, indices, primcount, basevertex));
}
static void GLAPIENTRY
_mesa_marshal_DrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei primcount, GLint basevertex)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawElementsInstancedBaseVertex);
   struct marshal_cmd_DrawElementsInstancedBaseVertex *cmd;
   debug_print_marshal("DrawElementsInstancedBaseVertex");
   if (_mesa_glthread_is_non_vbo_draw_elements(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("DrawElementsInstancedBaseVertex");
      CALL_DrawElementsInstancedBaseVertex(ctx->CurrentServerDispatch, (mode, count, type, indices, primcount, basevertex));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawElementsInstancedBaseVertex, cmd_size);
      cmd->mode = mode;
      cmd->count = count;
      cmd->type = type;
      cmd->indices = indices;
      cmd->primcount = primcount;
      cmd->basevertex = basevertex;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawElementsInstancedBaseVertex");
   CALL_DrawElementsInstancedBaseVertex(ctx->CurrentServerDispatch, (mode, count, type, indices, primcount, basevertex));
}


/* DisableClientState: marshalled asynchronously */
struct marshal_cmd_DisableClientState
{
   struct marshal_cmd_base cmd_base;
   GLenum array;
};
static inline void
_mesa_unmarshal_DisableClientState(struct gl_context *ctx, const struct marshal_cmd_DisableClientState *cmd)
{
   const GLenum array = cmd->array;
   CALL_DisableClientState(ctx->CurrentServerDispatch, (array));
}
static void GLAPIENTRY
_mesa_marshal_DisableClientState(GLenum array)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DisableClientState);
   struct marshal_cmd_DisableClientState *cmd;
   debug_print_marshal("DisableClientState");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DisableClientState, cmd_size);
      cmd->array = array;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DisableClientState");
   CALL_DisableClientState(ctx->CurrentServerDispatch, (array));
}


/* TexGeni: marshalled asynchronously */
struct marshal_cmd_TexGeni
{
   struct marshal_cmd_base cmd_base;
   GLenum coord;
   GLenum pname;
   GLint param;
};
static inline void
_mesa_unmarshal_TexGeni(struct gl_context *ctx, const struct marshal_cmd_TexGeni *cmd)
{
   const GLenum coord = cmd->coord;
   const GLenum pname = cmd->pname;
   const GLint param = cmd->param;
   CALL_TexGeni(ctx->CurrentServerDispatch, (coord, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_TexGeni(GLenum coord, GLenum pname, GLint param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexGeni);
   struct marshal_cmd_TexGeni *cmd;
   debug_print_marshal("TexGeni");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexGeni, cmd_size);
      cmd->coord = coord;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexGeni");
   CALL_TexGeni(ctx->CurrentServerDispatch, (coord, pname, param));
}


/* TexGenf: marshalled asynchronously */
struct marshal_cmd_TexGenf
{
   struct marshal_cmd_base cmd_base;
   GLenum coord;
   GLenum pname;
   GLfloat param;
};
static inline void
_mesa_unmarshal_TexGenf(struct gl_context *ctx, const struct marshal_cmd_TexGenf *cmd)
{
   const GLenum coord = cmd->coord;
   const GLenum pname = cmd->pname;
   const GLfloat param = cmd->param;
   CALL_TexGenf(ctx->CurrentServerDispatch, (coord, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_TexGenf(GLenum coord, GLenum pname, GLfloat param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexGenf);
   struct marshal_cmd_TexGenf *cmd;
   debug_print_marshal("TexGenf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexGenf, cmd_size);
      cmd->coord = coord;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexGenf");
   CALL_TexGenf(ctx->CurrentServerDispatch, (coord, pname, param));
}


/* TexGend: marshalled asynchronously */
struct marshal_cmd_TexGend
{
   struct marshal_cmd_base cmd_base;
   GLenum coord;
   GLenum pname;
   GLdouble param;
};
static inline void
_mesa_unmarshal_TexGend(struct gl_context *ctx, const struct marshal_cmd_TexGend *cmd)
{
   const GLenum coord = cmd->coord;
   const GLenum pname = cmd->pname;
   const GLdouble param = cmd->param;
   CALL_TexGend(ctx->CurrentServerDispatch, (coord, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_TexGend(GLenum coord, GLenum pname, GLdouble param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexGend);
   struct marshal_cmd_TexGend *cmd;
   debug_print_marshal("TexGend");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexGend, cmd_size);
      cmd->coord = coord;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexGend");
   CALL_TexGend(ctx->CurrentServerDispatch, (coord, pname, param));
}


/* ProgramUniform4i64vARB: marshalled asynchronously */
struct marshal_cmd_ProgramUniform4i64vARB
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 32) bytes are GLint64 value[count][4] */
};
static inline void
_mesa_unmarshal_ProgramUniform4i64vARB(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform4i64vARB *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLint64 * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLint64 *) variable_data;
   variable_data += count * 32;
   CALL_ProgramUniform4i64vARB(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform4i64vARB(GLuint program, GLint location, GLsizei count, const GLint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform4i64vARB) + safe_mul(count, 32);
   struct marshal_cmd_ProgramUniform4i64vARB *cmd;
   debug_print_marshal("ProgramUniform4i64vARB");
   if (unlikely(safe_mul(count, 32) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform4i64vARB, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 32);
      variable_data += count * 32;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform4i64vARB");
   CALL_ProgramUniform4i64vARB(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* Color4sv: marshalled asynchronously */
struct marshal_cmd_Color4sv
{
   struct marshal_cmd_base cmd_base;
   GLshort v[4];
};
static inline void
_mesa_unmarshal_Color4sv(struct gl_context *ctx, const struct marshal_cmd_Color4sv *cmd)
{
   const GLshort * v = cmd->v;
   CALL_Color4sv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Color4sv(const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color4sv);
   struct marshal_cmd_Color4sv *cmd;
   debug_print_marshal("Color4sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color4sv, cmd_size);
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color4sv");
   CALL_Color4sv(ctx->CurrentServerDispatch, (v));
}


/* LoadTransposeMatrixf: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_LoadTransposeMatrixf(const GLfloat * m)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("LoadTransposeMatrixf");
   CALL_LoadTransposeMatrixf(ctx->CurrentServerDispatch, (m));
}


/* LoadTransposeMatrixd: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_LoadTransposeMatrixd(const GLdouble * m)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("LoadTransposeMatrixd");
   CALL_LoadTransposeMatrixd(ctx->CurrentServerDispatch, (m));
}


/* PixelZoom: marshalled asynchronously */
struct marshal_cmd_PixelZoom
{
   struct marshal_cmd_base cmd_base;
   GLfloat xfactor;
   GLfloat yfactor;
};
static inline void
_mesa_unmarshal_PixelZoom(struct gl_context *ctx, const struct marshal_cmd_PixelZoom *cmd)
{
   const GLfloat xfactor = cmd->xfactor;
   const GLfloat yfactor = cmd->yfactor;
   CALL_PixelZoom(ctx->CurrentServerDispatch, (xfactor, yfactor));
}
static void GLAPIENTRY
_mesa_marshal_PixelZoom(GLfloat xfactor, GLfloat yfactor)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PixelZoom);
   struct marshal_cmd_PixelZoom *cmd;
   debug_print_marshal("PixelZoom");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PixelZoom, cmd_size);
      cmd->xfactor = xfactor;
      cmd->yfactor = yfactor;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PixelZoom");
   CALL_PixelZoom(ctx->CurrentServerDispatch, (xfactor, yfactor));
}


/* ProgramEnvParameter4dARB: marshalled asynchronously */
struct marshal_cmd_ProgramEnvParameter4dARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint index;
   GLdouble x;
   GLdouble y;
   GLdouble z;
   GLdouble w;
};
static inline void
_mesa_unmarshal_ProgramEnvParameter4dARB(struct gl_context *ctx, const struct marshal_cmd_ProgramEnvParameter4dARB *cmd)
{
   const GLenum target = cmd->target;
   const GLuint index = cmd->index;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   const GLdouble w = cmd->w;
   CALL_ProgramEnvParameter4dARB(ctx->CurrentServerDispatch, (target, index, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_ProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramEnvParameter4dARB);
   struct marshal_cmd_ProgramEnvParameter4dARB *cmd;
   debug_print_marshal("ProgramEnvParameter4dARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramEnvParameter4dARB, cmd_size);
      cmd->target = target;
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramEnvParameter4dARB");
   CALL_ProgramEnvParameter4dARB(ctx->CurrentServerDispatch, (target, index, x, y, z, w));
}


/* ColorTableParameterfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ColorTableParameterfv(GLenum target, GLenum pname, const GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ColorTableParameterfv");
   CALL_ColorTableParameterfv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* IsSemaphoreEXT: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsSemaphoreEXT(GLuint semaphore)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsSemaphoreEXT");
   return CALL_IsSemaphoreEXT(ctx->CurrentServerDispatch, (semaphore));
}


/* IsTexture: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsTexture(GLuint texture)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsTexture");
   return CALL_IsTexture(ctx->CurrentServerDispatch, (texture));
}


/* ProgramUniform3uiv: marshalled asynchronously */
struct marshal_cmd_ProgramUniform3uiv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 12) bytes are GLuint value[count][3] */
};
static inline void
_mesa_unmarshal_ProgramUniform3uiv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform3uiv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLuint * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLuint *) variable_data;
   variable_data += count * 12;
   CALL_ProgramUniform3uiv(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform3uiv) + safe_mul(count, 12);
   struct marshal_cmd_ProgramUniform3uiv *cmd;
   debug_print_marshal("ProgramUniform3uiv");
   if (unlikely(safe_mul(count, 12) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform3uiv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 12);
      variable_data += count * 12;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform3uiv");
   CALL_ProgramUniform3uiv(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* GetTextureImage: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTextureImage(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, GLvoid * pixels)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTextureImage");
   CALL_GetTextureImage(ctx->CurrentServerDispatch, (texture, level, format, type, bufSize, pixels));
}


/* VertexAttrib4sNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4sNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLshort x;
   GLshort y;
   GLshort z;
   GLshort w;
};
static inline void
_mesa_unmarshal_VertexAttrib4sNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4sNV *cmd)
{
   const GLuint index = cmd->index;
   const GLshort x = cmd->x;
   const GLshort y = cmd->y;
   const GLshort z = cmd->z;
   const GLshort w = cmd->w;
   CALL_VertexAttrib4sNV(ctx->CurrentServerDispatch, (index, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4sNV);
   struct marshal_cmd_VertexAttrib4sNV *cmd;
   debug_print_marshal("VertexAttrib4sNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4sNV, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4sNV");
   CALL_VertexAttrib4sNV(ctx->CurrentServerDispatch, (index, x, y, z, w));
}


/* GetMapdv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetMapdv(GLenum target, GLenum query, GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetMapdv");
   CALL_GetMapdv(ctx->CurrentServerDispatch, (target, query, v));
}


/* Uniform3ui64vARB: marshalled asynchronously */
struct marshal_cmd_Uniform3ui64vARB
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 24) bytes are GLuint64 value[count][3] */
};
static inline void
_mesa_unmarshal_Uniform3ui64vARB(struct gl_context *ctx, const struct marshal_cmd_Uniform3ui64vARB *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLuint64 * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLuint64 *) variable_data;
   variable_data += count * 24;
   CALL_Uniform3ui64vARB(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform3ui64vARB(GLint location, GLsizei count, const GLuint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform3ui64vARB) + safe_mul(count, 24);
   struct marshal_cmd_Uniform3ui64vARB *cmd;
   debug_print_marshal("Uniform3ui64vARB");
   if (unlikely(safe_mul(count, 24) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform3ui64vARB, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 24);
      variable_data += count * 24;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform3ui64vARB");
   CALL_Uniform3ui64vARB(ctx->CurrentServerDispatch, (location, count, value));
}


/* GetInteger64i_v: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetInteger64i_v(GLenum cap, GLuint index, GLint64 * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetInteger64i_v");
   CALL_GetInteger64i_v(ctx->CurrentServerDispatch, (cap, index, data));
}


/* BufferPageCommitmentARB: marshalled asynchronously */
struct marshal_cmd_BufferPageCommitmentARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLintptr offset;
   GLsizeiptr size;
   GLboolean commit;
};
static inline void
_mesa_unmarshal_BufferPageCommitmentARB(struct gl_context *ctx, const struct marshal_cmd_BufferPageCommitmentARB *cmd)
{
   const GLenum target = cmd->target;
   const GLintptr offset = cmd->offset;
   const GLsizeiptr size = cmd->size;
   const GLboolean commit = cmd->commit;
   CALL_BufferPageCommitmentARB(ctx->CurrentServerDispatch, (target, offset, size, commit));
}
static void GLAPIENTRY
_mesa_marshal_BufferPageCommitmentARB(GLenum target, GLintptr offset, GLsizeiptr size, GLboolean commit)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BufferPageCommitmentARB);
   struct marshal_cmd_BufferPageCommitmentARB *cmd;
   debug_print_marshal("BufferPageCommitmentARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BufferPageCommitmentARB, cmd_size);
      cmd->target = target;
      cmd->offset = offset;
      cmd->size = size;
      cmd->commit = commit;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BufferPageCommitmentARB");
   CALL_BufferPageCommitmentARB(ctx->CurrentServerDispatch, (target, offset, size, commit));
}


/* IsBuffer: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsBuffer(GLuint buffer)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsBuffer");
   return CALL_IsBuffer(ctx->CurrentServerDispatch, (buffer));
}


/* ColorP4ui: marshalled asynchronously */
struct marshal_cmd_ColorP4ui
{
   struct marshal_cmd_base cmd_base;
   GLenum type;
   GLuint color;
};
static inline void
_mesa_unmarshal_ColorP4ui(struct gl_context *ctx, const struct marshal_cmd_ColorP4ui *cmd)
{
   const GLenum type = cmd->type;
   const GLuint color = cmd->color;
   CALL_ColorP4ui(ctx->CurrentServerDispatch, (type, color));
}
static void GLAPIENTRY
_mesa_marshal_ColorP4ui(GLenum type, GLuint color)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ColorP4ui);
   struct marshal_cmd_ColorP4ui *cmd;
   debug_print_marshal("ColorP4ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ColorP4ui, cmd_size);
      cmd->type = type;
      cmd->color = color;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ColorP4ui");
   CALL_ColorP4ui(ctx->CurrentServerDispatch, (type, color));
}


/* TextureStorage3D: marshalled asynchronously */
struct marshal_cmd_TextureStorage3D
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLsizei levels;
   GLenum internalformat;
   GLsizei width;
   GLsizei height;
   GLsizei depth;
};
static inline void
_mesa_unmarshal_TextureStorage3D(struct gl_context *ctx, const struct marshal_cmd_TextureStorage3D *cmd)
{
   const GLuint texture = cmd->texture;
   const GLsizei levels = cmd->levels;
   const GLenum internalformat = cmd->internalformat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLsizei depth = cmd->depth;
   CALL_TextureStorage3D(ctx->CurrentServerDispatch, (texture, levels, internalformat, width, height, depth));
}
static void GLAPIENTRY
_mesa_marshal_TextureStorage3D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureStorage3D);
   struct marshal_cmd_TextureStorage3D *cmd;
   debug_print_marshal("TextureStorage3D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureStorage3D, cmd_size);
      cmd->texture = texture;
      cmd->levels = levels;
      cmd->internalformat = internalformat;
      cmd->width = width;
      cmd->height = height;
      cmd->depth = depth;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureStorage3D");
   CALL_TextureStorage3D(ctx->CurrentServerDispatch, (texture, levels, internalformat, width, height, depth));
}


/* TexCoordP3uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexCoordP3uiv(GLenum type, const GLuint * coords)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexCoordP3uiv");
   CALL_TexCoordP3uiv(ctx->CurrentServerDispatch, (type, coords));
}


/* GetnUniformui64vARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnUniformui64vARB(GLuint program, GLint location, GLsizei bufSize, GLuint64 * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnUniformui64vARB");
   CALL_GetnUniformui64vARB(ctx->CurrentServerDispatch, (program, location, bufSize, params));
}


/* TextureStorageMem2DMultisampleEXT: marshalled asynchronously */
struct marshal_cmd_TextureStorageMem2DMultisampleEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLsizei samples;
   GLenum internalFormat;
   GLsizei width;
   GLsizei height;
   GLboolean fixedSampleLocations;
   GLuint memory;
   GLuint64 offset;
};
static inline void
_mesa_unmarshal_TextureStorageMem2DMultisampleEXT(struct gl_context *ctx, const struct marshal_cmd_TextureStorageMem2DMultisampleEXT *cmd)
{
   const GLuint texture = cmd->texture;
   const GLsizei samples = cmd->samples;
   const GLenum internalFormat = cmd->internalFormat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLboolean fixedSampleLocations = cmd->fixedSampleLocations;
   const GLuint memory = cmd->memory;
   const GLuint64 offset = cmd->offset;
   CALL_TextureStorageMem2DMultisampleEXT(ctx->CurrentServerDispatch, (texture, samples, internalFormat, width, height, fixedSampleLocations, memory, offset));
}
static void GLAPIENTRY
_mesa_marshal_TextureStorageMem2DMultisampleEXT(GLuint texture, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureStorageMem2DMultisampleEXT);
   struct marshal_cmd_TextureStorageMem2DMultisampleEXT *cmd;
   debug_print_marshal("TextureStorageMem2DMultisampleEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureStorageMem2DMultisampleEXT, cmd_size);
      cmd->texture = texture;
      cmd->samples = samples;
      cmd->internalFormat = internalFormat;
      cmd->width = width;
      cmd->height = height;
      cmd->fixedSampleLocations = fixedSampleLocations;
      cmd->memory = memory;
      cmd->offset = offset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureStorageMem2DMultisampleEXT");
   CALL_TextureStorageMem2DMultisampleEXT(ctx->CurrentServerDispatch, (texture, samples, internalFormat, width, height, fixedSampleLocations, memory, offset));
}


/* Uniform1iv: marshalled asynchronously */
struct marshal_cmd_Uniform1iv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 4) bytes are GLint value[count] */
};
static inline void
_mesa_unmarshal_Uniform1iv(struct gl_context *ctx, const struct marshal_cmd_Uniform1iv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLint * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLint *) variable_data;
   variable_data += count * 4;
   CALL_Uniform1iv(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform1iv(GLint location, GLsizei count, const GLint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform1iv) + safe_mul(count, 4);
   struct marshal_cmd_Uniform1iv *cmd;
   debug_print_marshal("Uniform1iv");
   if (unlikely(safe_mul(count, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform1iv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 4);
      variable_data += count * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform1iv");
   CALL_Uniform1iv(ctx->CurrentServerDispatch, (location, count, value));
}


/* Uniform4uiv: marshalled asynchronously */
struct marshal_cmd_Uniform4uiv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 16) bytes are GLuint value[count][4] */
};
static inline void
_mesa_unmarshal_Uniform4uiv(struct gl_context *ctx, const struct marshal_cmd_Uniform4uiv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLuint * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLuint *) variable_data;
   variable_data += count * 16;
   CALL_Uniform4uiv(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform4uiv(GLint location, GLsizei count, const GLuint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform4uiv) + safe_mul(count, 16);
   struct marshal_cmd_Uniform4uiv *cmd;
   debug_print_marshal("Uniform4uiv");
   if (unlikely(safe_mul(count, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform4uiv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 16);
      variable_data += count * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform4uiv");
   CALL_Uniform4uiv(ctx->CurrentServerDispatch, (location, count, value));
}


/* PopDebugGroup: marshalled asynchronously */
struct marshal_cmd_PopDebugGroup
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_PopDebugGroup(struct gl_context *ctx, const struct marshal_cmd_PopDebugGroup *cmd)
{
   CALL_PopDebugGroup(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_PopDebugGroup(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PopDebugGroup);
   struct marshal_cmd_PopDebugGroup *cmd;
   debug_print_marshal("PopDebugGroup");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PopDebugGroup, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PopDebugGroup");
   CALL_PopDebugGroup(ctx->CurrentServerDispatch, ());
}


/* VertexAttrib1d: marshalled asynchronously */
struct marshal_cmd_VertexAttrib1d
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble x;
};
static inline void
_mesa_unmarshal_VertexAttrib1d(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib1d *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble x = cmd->x;
   CALL_VertexAttrib1d(ctx->CurrentServerDispatch, (index, x));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib1d(GLuint index, GLdouble x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib1d);
   struct marshal_cmd_VertexAttrib1d *cmd;
   debug_print_marshal("VertexAttrib1d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib1d, cmd_size);
      cmd->index = index;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib1d");
   CALL_VertexAttrib1d(ctx->CurrentServerDispatch, (index, x));
}


/* CompressedTexImage1D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CompressedTexImage1D");
   CALL_CompressedTexImage1D(ctx->CurrentServerDispatch, (target, level, internalformat, width, border, imageSize, data));
}


/* TexBufferRange: marshalled asynchronously */
struct marshal_cmd_TexBufferRange
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum internalformat;
   GLuint buffer;
   GLintptr offset;
   GLsizeiptr size;
};
static inline void
_mesa_unmarshal_TexBufferRange(struct gl_context *ctx, const struct marshal_cmd_TexBufferRange *cmd)
{
   const GLenum target = cmd->target;
   const GLenum internalformat = cmd->internalformat;
   const GLuint buffer = cmd->buffer;
   const GLintptr offset = cmd->offset;
   const GLsizeiptr size = cmd->size;
   CALL_TexBufferRange(ctx->CurrentServerDispatch, (target, internalformat, buffer, offset, size));
}
static void GLAPIENTRY
_mesa_marshal_TexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexBufferRange);
   struct marshal_cmd_TexBufferRange *cmd;
   debug_print_marshal("TexBufferRange");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexBufferRange, cmd_size);
      cmd->target = target;
      cmd->internalformat = internalformat;
      cmd->buffer = buffer;
      cmd->offset = offset;
      cmd->size = size;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexBufferRange");
   CALL_TexBufferRange(ctx->CurrentServerDispatch, (target, internalformat, buffer, offset, size));
}


/* VertexAttrib1s: marshalled asynchronously */
struct marshal_cmd_VertexAttrib1s
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLshort x;
};
static inline void
_mesa_unmarshal_VertexAttrib1s(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib1s *cmd)
{
   const GLuint index = cmd->index;
   const GLshort x = cmd->x;
   CALL_VertexAttrib1s(ctx->CurrentServerDispatch, (index, x));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib1s(GLuint index, GLshort x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib1s);
   struct marshal_cmd_VertexAttrib1s *cmd;
   debug_print_marshal("VertexAttrib1s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib1s, cmd_size);
      cmd->index = index;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib1s");
   CALL_VertexAttrib1s(ctx->CurrentServerDispatch, (index, x));
}


/* MultiDrawElementsIndirect: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_MultiDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid * indirect, GLsizei primcount, GLsizei stride)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MultiDrawElementsIndirect");
   CALL_MultiDrawElementsIndirect(ctx->CurrentServerDispatch, (mode, type, indirect, primcount, stride));
}


/* UniformMatrix4x3dv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix4x3dv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 96) bytes are GLdouble value[count][12] */
};
static inline void
_mesa_unmarshal_UniformMatrix4x3dv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix4x3dv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 96;
   CALL_UniformMatrix4x3dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix4x3dv) + safe_mul(count, 96);
   struct marshal_cmd_UniformMatrix4x3dv *cmd;
   debug_print_marshal("UniformMatrix4x3dv");
   if (unlikely(safe_mul(count, 96) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix4x3dv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 96);
      variable_data += count * 96;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix4x3dv");
   CALL_UniformMatrix4x3dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* TransformFeedbackBufferBase: marshalled asynchronously */
struct marshal_cmd_TransformFeedbackBufferBase
{
   struct marshal_cmd_base cmd_base;
   GLuint xfb;
   GLuint index;
   GLuint buffer;
};
static inline void
_mesa_unmarshal_TransformFeedbackBufferBase(struct gl_context *ctx, const struct marshal_cmd_TransformFeedbackBufferBase *cmd)
{
   const GLuint xfb = cmd->xfb;
   const GLuint index = cmd->index;
   const GLuint buffer = cmd->buffer;
   CALL_TransformFeedbackBufferBase(ctx->CurrentServerDispatch, (xfb, index, buffer));
}
static void GLAPIENTRY
_mesa_marshal_TransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint buffer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TransformFeedbackBufferBase);
   struct marshal_cmd_TransformFeedbackBufferBase *cmd;
   debug_print_marshal("TransformFeedbackBufferBase");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TransformFeedbackBufferBase, cmd_size);
      cmd->xfb = xfb;
      cmd->index = index;
      cmd->buffer = buffer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TransformFeedbackBufferBase");
   CALL_TransformFeedbackBufferBase(ctx->CurrentServerDispatch, (xfb, index, buffer));
}


/* FogCoordfvEXT: marshalled asynchronously */
struct marshal_cmd_FogCoordfvEXT
{
   struct marshal_cmd_base cmd_base;
   GLfloat coord[1];
};
static inline void
_mesa_unmarshal_FogCoordfvEXT(struct gl_context *ctx, const struct marshal_cmd_FogCoordfvEXT *cmd)
{
   const GLfloat * coord = cmd->coord;
   CALL_FogCoordfvEXT(ctx->CurrentServerDispatch, (coord));
}
static void GLAPIENTRY
_mesa_marshal_FogCoordfvEXT(const GLfloat * coord)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_FogCoordfvEXT);
   struct marshal_cmd_FogCoordfvEXT *cmd;
   debug_print_marshal("FogCoordfvEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_FogCoordfvEXT, cmd_size);
      memcpy(cmd->coord, coord, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("FogCoordfvEXT");
   CALL_FogCoordfvEXT(ctx->CurrentServerDispatch, (coord));
}


/* Uniform2ui64vARB: marshalled asynchronously */
struct marshal_cmd_Uniform2ui64vARB
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 16) bytes are GLuint64 value[count][2] */
};
static inline void
_mesa_unmarshal_Uniform2ui64vARB(struct gl_context *ctx, const struct marshal_cmd_Uniform2ui64vARB *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLuint64 * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLuint64 *) variable_data;
   variable_data += count * 16;
   CALL_Uniform2ui64vARB(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform2ui64vARB(GLint location, GLsizei count, const GLuint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform2ui64vARB) + safe_mul(count, 16);
   struct marshal_cmd_Uniform2ui64vARB *cmd;
   debug_print_marshal("Uniform2ui64vARB");
   if (unlikely(safe_mul(count, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform2ui64vARB, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 16);
      variable_data += count * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform2ui64vARB");
   CALL_Uniform2ui64vARB(ctx->CurrentServerDispatch, (location, count, value));
}


/* GetColorTableParameterfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetColorTableParameterfv(GLenum target, GLenum pname, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetColorTableParameterfv");
   CALL_GetColorTableParameterfv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* MultiTexCoord3fARB: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord3fARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLfloat s;
   GLfloat t;
   GLfloat r;
};
static inline void
_mesa_unmarshal_MultiTexCoord3fARB(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord3fARB *cmd)
{
   const GLenum target = cmd->target;
   const GLfloat s = cmd->s;
   const GLfloat t = cmd->t;
   const GLfloat r = cmd->r;
   CALL_MultiTexCoord3fARB(ctx->CurrentServerDispatch, (target, s, t, r));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord3fARB);
   struct marshal_cmd_MultiTexCoord3fARB *cmd;
   debug_print_marshal("MultiTexCoord3fARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord3fARB, cmd_size);
      cmd->target = target;
      cmd->s = s;
      cmd->t = t;
      cmd->r = r;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord3fARB");
   CALL_MultiTexCoord3fARB(ctx->CurrentServerDispatch, (target, s, t, r));
}


/* GetTexLevelParameterfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTexLevelParameterfv");
   CALL_GetTexLevelParameterfv(ctx->CurrentServerDispatch, (target, level, pname, params));
}


/* Vertex2sv: marshalled asynchronously */
struct marshal_cmd_Vertex2sv
{
   struct marshal_cmd_base cmd_base;
   GLshort v[2];
};
static inline void
_mesa_unmarshal_Vertex2sv(struct gl_context *ctx, const struct marshal_cmd_Vertex2sv *cmd)
{
   const GLshort * v = cmd->v;
   CALL_Vertex2sv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Vertex2sv(const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex2sv);
   struct marshal_cmd_Vertex2sv *cmd;
   debug_print_marshal("Vertex2sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex2sv, cmd_size);
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex2sv");
   CALL_Vertex2sv(ctx->CurrentServerDispatch, (v));
}


/* GetnMapdvARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnMapdvARB(GLenum target, GLenum query, GLsizei bufSize, GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnMapdvARB");
   CALL_GetnMapdvARB(ctx->CurrentServerDispatch, (target, query, bufSize, v));
}


/* VertexAttrib2dNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib2dNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble x;
   GLdouble y;
};
static inline void
_mesa_unmarshal_VertexAttrib2dNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib2dNV *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   CALL_VertexAttrib2dNV(ctx->CurrentServerDispatch, (index, x, y));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib2dNV);
   struct marshal_cmd_VertexAttrib2dNV *cmd;
   debug_print_marshal("VertexAttrib2dNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib2dNV, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib2dNV");
   CALL_VertexAttrib2dNV(ctx->CurrentServerDispatch, (index, x, y));
}


/* VertexAttrib3svNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib3svNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLshort v[3];
};
static inline void
_mesa_unmarshal_VertexAttrib3svNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib3svNV *cmd)
{
   const GLuint index = cmd->index;
   const GLshort * v = cmd->v;
   CALL_VertexAttrib3svNV(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib3svNV(GLuint index, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib3svNV);
   struct marshal_cmd_VertexAttrib3svNV *cmd;
   debug_print_marshal("VertexAttrib3svNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib3svNV, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 6);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib3svNV");
   CALL_VertexAttrib3svNV(ctx->CurrentServerDispatch, (index, v));
}


/* GetTexEnviv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTexEnviv(GLenum target, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTexEnviv");
   CALL_GetTexEnviv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* ViewportArrayv: marshalled asynchronously */
struct marshal_cmd_ViewportArrayv
{
   struct marshal_cmd_base cmd_base;
   GLuint first;
   GLsizei count;
   /* Next safe_mul(count, 16) bytes are GLfloat v[count][4] */
};
static inline void
_mesa_unmarshal_ViewportArrayv(struct gl_context *ctx, const struct marshal_cmd_ViewportArrayv *cmd)
{
   const GLuint first = cmd->first;
   const GLsizei count = cmd->count;
   const GLfloat * v;
   const char *variable_data = (const char *) (cmd + 1);
   v = (const GLfloat *) variable_data;
   variable_data += count * 16;
   CALL_ViewportArrayv(ctx->CurrentServerDispatch, (first, count, v));
}
static void GLAPIENTRY
_mesa_marshal_ViewportArrayv(GLuint first, GLsizei count, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ViewportArrayv) + safe_mul(count, 16);
   struct marshal_cmd_ViewportArrayv *cmd;
   debug_print_marshal("ViewportArrayv");
   if (unlikely(safe_mul(count, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ViewportArrayv, cmd_size);
      cmd->first = first;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, v, count * 16);
      variable_data += count * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ViewportArrayv");
   CALL_ViewportArrayv(ctx->CurrentServerDispatch, (first, count, v));
}


/* SeparableFilter2D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_SeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * row, const GLvoid * column)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("SeparableFilter2D");
   CALL_SeparableFilter2D(ctx->CurrentServerDispatch, (target, internalformat, width, height, format, type, row, column));
}


/* ArrayElement: marshalled asynchronously */
struct marshal_cmd_ArrayElement
{
   struct marshal_cmd_base cmd_base;
   GLint i;
};
static inline void
_mesa_unmarshal_ArrayElement(struct gl_context *ctx, const struct marshal_cmd_ArrayElement *cmd)
{
   const GLint i = cmd->i;
   CALL_ArrayElement(ctx->CurrentServerDispatch, (i));
}
static void GLAPIENTRY
_mesa_marshal_ArrayElement(GLint i)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ArrayElement);
   struct marshal_cmd_ArrayElement *cmd;
   debug_print_marshal("ArrayElement");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ArrayElement, cmd_size);
      cmd->i = i;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ArrayElement");
   CALL_ArrayElement(ctx->CurrentServerDispatch, (i));
}


/* TexImage2D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexImage2D");
   CALL_TexImage2D(ctx->CurrentServerDispatch, (target, level, internalformat, width, height, border, format, type, pixels));
}


/* RasterPos2dv: marshalled asynchronously */
struct marshal_cmd_RasterPos2dv
{
   struct marshal_cmd_base cmd_base;
   GLdouble v[2];
};
static inline void
_mesa_unmarshal_RasterPos2dv(struct gl_context *ctx, const struct marshal_cmd_RasterPos2dv *cmd)
{
   const GLdouble * v = cmd->v;
   CALL_RasterPos2dv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos2dv(const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos2dv);
   struct marshal_cmd_RasterPos2dv *cmd;
   debug_print_marshal("RasterPos2dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos2dv, cmd_size);
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos2dv");
   CALL_RasterPos2dv(ctx->CurrentServerDispatch, (v));
}


/* Fogiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_Fogiv(GLenum pname, const GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("Fogiv");
   CALL_Fogiv(ctx->CurrentServerDispatch, (pname, params));
}


/* EndQuery: marshalled asynchronously */
struct marshal_cmd_EndQuery
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
};
static inline void
_mesa_unmarshal_EndQuery(struct gl_context *ctx, const struct marshal_cmd_EndQuery *cmd)
{
   const GLenum target = cmd->target;
   CALL_EndQuery(ctx->CurrentServerDispatch, (target));
}
static void GLAPIENTRY
_mesa_marshal_EndQuery(GLenum target)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EndQuery);
   struct marshal_cmd_EndQuery *cmd;
   debug_print_marshal("EndQuery");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EndQuery, cmd_size);
      cmd->target = target;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EndQuery");
   CALL_EndQuery(ctx->CurrentServerDispatch, (target));
}


/* TexCoord1dv: marshalled asynchronously */
struct marshal_cmd_TexCoord1dv
{
   struct marshal_cmd_base cmd_base;
   GLdouble v[1];
};
static inline void
_mesa_unmarshal_TexCoord1dv(struct gl_context *ctx, const struct marshal_cmd_TexCoord1dv *cmd)
{
   const GLdouble * v = cmd->v;
   CALL_TexCoord1dv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord1dv(const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord1dv);
   struct marshal_cmd_TexCoord1dv *cmd;
   debug_print_marshal("TexCoord1dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord1dv, cmd_size);
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord1dv");
   CALL_TexCoord1dv(ctx->CurrentServerDispatch, (v));
}


/* AlphaFragmentOp3ATI: marshalled asynchronously */
struct marshal_cmd_AlphaFragmentOp3ATI
{
   struct marshal_cmd_base cmd_base;
   GLenum op;
   GLuint dst;
   GLuint dstMod;
   GLuint arg1;
   GLuint arg1Rep;
   GLuint arg1Mod;
   GLuint arg2;
   GLuint arg2Rep;
   GLuint arg2Mod;
   GLuint arg3;
   GLuint arg3Rep;
   GLuint arg3Mod;
};
static inline void
_mesa_unmarshal_AlphaFragmentOp3ATI(struct gl_context *ctx, const struct marshal_cmd_AlphaFragmentOp3ATI *cmd)
{
   const GLenum op = cmd->op;
   const GLuint dst = cmd->dst;
   const GLuint dstMod = cmd->dstMod;
   const GLuint arg1 = cmd->arg1;
   const GLuint arg1Rep = cmd->arg1Rep;
   const GLuint arg1Mod = cmd->arg1Mod;
   const GLuint arg2 = cmd->arg2;
   const GLuint arg2Rep = cmd->arg2Rep;
   const GLuint arg2Mod = cmd->arg2Mod;
   const GLuint arg3 = cmd->arg3;
   const GLuint arg3Rep = cmd->arg3Rep;
   const GLuint arg3Mod = cmd->arg3Mod;
   CALL_AlphaFragmentOp3ATI(ctx->CurrentServerDispatch, (op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod));
}
static void GLAPIENTRY
_mesa_marshal_AlphaFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_AlphaFragmentOp3ATI);
   struct marshal_cmd_AlphaFragmentOp3ATI *cmd;
   debug_print_marshal("AlphaFragmentOp3ATI");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_AlphaFragmentOp3ATI, cmd_size);
      cmd->op = op;
      cmd->dst = dst;
      cmd->dstMod = dstMod;
      cmd->arg1 = arg1;
      cmd->arg1Rep = arg1Rep;
      cmd->arg1Mod = arg1Mod;
      cmd->arg2 = arg2;
      cmd->arg2Rep = arg2Rep;
      cmd->arg2Mod = arg2Mod;
      cmd->arg3 = arg3;
      cmd->arg3Rep = arg3Rep;
      cmd->arg3Mod = arg3Mod;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("AlphaFragmentOp3ATI");
   CALL_AlphaFragmentOp3ATI(ctx->CurrentServerDispatch, (op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod));
}


/* Clear: marshalled asynchronously */
struct marshal_cmd_Clear
{
   struct marshal_cmd_base cmd_base;
   GLbitfield mask;
};
static inline void
_mesa_unmarshal_Clear(struct gl_context *ctx, const struct marshal_cmd_Clear *cmd)
{
   const GLbitfield mask = cmd->mask;
   CALL_Clear(ctx->CurrentServerDispatch, (mask));
}
static void GLAPIENTRY
_mesa_marshal_Clear(GLbitfield mask)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Clear);
   struct marshal_cmd_Clear *cmd;
   debug_print_marshal("Clear");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Clear, cmd_size);
      cmd->mask = mask;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Clear");
   CALL_Clear(ctx->CurrentServerDispatch, (mask));
}


/* VertexAttrib4sv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4sv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLshort v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4sv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4sv *cmd)
{
   const GLuint index = cmd->index;
   const GLshort * v = cmd->v;
   CALL_VertexAttrib4sv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4sv(GLuint index, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4sv);
   struct marshal_cmd_VertexAttrib4sv *cmd;
   debug_print_marshal("VertexAttrib4sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4sv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4sv");
   CALL_VertexAttrib4sv(ctx->CurrentServerDispatch, (index, v));
}


/* Ortho: marshalled asynchronously */
struct marshal_cmd_Ortho
{
   struct marshal_cmd_base cmd_base;
   GLdouble left;
   GLdouble right;
   GLdouble bottom;
   GLdouble top;
   GLdouble zNear;
   GLdouble zFar;
};
static inline void
_mesa_unmarshal_Ortho(struct gl_context *ctx, const struct marshal_cmd_Ortho *cmd)
{
   const GLdouble left = cmd->left;
   const GLdouble right = cmd->right;
   const GLdouble bottom = cmd->bottom;
   const GLdouble top = cmd->top;
   const GLdouble zNear = cmd->zNear;
   const GLdouble zFar = cmd->zFar;
   CALL_Ortho(ctx->CurrentServerDispatch, (left, right, bottom, top, zNear, zFar));
}
static void GLAPIENTRY
_mesa_marshal_Ortho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Ortho);
   struct marshal_cmd_Ortho *cmd;
   debug_print_marshal("Ortho");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Ortho, cmd_size);
      cmd->left = left;
      cmd->right = right;
      cmd->bottom = bottom;
      cmd->top = top;
      cmd->zNear = zNear;
      cmd->zFar = zFar;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Ortho");
   CALL_Ortho(ctx->CurrentServerDispatch, (left, right, bottom, top, zNear, zFar));
}


/* Uniform3uiv: marshalled asynchronously */
struct marshal_cmd_Uniform3uiv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 12) bytes are GLuint value[count][3] */
};
static inline void
_mesa_unmarshal_Uniform3uiv(struct gl_context *ctx, const struct marshal_cmd_Uniform3uiv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLuint * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLuint *) variable_data;
   variable_data += count * 12;
   CALL_Uniform3uiv(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform3uiv(GLint location, GLsizei count, const GLuint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform3uiv) + safe_mul(count, 12);
   struct marshal_cmd_Uniform3uiv *cmd;
   debug_print_marshal("Uniform3uiv");
   if (unlikely(safe_mul(count, 12) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform3uiv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 12);
      variable_data += count * 12;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform3uiv");
   CALL_Uniform3uiv(ctx->CurrentServerDispatch, (location, count, value));
}


/* GetUniformi64vARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetUniformi64vARB(GLuint program, GLint location, GLint64 * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetUniformi64vARB");
   CALL_GetUniformi64vARB(ctx->CurrentServerDispatch, (program, location, params));
}


/* EndQueryIndexed: marshalled asynchronously */
struct marshal_cmd_EndQueryIndexed
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint index;
};
static inline void
_mesa_unmarshal_EndQueryIndexed(struct gl_context *ctx, const struct marshal_cmd_EndQueryIndexed *cmd)
{
   const GLenum target = cmd->target;
   const GLuint index = cmd->index;
   CALL_EndQueryIndexed(ctx->CurrentServerDispatch, (target, index));
}
static void GLAPIENTRY
_mesa_marshal_EndQueryIndexed(GLenum target, GLuint index)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EndQueryIndexed);
   struct marshal_cmd_EndQueryIndexed *cmd;
   debug_print_marshal("EndQueryIndexed");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EndQueryIndexed, cmd_size);
      cmd->target = target;
      cmd->index = index;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EndQueryIndexed");
   CALL_EndQueryIndexed(ctx->CurrentServerDispatch, (target, index));
}


/* TexParameterxv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexParameterxv(GLenum target, GLenum pname, const GLfixed * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexParameterxv");
   CALL_TexParameterxv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* MultiDrawArraysIndirectCountARB: marshalled asynchronously */
struct marshal_cmd_MultiDrawArraysIndirectCountARB
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLintptr indirect;
   GLintptr drawcount;
   GLsizei maxdrawcount;
   GLsizei stride;
};
static inline void
_mesa_unmarshal_MultiDrawArraysIndirectCountARB(struct gl_context *ctx, const struct marshal_cmd_MultiDrawArraysIndirectCountARB *cmd)
{
   const GLenum mode = cmd->mode;
   const GLintptr indirect = cmd->indirect;
   const GLintptr drawcount = cmd->drawcount;
   const GLsizei maxdrawcount = cmd->maxdrawcount;
   const GLsizei stride = cmd->stride;
   CALL_MultiDrawArraysIndirectCountARB(ctx->CurrentServerDispatch, (mode, indirect, drawcount, maxdrawcount, stride));
}
static void GLAPIENTRY
_mesa_marshal_MultiDrawArraysIndirectCountARB(GLenum mode, GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiDrawArraysIndirectCountARB);
   struct marshal_cmd_MultiDrawArraysIndirectCountARB *cmd;
   debug_print_marshal("MultiDrawArraysIndirectCountARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiDrawArraysIndirectCountARB, cmd_size);
      cmd->mode = mode;
      cmd->indirect = indirect;
      cmd->drawcount = drawcount;
      cmd->maxdrawcount = maxdrawcount;
      cmd->stride = stride;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiDrawArraysIndirectCountARB");
   CALL_MultiDrawArraysIndirectCountARB(ctx->CurrentServerDispatch, (mode, indirect, drawcount, maxdrawcount, stride));
}


/* ProgramUniformMatrix2fv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix2fv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 16) bytes are GLfloat value[count][4] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix2fv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix2fv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 16;
   CALL_ProgramUniformMatrix2fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix2fv) + safe_mul(count, 16);
   struct marshal_cmd_ProgramUniformMatrix2fv *cmd;
   debug_print_marshal("ProgramUniformMatrix2fv");
   if (unlikely(safe_mul(count, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix2fv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 16);
      variable_data += count * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix2fv");
   CALL_ProgramUniformMatrix2fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* ProgramLocalParameter4fvARB: marshalled asynchronously */
struct marshal_cmd_ProgramLocalParameter4fvARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint index;
   GLfloat params[4];
};
static inline void
_mesa_unmarshal_ProgramLocalParameter4fvARB(struct gl_context *ctx, const struct marshal_cmd_ProgramLocalParameter4fvARB *cmd)
{
   const GLenum target = cmd->target;
   const GLuint index = cmd->index;
   const GLfloat * params = cmd->params;
   CALL_ProgramLocalParameter4fvARB(ctx->CurrentServerDispatch, (target, index, params));
}
static void GLAPIENTRY
_mesa_marshal_ProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramLocalParameter4fvARB);
   struct marshal_cmd_ProgramLocalParameter4fvARB *cmd;
   debug_print_marshal("ProgramLocalParameter4fvARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramLocalParameter4fvARB, cmd_size);
      cmd->target = target;
      cmd->index = index;
      memcpy(cmd->params, params, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramLocalParameter4fvARB");
   CALL_ProgramLocalParameter4fvARB(ctx->CurrentServerDispatch, (target, index, params));
}


/* Uniform4dv: marshalled asynchronously */
struct marshal_cmd_Uniform4dv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 32) bytes are GLdouble value[count][4] */
};
static inline void
_mesa_unmarshal_Uniform4dv(struct gl_context *ctx, const struct marshal_cmd_Uniform4dv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 32;
   CALL_Uniform4dv(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform4dv(GLint location, GLsizei count, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform4dv) + safe_mul(count, 32);
   struct marshal_cmd_Uniform4dv *cmd;
   debug_print_marshal("Uniform4dv");
   if (unlikely(safe_mul(count, 32) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform4dv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 32);
      variable_data += count * 32;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform4dv");
   CALL_Uniform4dv(ctx->CurrentServerDispatch, (location, count, value));
}


/* GetUnsignedBytevEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetUnsignedBytevEXT(GLenum pname, GLubyte * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetUnsignedBytevEXT");
   CALL_GetUnsignedBytevEXT(ctx->CurrentServerDispatch, (pname, data));
}


/* LightModelx: marshalled asynchronously */
struct marshal_cmd_LightModelx
{
   struct marshal_cmd_base cmd_base;
   GLenum pname;
   GLfixed param;
};
static inline void
_mesa_unmarshal_LightModelx(struct gl_context *ctx, const struct marshal_cmd_LightModelx *cmd)
{
   const GLenum pname = cmd->pname;
   const GLfixed param = cmd->param;
   CALL_LightModelx(ctx->CurrentServerDispatch, (pname, param));
}
static void GLAPIENTRY
_mesa_marshal_LightModelx(GLenum pname, GLfixed param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_LightModelx);
   struct marshal_cmd_LightModelx *cmd;
   debug_print_marshal("LightModelx");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_LightModelx, cmd_size);
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("LightModelx");
   CALL_LightModelx(ctx->CurrentServerDispatch, (pname, param));
}


/* VertexAttribI3iEXT: marshalled asynchronously */
struct marshal_cmd_VertexAttribI3iEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLint x;
   GLint y;
   GLint z;
};
static inline void
_mesa_unmarshal_VertexAttribI3iEXT(struct gl_context *ctx, const struct marshal_cmd_VertexAttribI3iEXT *cmd)
{
   const GLuint index = cmd->index;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLint z = cmd->z;
   CALL_VertexAttribI3iEXT(ctx->CurrentServerDispatch, (index, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribI3iEXT(GLuint index, GLint x, GLint y, GLint z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribI3iEXT);
   struct marshal_cmd_VertexAttribI3iEXT *cmd;
   debug_print_marshal("VertexAttribI3iEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribI3iEXT, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribI3iEXT");
   CALL_VertexAttribI3iEXT(ctx->CurrentServerDispatch, (index, x, y, z));
}


/* ClearColorx: marshalled asynchronously */
struct marshal_cmd_ClearColorx
{
   struct marshal_cmd_base cmd_base;
   GLclampx red;
   GLclampx green;
   GLclampx blue;
   GLclampx alpha;
};
static inline void
_mesa_unmarshal_ClearColorx(struct gl_context *ctx, const struct marshal_cmd_ClearColorx *cmd)
{
   const GLclampx red = cmd->red;
   const GLclampx green = cmd->green;
   const GLclampx blue = cmd->blue;
   const GLclampx alpha = cmd->alpha;
   CALL_ClearColorx(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}
static void GLAPIENTRY
_mesa_marshal_ClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ClearColorx);
   struct marshal_cmd_ClearColorx *cmd;
   debug_print_marshal("ClearColorx");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ClearColorx, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      cmd->alpha = alpha;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ClearColorx");
   CALL_ClearColorx(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}


/* EndTransformFeedback: marshalled asynchronously */
struct marshal_cmd_EndTransformFeedback
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_EndTransformFeedback(struct gl_context *ctx, const struct marshal_cmd_EndTransformFeedback *cmd)
{
   CALL_EndTransformFeedback(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_EndTransformFeedback(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EndTransformFeedback);
   struct marshal_cmd_EndTransformFeedback *cmd;
   debug_print_marshal("EndTransformFeedback");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EndTransformFeedback, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EndTransformFeedback");
   CALL_EndTransformFeedback(ctx->CurrentServerDispatch, ());
}


/* VertexAttribL2dv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribL2dv(GLuint index, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribL2dv");
   CALL_VertexAttribL2dv(ctx->CurrentServerDispatch, (index, v));
}


/* GetActiveUniformName: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetActiveUniformName");
   CALL_GetActiveUniformName(ctx->CurrentServerDispatch, (program, uniformIndex, bufSize, length, uniformName));
}


/* GetProgramBinary: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei * length, GLenum * binaryFormat, GLvoid * binary)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramBinary");
   CALL_GetProgramBinary(ctx->CurrentServerDispatch, (program, bufSize, length, binaryFormat, binary));
}


/* ViewportIndexedfv: marshalled asynchronously */
struct marshal_cmd_ViewportIndexedfv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat v[4];
};
static inline void
_mesa_unmarshal_ViewportIndexedfv(struct gl_context *ctx, const struct marshal_cmd_ViewportIndexedfv *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat * v = cmd->v;
   CALL_ViewportIndexedfv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_ViewportIndexedfv(GLuint index, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ViewportIndexedfv);
   struct marshal_cmd_ViewportIndexedfv *cmd;
   debug_print_marshal("ViewportIndexedfv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ViewportIndexedfv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ViewportIndexedfv");
   CALL_ViewportIndexedfv(ctx->CurrentServerDispatch, (index, v));
}


/* BindTextureUnit: marshalled asynchronously */
struct marshal_cmd_BindTextureUnit
{
   struct marshal_cmd_base cmd_base;
   GLuint unit;
   GLuint texture;
};
static inline void
_mesa_unmarshal_BindTextureUnit(struct gl_context *ctx, const struct marshal_cmd_BindTextureUnit *cmd)
{
   const GLuint unit = cmd->unit;
   const GLuint texture = cmd->texture;
   CALL_BindTextureUnit(ctx->CurrentServerDispatch, (unit, texture));
}
static void GLAPIENTRY
_mesa_marshal_BindTextureUnit(GLuint unit, GLuint texture)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BindTextureUnit);
   struct marshal_cmd_BindTextureUnit *cmd;
   debug_print_marshal("BindTextureUnit");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BindTextureUnit, cmd_size);
      cmd->unit = unit;
      cmd->texture = texture;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BindTextureUnit");
   CALL_BindTextureUnit(ctx->CurrentServerDispatch, (unit, texture));
}


/* CallList: marshalled asynchronously */
struct marshal_cmd_CallList
{
   struct marshal_cmd_base cmd_base;
   GLuint list;
};
static inline void
_mesa_unmarshal_CallList(struct gl_context *ctx, const struct marshal_cmd_CallList *cmd)
{
   const GLuint list = cmd->list;
   CALL_CallList(ctx->CurrentServerDispatch, (list));
}
static void GLAPIENTRY
_mesa_marshal_CallList(GLuint list)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CallList);
   struct marshal_cmd_CallList *cmd;
   debug_print_marshal("CallList");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CallList, cmd_size);
      cmd->list = list;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CallList");
   CALL_CallList(ctx->CurrentServerDispatch, (list));
}


/* Materialfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_Materialfv(GLenum face, GLenum pname, const GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("Materialfv");
   CALL_Materialfv(ctx->CurrentServerDispatch, (face, pname, params));
}


/* DeleteProgram: marshalled asynchronously */
struct marshal_cmd_DeleteProgram
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
};
static inline void
_mesa_unmarshal_DeleteProgram(struct gl_context *ctx, const struct marshal_cmd_DeleteProgram *cmd)
{
   const GLuint program = cmd->program;
   CALL_DeleteProgram(ctx->CurrentServerDispatch, (program));
}
static void GLAPIENTRY
_mesa_marshal_DeleteProgram(GLuint program)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DeleteProgram);
   struct marshal_cmd_DeleteProgram *cmd;
   debug_print_marshal("DeleteProgram");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DeleteProgram, cmd_size);
      cmd->program = program;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DeleteProgram");
   CALL_DeleteProgram(ctx->CurrentServerDispatch, (program));
}


/* GetActiveAtomicCounterBufferiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetActiveAtomicCounterBufferiv");
   CALL_GetActiveAtomicCounterBufferiv(ctx->CurrentServerDispatch, (program, bufferIndex, pname, params));
}


/* ClearDepthf: marshalled asynchronously */
struct marshal_cmd_ClearDepthf
{
   struct marshal_cmd_base cmd_base;
   GLclampf depth;
};
static inline void
_mesa_unmarshal_ClearDepthf(struct gl_context *ctx, const struct marshal_cmd_ClearDepthf *cmd)
{
   const GLclampf depth = cmd->depth;
   CALL_ClearDepthf(ctx->CurrentServerDispatch, (depth));
}
static void GLAPIENTRY
_mesa_marshal_ClearDepthf(GLclampf depth)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ClearDepthf);
   struct marshal_cmd_ClearDepthf *cmd;
   debug_print_marshal("ClearDepthf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ClearDepthf, cmd_size);
      cmd->depth = depth;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ClearDepthf");
   CALL_ClearDepthf(ctx->CurrentServerDispatch, (depth));
}


/* GetTextureHandleARB: marshalled synchronously */
static GLuint64 GLAPIENTRY
_mesa_marshal_GetTextureHandleARB(GLuint texture)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTextureHandleARB");
   return CALL_GetTextureHandleARB(ctx->CurrentServerDispatch, (texture));
}


/* GetConvolutionFilter: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid * image)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetConvolutionFilter");
   CALL_GetConvolutionFilter(ctx->CurrentServerDispatch, (target, format, type, image));
}


/* MultiModeDrawElementsIBM: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_MultiModeDrawElementsIBM(const GLenum * mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, GLint modestride)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MultiModeDrawElementsIBM");
   CALL_MultiModeDrawElementsIBM(ctx->CurrentServerDispatch, (mode, count, type, indices, primcount, modestride));
}


/* Uniform2iv: marshalled asynchronously */
struct marshal_cmd_Uniform2iv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 8) bytes are GLint value[count][2] */
};
static inline void
_mesa_unmarshal_Uniform2iv(struct gl_context *ctx, const struct marshal_cmd_Uniform2iv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLint * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLint *) variable_data;
   variable_data += count * 8;
   CALL_Uniform2iv(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform2iv(GLint location, GLsizei count, const GLint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform2iv) + safe_mul(count, 8);
   struct marshal_cmd_Uniform2iv *cmd;
   debug_print_marshal("Uniform2iv");
   if (unlikely(safe_mul(count, 8) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform2iv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 8);
      variable_data += count * 8;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform2iv");
   CALL_Uniform2iv(ctx->CurrentServerDispatch, (location, count, value));
}


/* GetFixedv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetFixedv(GLenum pname, GLfixed * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetFixedv");
   CALL_GetFixedv(ctx->CurrentServerDispatch, (pname, params));
}


/* SampleCoveragex: marshalled asynchronously */
struct marshal_cmd_SampleCoveragex
{
   struct marshal_cmd_base cmd_base;
   GLclampx value;
   GLboolean invert;
};
static inline void
_mesa_unmarshal_SampleCoveragex(struct gl_context *ctx, const struct marshal_cmd_SampleCoveragex *cmd)
{
   const GLclampx value = cmd->value;
   const GLboolean invert = cmd->invert;
   CALL_SampleCoveragex(ctx->CurrentServerDispatch, (value, invert));
}
static void GLAPIENTRY
_mesa_marshal_SampleCoveragex(GLclampx value, GLboolean invert)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SampleCoveragex);
   struct marshal_cmd_SampleCoveragex *cmd;
   debug_print_marshal("SampleCoveragex");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SampleCoveragex, cmd_size);
      cmd->value = value;
      cmd->invert = invert;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SampleCoveragex");
   CALL_SampleCoveragex(ctx->CurrentServerDispatch, (value, invert));
}


/* GetPerfQueryInfoINTEL: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetPerfQueryInfoINTEL(GLuint queryId, GLuint queryNameLength, GLchar * queryName, GLuint * dataSize, GLuint * noCounters, GLuint * noInstances, GLuint * capsMask)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetPerfQueryInfoINTEL");
   CALL_GetPerfQueryInfoINTEL(ctx->CurrentServerDispatch, (queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask));
}


/* DeleteFramebuffers: marshalled asynchronously */
struct marshal_cmd_DeleteFramebuffers
{
   struct marshal_cmd_base cmd_base;
   GLsizei n;
   /* Next safe_mul(n, 4) bytes are GLuint framebuffers[n] */
};
static inline void
_mesa_unmarshal_DeleteFramebuffers(struct gl_context *ctx, const struct marshal_cmd_DeleteFramebuffers *cmd)
{
   const GLsizei n = cmd->n;
   const GLuint * framebuffers;
   const char *variable_data = (const char *) (cmd + 1);
   framebuffers = (const GLuint *) variable_data;
   variable_data += n * 4;
   CALL_DeleteFramebuffers(ctx->CurrentServerDispatch, (n, framebuffers));
}
static void GLAPIENTRY
_mesa_marshal_DeleteFramebuffers(GLsizei n, const GLuint * framebuffers)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DeleteFramebuffers) + safe_mul(n, 4);
   struct marshal_cmd_DeleteFramebuffers *cmd;
   debug_print_marshal("DeleteFramebuffers");
   if (unlikely(safe_mul(n, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DeleteFramebuffers, cmd_size);
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, framebuffers, n * 4);
      variable_data += n * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DeleteFramebuffers");
   CALL_DeleteFramebuffers(ctx->CurrentServerDispatch, (n, framebuffers));
}


/* VertexAttrib4uiv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4uiv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLuint v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4uiv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4uiv *cmd)
{
   const GLuint index = cmd->index;
   const GLuint * v = cmd->v;
   CALL_VertexAttrib4uiv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4uiv(GLuint index, const GLuint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4uiv);
   struct marshal_cmd_VertexAttrib4uiv *cmd;
   debug_print_marshal("VertexAttrib4uiv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4uiv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4uiv");
   CALL_VertexAttrib4uiv(ctx->CurrentServerDispatch, (index, v));
}


/* VertexAttrib4Nsv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4Nsv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLshort v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4Nsv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4Nsv *cmd)
{
   const GLuint index = cmd->index;
   const GLshort * v = cmd->v;
   CALL_VertexAttrib4Nsv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4Nsv(GLuint index, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4Nsv);
   struct marshal_cmd_VertexAttrib4Nsv *cmd;
   debug_print_marshal("VertexAttrib4Nsv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4Nsv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4Nsv");
   CALL_VertexAttrib4Nsv(ctx->CurrentServerDispatch, (index, v));
}


/* Vertex4s: marshalled asynchronously */
struct marshal_cmd_Vertex4s
{
   struct marshal_cmd_base cmd_base;
   GLshort x;
   GLshort y;
   GLshort z;
   GLshort w;
};
static inline void
_mesa_unmarshal_Vertex4s(struct gl_context *ctx, const struct marshal_cmd_Vertex4s *cmd)
{
   const GLshort x = cmd->x;
   const GLshort y = cmd->y;
   const GLshort z = cmd->z;
   const GLshort w = cmd->w;
   CALL_Vertex4s(ctx->CurrentServerDispatch, (x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_Vertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex4s);
   struct marshal_cmd_Vertex4s *cmd;
   debug_print_marshal("Vertex4s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex4s, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex4s");
   CALL_Vertex4s(ctx->CurrentServerDispatch, (x, y, z, w));
}


/* VertexAttribI2iEXT: marshalled asynchronously */
struct marshal_cmd_VertexAttribI2iEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLint x;
   GLint y;
};
static inline void
_mesa_unmarshal_VertexAttribI2iEXT(struct gl_context *ctx, const struct marshal_cmd_VertexAttribI2iEXT *cmd)
{
   const GLuint index = cmd->index;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   CALL_VertexAttribI2iEXT(ctx->CurrentServerDispatch, (index, x, y));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribI2iEXT(GLuint index, GLint x, GLint y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribI2iEXT);
   struct marshal_cmd_VertexAttribI2iEXT *cmd;
   debug_print_marshal("VertexAttribI2iEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribI2iEXT, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribI2iEXT");
   CALL_VertexAttribI2iEXT(ctx->CurrentServerDispatch, (index, x, y));
}


/* Vertex4f: marshalled asynchronously */
struct marshal_cmd_Vertex4f
{
   struct marshal_cmd_base cmd_base;
   GLfloat x;
   GLfloat y;
   GLfloat z;
   GLfloat w;
};
static inline void
_mesa_unmarshal_Vertex4f(struct gl_context *ctx, const struct marshal_cmd_Vertex4f *cmd)
{
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   const GLfloat w = cmd->w;
   CALL_Vertex4f(ctx->CurrentServerDispatch, (x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_Vertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex4f);
   struct marshal_cmd_Vertex4f *cmd;
   debug_print_marshal("Vertex4f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex4f, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex4f");
   CALL_Vertex4f(ctx->CurrentServerDispatch, (x, y, z, w));
}


/* Vertex4d: marshalled asynchronously */
struct marshal_cmd_Vertex4d
{
   struct marshal_cmd_base cmd_base;
   GLdouble x;
   GLdouble y;
   GLdouble z;
   GLdouble w;
};
static inline void
_mesa_unmarshal_Vertex4d(struct gl_context *ctx, const struct marshal_cmd_Vertex4d *cmd)
{
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   const GLdouble w = cmd->w;
   CALL_Vertex4d(ctx->CurrentServerDispatch, (x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_Vertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex4d);
   struct marshal_cmd_Vertex4d *cmd;
   debug_print_marshal("Vertex4d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex4d, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex4d");
   CALL_Vertex4d(ctx->CurrentServerDispatch, (x, y, z, w));
}


/* VertexAttribL4dv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribL4dv(GLuint index, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribL4dv");
   CALL_VertexAttribL4dv(ctx->CurrentServerDispatch, (index, v));
}


/* GetnUniformi64vARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnUniformi64vARB(GLuint program, GLint location, GLsizei bufSize, GLint64 * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnUniformi64vARB");
   CALL_GetnUniformi64vARB(ctx->CurrentServerDispatch, (program, location, bufSize, params));
}


/* GetTexGenfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTexGenfv(GLenum coord, GLenum pname, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTexGenfv");
   CALL_GetTexGenfv(ctx->CurrentServerDispatch, (coord, pname, params));
}


/* Vertex4i: marshalled asynchronously */
struct marshal_cmd_Vertex4i
{
   struct marshal_cmd_base cmd_base;
   GLint x;
   GLint y;
   GLint z;
   GLint w;
};
static inline void
_mesa_unmarshal_Vertex4i(struct gl_context *ctx, const struct marshal_cmd_Vertex4i *cmd)
{
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLint z = cmd->z;
   const GLint w = cmd->w;
   CALL_Vertex4i(ctx->CurrentServerDispatch, (x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_Vertex4i(GLint x, GLint y, GLint z, GLint w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex4i);
   struct marshal_cmd_Vertex4i *cmd;
   debug_print_marshal("Vertex4i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex4i, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex4i");
   CALL_Vertex4i(ctx->CurrentServerDispatch, (x, y, z, w));
}


/* MemoryBarrierByRegion: marshalled asynchronously */
struct marshal_cmd_MemoryBarrierByRegion
{
   struct marshal_cmd_base cmd_base;
   GLbitfield barriers;
};
static inline void
_mesa_unmarshal_MemoryBarrierByRegion(struct gl_context *ctx, const struct marshal_cmd_MemoryBarrierByRegion *cmd)
{
   const GLbitfield barriers = cmd->barriers;
   CALL_MemoryBarrierByRegion(ctx->CurrentServerDispatch, (barriers));
}
static void GLAPIENTRY
_mesa_marshal_MemoryBarrierByRegion(GLbitfield barriers)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MemoryBarrierByRegion);
   struct marshal_cmd_MemoryBarrierByRegion *cmd;
   debug_print_marshal("MemoryBarrierByRegion");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MemoryBarrierByRegion, cmd_size);
      cmd->barriers = barriers;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MemoryBarrierByRegion");
   CALL_MemoryBarrierByRegion(ctx->CurrentServerDispatch, (barriers));
}


/* StencilFuncSeparateATI: marshalled asynchronously */
struct marshal_cmd_StencilFuncSeparateATI
{
   struct marshal_cmd_base cmd_base;
   GLenum frontfunc;
   GLenum backfunc;
   GLint ref;
   GLuint mask;
};
static inline void
_mesa_unmarshal_StencilFuncSeparateATI(struct gl_context *ctx, const struct marshal_cmd_StencilFuncSeparateATI *cmd)
{
   const GLenum frontfunc = cmd->frontfunc;
   const GLenum backfunc = cmd->backfunc;
   const GLint ref = cmd->ref;
   const GLuint mask = cmd->mask;
   CALL_StencilFuncSeparateATI(ctx->CurrentServerDispatch, (frontfunc, backfunc, ref, mask));
}
static void GLAPIENTRY
_mesa_marshal_StencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_StencilFuncSeparateATI);
   struct marshal_cmd_StencilFuncSeparateATI *cmd;
   debug_print_marshal("StencilFuncSeparateATI");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_StencilFuncSeparateATI, cmd_size);
      cmd->frontfunc = frontfunc;
      cmd->backfunc = backfunc;
      cmd->ref = ref;
      cmd->mask = mask;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("StencilFuncSeparateATI");
   CALL_StencilFuncSeparateATI(ctx->CurrentServerDispatch, (frontfunc, backfunc, ref, mask));
}


/* GetVertexAttribIuiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetVertexAttribIuiv");
   CALL_GetVertexAttribIuiv(ctx->CurrentServerDispatch, (index, pname, params));
}


/* LightModelfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_LightModelfv(GLenum pname, const GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("LightModelfv");
   CALL_LightModelfv(ctx->CurrentServerDispatch, (pname, params));
}


/* Vertex4dv: marshalled asynchronously */
struct marshal_cmd_Vertex4dv
{
   struct marshal_cmd_base cmd_base;
   GLdouble v[4];
};
static inline void
_mesa_unmarshal_Vertex4dv(struct gl_context *ctx, const struct marshal_cmd_Vertex4dv *cmd)
{
   const GLdouble * v = cmd->v;
   CALL_Vertex4dv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Vertex4dv(const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex4dv);
   struct marshal_cmd_Vertex4dv *cmd;
   debug_print_marshal("Vertex4dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex4dv, cmd_size);
      memcpy(cmd->v, v, 32);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex4dv");
   CALL_Vertex4dv(ctx->CurrentServerDispatch, (v));
}


/* GetInfoLogARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetInfoLogARB");
   CALL_GetInfoLogARB(ctx->CurrentServerDispatch, (obj, maxLength, length, infoLog));
}


/* StencilMask: marshalled asynchronously */
struct marshal_cmd_StencilMask
{
   struct marshal_cmd_base cmd_base;
   GLuint mask;
};
static inline void
_mesa_unmarshal_StencilMask(struct gl_context *ctx, const struct marshal_cmd_StencilMask *cmd)
{
   const GLuint mask = cmd->mask;
   CALL_StencilMask(ctx->CurrentServerDispatch, (mask));
}
static void GLAPIENTRY
_mesa_marshal_StencilMask(GLuint mask)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_StencilMask);
   struct marshal_cmd_StencilMask *cmd;
   debug_print_marshal("StencilMask");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_StencilMask, cmd_size);
      cmd->mask = mask;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("StencilMask");
   CALL_StencilMask(ctx->CurrentServerDispatch, (mask));
}


/* NamedFramebufferReadBuffer: marshalled asynchronously */
struct marshal_cmd_NamedFramebufferReadBuffer
{
   struct marshal_cmd_base cmd_base;
   GLuint framebuffer;
   GLenum buf;
};
static inline void
_mesa_unmarshal_NamedFramebufferReadBuffer(struct gl_context *ctx, const struct marshal_cmd_NamedFramebufferReadBuffer *cmd)
{
   const GLuint framebuffer = cmd->framebuffer;
   const GLenum buf = cmd->buf;
   CALL_NamedFramebufferReadBuffer(ctx->CurrentServerDispatch, (framebuffer, buf));
}
static void GLAPIENTRY
_mesa_marshal_NamedFramebufferReadBuffer(GLuint framebuffer, GLenum buf)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_NamedFramebufferReadBuffer);
   struct marshal_cmd_NamedFramebufferReadBuffer *cmd;
   debug_print_marshal("NamedFramebufferReadBuffer");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_NamedFramebufferReadBuffer, cmd_size);
      cmd->framebuffer = framebuffer;
      cmd->buf = buf;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("NamedFramebufferReadBuffer");
   CALL_NamedFramebufferReadBuffer(ctx->CurrentServerDispatch, (framebuffer, buf));
}


/* ProgramUniformHandleui64ARB: marshalled asynchronously */
struct marshal_cmd_ProgramUniformHandleui64ARB
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLuint64 value;
};
static inline void
_mesa_unmarshal_ProgramUniformHandleui64ARB(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformHandleui64ARB *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLuint64 value = cmd->value;
   CALL_ProgramUniformHandleui64ARB(ctx->CurrentServerDispatch, (program, location, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformHandleui64ARB(GLuint program, GLint location, GLuint64 value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformHandleui64ARB);
   struct marshal_cmd_ProgramUniformHandleui64ARB *cmd;
   debug_print_marshal("ProgramUniformHandleui64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformHandleui64ARB, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->value = value;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformHandleui64ARB");
   CALL_ProgramUniformHandleui64ARB(ctx->CurrentServerDispatch, (program, location, value));
}


/* ProgramUniform2i64ARB: marshalled asynchronously */
struct marshal_cmd_ProgramUniform2i64ARB
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLint64 x;
   GLint64 y;
};
static inline void
_mesa_unmarshal_ProgramUniform2i64ARB(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform2i64ARB *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLint64 x = cmd->x;
   const GLint64 y = cmd->y;
   CALL_ProgramUniform2i64ARB(ctx->CurrentServerDispatch, (program, location, x, y));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform2i64ARB(GLuint program, GLint location, GLint64 x, GLint64 y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform2i64ARB);
   struct marshal_cmd_ProgramUniform2i64ARB *cmd;
   debug_print_marshal("ProgramUniform2i64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform2i64ARB, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform2i64ARB");
   CALL_ProgramUniform2i64ARB(ctx->CurrentServerDispatch, (program, location, x, y));
}


/* IsList: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsList(GLuint list)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsList");
   return CALL_IsList(ctx->CurrentServerDispatch, (list));
}


/* GetIntegeri_v: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetIntegeri_v(GLenum value, GLuint index, GLint * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetIntegeri_v");
   CALL_GetIntegeri_v(ctx->CurrentServerDispatch, (value, index, data));
}


/* ProgramUniform2iv: marshalled asynchronously */
struct marshal_cmd_ProgramUniform2iv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 8) bytes are GLint value[count][2] */
};
static inline void
_mesa_unmarshal_ProgramUniform2iv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform2iv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLint * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLint *) variable_data;
   variable_data += count * 8;
   CALL_ProgramUniform2iv(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform2iv) + safe_mul(count, 8);
   struct marshal_cmd_ProgramUniform2iv *cmd;
   debug_print_marshal("ProgramUniform2iv");
   if (unlikely(safe_mul(count, 8) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform2iv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 8);
      variable_data += count * 8;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform2iv");
   CALL_ProgramUniform2iv(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* CreateVertexArrays: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CreateVertexArrays(GLsizei n, GLuint * arrays)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CreateVertexArrays");
   CALL_CreateVertexArrays(ctx->CurrentServerDispatch, (n, arrays));
}


/* FogCoordPointer: marshalled asynchronously */
struct marshal_cmd_FogCoordPointer
{
   struct marshal_cmd_base cmd_base;
   GLenum type;
   GLsizei stride;
   const GLvoid * pointer;
};
static inline void
_mesa_unmarshal_FogCoordPointer(struct gl_context *ctx, const struct marshal_cmd_FogCoordPointer *cmd)
{
   const GLenum type = cmd->type;
   const GLsizei stride = cmd->stride;
   const GLvoid * pointer = cmd->pointer;
   CALL_FogCoordPointer(ctx->CurrentServerDispatch, (type, stride, pointer));
}
static void GLAPIENTRY
_mesa_marshal_FogCoordPointer(GLenum type, GLsizei stride, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_FogCoordPointer);
   struct marshal_cmd_FogCoordPointer *cmd;
   debug_print_marshal("FogCoordPointer");
   if (_mesa_glthread_is_non_vbo_vertex_attrib_pointer(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("FogCoordPointer");
      CALL_FogCoordPointer(ctx->CurrentServerDispatch, (type, stride, pointer));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_FogCoordPointer, cmd_size);
      cmd->type = type;
      cmd->stride = stride;
      cmd->pointer = pointer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("FogCoordPointer");
   CALL_FogCoordPointer(ctx->CurrentServerDispatch, (type, stride, pointer));
}


/* SecondaryColor3us: marshalled asynchronously */
struct marshal_cmd_SecondaryColor3us
{
   struct marshal_cmd_base cmd_base;
   GLushort red;
   GLushort green;
   GLushort blue;
};
static inline void
_mesa_unmarshal_SecondaryColor3us(struct gl_context *ctx, const struct marshal_cmd_SecondaryColor3us *cmd)
{
   const GLushort red = cmd->red;
   const GLushort green = cmd->green;
   const GLushort blue = cmd->blue;
   CALL_SecondaryColor3us(ctx->CurrentServerDispatch, (red, green, blue));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColor3us(GLushort red, GLushort green, GLushort blue)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColor3us);
   struct marshal_cmd_SecondaryColor3us *cmd;
   debug_print_marshal("SecondaryColor3us");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColor3us, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColor3us");
   CALL_SecondaryColor3us(ctx->CurrentServerDispatch, (red, green, blue));
}


/* TextureStorageMem1DEXT: marshalled asynchronously */
struct marshal_cmd_TextureStorageMem1DEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLsizei levels;
   GLenum internalFormat;
   GLsizei width;
   GLuint memory;
   GLuint64 offset;
};
static inline void
_mesa_unmarshal_TextureStorageMem1DEXT(struct gl_context *ctx, const struct marshal_cmd_TextureStorageMem1DEXT *cmd)
{
   const GLuint texture = cmd->texture;
   const GLsizei levels = cmd->levels;
   const GLenum internalFormat = cmd->internalFormat;
   const GLsizei width = cmd->width;
   const GLuint memory = cmd->memory;
   const GLuint64 offset = cmd->offset;
   CALL_TextureStorageMem1DEXT(ctx->CurrentServerDispatch, (texture, levels, internalFormat, width, memory, offset));
}
static void GLAPIENTRY
_mesa_marshal_TextureStorageMem1DEXT(GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLuint memory, GLuint64 offset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureStorageMem1DEXT);
   struct marshal_cmd_TextureStorageMem1DEXT *cmd;
   debug_print_marshal("TextureStorageMem1DEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureStorageMem1DEXT, cmd_size);
      cmd->texture = texture;
      cmd->levels = levels;
      cmd->internalFormat = internalFormat;
      cmd->width = width;
      cmd->memory = memory;
      cmd->offset = offset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureStorageMem1DEXT");
   CALL_TextureStorageMem1DEXT(ctx->CurrentServerDispatch, (texture, levels, internalFormat, width, memory, offset));
}


/* SecondaryColor3ub: marshalled asynchronously */
struct marshal_cmd_SecondaryColor3ub
{
   struct marshal_cmd_base cmd_base;
   GLubyte red;
   GLubyte green;
   GLubyte blue;
};
static inline void
_mesa_unmarshal_SecondaryColor3ub(struct gl_context *ctx, const struct marshal_cmd_SecondaryColor3ub *cmd)
{
   const GLubyte red = cmd->red;
   const GLubyte green = cmd->green;
   const GLubyte blue = cmd->blue;
   CALL_SecondaryColor3ub(ctx->CurrentServerDispatch, (red, green, blue));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColor3ub);
   struct marshal_cmd_SecondaryColor3ub *cmd;
   debug_print_marshal("SecondaryColor3ub");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColor3ub, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColor3ub");
   CALL_SecondaryColor3ub(ctx->CurrentServerDispatch, (red, green, blue));
}


/* NamedBufferStorageMemEXT: marshalled asynchronously */
struct marshal_cmd_NamedBufferStorageMemEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint buffer;
   GLsizeiptr size;
   GLuint memory;
   GLuint64 offset;
};
static inline void
_mesa_unmarshal_NamedBufferStorageMemEXT(struct gl_context *ctx, const struct marshal_cmd_NamedBufferStorageMemEXT *cmd)
{
   const GLuint buffer = cmd->buffer;
   const GLsizeiptr size = cmd->size;
   const GLuint memory = cmd->memory;
   const GLuint64 offset = cmd->offset;
   CALL_NamedBufferStorageMemEXT(ctx->CurrentServerDispatch, (buffer, size, memory, offset));
}
static void GLAPIENTRY
_mesa_marshal_NamedBufferStorageMemEXT(GLuint buffer, GLsizeiptr size, GLuint memory, GLuint64 offset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_NamedBufferStorageMemEXT);
   struct marshal_cmd_NamedBufferStorageMemEXT *cmd;
   debug_print_marshal("NamedBufferStorageMemEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_NamedBufferStorageMemEXT, cmd_size);
      cmd->buffer = buffer;
      cmd->size = size;
      cmd->memory = memory;
      cmd->offset = offset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("NamedBufferStorageMemEXT");
   CALL_NamedBufferStorageMemEXT(ctx->CurrentServerDispatch, (buffer, size, memory, offset));
}


/* SecondaryColor3ui: marshalled asynchronously */
struct marshal_cmd_SecondaryColor3ui
{
   struct marshal_cmd_base cmd_base;
   GLuint red;
   GLuint green;
   GLuint blue;
};
static inline void
_mesa_unmarshal_SecondaryColor3ui(struct gl_context *ctx, const struct marshal_cmd_SecondaryColor3ui *cmd)
{
   const GLuint red = cmd->red;
   const GLuint green = cmd->green;
   const GLuint blue = cmd->blue;
   CALL_SecondaryColor3ui(ctx->CurrentServerDispatch, (red, green, blue));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColor3ui);
   struct marshal_cmd_SecondaryColor3ui *cmd;
   debug_print_marshal("SecondaryColor3ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColor3ui, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColor3ui");
   CALL_SecondaryColor3ui(ctx->CurrentServerDispatch, (red, green, blue));
}


/* ProgramUniform4ui64ARB: marshalled asynchronously */
struct marshal_cmd_ProgramUniform4ui64ARB
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLuint64 x;
   GLuint64 y;
   GLuint64 z;
   GLuint64 w;
};
static inline void
_mesa_unmarshal_ProgramUniform4ui64ARB(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform4ui64ARB *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLuint64 x = cmd->x;
   const GLuint64 y = cmd->y;
   const GLuint64 z = cmd->z;
   const GLuint64 w = cmd->w;
   CALL_ProgramUniform4ui64ARB(ctx->CurrentServerDispatch, (program, location, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform4ui64ARB(GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform4ui64ARB);
   struct marshal_cmd_ProgramUniform4ui64ARB *cmd;
   debug_print_marshal("ProgramUniform4ui64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform4ui64ARB, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform4ui64ARB");
   CALL_ProgramUniform4ui64ARB(ctx->CurrentServerDispatch, (program, location, x, y, z, w));
}


/* VertexAttrib1sNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib1sNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLshort x;
};
static inline void
_mesa_unmarshal_VertexAttrib1sNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib1sNV *cmd)
{
   const GLuint index = cmd->index;
   const GLshort x = cmd->x;
   CALL_VertexAttrib1sNV(ctx->CurrentServerDispatch, (index, x));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib1sNV(GLuint index, GLshort x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib1sNV);
   struct marshal_cmd_VertexAttrib1sNV *cmd;
   debug_print_marshal("VertexAttrib1sNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib1sNV, cmd_size);
      cmd->index = index;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib1sNV");
   CALL_VertexAttrib1sNV(ctx->CurrentServerDispatch, (index, x));
}


/* SignalSemaphoreEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_SignalSemaphoreEXT(GLuint semaphore, GLuint numBufferBarriers, const GLuint * buffers, GLuint numTextureBarriers, const GLuint * textures, const GLenum * dstLayouts)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("SignalSemaphoreEXT");
   CALL_SignalSemaphoreEXT(ctx->CurrentServerDispatch, (semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, dstLayouts));
}


/* TextureBuffer: marshalled asynchronously */
struct marshal_cmd_TextureBuffer
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLenum internalformat;
   GLuint buffer;
};
static inline void
_mesa_unmarshal_TextureBuffer(struct gl_context *ctx, const struct marshal_cmd_TextureBuffer *cmd)
{
   const GLuint texture = cmd->texture;
   const GLenum internalformat = cmd->internalformat;
   const GLuint buffer = cmd->buffer;
   CALL_TextureBuffer(ctx->CurrentServerDispatch, (texture, internalformat, buffer));
}
static void GLAPIENTRY
_mesa_marshal_TextureBuffer(GLuint texture, GLenum internalformat, GLuint buffer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureBuffer);
   struct marshal_cmd_TextureBuffer *cmd;
   debug_print_marshal("TextureBuffer");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureBuffer, cmd_size);
      cmd->texture = texture;
      cmd->internalformat = internalformat;
      cmd->buffer = buffer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureBuffer");
   CALL_TextureBuffer(ctx->CurrentServerDispatch, (texture, internalformat, buffer));
}


/* InitNames: marshalled asynchronously */
struct marshal_cmd_InitNames
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_InitNames(struct gl_context *ctx, const struct marshal_cmd_InitNames *cmd)
{
   CALL_InitNames(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_InitNames(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_InitNames);
   struct marshal_cmd_InitNames *cmd;
   debug_print_marshal("InitNames");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_InitNames, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("InitNames");
   CALL_InitNames(ctx->CurrentServerDispatch, ());
}


/* Normal3sv: marshalled asynchronously */
struct marshal_cmd_Normal3sv
{
   struct marshal_cmd_base cmd_base;
   GLshort v[3];
};
static inline void
_mesa_unmarshal_Normal3sv(struct gl_context *ctx, const struct marshal_cmd_Normal3sv *cmd)
{
   const GLshort * v = cmd->v;
   CALL_Normal3sv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Normal3sv(const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Normal3sv);
   struct marshal_cmd_Normal3sv *cmd;
   debug_print_marshal("Normal3sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Normal3sv, cmd_size);
      memcpy(cmd->v, v, 6);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Normal3sv");
   CALL_Normal3sv(ctx->CurrentServerDispatch, (v));
}


/* DeleteQueries: marshalled asynchronously */
struct marshal_cmd_DeleteQueries
{
   struct marshal_cmd_base cmd_base;
   GLsizei n;
   /* Next safe_mul(n, 4) bytes are GLuint ids[n] */
};
static inline void
_mesa_unmarshal_DeleteQueries(struct gl_context *ctx, const struct marshal_cmd_DeleteQueries *cmd)
{
   const GLsizei n = cmd->n;
   const GLuint * ids;
   const char *variable_data = (const char *) (cmd + 1);
   ids = (const GLuint *) variable_data;
   variable_data += n * 4;
   CALL_DeleteQueries(ctx->CurrentServerDispatch, (n, ids));
}
static void GLAPIENTRY
_mesa_marshal_DeleteQueries(GLsizei n, const GLuint * ids)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DeleteQueries) + safe_mul(n, 4);
   struct marshal_cmd_DeleteQueries *cmd;
   debug_print_marshal("DeleteQueries");
   if (unlikely(safe_mul(n, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DeleteQueries, cmd_size);
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, ids, n * 4);
      variable_data += n * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DeleteQueries");
   CALL_DeleteQueries(ctx->CurrentServerDispatch, (n, ids));
}


/* InvalidateFramebuffer: marshalled asynchronously */
struct marshal_cmd_InvalidateFramebuffer
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei numAttachments;
   /* Next safe_mul(numAttachments, 4) bytes are GLenum attachments[numAttachments] */
};
static inline void
_mesa_unmarshal_InvalidateFramebuffer(struct gl_context *ctx, const struct marshal_cmd_InvalidateFramebuffer *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei numAttachments = cmd->numAttachments;
   const GLenum * attachments;
   const char *variable_data = (const char *) (cmd + 1);
   attachments = (const GLenum *) variable_data;
   variable_data += numAttachments * 4;
   CALL_InvalidateFramebuffer(ctx->CurrentServerDispatch, (target, numAttachments, attachments));
}
static void GLAPIENTRY
_mesa_marshal_InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum * attachments)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_InvalidateFramebuffer) + safe_mul(numAttachments, 4);
   struct marshal_cmd_InvalidateFramebuffer *cmd;
   debug_print_marshal("InvalidateFramebuffer");
   if (unlikely(safe_mul(numAttachments, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_InvalidateFramebuffer, cmd_size);
      cmd->target = target;
      cmd->numAttachments = numAttachments;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, attachments, numAttachments * 4);
      variable_data += numAttachments * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("InvalidateFramebuffer");
   CALL_InvalidateFramebuffer(ctx->CurrentServerDispatch, (target, numAttachments, attachments));
}


/* Hint: marshalled asynchronously */
struct marshal_cmd_Hint
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum mode;
};
static inline void
_mesa_unmarshal_Hint(struct gl_context *ctx, const struct marshal_cmd_Hint *cmd)
{
   const GLenum target = cmd->target;
   const GLenum mode = cmd->mode;
   CALL_Hint(ctx->CurrentServerDispatch, (target, mode));
}
static void GLAPIENTRY
_mesa_marshal_Hint(GLenum target, GLenum mode)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Hint);
   struct marshal_cmd_Hint *cmd;
   debug_print_marshal("Hint");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Hint, cmd_size);
      cmd->target = target;
      cmd->mode = mode;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Hint");
   CALL_Hint(ctx->CurrentServerDispatch, (target, mode));
}


/* MemoryBarrier: marshalled asynchronously */
struct marshal_cmd_MemoryBarrier
{
   struct marshal_cmd_base cmd_base;
   GLbitfield barriers;
};
static inline void
_mesa_unmarshal_MemoryBarrier(struct gl_context *ctx, const struct marshal_cmd_MemoryBarrier *cmd)
{
   const GLbitfield barriers = cmd->barriers;
   CALL_MemoryBarrier(ctx->CurrentServerDispatch, (barriers));
}
static void GLAPIENTRY
_mesa_marshal_MemoryBarrier(GLbitfield barriers)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MemoryBarrier);
   struct marshal_cmd_MemoryBarrier *cmd;
   debug_print_marshal("MemoryBarrier");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MemoryBarrier, cmd_size);
      cmd->barriers = barriers;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MemoryBarrier");
   CALL_MemoryBarrier(ctx->CurrentServerDispatch, (barriers));
}


/* CopyColorSubTable: marshalled asynchronously */
struct marshal_cmd_CopyColorSubTable
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei start;
   GLint x;
   GLint y;
   GLsizei width;
};
static inline void
_mesa_unmarshal_CopyColorSubTable(struct gl_context *ctx, const struct marshal_cmd_CopyColorSubTable *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei start = cmd->start;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLsizei width = cmd->width;
   CALL_CopyColorSubTable(ctx->CurrentServerDispatch, (target, start, x, y, width));
}
static void GLAPIENTRY
_mesa_marshal_CopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CopyColorSubTable);
   struct marshal_cmd_CopyColorSubTable *cmd;
   debug_print_marshal("CopyColorSubTable");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CopyColorSubTable, cmd_size);
      cmd->target = target;
      cmd->start = start;
      cmd->x = x;
      cmd->y = y;
      cmd->width = width;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CopyColorSubTable");
   CALL_CopyColorSubTable(ctx->CurrentServerDispatch, (target, start, x, y, width));
}


/* GetObjectParameterfvARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetObjectParameterfvARB(GLhandleARB obj, GLenum pname, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetObjectParameterfvARB");
   CALL_GetObjectParameterfvARB(ctx->CurrentServerDispatch, (obj, pname, params));
}


/* GetTexEnvxv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTexEnvxv(GLenum target, GLenum pname, GLfixed * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTexEnvxv");
   CALL_GetTexEnvxv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* DrawTexsvOES: marshalled asynchronously */
struct marshal_cmd_DrawTexsvOES
{
   struct marshal_cmd_base cmd_base;
   GLshort coords[5];
};
static inline void
_mesa_unmarshal_DrawTexsvOES(struct gl_context *ctx, const struct marshal_cmd_DrawTexsvOES *cmd)
{
   const GLshort * coords = cmd->coords;
   CALL_DrawTexsvOES(ctx->CurrentServerDispatch, (coords));
}
static void GLAPIENTRY
_mesa_marshal_DrawTexsvOES(const GLshort * coords)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawTexsvOES);
   struct marshal_cmd_DrawTexsvOES *cmd;
   debug_print_marshal("DrawTexsvOES");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawTexsvOES, cmd_size);
      memcpy(cmd->coords, coords, 10);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawTexsvOES");
   CALL_DrawTexsvOES(ctx->CurrentServerDispatch, (coords));
}


/* Disable: marshalled asynchronously */
struct marshal_cmd_Disable
{
   struct marshal_cmd_base cmd_base;
   GLenum cap;
};
static inline void
_mesa_unmarshal_Disable(struct gl_context *ctx, const struct marshal_cmd_Disable *cmd)
{
   const GLenum cap = cmd->cap;
   CALL_Disable(ctx->CurrentServerDispatch, (cap));
}
static void GLAPIENTRY
_mesa_marshal_Disable(GLenum cap)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Disable);
   struct marshal_cmd_Disable *cmd;
   debug_print_marshal("Disable");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Disable, cmd_size);
      cmd->cap = cap;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Disable");
   CALL_Disable(ctx->CurrentServerDispatch, (cap));
}


/* ClearColor: marshalled asynchronously */
struct marshal_cmd_ClearColor
{
   struct marshal_cmd_base cmd_base;
   GLclampf red;
   GLclampf green;
   GLclampf blue;
   GLclampf alpha;
};
static inline void
_mesa_unmarshal_ClearColor(struct gl_context *ctx, const struct marshal_cmd_ClearColor *cmd)
{
   const GLclampf red = cmd->red;
   const GLclampf green = cmd->green;
   const GLclampf blue = cmd->blue;
   const GLclampf alpha = cmd->alpha;
   CALL_ClearColor(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}
static void GLAPIENTRY
_mesa_marshal_ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ClearColor);
   struct marshal_cmd_ClearColor *cmd;
   debug_print_marshal("ClearColor");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ClearColor, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      cmd->alpha = alpha;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ClearColor");
   CALL_ClearColor(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}


/* GetTextureParameterIuiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTextureParameterIuiv(GLuint texture, GLenum pname, GLuint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTextureParameterIuiv");
   CALL_GetTextureParameterIuiv(ctx->CurrentServerDispatch, (texture, pname, params));
}


/* RasterPos4iv: marshalled asynchronously */
struct marshal_cmd_RasterPos4iv
{
   struct marshal_cmd_base cmd_base;
   GLint v[4];
};
static inline void
_mesa_unmarshal_RasterPos4iv(struct gl_context *ctx, const struct marshal_cmd_RasterPos4iv *cmd)
{
   const GLint * v = cmd->v;
   CALL_RasterPos4iv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos4iv(const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos4iv);
   struct marshal_cmd_RasterPos4iv *cmd;
   debug_print_marshal("RasterPos4iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos4iv, cmd_size);
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos4iv");
   CALL_RasterPos4iv(ctx->CurrentServerDispatch, (v));
}


/* VDPAUIsSurfaceNV: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_VDPAUIsSurfaceNV(GLintptr surface)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VDPAUIsSurfaceNV");
   return CALL_VDPAUIsSurfaceNV(ctx->CurrentServerDispatch, (surface));
}


/* ProgramUniformMatrix2x3fv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix2x3fv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 24) bytes are GLfloat value[count][6] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix2x3fv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix2x3fv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 24;
   CALL_ProgramUniformMatrix2x3fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix2x3fv) + safe_mul(count, 24);
   struct marshal_cmd_ProgramUniformMatrix2x3fv *cmd;
   debug_print_marshal("ProgramUniformMatrix2x3fv");
   if (unlikely(safe_mul(count, 24) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix2x3fv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 24);
      variable_data += count * 24;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix2x3fv");
   CALL_ProgramUniformMatrix2x3fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* BindVertexBuffer: marshalled asynchronously */
struct marshal_cmd_BindVertexBuffer
{
   struct marshal_cmd_base cmd_base;
   GLuint bindingindex;
   GLuint buffer;
   GLintptr offset;
   GLsizei stride;
};
static inline void
_mesa_unmarshal_BindVertexBuffer(struct gl_context *ctx, const struct marshal_cmd_BindVertexBuffer *cmd)
{
   const GLuint bindingindex = cmd->bindingindex;
   const GLuint buffer = cmd->buffer;
   const GLintptr offset = cmd->offset;
   const GLsizei stride = cmd->stride;
   CALL_BindVertexBuffer(ctx->CurrentServerDispatch, (bindingindex, buffer, offset, stride));
}
static void GLAPIENTRY
_mesa_marshal_BindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BindVertexBuffer);
   struct marshal_cmd_BindVertexBuffer *cmd;
   debug_print_marshal("BindVertexBuffer");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BindVertexBuffer, cmd_size);
      cmd->bindingindex = bindingindex;
      cmd->buffer = buffer;
      cmd->offset = offset;
      cmd->stride = stride;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BindVertexBuffer");
   CALL_BindVertexBuffer(ctx->CurrentServerDispatch, (bindingindex, buffer, offset, stride));
}


/* RasterPos4i: marshalled asynchronously */
struct marshal_cmd_RasterPos4i
{
   struct marshal_cmd_base cmd_base;
   GLint x;
   GLint y;
   GLint z;
   GLint w;
};
static inline void
_mesa_unmarshal_RasterPos4i(struct gl_context *ctx, const struct marshal_cmd_RasterPos4i *cmd)
{
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLint z = cmd->z;
   const GLint w = cmd->w;
   CALL_RasterPos4i(ctx->CurrentServerDispatch, (x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos4i(GLint x, GLint y, GLint z, GLint w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos4i);
   struct marshal_cmd_RasterPos4i *cmd;
   debug_print_marshal("RasterPos4i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos4i, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos4i");
   CALL_RasterPos4i(ctx->CurrentServerDispatch, (x, y, z, w));
}


/* RasterPos4d: marshalled asynchronously */
struct marshal_cmd_RasterPos4d
{
   struct marshal_cmd_base cmd_base;
   GLdouble x;
   GLdouble y;
   GLdouble z;
   GLdouble w;
};
static inline void
_mesa_unmarshal_RasterPos4d(struct gl_context *ctx, const struct marshal_cmd_RasterPos4d *cmd)
{
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   const GLdouble w = cmd->w;
   CALL_RasterPos4d(ctx->CurrentServerDispatch, (x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos4d);
   struct marshal_cmd_RasterPos4d *cmd;
   debug_print_marshal("RasterPos4d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos4d, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos4d");
   CALL_RasterPos4d(ctx->CurrentServerDispatch, (x, y, z, w));
}


/* RasterPos4f: marshalled asynchronously */
struct marshal_cmd_RasterPos4f
{
   struct marshal_cmd_base cmd_base;
   GLfloat x;
   GLfloat y;
   GLfloat z;
   GLfloat w;
};
static inline void
_mesa_unmarshal_RasterPos4f(struct gl_context *ctx, const struct marshal_cmd_RasterPos4f *cmd)
{
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   const GLfloat w = cmd->w;
   CALL_RasterPos4f(ctx->CurrentServerDispatch, (x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos4f);
   struct marshal_cmd_RasterPos4f *cmd;
   debug_print_marshal("RasterPos4f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos4f, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos4f");
   CALL_RasterPos4f(ctx->CurrentServerDispatch, (x, y, z, w));
}


/* VDPAUMapSurfacesNV: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VDPAUMapSurfacesNV(GLsizei numSurfaces, const GLintptr * surfaces)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VDPAUMapSurfacesNV");
   CALL_VDPAUMapSurfacesNV(ctx->CurrentServerDispatch, (numSurfaces, surfaces));
}


/* GetQueryIndexediv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetQueryIndexediv");
   CALL_GetQueryIndexediv(ctx->CurrentServerDispatch, (target, index, pname, params));
}


/* RasterPos3dv: marshalled asynchronously */
struct marshal_cmd_RasterPos3dv
{
   struct marshal_cmd_base cmd_base;
   GLdouble v[3];
};
static inline void
_mesa_unmarshal_RasterPos3dv(struct gl_context *ctx, const struct marshal_cmd_RasterPos3dv *cmd)
{
   const GLdouble * v = cmd->v;
   CALL_RasterPos3dv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos3dv(const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos3dv);
   struct marshal_cmd_RasterPos3dv *cmd;
   debug_print_marshal("RasterPos3dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos3dv, cmd_size);
      memcpy(cmd->v, v, 24);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos3dv");
   CALL_RasterPos3dv(ctx->CurrentServerDispatch, (v));
}


/* GetProgramiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetProgramiv(GLuint program, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramiv");
   CALL_GetProgramiv(ctx->CurrentServerDispatch, (program, pname, params));
}


/* TexCoord1iv: marshalled asynchronously */
struct marshal_cmd_TexCoord1iv
{
   struct marshal_cmd_base cmd_base;
   GLint v[1];
};
static inline void
_mesa_unmarshal_TexCoord1iv(struct gl_context *ctx, const struct marshal_cmd_TexCoord1iv *cmd)
{
   const GLint * v = cmd->v;
   CALL_TexCoord1iv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord1iv(const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord1iv);
   struct marshal_cmd_TexCoord1iv *cmd;
   debug_print_marshal("TexCoord1iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord1iv, cmd_size);
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord1iv");
   CALL_TexCoord1iv(ctx->CurrentServerDispatch, (v));
}


/* RasterPos4s: marshalled asynchronously */
struct marshal_cmd_RasterPos4s
{
   struct marshal_cmd_base cmd_base;
   GLshort x;
   GLshort y;
   GLshort z;
   GLshort w;
};
static inline void
_mesa_unmarshal_RasterPos4s(struct gl_context *ctx, const struct marshal_cmd_RasterPos4s *cmd)
{
   const GLshort x = cmd->x;
   const GLshort y = cmd->y;
   const GLshort z = cmd->z;
   const GLshort w = cmd->w;
   CALL_RasterPos4s(ctx->CurrentServerDispatch, (x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos4s);
   struct marshal_cmd_RasterPos4s *cmd;
   debug_print_marshal("RasterPos4s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos4s, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos4s");
   CALL_RasterPos4s(ctx->CurrentServerDispatch, (x, y, z, w));
}


/* VertexAttrib3dv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib3dv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble v[3];
};
static inline void
_mesa_unmarshal_VertexAttrib3dv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib3dv *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble * v = cmd->v;
   CALL_VertexAttrib3dv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib3dv(GLuint index, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib3dv);
   struct marshal_cmd_VertexAttrib3dv *cmd;
   debug_print_marshal("VertexAttrib3dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib3dv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 24);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib3dv");
   CALL_VertexAttrib3dv(ctx->CurrentServerDispatch, (index, v));
}


/* Histogram: marshalled asynchronously */
struct marshal_cmd_Histogram
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei width;
   GLenum internalformat;
   GLboolean sink;
};
static inline void
_mesa_unmarshal_Histogram(struct gl_context *ctx, const struct marshal_cmd_Histogram *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei width = cmd->width;
   const GLenum internalformat = cmd->internalformat;
   const GLboolean sink = cmd->sink;
   CALL_Histogram(ctx->CurrentServerDispatch, (target, width, internalformat, sink));
}
static void GLAPIENTRY
_mesa_marshal_Histogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Histogram);
   struct marshal_cmd_Histogram *cmd;
   debug_print_marshal("Histogram");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Histogram, cmd_size);
      cmd->target = target;
      cmd->width = width;
      cmd->internalformat = internalformat;
      cmd->sink = sink;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Histogram");
   CALL_Histogram(ctx->CurrentServerDispatch, (target, width, internalformat, sink));
}


/* Uniform2fv: marshalled asynchronously */
struct marshal_cmd_Uniform2fv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 8) bytes are GLfloat value[count][2] */
};
static inline void
_mesa_unmarshal_Uniform2fv(struct gl_context *ctx, const struct marshal_cmd_Uniform2fv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 8;
   CALL_Uniform2fv(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform2fv(GLint location, GLsizei count, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform2fv) + safe_mul(count, 8);
   struct marshal_cmd_Uniform2fv *cmd;
   debug_print_marshal("Uniform2fv");
   if (unlikely(safe_mul(count, 8) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform2fv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 8);
      variable_data += count * 8;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform2fv");
   CALL_Uniform2fv(ctx->CurrentServerDispatch, (location, count, value));
}


/* ProgramUniformMatrix3x4dv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix3x4dv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 96) bytes are GLdouble value[count][12] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix3x4dv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix3x4dv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 96;
   CALL_ProgramUniformMatrix3x4dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix3x4dv) + safe_mul(count, 96);
   struct marshal_cmd_ProgramUniformMatrix3x4dv *cmd;
   debug_print_marshal("ProgramUniformMatrix3x4dv");
   if (unlikely(safe_mul(count, 96) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix3x4dv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 96);
      variable_data += count * 96;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix3x4dv");
   CALL_ProgramUniformMatrix3x4dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* DrawBuffers: marshalled asynchronously */
struct marshal_cmd_DrawBuffers
{
   struct marshal_cmd_base cmd_base;
   GLsizei n;
   /* Next safe_mul(n, 4) bytes are GLenum bufs[n] */
};
static inline void
_mesa_unmarshal_DrawBuffers(struct gl_context *ctx, const struct marshal_cmd_DrawBuffers *cmd)
{
   const GLsizei n = cmd->n;
   const GLenum * bufs;
   const char *variable_data = (const char *) (cmd + 1);
   bufs = (const GLenum *) variable_data;
   variable_data += n * 4;
   CALL_DrawBuffers(ctx->CurrentServerDispatch, (n, bufs));
}
static void GLAPIENTRY
_mesa_marshal_DrawBuffers(GLsizei n, const GLenum * bufs)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawBuffers) + safe_mul(n, 4);
   struct marshal_cmd_DrawBuffers *cmd;
   debug_print_marshal("DrawBuffers");
   if (unlikely(safe_mul(n, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawBuffers, cmd_size);
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, bufs, n * 4);
      variable_data += n * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawBuffers");
   CALL_DrawBuffers(ctx->CurrentServerDispatch, (n, bufs));
}


/* VertexAttribL1ui64ARB: marshalled asynchronously */
struct marshal_cmd_VertexAttribL1ui64ARB
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLuint64EXT x;
};
static inline void
_mesa_unmarshal_VertexAttribL1ui64ARB(struct gl_context *ctx, const struct marshal_cmd_VertexAttribL1ui64ARB *cmd)
{
   const GLuint index = cmd->index;
   const GLuint64EXT x = cmd->x;
   CALL_VertexAttribL1ui64ARB(ctx->CurrentServerDispatch, (index, x));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribL1ui64ARB(GLuint index, GLuint64EXT x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribL1ui64ARB);
   struct marshal_cmd_VertexAttribL1ui64ARB *cmd;
   debug_print_marshal("VertexAttribL1ui64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribL1ui64ARB, cmd_size);
      cmd->index = index;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribL1ui64ARB");
   CALL_VertexAttribL1ui64ARB(ctx->CurrentServerDispatch, (index, x));
}


/* GetnPolygonStippleARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnPolygonStippleARB(GLsizei bufSize, GLubyte * pattern)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnPolygonStippleARB");
   CALL_GetnPolygonStippleARB(ctx->CurrentServerDispatch, (bufSize, pattern));
}


/* Color3uiv: marshalled asynchronously */
struct marshal_cmd_Color3uiv
{
   struct marshal_cmd_base cmd_base;
   GLuint v[3];
};
static inline void
_mesa_unmarshal_Color3uiv(struct gl_context *ctx, const struct marshal_cmd_Color3uiv *cmd)
{
   const GLuint * v = cmd->v;
   CALL_Color3uiv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Color3uiv(const GLuint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color3uiv);
   struct marshal_cmd_Color3uiv *cmd;
   debug_print_marshal("Color3uiv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color3uiv, cmd_size);
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color3uiv");
   CALL_Color3uiv(ctx->CurrentServerDispatch, (v));
}


/* EvalCoord2fv: marshalled asynchronously */
struct marshal_cmd_EvalCoord2fv
{
   struct marshal_cmd_base cmd_base;
   GLfloat u[2];
};
static inline void
_mesa_unmarshal_EvalCoord2fv(struct gl_context *ctx, const struct marshal_cmd_EvalCoord2fv *cmd)
{
   const GLfloat * u = cmd->u;
   CALL_EvalCoord2fv(ctx->CurrentServerDispatch, (u));
}
static void GLAPIENTRY
_mesa_marshal_EvalCoord2fv(const GLfloat * u)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EvalCoord2fv);
   struct marshal_cmd_EvalCoord2fv *cmd;
   debug_print_marshal("EvalCoord2fv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EvalCoord2fv, cmd_size);
      memcpy(cmd->u, u, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EvalCoord2fv");
   CALL_EvalCoord2fv(ctx->CurrentServerDispatch, (u));
}


/* TextureStorage3DEXT: marshalled asynchronously */
struct marshal_cmd_TextureStorage3DEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLenum target;
   GLsizei levels;
   GLenum internalFormat;
   GLsizei width;
   GLsizei height;
   GLsizei depth;
};
static inline void
_mesa_unmarshal_TextureStorage3DEXT(struct gl_context *ctx, const struct marshal_cmd_TextureStorage3DEXT *cmd)
{
   const GLuint texture = cmd->texture;
   const GLenum target = cmd->target;
   const GLsizei levels = cmd->levels;
   const GLenum internalFormat = cmd->internalFormat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLsizei depth = cmd->depth;
   CALL_TextureStorage3DEXT(ctx->CurrentServerDispatch, (texture, target, levels, internalFormat, width, height, depth));
}
static void GLAPIENTRY
_mesa_marshal_TextureStorage3DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureStorage3DEXT);
   struct marshal_cmd_TextureStorage3DEXT *cmd;
   debug_print_marshal("TextureStorage3DEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureStorage3DEXT, cmd_size);
      cmd->texture = texture;
      cmd->target = target;
      cmd->levels = levels;
      cmd->internalFormat = internalFormat;
      cmd->width = width;
      cmd->height = height;
      cmd->depth = depth;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureStorage3DEXT");
   CALL_TextureStorage3DEXT(ctx->CurrentServerDispatch, (texture, target, levels, internalFormat, width, height, depth));
}


/* VertexAttrib2fARB: marshalled asynchronously */
struct marshal_cmd_VertexAttrib2fARB
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat x;
   GLfloat y;
};
static inline void
_mesa_unmarshal_VertexAttrib2fARB(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib2fARB *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   CALL_VertexAttrib2fARB(ctx->CurrentServerDispatch, (index, x, y));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib2fARB);
   struct marshal_cmd_VertexAttrib2fARB *cmd;
   debug_print_marshal("VertexAttrib2fARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib2fARB, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib2fARB");
   CALL_VertexAttrib2fARB(ctx->CurrentServerDispatch, (index, x, y));
}


/* SpecializeShaderARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_SpecializeShaderARB(GLuint shader, const GLchar * pEntryPoint, GLuint numSpecializationConstants, const GLuint * pConstantIndex, const GLuint * pConstantValue)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("SpecializeShaderARB");
   CALL_SpecializeShaderARB(ctx->CurrentServerDispatch, (shader, pEntryPoint, numSpecializationConstants, pConstantIndex, pConstantValue));
}


/* BeginPerfMonitorAMD: marshalled asynchronously */
struct marshal_cmd_BeginPerfMonitorAMD
{
   struct marshal_cmd_base cmd_base;
   GLuint monitor;
};
static inline void
_mesa_unmarshal_BeginPerfMonitorAMD(struct gl_context *ctx, const struct marshal_cmd_BeginPerfMonitorAMD *cmd)
{
   const GLuint monitor = cmd->monitor;
   CALL_BeginPerfMonitorAMD(ctx->CurrentServerDispatch, (monitor));
}
static void GLAPIENTRY
_mesa_marshal_BeginPerfMonitorAMD(GLuint monitor)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BeginPerfMonitorAMD);
   struct marshal_cmd_BeginPerfMonitorAMD *cmd;
   debug_print_marshal("BeginPerfMonitorAMD");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BeginPerfMonitorAMD, cmd_size);
      cmd->monitor = monitor;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BeginPerfMonitorAMD");
   CALL_BeginPerfMonitorAMD(ctx->CurrentServerDispatch, (monitor));
}


/* WindowPos2fv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_WindowPos2fv(const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("WindowPos2fv");
   CALL_WindowPos2fv(ctx->CurrentServerDispatch, (v));
}


/* TexImage3D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexImage3D");
   CALL_TexImage3D(ctx->CurrentServerDispatch, (target, level, internalformat, width, height, depth, border, format, type, pixels));
}


/* GetPerfQueryIdByNameINTEL: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetPerfQueryIdByNameINTEL(GLchar * queryName, GLuint * queryId)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetPerfQueryIdByNameINTEL");
   CALL_GetPerfQueryIdByNameINTEL(ctx->CurrentServerDispatch, (queryName, queryId));
}


/* BindFragDataLocation: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_BindFragDataLocation(GLuint program, GLuint colorNumber, const GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("BindFragDataLocation");
   CALL_BindFragDataLocation(ctx->CurrentServerDispatch, (program, colorNumber, name));
}


/* LightModeliv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_LightModeliv(GLenum pname, const GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("LightModeliv");
   CALL_LightModeliv(ctx->CurrentServerDispatch, (pname, params));
}


/* Normal3bv: marshalled asynchronously */
struct marshal_cmd_Normal3bv
{
   struct marshal_cmd_base cmd_base;
   GLbyte v[3];
};
static inline void
_mesa_unmarshal_Normal3bv(struct gl_context *ctx, const struct marshal_cmd_Normal3bv *cmd)
{
   const GLbyte * v = cmd->v;
   CALL_Normal3bv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Normal3bv(const GLbyte * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Normal3bv);
   struct marshal_cmd_Normal3bv *cmd;
   debug_print_marshal("Normal3bv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Normal3bv, cmd_size);
      memcpy(cmd->v, v, 3);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Normal3bv");
   CALL_Normal3bv(ctx->CurrentServerDispatch, (v));
}


/* BeginQueryIndexed: marshalled asynchronously */
struct marshal_cmd_BeginQueryIndexed
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint index;
   GLuint id;
};
static inline void
_mesa_unmarshal_BeginQueryIndexed(struct gl_context *ctx, const struct marshal_cmd_BeginQueryIndexed *cmd)
{
   const GLenum target = cmd->target;
   const GLuint index = cmd->index;
   const GLuint id = cmd->id;
   CALL_BeginQueryIndexed(ctx->CurrentServerDispatch, (target, index, id));
}
static void GLAPIENTRY
_mesa_marshal_BeginQueryIndexed(GLenum target, GLuint index, GLuint id)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BeginQueryIndexed);
   struct marshal_cmd_BeginQueryIndexed *cmd;
   debug_print_marshal("BeginQueryIndexed");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BeginQueryIndexed, cmd_size);
      cmd->target = target;
      cmd->index = index;
      cmd->id = id;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BeginQueryIndexed");
   CALL_BeginQueryIndexed(ctx->CurrentServerDispatch, (target, index, id));
}


/* ClearNamedBufferData: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ClearNamedBufferData(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ClearNamedBufferData");
   CALL_ClearNamedBufferData(ctx->CurrentServerDispatch, (buffer, internalformat, format, type, data));
}


/* Vertex3iv: marshalled asynchronously */
struct marshal_cmd_Vertex3iv
{
   struct marshal_cmd_base cmd_base;
   GLint v[3];
};
static inline void
_mesa_unmarshal_Vertex3iv(struct gl_context *ctx, const struct marshal_cmd_Vertex3iv *cmd)
{
   const GLint * v = cmd->v;
   CALL_Vertex3iv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Vertex3iv(const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex3iv);
   struct marshal_cmd_Vertex3iv *cmd;
   debug_print_marshal("Vertex3iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex3iv, cmd_size);
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex3iv");
   CALL_Vertex3iv(ctx->CurrentServerDispatch, (v));
}


/* UniformMatrix2x3dv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix2x3dv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 48) bytes are GLdouble value[count][6] */
};
static inline void
_mesa_unmarshal_UniformMatrix2x3dv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix2x3dv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 48;
   CALL_UniformMatrix2x3dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix2x3dv) + safe_mul(count, 48);
   struct marshal_cmd_UniformMatrix2x3dv *cmd;
   debug_print_marshal("UniformMatrix2x3dv");
   if (unlikely(safe_mul(count, 48) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix2x3dv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 48);
      variable_data += count * 48;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix2x3dv");
   CALL_UniformMatrix2x3dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* UniformHandleui64vARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_UniformHandleui64vARB(GLint location, GLsizei count, const GLuint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("UniformHandleui64vARB");
   CALL_UniformHandleui64vARB(ctx->CurrentServerDispatch, (location, count, value));
}


/* TexCoord3dv: marshalled asynchronously */
struct marshal_cmd_TexCoord3dv
{
   struct marshal_cmd_base cmd_base;
   GLdouble v[3];
};
static inline void
_mesa_unmarshal_TexCoord3dv(struct gl_context *ctx, const struct marshal_cmd_TexCoord3dv *cmd)
{
   const GLdouble * v = cmd->v;
   CALL_TexCoord3dv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord3dv(const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord3dv);
   struct marshal_cmd_TexCoord3dv *cmd;
   debug_print_marshal("TexCoord3dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord3dv, cmd_size);
      memcpy(cmd->v, v, 24);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord3dv");
   CALL_TexCoord3dv(ctx->CurrentServerDispatch, (v));
}


/* GetProgramStringARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetProgramStringARB(GLenum target, GLenum pname, GLvoid * string)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramStringARB");
   CALL_GetProgramStringARB(ctx->CurrentServerDispatch, (target, pname, string));
}


/* VertexP3ui: marshalled asynchronously */
struct marshal_cmd_VertexP3ui
{
   struct marshal_cmd_base cmd_base;
   GLenum type;
   GLuint value;
};
static inline void
_mesa_unmarshal_VertexP3ui(struct gl_context *ctx, const struct marshal_cmd_VertexP3ui *cmd)
{
   const GLenum type = cmd->type;
   const GLuint value = cmd->value;
   CALL_VertexP3ui(ctx->CurrentServerDispatch, (type, value));
}
static void GLAPIENTRY
_mesa_marshal_VertexP3ui(GLenum type, GLuint value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexP3ui);
   struct marshal_cmd_VertexP3ui *cmd;
   debug_print_marshal("VertexP3ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexP3ui, cmd_size);
      cmd->type = type;
      cmd->value = value;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexP3ui");
   CALL_VertexP3ui(ctx->CurrentServerDispatch, (type, value));
}


/* CreateProgramObjectARB: marshalled synchronously */
static GLhandleARB GLAPIENTRY
_mesa_marshal_CreateProgramObjectARB(void)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CreateProgramObjectARB");
   return CALL_CreateProgramObjectARB(ctx->CurrentServerDispatch, ());
}


/* UniformMatrix3fv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix3fv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 36) bytes are GLfloat value[count][9] */
};
static inline void
_mesa_unmarshal_UniformMatrix3fv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix3fv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 36;
   CALL_UniformMatrix3fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix3fv) + safe_mul(count, 36);
   struct marshal_cmd_UniformMatrix3fv *cmd;
   debug_print_marshal("UniformMatrix3fv");
   if (unlikely(safe_mul(count, 36) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix3fv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 36);
      variable_data += count * 36;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix3fv");
   CALL_UniformMatrix3fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* PrioritizeTextures: marshalled asynchronously */
struct marshal_cmd_PrioritizeTextures
{
   struct marshal_cmd_base cmd_base;
   GLsizei n;
   /* Next safe_mul(n, 4) bytes are GLuint textures[n] */
   /* Next safe_mul(n, 4) bytes are GLclampf priorities[n] */
};
static inline void
_mesa_unmarshal_PrioritizeTextures(struct gl_context *ctx, const struct marshal_cmd_PrioritizeTextures *cmd)
{
   const GLsizei n = cmd->n;
   const GLuint * textures;
   const GLclampf * priorities;
   const char *variable_data = (const char *) (cmd + 1);
   textures = (const GLuint *) variable_data;
   variable_data += n * 4;
   priorities = (const GLclampf *) variable_data;
   variable_data += n * 4;
   CALL_PrioritizeTextures(ctx->CurrentServerDispatch, (n, textures, priorities));
}
static void GLAPIENTRY
_mesa_marshal_PrioritizeTextures(GLsizei n, const GLuint * textures, const GLclampf * priorities)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PrioritizeTextures) + safe_mul(n, 4) + safe_mul(n, 4);
   struct marshal_cmd_PrioritizeTextures *cmd;
   debug_print_marshal("PrioritizeTextures");
   if (unlikely(safe_mul(n, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PrioritizeTextures, cmd_size);
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, textures, n * 4);
      variable_data += n * 4;
      memcpy(variable_data, priorities, n * 4);
      variable_data += n * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PrioritizeTextures");
   CALL_PrioritizeTextures(ctx->CurrentServerDispatch, (n, textures, priorities));
}


/* VertexAttribI3uiEXT: marshalled asynchronously */
struct marshal_cmd_VertexAttribI3uiEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLuint x;
   GLuint y;
   GLuint z;
};
static inline void
_mesa_unmarshal_VertexAttribI3uiEXT(struct gl_context *ctx, const struct marshal_cmd_VertexAttribI3uiEXT *cmd)
{
   const GLuint index = cmd->index;
   const GLuint x = cmd->x;
   const GLuint y = cmd->y;
   const GLuint z = cmd->z;
   CALL_VertexAttribI3uiEXT(ctx->CurrentServerDispatch, (index, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribI3uiEXT(GLuint index, GLuint x, GLuint y, GLuint z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribI3uiEXT);
   struct marshal_cmd_VertexAttribI3uiEXT *cmd;
   debug_print_marshal("VertexAttribI3uiEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribI3uiEXT, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribI3uiEXT");
   CALL_VertexAttribI3uiEXT(ctx->CurrentServerDispatch, (index, x, y, z));
}


/* ProgramUniform1i64ARB: marshalled asynchronously */
struct marshal_cmd_ProgramUniform1i64ARB
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLint64 x;
};
static inline void
_mesa_unmarshal_ProgramUniform1i64ARB(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform1i64ARB *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLint64 x = cmd->x;
   CALL_ProgramUniform1i64ARB(ctx->CurrentServerDispatch, (program, location, x));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform1i64ARB(GLuint program, GLint location, GLint64 x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform1i64ARB);
   struct marshal_cmd_ProgramUniform1i64ARB *cmd;
   debug_print_marshal("ProgramUniform1i64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform1i64ARB, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform1i64ARB");
   CALL_ProgramUniform1i64ARB(ctx->CurrentServerDispatch, (program, location, x));
}


/* GetMaterialxv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetMaterialxv(GLenum face, GLenum pname, GLfixed * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetMaterialxv");
   CALL_GetMaterialxv(ctx->CurrentServerDispatch, (face, pname, params));
}


/* SecondaryColor3uiv: marshalled asynchronously */
struct marshal_cmd_SecondaryColor3uiv
{
   struct marshal_cmd_base cmd_base;
   GLuint v[3];
};
static inline void
_mesa_unmarshal_SecondaryColor3uiv(struct gl_context *ctx, const struct marshal_cmd_SecondaryColor3uiv *cmd)
{
   const GLuint * v = cmd->v;
   CALL_SecondaryColor3uiv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColor3uiv(const GLuint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColor3uiv);
   struct marshal_cmd_SecondaryColor3uiv *cmd;
   debug_print_marshal("SecondaryColor3uiv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColor3uiv, cmd_size);
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColor3uiv");
   CALL_SecondaryColor3uiv(ctx->CurrentServerDispatch, (v));
}


/* EndConditionalRender: marshalled asynchronously */
struct marshal_cmd_EndConditionalRender
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_EndConditionalRender(struct gl_context *ctx, const struct marshal_cmd_EndConditionalRender *cmd)
{
   CALL_EndConditionalRender(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_EndConditionalRender(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EndConditionalRender);
   struct marshal_cmd_EndConditionalRender *cmd;
   debug_print_marshal("EndConditionalRender");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EndConditionalRender, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EndConditionalRender");
   CALL_EndConditionalRender(ctx->CurrentServerDispatch, ());
}


/* ProgramLocalParameter4dARB: marshalled asynchronously */
struct marshal_cmd_ProgramLocalParameter4dARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint index;
   GLdouble x;
   GLdouble y;
   GLdouble z;
   GLdouble w;
};
static inline void
_mesa_unmarshal_ProgramLocalParameter4dARB(struct gl_context *ctx, const struct marshal_cmd_ProgramLocalParameter4dARB *cmd)
{
   const GLenum target = cmd->target;
   const GLuint index = cmd->index;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   const GLdouble w = cmd->w;
   CALL_ProgramLocalParameter4dARB(ctx->CurrentServerDispatch, (target, index, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_ProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramLocalParameter4dARB);
   struct marshal_cmd_ProgramLocalParameter4dARB *cmd;
   debug_print_marshal("ProgramLocalParameter4dARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramLocalParameter4dARB, cmd_size);
      cmd->target = target;
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramLocalParameter4dARB");
   CALL_ProgramLocalParameter4dARB(ctx->CurrentServerDispatch, (target, index, x, y, z, w));
}


/* Color3sv: marshalled asynchronously */
struct marshal_cmd_Color3sv
{
   struct marshal_cmd_base cmd_base;
   GLshort v[3];
};
static inline void
_mesa_unmarshal_Color3sv(struct gl_context *ctx, const struct marshal_cmd_Color3sv *cmd)
{
   const GLshort * v = cmd->v;
   CALL_Color3sv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Color3sv(const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color3sv);
   struct marshal_cmd_Color3sv *cmd;
   debug_print_marshal("Color3sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color3sv, cmd_size);
      memcpy(cmd->v, v, 6);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color3sv");
   CALL_Color3sv(ctx->CurrentServerDispatch, (v));
}


/* GenFragmentShadersATI: marshalled synchronously */
static GLuint GLAPIENTRY
_mesa_marshal_GenFragmentShadersATI(GLuint range)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GenFragmentShadersATI");
   return CALL_GenFragmentShadersATI(ctx->CurrentServerDispatch, (range));
}


/* GetNamedBufferParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetNamedBufferParameteriv(GLuint buffer, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetNamedBufferParameteriv");
   CALL_GetNamedBufferParameteriv(ctx->CurrentServerDispatch, (buffer, pname, params));
}


/* BlendEquationSeparateiARB: marshalled asynchronously */
struct marshal_cmd_BlendEquationSeparateiARB
{
   struct marshal_cmd_base cmd_base;
   GLuint buf;
   GLenum modeRGB;
   GLenum modeA;
};
static inline void
_mesa_unmarshal_BlendEquationSeparateiARB(struct gl_context *ctx, const struct marshal_cmd_BlendEquationSeparateiARB *cmd)
{
   const GLuint buf = cmd->buf;
   const GLenum modeRGB = cmd->modeRGB;
   const GLenum modeA = cmd->modeA;
   CALL_BlendEquationSeparateiARB(ctx->CurrentServerDispatch, (buf, modeRGB, modeA));
}
static void GLAPIENTRY
_mesa_marshal_BlendEquationSeparateiARB(GLuint buf, GLenum modeRGB, GLenum modeA)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BlendEquationSeparateiARB);
   struct marshal_cmd_BlendEquationSeparateiARB *cmd;
   debug_print_marshal("BlendEquationSeparateiARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BlendEquationSeparateiARB, cmd_size);
      cmd->buf = buf;
      cmd->modeRGB = modeRGB;
      cmd->modeA = modeA;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BlendEquationSeparateiARB");
   CALL_BlendEquationSeparateiARB(ctx->CurrentServerDispatch, (buf, modeRGB, modeA));
}


/* MultiTexCoord1fvARB: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord1fvARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLfloat v[1];
};
static inline void
_mesa_unmarshal_MultiTexCoord1fvARB(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord1fvARB *cmd)
{
   const GLenum target = cmd->target;
   const GLfloat * v = cmd->v;
   CALL_MultiTexCoord1fvARB(ctx->CurrentServerDispatch, (target, v));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord1fvARB(GLenum target, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord1fvARB);
   struct marshal_cmd_MultiTexCoord1fvARB *cmd;
   debug_print_marshal("MultiTexCoord1fvARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord1fvARB, cmd_size);
      cmd->target = target;
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord1fvARB");
   CALL_MultiTexCoord1fvARB(ctx->CurrentServerDispatch, (target, v));
}


/* TexStorage2D: marshalled asynchronously */
struct marshal_cmd_TexStorage2D
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei levels;
   GLenum internalFormat;
   GLsizei width;
   GLsizei height;
};
static inline void
_mesa_unmarshal_TexStorage2D(struct gl_context *ctx, const struct marshal_cmd_TexStorage2D *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei levels = cmd->levels;
   const GLenum internalFormat = cmd->internalFormat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   CALL_TexStorage2D(ctx->CurrentServerDispatch, (target, levels, internalFormat, width, height));
}
static void GLAPIENTRY
_mesa_marshal_TexStorage2D(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexStorage2D);
   struct marshal_cmd_TexStorage2D *cmd;
   debug_print_marshal("TexStorage2D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexStorage2D, cmd_size);
      cmd->target = target;
      cmd->levels = levels;
      cmd->internalFormat = internalFormat;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexStorage2D");
   CALL_TexStorage2D(ctx->CurrentServerDispatch, (target, levels, internalFormat, width, height));
}


/* FramebufferTexture2D: marshalled asynchronously */
struct marshal_cmd_FramebufferTexture2D
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum attachment;
   GLenum textarget;
   GLuint texture;
   GLint level;
};
static inline void
_mesa_unmarshal_FramebufferTexture2D(struct gl_context *ctx, const struct marshal_cmd_FramebufferTexture2D *cmd)
{
   const GLenum target = cmd->target;
   const GLenum attachment = cmd->attachment;
   const GLenum textarget = cmd->textarget;
   const GLuint texture = cmd->texture;
   const GLint level = cmd->level;
   CALL_FramebufferTexture2D(ctx->CurrentServerDispatch, (target, attachment, textarget, texture, level));
}
static void GLAPIENTRY
_mesa_marshal_FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_FramebufferTexture2D);
   struct marshal_cmd_FramebufferTexture2D *cmd;
   debug_print_marshal("FramebufferTexture2D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_FramebufferTexture2D, cmd_size);
      cmd->target = target;
      cmd->attachment = attachment;
      cmd->textarget = textarget;
      cmd->texture = texture;
      cmd->level = level;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("FramebufferTexture2D");
   CALL_FramebufferTexture2D(ctx->CurrentServerDispatch, (target, attachment, textarget, texture, level));
}


/* GetSamplerParameterfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetSamplerParameterfv");
   CALL_GetSamplerParameterfv(ctx->CurrentServerDispatch, (sampler, pname, params));
}


/* VertexAttrib2dv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib2dv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble v[2];
};
static inline void
_mesa_unmarshal_VertexAttrib2dv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib2dv *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble * v = cmd->v;
   CALL_VertexAttrib2dv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib2dv(GLuint index, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib2dv);
   struct marshal_cmd_VertexAttrib2dv *cmd;
   debug_print_marshal("VertexAttrib2dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib2dv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib2dv");
   CALL_VertexAttrib2dv(ctx->CurrentServerDispatch, (index, v));
}


/* Vertex4sv: marshalled asynchronously */
struct marshal_cmd_Vertex4sv
{
   struct marshal_cmd_base cmd_base;
   GLshort v[4];
};
static inline void
_mesa_unmarshal_Vertex4sv(struct gl_context *ctx, const struct marshal_cmd_Vertex4sv *cmd)
{
   const GLshort * v = cmd->v;
   CALL_Vertex4sv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Vertex4sv(const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex4sv);
   struct marshal_cmd_Vertex4sv *cmd;
   debug_print_marshal("Vertex4sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex4sv, cmd_size);
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex4sv");
   CALL_Vertex4sv(ctx->CurrentServerDispatch, (v));
}


/* GetQueryObjecti64v: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetQueryObjecti64v(GLuint id, GLenum pname, GLint64 * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetQueryObjecti64v");
   CALL_GetQueryObjecti64v(ctx->CurrentServerDispatch, (id, pname, params));
}


/* ClampColor: marshalled asynchronously */
struct marshal_cmd_ClampColor
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum clamp;
};
static inline void
_mesa_unmarshal_ClampColor(struct gl_context *ctx, const struct marshal_cmd_ClampColor *cmd)
{
   const GLenum target = cmd->target;
   const GLenum clamp = cmd->clamp;
   CALL_ClampColor(ctx->CurrentServerDispatch, (target, clamp));
}
static void GLAPIENTRY
_mesa_marshal_ClampColor(GLenum target, GLenum clamp)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ClampColor);
   struct marshal_cmd_ClampColor *cmd;
   debug_print_marshal("ClampColor");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ClampColor, cmd_size);
      cmd->target = target;
      cmd->clamp = clamp;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ClampColor");
   CALL_ClampColor(ctx->CurrentServerDispatch, (target, clamp));
}


/* Uniform1i64ARB: marshalled asynchronously */
struct marshal_cmd_Uniform1i64ARB
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLint64 x;
};
static inline void
_mesa_unmarshal_Uniform1i64ARB(struct gl_context *ctx, const struct marshal_cmd_Uniform1i64ARB *cmd)
{
   const GLint location = cmd->location;
   const GLint64 x = cmd->x;
   CALL_Uniform1i64ARB(ctx->CurrentServerDispatch, (location, x));
}
static void GLAPIENTRY
_mesa_marshal_Uniform1i64ARB(GLint location, GLint64 x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform1i64ARB);
   struct marshal_cmd_Uniform1i64ARB *cmd;
   debug_print_marshal("Uniform1i64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform1i64ARB, cmd_size);
      cmd->location = location;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform1i64ARB");
   CALL_Uniform1i64ARB(ctx->CurrentServerDispatch, (location, x));
}


/* DepthRangeArrayfvOES: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_DepthRangeArrayfvOES(GLuint first, GLsizei count, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("DepthRangeArrayfvOES");
   CALL_DepthRangeArrayfvOES(ctx->CurrentServerDispatch, (first, count, v));
}


/* ConvolutionFilter1D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid * image)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ConvolutionFilter1D");
   CALL_ConvolutionFilter1D(ctx->CurrentServerDispatch, (target, internalformat, width, format, type, image));
}


/* DrawElementsIndirect: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_DrawElementsIndirect(GLenum mode, GLenum type, const GLvoid * indirect)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("DrawElementsIndirect");
   CALL_DrawElementsIndirect(ctx->CurrentServerDispatch, (mode, type, indirect));
}


/* WindowPos3sv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_WindowPos3sv(const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("WindowPos3sv");
   CALL_WindowPos3sv(ctx->CurrentServerDispatch, (v));
}


/* CallLists: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CallLists(GLsizei n, GLenum type, const GLvoid * lists)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CallLists");
   CALL_CallLists(ctx->CurrentServerDispatch, (n, type, lists));
}


/* AlphaFunc: marshalled asynchronously */
struct marshal_cmd_AlphaFunc
{
   struct marshal_cmd_base cmd_base;
   GLenum func;
   GLclampf ref;
};
static inline void
_mesa_unmarshal_AlphaFunc(struct gl_context *ctx, const struct marshal_cmd_AlphaFunc *cmd)
{
   const GLenum func = cmd->func;
   const GLclampf ref = cmd->ref;
   CALL_AlphaFunc(ctx->CurrentServerDispatch, (func, ref));
}
static void GLAPIENTRY
_mesa_marshal_AlphaFunc(GLenum func, GLclampf ref)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_AlphaFunc);
   struct marshal_cmd_AlphaFunc *cmd;
   debug_print_marshal("AlphaFunc");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_AlphaFunc, cmd_size);
      cmd->func = func;
      cmd->ref = ref;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("AlphaFunc");
   CALL_AlphaFunc(ctx->CurrentServerDispatch, (func, ref));
}


/* GetTextureParameterfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTextureParameterfv(GLuint texture, GLenum pname, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTextureParameterfv");
   CALL_GetTextureParameterfv(ctx->CurrentServerDispatch, (texture, pname, params));
}


/* EdgeFlag: marshalled asynchronously */
struct marshal_cmd_EdgeFlag
{
   struct marshal_cmd_base cmd_base;
   GLboolean flag;
};
static inline void
_mesa_unmarshal_EdgeFlag(struct gl_context *ctx, const struct marshal_cmd_EdgeFlag *cmd)
{
   const GLboolean flag = cmd->flag;
   CALL_EdgeFlag(ctx->CurrentServerDispatch, (flag));
}
static void GLAPIENTRY
_mesa_marshal_EdgeFlag(GLboolean flag)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EdgeFlag);
   struct marshal_cmd_EdgeFlag *cmd;
   debug_print_marshal("EdgeFlag");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EdgeFlag, cmd_size);
      cmd->flag = flag;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EdgeFlag");
   CALL_EdgeFlag(ctx->CurrentServerDispatch, (flag));
}


/* EdgeFlagv: marshalled asynchronously */
struct marshal_cmd_EdgeFlagv
{
   struct marshal_cmd_base cmd_base;
   GLboolean flag[1];
};
static inline void
_mesa_unmarshal_EdgeFlagv(struct gl_context *ctx, const struct marshal_cmd_EdgeFlagv *cmd)
{
   const GLboolean * flag = cmd->flag;
   CALL_EdgeFlagv(ctx->CurrentServerDispatch, (flag));
}
static void GLAPIENTRY
_mesa_marshal_EdgeFlagv(const GLboolean * flag)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EdgeFlagv);
   struct marshal_cmd_EdgeFlagv *cmd;
   debug_print_marshal("EdgeFlagv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EdgeFlagv, cmd_size);
      memcpy(cmd->flag, flag, 1);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EdgeFlagv");
   CALL_EdgeFlagv(ctx->CurrentServerDispatch, (flag));
}


/* DepthRangex: marshalled asynchronously */
struct marshal_cmd_DepthRangex
{
   struct marshal_cmd_base cmd_base;
   GLclampx zNear;
   GLclampx zFar;
};
static inline void
_mesa_unmarshal_DepthRangex(struct gl_context *ctx, const struct marshal_cmd_DepthRangex *cmd)
{
   const GLclampx zNear = cmd->zNear;
   const GLclampx zFar = cmd->zFar;
   CALL_DepthRangex(ctx->CurrentServerDispatch, (zNear, zFar));
}
static void GLAPIENTRY
_mesa_marshal_DepthRangex(GLclampx zNear, GLclampx zFar)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DepthRangex);
   struct marshal_cmd_DepthRangex *cmd;
   debug_print_marshal("DepthRangex");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DepthRangex, cmd_size);
      cmd->zNear = zNear;
      cmd->zFar = zFar;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DepthRangex");
   CALL_DepthRangex(ctx->CurrentServerDispatch, (zNear, zFar));
}


/* ProgramUniformHandleui64vARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ProgramUniformHandleui64vARB(GLuint program, GLint location, GLsizei count, const GLuint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ProgramUniformHandleui64vARB");
   CALL_ProgramUniformHandleui64vARB(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* VDPAUInitNV: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VDPAUInitNV(const GLvoid * vdpDevice, const GLvoid * getProcAddress)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VDPAUInitNV");
   CALL_VDPAUInitNV(ctx->CurrentServerDispatch, (vdpDevice, getProcAddress));
}


/* GetBufferParameteri64v: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetBufferParameteri64v(GLenum target, GLenum pname, GLint64 * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetBufferParameteri64v");
   CALL_GetBufferParameteri64v(ctx->CurrentServerDispatch, (target, pname, params));
}


/* CreateProgram: marshalled synchronously */
static GLuint GLAPIENTRY
_mesa_marshal_CreateProgram(void)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CreateProgram");
   return CALL_CreateProgram(ctx->CurrentServerDispatch, ());
}


/* DepthRangef: marshalled asynchronously */
struct marshal_cmd_DepthRangef
{
   struct marshal_cmd_base cmd_base;
   GLclampf zNear;
   GLclampf zFar;
};
static inline void
_mesa_unmarshal_DepthRangef(struct gl_context *ctx, const struct marshal_cmd_DepthRangef *cmd)
{
   const GLclampf zNear = cmd->zNear;
   const GLclampf zFar = cmd->zFar;
   CALL_DepthRangef(ctx->CurrentServerDispatch, (zNear, zFar));
}
static void GLAPIENTRY
_mesa_marshal_DepthRangef(GLclampf zNear, GLclampf zFar)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DepthRangef);
   struct marshal_cmd_DepthRangef *cmd;
   debug_print_marshal("DepthRangef");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DepthRangef, cmd_size);
      cmd->zNear = zNear;
      cmd->zFar = zFar;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DepthRangef");
   CALL_DepthRangef(ctx->CurrentServerDispatch, (zNear, zFar));
}


/* TextureParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TextureParameteriv(GLuint texture, GLenum pname, const GLint * param)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TextureParameteriv");
   CALL_TextureParameteriv(ctx->CurrentServerDispatch, (texture, pname, param));
}


/* ColorFragmentOp3ATI: marshalled asynchronously */
struct marshal_cmd_ColorFragmentOp3ATI
{
   struct marshal_cmd_base cmd_base;
   GLenum op;
   GLuint dst;
   GLuint dstMask;
   GLuint dstMod;
   GLuint arg1;
   GLuint arg1Rep;
   GLuint arg1Mod;
   GLuint arg2;
   GLuint arg2Rep;
   GLuint arg2Mod;
   GLuint arg3;
   GLuint arg3Rep;
   GLuint arg3Mod;
};
static inline void
_mesa_unmarshal_ColorFragmentOp3ATI(struct gl_context *ctx, const struct marshal_cmd_ColorFragmentOp3ATI *cmd)
{
   const GLenum op = cmd->op;
   const GLuint dst = cmd->dst;
   const GLuint dstMask = cmd->dstMask;
   const GLuint dstMod = cmd->dstMod;
   const GLuint arg1 = cmd->arg1;
   const GLuint arg1Rep = cmd->arg1Rep;
   const GLuint arg1Mod = cmd->arg1Mod;
   const GLuint arg2 = cmd->arg2;
   const GLuint arg2Rep = cmd->arg2Rep;
   const GLuint arg2Mod = cmd->arg2Mod;
   const GLuint arg3 = cmd->arg3;
   const GLuint arg3Rep = cmd->arg3Rep;
   const GLuint arg3Mod = cmd->arg3Mod;
   CALL_ColorFragmentOp3ATI(ctx->CurrentServerDispatch, (op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod));
}
static void GLAPIENTRY
_mesa_marshal_ColorFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ColorFragmentOp3ATI);
   struct marshal_cmd_ColorFragmentOp3ATI *cmd;
   debug_print_marshal("ColorFragmentOp3ATI");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ColorFragmentOp3ATI, cmd_size);
      cmd->op = op;
      cmd->dst = dst;
      cmd->dstMask = dstMask;
      cmd->dstMod = dstMod;
      cmd->arg1 = arg1;
      cmd->arg1Rep = arg1Rep;
      cmd->arg1Mod = arg1Mod;
      cmd->arg2 = arg2;
      cmd->arg2Rep = arg2Rep;
      cmd->arg2Mod = arg2Mod;
      cmd->arg3 = arg3;
      cmd->arg3Rep = arg3Rep;
      cmd->arg3Mod = arg3Mod;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ColorFragmentOp3ATI");
   CALL_ColorFragmentOp3ATI(ctx->CurrentServerDispatch, (op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod));
}


/* ValidateProgram: marshalled asynchronously */
struct marshal_cmd_ValidateProgram
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
};
static inline void
_mesa_unmarshal_ValidateProgram(struct gl_context *ctx, const struct marshal_cmd_ValidateProgram *cmd)
{
   const GLuint program = cmd->program;
   CALL_ValidateProgram(ctx->CurrentServerDispatch, (program));
}
static void GLAPIENTRY
_mesa_marshal_ValidateProgram(GLuint program)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ValidateProgram);
   struct marshal_cmd_ValidateProgram *cmd;
   debug_print_marshal("ValidateProgram");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ValidateProgram, cmd_size);
      cmd->program = program;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ValidateProgram");
   CALL_ValidateProgram(ctx->CurrentServerDispatch, (program));
}


/* VertexPointerEXT: marshalled asynchronously */
struct marshal_cmd_VertexPointerEXT
{
   struct marshal_cmd_base cmd_base;
   GLint size;
   GLenum type;
   GLsizei stride;
   GLsizei count;
   const GLvoid * pointer;
};
static inline void
_mesa_unmarshal_VertexPointerEXT(struct gl_context *ctx, const struct marshal_cmd_VertexPointerEXT *cmd)
{
   const GLint size = cmd->size;
   const GLenum type = cmd->type;
   const GLsizei stride = cmd->stride;
   const GLsizei count = cmd->count;
   const GLvoid * pointer = cmd->pointer;
   CALL_VertexPointerEXT(ctx->CurrentServerDispatch, (size, type, stride, count, pointer));
}
static void GLAPIENTRY
_mesa_marshal_VertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexPointerEXT);
   struct marshal_cmd_VertexPointerEXT *cmd;
   debug_print_marshal("VertexPointerEXT");
   if (_mesa_glthread_is_non_vbo_vertex_attrib_pointer(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("VertexPointerEXT");
      CALL_VertexPointerEXT(ctx->CurrentServerDispatch, (size, type, stride, count, pointer));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexPointerEXT, cmd_size);
      cmd->size = size;
      cmd->type = type;
      cmd->stride = stride;
      cmd->count = count;
      cmd->pointer = pointer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexPointerEXT");
   CALL_VertexPointerEXT(ctx->CurrentServerDispatch, (size, type, stride, count, pointer));
}


/* VertexAttribI4sv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribI4sv(GLuint index, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribI4sv");
   CALL_VertexAttribI4sv(ctx->CurrentServerDispatch, (index, v));
}


/* Scissor: marshalled asynchronously */
struct marshal_cmd_Scissor
{
   struct marshal_cmd_base cmd_base;
   GLint x;
   GLint y;
   GLsizei width;
   GLsizei height;
};
static inline void
_mesa_unmarshal_Scissor(struct gl_context *ctx, const struct marshal_cmd_Scissor *cmd)
{
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   CALL_Scissor(ctx->CurrentServerDispatch, (x, y, width, height));
}
static void GLAPIENTRY
_mesa_marshal_Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Scissor);
   struct marshal_cmd_Scissor *cmd;
   debug_print_marshal("Scissor");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Scissor, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Scissor");
   CALL_Scissor(ctx->CurrentServerDispatch, (x, y, width, height));
}


/* BeginTransformFeedback: marshalled asynchronously */
struct marshal_cmd_BeginTransformFeedback
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
};
static inline void
_mesa_unmarshal_BeginTransformFeedback(struct gl_context *ctx, const struct marshal_cmd_BeginTransformFeedback *cmd)
{
   const GLenum mode = cmd->mode;
   CALL_BeginTransformFeedback(ctx->CurrentServerDispatch, (mode));
}
static void GLAPIENTRY
_mesa_marshal_BeginTransformFeedback(GLenum mode)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BeginTransformFeedback);
   struct marshal_cmd_BeginTransformFeedback *cmd;
   debug_print_marshal("BeginTransformFeedback");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BeginTransformFeedback, cmd_size);
      cmd->mode = mode;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BeginTransformFeedback");
   CALL_BeginTransformFeedback(ctx->CurrentServerDispatch, (mode));
}


/* TexCoord2i: marshalled asynchronously */
struct marshal_cmd_TexCoord2i
{
   struct marshal_cmd_base cmd_base;
   GLint s;
   GLint t;
};
static inline void
_mesa_unmarshal_TexCoord2i(struct gl_context *ctx, const struct marshal_cmd_TexCoord2i *cmd)
{
   const GLint s = cmd->s;
   const GLint t = cmd->t;
   CALL_TexCoord2i(ctx->CurrentServerDispatch, (s, t));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord2i(GLint s, GLint t)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord2i);
   struct marshal_cmd_TexCoord2i *cmd;
   debug_print_marshal("TexCoord2i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord2i, cmd_size);
      cmd->s = s;
      cmd->t = t;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord2i");
   CALL_TexCoord2i(ctx->CurrentServerDispatch, (s, t));
}


/* VertexArrayAttribBinding: marshalled asynchronously */
struct marshal_cmd_VertexArrayAttribBinding
{
   struct marshal_cmd_base cmd_base;
   GLuint vaobj;
   GLuint attribindex;
   GLuint bindingindex;
};
static inline void
_mesa_unmarshal_VertexArrayAttribBinding(struct gl_context *ctx, const struct marshal_cmd_VertexArrayAttribBinding *cmd)
{
   const GLuint vaobj = cmd->vaobj;
   const GLuint attribindex = cmd->attribindex;
   const GLuint bindingindex = cmd->bindingindex;
   CALL_VertexArrayAttribBinding(ctx->CurrentServerDispatch, (vaobj, attribindex, bindingindex));
}
static void GLAPIENTRY
_mesa_marshal_VertexArrayAttribBinding(GLuint vaobj, GLuint attribindex, GLuint bindingindex)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexArrayAttribBinding);
   struct marshal_cmd_VertexArrayAttribBinding *cmd;
   debug_print_marshal("VertexArrayAttribBinding");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexArrayAttribBinding, cmd_size);
      cmd->vaobj = vaobj;
      cmd->attribindex = attribindex;
      cmd->bindingindex = bindingindex;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexArrayAttribBinding");
   CALL_VertexArrayAttribBinding(ctx->CurrentServerDispatch, (vaobj, attribindex, bindingindex));
}


/* Color4ui: marshalled asynchronously */
struct marshal_cmd_Color4ui
{
   struct marshal_cmd_base cmd_base;
   GLuint red;
   GLuint green;
   GLuint blue;
   GLuint alpha;
};
static inline void
_mesa_unmarshal_Color4ui(struct gl_context *ctx, const struct marshal_cmd_Color4ui *cmd)
{
   const GLuint red = cmd->red;
   const GLuint green = cmd->green;
   const GLuint blue = cmd->blue;
   const GLuint alpha = cmd->alpha;
   CALL_Color4ui(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}
static void GLAPIENTRY
_mesa_marshal_Color4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color4ui);
   struct marshal_cmd_Color4ui *cmd;
   debug_print_marshal("Color4ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color4ui, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      cmd->alpha = alpha;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color4ui");
   CALL_Color4ui(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}


/* TexCoord2f: marshalled asynchronously */
struct marshal_cmd_TexCoord2f
{
   struct marshal_cmd_base cmd_base;
   GLfloat s;
   GLfloat t;
};
static inline void
_mesa_unmarshal_TexCoord2f(struct gl_context *ctx, const struct marshal_cmd_TexCoord2f *cmd)
{
   const GLfloat s = cmd->s;
   const GLfloat t = cmd->t;
   CALL_TexCoord2f(ctx->CurrentServerDispatch, (s, t));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord2f(GLfloat s, GLfloat t)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord2f);
   struct marshal_cmd_TexCoord2f *cmd;
   debug_print_marshal("TexCoord2f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord2f, cmd_size);
      cmd->s = s;
      cmd->t = t;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord2f");
   CALL_TexCoord2f(ctx->CurrentServerDispatch, (s, t));
}


/* TexCoord2d: marshalled asynchronously */
struct marshal_cmd_TexCoord2d
{
   struct marshal_cmd_base cmd_base;
   GLdouble s;
   GLdouble t;
};
static inline void
_mesa_unmarshal_TexCoord2d(struct gl_context *ctx, const struct marshal_cmd_TexCoord2d *cmd)
{
   const GLdouble s = cmd->s;
   const GLdouble t = cmd->t;
   CALL_TexCoord2d(ctx->CurrentServerDispatch, (s, t));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord2d(GLdouble s, GLdouble t)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord2d);
   struct marshal_cmd_TexCoord2d *cmd;
   debug_print_marshal("TexCoord2d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord2d, cmd_size);
      cmd->s = s;
      cmd->t = t;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord2d");
   CALL_TexCoord2d(ctx->CurrentServerDispatch, (s, t));
}


/* GetTransformFeedbackiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTransformFeedbackiv(GLuint xfb, GLenum pname, GLint * param)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTransformFeedbackiv");
   CALL_GetTransformFeedbackiv(ctx->CurrentServerDispatch, (xfb, pname, param));
}


/* TexCoord2s: marshalled asynchronously */
struct marshal_cmd_TexCoord2s
{
   struct marshal_cmd_base cmd_base;
   GLshort s;
   GLshort t;
};
static inline void
_mesa_unmarshal_TexCoord2s(struct gl_context *ctx, const struct marshal_cmd_TexCoord2s *cmd)
{
   const GLshort s = cmd->s;
   const GLshort t = cmd->t;
   CALL_TexCoord2s(ctx->CurrentServerDispatch, (s, t));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord2s(GLshort s, GLshort t)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord2s);
   struct marshal_cmd_TexCoord2s *cmd;
   debug_print_marshal("TexCoord2s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord2s, cmd_size);
      cmd->s = s;
      cmd->t = t;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord2s");
   CALL_TexCoord2s(ctx->CurrentServerDispatch, (s, t));
}


/* PointSizePointerOES: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_PointSizePointerOES(GLenum type, GLsizei stride, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("PointSizePointerOES");
   CALL_PointSizePointerOES(ctx->CurrentServerDispatch, (type, stride, pointer));
}


/* Color4us: marshalled asynchronously */
struct marshal_cmd_Color4us
{
   struct marshal_cmd_base cmd_base;
   GLushort red;
   GLushort green;
   GLushort blue;
   GLushort alpha;
};
static inline void
_mesa_unmarshal_Color4us(struct gl_context *ctx, const struct marshal_cmd_Color4us *cmd)
{
   const GLushort red = cmd->red;
   const GLushort green = cmd->green;
   const GLushort blue = cmd->blue;
   const GLushort alpha = cmd->alpha;
   CALL_Color4us(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}
static void GLAPIENTRY
_mesa_marshal_Color4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color4us);
   struct marshal_cmd_Color4us *cmd;
   debug_print_marshal("Color4us");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color4us, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      cmd->alpha = alpha;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color4us");
   CALL_Color4us(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}


/* Color3bv: marshalled asynchronously */
struct marshal_cmd_Color3bv
{
   struct marshal_cmd_base cmd_base;
   GLbyte v[3];
};
static inline void
_mesa_unmarshal_Color3bv(struct gl_context *ctx, const struct marshal_cmd_Color3bv *cmd)
{
   const GLbyte * v = cmd->v;
   CALL_Color3bv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Color3bv(const GLbyte * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color3bv);
   struct marshal_cmd_Color3bv *cmd;
   debug_print_marshal("Color3bv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color3bv, cmd_size);
      memcpy(cmd->v, v, 3);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color3bv");
   CALL_Color3bv(ctx->CurrentServerDispatch, (v));
}


/* PrimitiveRestartNV: marshalled asynchronously */
struct marshal_cmd_PrimitiveRestartNV
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_PrimitiveRestartNV(struct gl_context *ctx, const struct marshal_cmd_PrimitiveRestartNV *cmd)
{
   CALL_PrimitiveRestartNV(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_PrimitiveRestartNV(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PrimitiveRestartNV);
   struct marshal_cmd_PrimitiveRestartNV *cmd;
   debug_print_marshal("PrimitiveRestartNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PrimitiveRestartNV, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PrimitiveRestartNV");
   CALL_PrimitiveRestartNV(ctx->CurrentServerDispatch, ());
}


/* BindBufferOffsetEXT: marshalled asynchronously */
struct marshal_cmd_BindBufferOffsetEXT
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint index;
   GLuint buffer;
   GLintptr offset;
};
static inline void
_mesa_unmarshal_BindBufferOffsetEXT(struct gl_context *ctx, const struct marshal_cmd_BindBufferOffsetEXT *cmd)
{
   const GLenum target = cmd->target;
   const GLuint index = cmd->index;
   const GLuint buffer = cmd->buffer;
   const GLintptr offset = cmd->offset;
   CALL_BindBufferOffsetEXT(ctx->CurrentServerDispatch, (target, index, buffer, offset));
}
static void GLAPIENTRY
_mesa_marshal_BindBufferOffsetEXT(GLenum target, GLuint index, GLuint buffer, GLintptr offset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BindBufferOffsetEXT);
   struct marshal_cmd_BindBufferOffsetEXT *cmd;
   debug_print_marshal("BindBufferOffsetEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BindBufferOffsetEXT, cmd_size);
      cmd->target = target;
      cmd->index = index;
      cmd->buffer = buffer;
      cmd->offset = offset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BindBufferOffsetEXT");
   CALL_BindBufferOffsetEXT(ctx->CurrentServerDispatch, (target, index, buffer, offset));
}


/* ProvokingVertex: marshalled asynchronously */
struct marshal_cmd_ProvokingVertex
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
};
static inline void
_mesa_unmarshal_ProvokingVertex(struct gl_context *ctx, const struct marshal_cmd_ProvokingVertex *cmd)
{
   const GLenum mode = cmd->mode;
   CALL_ProvokingVertex(ctx->CurrentServerDispatch, (mode));
}
static void GLAPIENTRY
_mesa_marshal_ProvokingVertex(GLenum mode)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProvokingVertex);
   struct marshal_cmd_ProvokingVertex *cmd;
   debug_print_marshal("ProvokingVertex");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProvokingVertex, cmd_size);
      cmd->mode = mode;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProvokingVertex");
   CALL_ProvokingVertex(ctx->CurrentServerDispatch, (mode));
}


/* VertexAttribs4fvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttribs4fvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLsizei n;
   /* Next safe_mul(n, 16) bytes are GLfloat v[n][4] */
};
static inline void
_mesa_unmarshal_VertexAttribs4fvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttribs4fvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLsizei n = cmd->n;
   const GLfloat * v;
   const char *variable_data = (const char *) (cmd + 1);
   v = (const GLfloat *) variable_data;
   variable_data += n * 16;
   CALL_VertexAttribs4fvNV(ctx->CurrentServerDispatch, (index, n, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribs4fvNV(GLuint index, GLsizei n, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribs4fvNV) + safe_mul(n, 16);
   struct marshal_cmd_VertexAttribs4fvNV *cmd;
   debug_print_marshal("VertexAttribs4fvNV");
   if (unlikely(safe_mul(n, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribs4fvNV, cmd_size);
      cmd->index = index;
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, v, n * 16);
      variable_data += n * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribs4fvNV");
   CALL_VertexAttribs4fvNV(ctx->CurrentServerDispatch, (index, n, v));
}


/* Vertex2i: marshalled asynchronously */
struct marshal_cmd_Vertex2i
{
   struct marshal_cmd_base cmd_base;
   GLint x;
   GLint y;
};
static inline void
_mesa_unmarshal_Vertex2i(struct gl_context *ctx, const struct marshal_cmd_Vertex2i *cmd)
{
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   CALL_Vertex2i(ctx->CurrentServerDispatch, (x, y));
}
static void GLAPIENTRY
_mesa_marshal_Vertex2i(GLint x, GLint y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex2i);
   struct marshal_cmd_Vertex2i *cmd;
   debug_print_marshal("Vertex2i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex2i, cmd_size);
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex2i");
   CALL_Vertex2i(ctx->CurrentServerDispatch, (x, y));
}


/* GetQueryBufferObjecti64v: marshalled asynchronously */
struct marshal_cmd_GetQueryBufferObjecti64v
{
   struct marshal_cmd_base cmd_base;
   GLuint id;
   GLuint buffer;
   GLenum pname;
   GLintptr offset;
};
static inline void
_mesa_unmarshal_GetQueryBufferObjecti64v(struct gl_context *ctx, const struct marshal_cmd_GetQueryBufferObjecti64v *cmd)
{
   const GLuint id = cmd->id;
   const GLuint buffer = cmd->buffer;
   const GLenum pname = cmd->pname;
   const GLintptr offset = cmd->offset;
   CALL_GetQueryBufferObjecti64v(ctx->CurrentServerDispatch, (id, buffer, pname, offset));
}
static void GLAPIENTRY
_mesa_marshal_GetQueryBufferObjecti64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_GetQueryBufferObjecti64v);
   struct marshal_cmd_GetQueryBufferObjecti64v *cmd;
   debug_print_marshal("GetQueryBufferObjecti64v");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_GetQueryBufferObjecti64v, cmd_size);
      cmd->id = id;
      cmd->buffer = buffer;
      cmd->pname = pname;
      cmd->offset = offset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("GetQueryBufferObjecti64v");
   CALL_GetQueryBufferObjecti64v(ctx->CurrentServerDispatch, (id, buffer, pname, offset));
}


/* InterleavedArrays: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_InterleavedArrays(GLenum format, GLsizei stride, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("InterleavedArrays");
   CALL_InterleavedArrays(ctx->CurrentServerDispatch, (format, stride, pointer));
}


/* RasterPos2fv: marshalled asynchronously */
struct marshal_cmd_RasterPos2fv
{
   struct marshal_cmd_base cmd_base;
   GLfloat v[2];
};
static inline void
_mesa_unmarshal_RasterPos2fv(struct gl_context *ctx, const struct marshal_cmd_RasterPos2fv *cmd)
{
   const GLfloat * v = cmd->v;
   CALL_RasterPos2fv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos2fv(const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos2fv);
   struct marshal_cmd_RasterPos2fv *cmd;
   debug_print_marshal("RasterPos2fv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos2fv, cmd_size);
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos2fv");
   CALL_RasterPos2fv(ctx->CurrentServerDispatch, (v));
}


/* TexCoord1fv: marshalled asynchronously */
struct marshal_cmd_TexCoord1fv
{
   struct marshal_cmd_base cmd_base;
   GLfloat v[1];
};
static inline void
_mesa_unmarshal_TexCoord1fv(struct gl_context *ctx, const struct marshal_cmd_TexCoord1fv *cmd)
{
   const GLfloat * v = cmd->v;
   CALL_TexCoord1fv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord1fv(const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord1fv);
   struct marshal_cmd_TexCoord1fv *cmd;
   debug_print_marshal("TexCoord1fv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord1fv, cmd_size);
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord1fv");
   CALL_TexCoord1fv(ctx->CurrentServerDispatch, (v));
}


/* MultiTexCoord4dv: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord4dv
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLdouble v[4];
};
static inline void
_mesa_unmarshal_MultiTexCoord4dv(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord4dv *cmd)
{
   const GLenum target = cmd->target;
   const GLdouble * v = cmd->v;
   CALL_MultiTexCoord4dv(ctx->CurrentServerDispatch, (target, v));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord4dv(GLenum target, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord4dv);
   struct marshal_cmd_MultiTexCoord4dv *cmd;
   debug_print_marshal("MultiTexCoord4dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord4dv, cmd_size);
      cmd->target = target;
      memcpy(cmd->v, v, 32);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord4dv");
   CALL_MultiTexCoord4dv(ctx->CurrentServerDispatch, (target, v));
}


/* ProgramEnvParameter4fvARB: marshalled asynchronously */
struct marshal_cmd_ProgramEnvParameter4fvARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint index;
   GLfloat params[4];
};
static inline void
_mesa_unmarshal_ProgramEnvParameter4fvARB(struct gl_context *ctx, const struct marshal_cmd_ProgramEnvParameter4fvARB *cmd)
{
   const GLenum target = cmd->target;
   const GLuint index = cmd->index;
   const GLfloat * params = cmd->params;
   CALL_ProgramEnvParameter4fvARB(ctx->CurrentServerDispatch, (target, index, params));
}
static void GLAPIENTRY
_mesa_marshal_ProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramEnvParameter4fvARB);
   struct marshal_cmd_ProgramEnvParameter4fvARB *cmd;
   debug_print_marshal("ProgramEnvParameter4fvARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramEnvParameter4fvARB, cmd_size);
      cmd->target = target;
      cmd->index = index;
      memcpy(cmd->params, params, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramEnvParameter4fvARB");
   CALL_ProgramEnvParameter4fvARB(ctx->CurrentServerDispatch, (target, index, params));
}


/* RasterPos4fv: marshalled asynchronously */
struct marshal_cmd_RasterPos4fv
{
   struct marshal_cmd_base cmd_base;
   GLfloat v[4];
};
static inline void
_mesa_unmarshal_RasterPos4fv(struct gl_context *ctx, const struct marshal_cmd_RasterPos4fv *cmd)
{
   const GLfloat * v = cmd->v;
   CALL_RasterPos4fv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos4fv(const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos4fv);
   struct marshal_cmd_RasterPos4fv *cmd;
   debug_print_marshal("RasterPos4fv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos4fv, cmd_size);
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos4fv");
   CALL_RasterPos4fv(ctx->CurrentServerDispatch, (v));
}


/* PushMatrix: marshalled asynchronously */
struct marshal_cmd_PushMatrix
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_PushMatrix(struct gl_context *ctx, const struct marshal_cmd_PushMatrix *cmd)
{
   CALL_PushMatrix(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_PushMatrix(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PushMatrix);
   struct marshal_cmd_PushMatrix *cmd;
   debug_print_marshal("PushMatrix");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PushMatrix, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PushMatrix");
   CALL_PushMatrix(ctx->CurrentServerDispatch, ());
}


/* EndList: marshalled asynchronously */
struct marshal_cmd_EndList
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_EndList(struct gl_context *ctx, const struct marshal_cmd_EndList *cmd)
{
   CALL_EndList(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_EndList(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EndList);
   struct marshal_cmd_EndList *cmd;
   debug_print_marshal("EndList");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EndList, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EndList");
   CALL_EndList(ctx->CurrentServerDispatch, ());
}


/* DrawRangeElements: marshalled asynchronously */
struct marshal_cmd_DrawRangeElements
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLuint start;
   GLuint end;
   GLsizei count;
   GLenum type;
   const GLvoid * indices;
};
static inline void
_mesa_unmarshal_DrawRangeElements(struct gl_context *ctx, const struct marshal_cmd_DrawRangeElements *cmd)
{
   const GLenum mode = cmd->mode;
   const GLuint start = cmd->start;
   const GLuint end = cmd->end;
   const GLsizei count = cmd->count;
   const GLenum type = cmd->type;
   const GLvoid * indices = cmd->indices;
   CALL_DrawRangeElements(ctx->CurrentServerDispatch, (mode, start, end, count, type, indices));
}
static void GLAPIENTRY
_mesa_marshal_DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawRangeElements);
   struct marshal_cmd_DrawRangeElements *cmd;
   debug_print_marshal("DrawRangeElements");
   if (_mesa_glthread_is_non_vbo_draw_elements(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("DrawRangeElements");
      CALL_DrawRangeElements(ctx->CurrentServerDispatch, (mode, start, end, count, type, indices));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawRangeElements, cmd_size);
      cmd->mode = mode;
      cmd->start = start;
      cmd->end = end;
      cmd->count = count;
      cmd->type = type;
      cmd->indices = indices;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawRangeElements");
   CALL_DrawRangeElements(ctx->CurrentServerDispatch, (mode, start, end, count, type, indices));
}


/* GetTexGenxvOES: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTexGenxvOES(GLenum coord, GLenum pname, GLfixed * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTexGenxvOES");
   CALL_GetTexGenxvOES(ctx->CurrentServerDispatch, (coord, pname, params));
}


/* GetHandleARB: marshalled synchronously */
static GLhandleARB GLAPIENTRY
_mesa_marshal_GetHandleARB(GLenum pname)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetHandleARB");
   return CALL_GetHandleARB(ctx->CurrentServerDispatch, (pname));
}


/* DrawTexfvOES: marshalled asynchronously */
struct marshal_cmd_DrawTexfvOES
{
   struct marshal_cmd_base cmd_base;
   GLfloat coords[5];
};
static inline void
_mesa_unmarshal_DrawTexfvOES(struct gl_context *ctx, const struct marshal_cmd_DrawTexfvOES *cmd)
{
   const GLfloat * coords = cmd->coords;
   CALL_DrawTexfvOES(ctx->CurrentServerDispatch, (coords));
}
static void GLAPIENTRY
_mesa_marshal_DrawTexfvOES(const GLfloat * coords)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawTexfvOES);
   struct marshal_cmd_DrawTexfvOES *cmd;
   debug_print_marshal("DrawTexfvOES");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawTexfvOES, cmd_size);
      memcpy(cmd->coords, coords, 20);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawTexfvOES");
   CALL_DrawTexfvOES(ctx->CurrentServerDispatch, (coords));
}


/* BlendFunciARB: marshalled asynchronously */
struct marshal_cmd_BlendFunciARB
{
   struct marshal_cmd_base cmd_base;
   GLuint buf;
   GLenum src;
   GLenum dst;
};
static inline void
_mesa_unmarshal_BlendFunciARB(struct gl_context *ctx, const struct marshal_cmd_BlendFunciARB *cmd)
{
   const GLuint buf = cmd->buf;
   const GLenum src = cmd->src;
   const GLenum dst = cmd->dst;
   CALL_BlendFunciARB(ctx->CurrentServerDispatch, (buf, src, dst));
}
static void GLAPIENTRY
_mesa_marshal_BlendFunciARB(GLuint buf, GLenum src, GLenum dst)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BlendFunciARB);
   struct marshal_cmd_BlendFunciARB *cmd;
   debug_print_marshal("BlendFunciARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BlendFunciARB, cmd_size);
      cmd->buf = buf;
      cmd->src = src;
      cmd->dst = dst;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BlendFunciARB");
   CALL_BlendFunciARB(ctx->CurrentServerDispatch, (buf, src, dst));
}


/* ClearNamedFramebufferfi: marshalled asynchronously */
struct marshal_cmd_ClearNamedFramebufferfi
{
   struct marshal_cmd_base cmd_base;
   GLuint framebuffer;
   GLenum buffer;
   GLint drawbuffer;
   GLfloat depth;
   GLint stencil;
};
static inline void
_mesa_unmarshal_ClearNamedFramebufferfi(struct gl_context *ctx, const struct marshal_cmd_ClearNamedFramebufferfi *cmd)
{
   const GLuint framebuffer = cmd->framebuffer;
   const GLenum buffer = cmd->buffer;
   const GLint drawbuffer = cmd->drawbuffer;
   const GLfloat depth = cmd->depth;
   const GLint stencil = cmd->stencil;
   CALL_ClearNamedFramebufferfi(ctx->CurrentServerDispatch, (framebuffer, buffer, drawbuffer, depth, stencil));
}
static void GLAPIENTRY
_mesa_marshal_ClearNamedFramebufferfi(GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ClearNamedFramebufferfi);
   struct marshal_cmd_ClearNamedFramebufferfi *cmd;
   debug_print_marshal("ClearNamedFramebufferfi");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ClearNamedFramebufferfi, cmd_size);
      cmd->framebuffer = framebuffer;
      cmd->buffer = buffer;
      cmd->drawbuffer = drawbuffer;
      cmd->depth = depth;
      cmd->stencil = stencil;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ClearNamedFramebufferfi");
   CALL_ClearNamedFramebufferfi(ctx->CurrentServerDispatch, (framebuffer, buffer, drawbuffer, depth, stencil));
}


/* ClearNamedFramebufferfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ClearNamedFramebufferfv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ClearNamedFramebufferfv");
   CALL_ClearNamedFramebufferfv(ctx->CurrentServerDispatch, (framebuffer, buffer, drawbuffer, value));
}


/* Uniform2ui: marshalled asynchronously */
struct marshal_cmd_Uniform2ui
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLuint x;
   GLuint y;
};
static inline void
_mesa_unmarshal_Uniform2ui(struct gl_context *ctx, const struct marshal_cmd_Uniform2ui *cmd)
{
   const GLint location = cmd->location;
   const GLuint x = cmd->x;
   const GLuint y = cmd->y;
   CALL_Uniform2ui(ctx->CurrentServerDispatch, (location, x, y));
}
static void GLAPIENTRY
_mesa_marshal_Uniform2ui(GLint location, GLuint x, GLuint y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform2ui);
   struct marshal_cmd_Uniform2ui *cmd;
   debug_print_marshal("Uniform2ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform2ui, cmd_size);
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform2ui");
   CALL_Uniform2ui(ctx->CurrentServerDispatch, (location, x, y));
}


/* ScissorIndexed: marshalled asynchronously */
struct marshal_cmd_ScissorIndexed
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLint left;
   GLint bottom;
   GLsizei width;
   GLsizei height;
};
static inline void
_mesa_unmarshal_ScissorIndexed(struct gl_context *ctx, const struct marshal_cmd_ScissorIndexed *cmd)
{
   const GLuint index = cmd->index;
   const GLint left = cmd->left;
   const GLint bottom = cmd->bottom;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   CALL_ScissorIndexed(ctx->CurrentServerDispatch, (index, left, bottom, width, height));
}
static void GLAPIENTRY
_mesa_marshal_ScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ScissorIndexed);
   struct marshal_cmd_ScissorIndexed *cmd;
   debug_print_marshal("ScissorIndexed");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ScissorIndexed, cmd_size);
      cmd->index = index;
      cmd->left = left;
      cmd->bottom = bottom;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ScissorIndexed");
   CALL_ScissorIndexed(ctx->CurrentServerDispatch, (index, left, bottom, width, height));
}


/* End: marshalled asynchronously */
struct marshal_cmd_End
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_End(struct gl_context *ctx, const struct marshal_cmd_End *cmd)
{
   CALL_End(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_End(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_End);
   struct marshal_cmd_End *cmd;
   debug_print_marshal("End");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_End, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("End");
   CALL_End(ctx->CurrentServerDispatch, ());
}


/* GetNamedBufferSubData: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr size, GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetNamedBufferSubData");
   CALL_GetNamedBufferSubData(ctx->CurrentServerDispatch, (buffer, offset, size, data));
}


/* BindVertexBuffers: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_BindVertexBuffers(GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizei * strides)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("BindVertexBuffers");
   CALL_BindVertexBuffers(ctx->CurrentServerDispatch, (first, count, buffers, offsets, strides));
}


/* GetSamplerParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetSamplerParameteriv");
   CALL_GetSamplerParameteriv(ctx->CurrentServerDispatch, (sampler, pname, params));
}


/* GenProgramPipelines: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GenProgramPipelines(GLsizei n, GLuint * pipelines)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GenProgramPipelines");
   CALL_GenProgramPipelines(ctx->CurrentServerDispatch, (n, pipelines));
}


/* IsProgramPipeline: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsProgramPipeline(GLuint pipeline)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsProgramPipeline");
   return CALL_IsProgramPipeline(ctx->CurrentServerDispatch, (pipeline));
}


/* ShaderBinary: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ShaderBinary(GLsizei n, const GLuint * shaders, GLenum binaryformat, const GLvoid * binary, GLsizei length)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ShaderBinary");
   CALL_ShaderBinary(ctx->CurrentServerDispatch, (n, shaders, binaryformat, binary, length));
}


/* TextureSubImage1D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TextureSubImage1D");
   CALL_TextureSubImage1D(ctx->CurrentServerDispatch, (texture, level, xoffset, width, format, type, pixels));
}


/* Normal3x: marshalled asynchronously */
struct marshal_cmd_Normal3x
{
   struct marshal_cmd_base cmd_base;
   GLfixed nx;
   GLfixed ny;
   GLfixed nz;
};
static inline void
_mesa_unmarshal_Normal3x(struct gl_context *ctx, const struct marshal_cmd_Normal3x *cmd)
{
   const GLfixed nx = cmd->nx;
   const GLfixed ny = cmd->ny;
   const GLfixed nz = cmd->nz;
   CALL_Normal3x(ctx->CurrentServerDispatch, (nx, ny, nz));
}
static void GLAPIENTRY
_mesa_marshal_Normal3x(GLfixed nx, GLfixed ny, GLfixed nz)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Normal3x);
   struct marshal_cmd_Normal3x *cmd;
   debug_print_marshal("Normal3x");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Normal3x, cmd_size);
      cmd->nx = nx;
      cmd->ny = ny;
      cmd->nz = nz;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Normal3x");
   CALL_Normal3x(ctx->CurrentServerDispatch, (nx, ny, nz));
}


/* VertexAttrib4fARB: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4fARB
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat x;
   GLfloat y;
   GLfloat z;
   GLfloat w;
};
static inline void
_mesa_unmarshal_VertexAttrib4fARB(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4fARB *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   const GLfloat w = cmd->w;
   CALL_VertexAttrib4fARB(ctx->CurrentServerDispatch, (index, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4fARB);
   struct marshal_cmd_VertexAttrib4fARB *cmd;
   debug_print_marshal("VertexAttrib4fARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4fARB, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4fARB");
   CALL_VertexAttrib4fARB(ctx->CurrentServerDispatch, (index, x, y, z, w));
}


/* TexCoord4fv: marshalled asynchronously */
struct marshal_cmd_TexCoord4fv
{
   struct marshal_cmd_base cmd_base;
   GLfloat v[4];
};
static inline void
_mesa_unmarshal_TexCoord4fv(struct gl_context *ctx, const struct marshal_cmd_TexCoord4fv *cmd)
{
   const GLfloat * v = cmd->v;
   CALL_TexCoord4fv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord4fv(const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord4fv);
   struct marshal_cmd_TexCoord4fv *cmd;
   debug_print_marshal("TexCoord4fv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord4fv, cmd_size);
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord4fv");
   CALL_TexCoord4fv(ctx->CurrentServerDispatch, (v));
}


/* ReadnPixelsARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ReadnPixelsARB(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ReadnPixelsARB");
   CALL_ReadnPixelsARB(ctx->CurrentServerDispatch, (x, y, width, height, format, type, bufSize, data));
}


/* InvalidateTexSubImage: marshalled asynchronously */
struct marshal_cmd_InvalidateTexSubImage
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLint level;
   GLint xoffset;
   GLint yoffset;
   GLint zoffset;
   GLsizei width;
   GLsizei height;
   GLsizei depth;
};
static inline void
_mesa_unmarshal_InvalidateTexSubImage(struct gl_context *ctx, const struct marshal_cmd_InvalidateTexSubImage *cmd)
{
   const GLuint texture = cmd->texture;
   const GLint level = cmd->level;
   const GLint xoffset = cmd->xoffset;
   const GLint yoffset = cmd->yoffset;
   const GLint zoffset = cmd->zoffset;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLsizei depth = cmd->depth;
   CALL_InvalidateTexSubImage(ctx->CurrentServerDispatch, (texture, level, xoffset, yoffset, zoffset, width, height, depth));
}
static void GLAPIENTRY
_mesa_marshal_InvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_InvalidateTexSubImage);
   struct marshal_cmd_InvalidateTexSubImage *cmd;
   debug_print_marshal("InvalidateTexSubImage");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_InvalidateTexSubImage, cmd_size);
      cmd->texture = texture;
      cmd->level = level;
      cmd->xoffset = xoffset;
      cmd->yoffset = yoffset;
      cmd->zoffset = zoffset;
      cmd->width = width;
      cmd->height = height;
      cmd->depth = depth;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("InvalidateTexSubImage");
   CALL_InvalidateTexSubImage(ctx->CurrentServerDispatch, (texture, level, xoffset, yoffset, zoffset, width, height, depth));
}


/* Normal3s: marshalled asynchronously */
struct marshal_cmd_Normal3s
{
   struct marshal_cmd_base cmd_base;
   GLshort nx;
   GLshort ny;
   GLshort nz;
};
static inline void
_mesa_unmarshal_Normal3s(struct gl_context *ctx, const struct marshal_cmd_Normal3s *cmd)
{
   const GLshort nx = cmd->nx;
   const GLshort ny = cmd->ny;
   const GLshort nz = cmd->nz;
   CALL_Normal3s(ctx->CurrentServerDispatch, (nx, ny, nz));
}
static void GLAPIENTRY
_mesa_marshal_Normal3s(GLshort nx, GLshort ny, GLshort nz)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Normal3s);
   struct marshal_cmd_Normal3s *cmd;
   debug_print_marshal("Normal3s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Normal3s, cmd_size);
      cmd->nx = nx;
      cmd->ny = ny;
      cmd->nz = nz;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Normal3s");
   CALL_Normal3s(ctx->CurrentServerDispatch, (nx, ny, nz));
}


/* Materialxv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_Materialxv(GLenum face, GLenum pname, const GLfixed * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("Materialxv");
   CALL_Materialxv(ctx->CurrentServerDispatch, (face, pname, params));
}


/* Normal3i: marshalled asynchronously */
struct marshal_cmd_Normal3i
{
   struct marshal_cmd_base cmd_base;
   GLint nx;
   GLint ny;
   GLint nz;
};
static inline void
_mesa_unmarshal_Normal3i(struct gl_context *ctx, const struct marshal_cmd_Normal3i *cmd)
{
   const GLint nx = cmd->nx;
   const GLint ny = cmd->ny;
   const GLint nz = cmd->nz;
   CALL_Normal3i(ctx->CurrentServerDispatch, (nx, ny, nz));
}
static void GLAPIENTRY
_mesa_marshal_Normal3i(GLint nx, GLint ny, GLint nz)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Normal3i);
   struct marshal_cmd_Normal3i *cmd;
   debug_print_marshal("Normal3i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Normal3i, cmd_size);
      cmd->nx = nx;
      cmd->ny = ny;
      cmd->nz = nz;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Normal3i");
   CALL_Normal3i(ctx->CurrentServerDispatch, (nx, ny, nz));
}


/* Normal3b: marshalled asynchronously */
struct marshal_cmd_Normal3b
{
   struct marshal_cmd_base cmd_base;
   GLbyte nx;
   GLbyte ny;
   GLbyte nz;
};
static inline void
_mesa_unmarshal_Normal3b(struct gl_context *ctx, const struct marshal_cmd_Normal3b *cmd)
{
   const GLbyte nx = cmd->nx;
   const GLbyte ny = cmd->ny;
   const GLbyte nz = cmd->nz;
   CALL_Normal3b(ctx->CurrentServerDispatch, (nx, ny, nz));
}
static void GLAPIENTRY
_mesa_marshal_Normal3b(GLbyte nx, GLbyte ny, GLbyte nz)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Normal3b);
   struct marshal_cmd_Normal3b *cmd;
   debug_print_marshal("Normal3b");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Normal3b, cmd_size);
      cmd->nx = nx;
      cmd->ny = ny;
      cmd->nz = nz;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Normal3b");
   CALL_Normal3b(ctx->CurrentServerDispatch, (nx, ny, nz));
}


/* Normal3d: marshalled asynchronously */
struct marshal_cmd_Normal3d
{
   struct marshal_cmd_base cmd_base;
   GLdouble nx;
   GLdouble ny;
   GLdouble nz;
};
static inline void
_mesa_unmarshal_Normal3d(struct gl_context *ctx, const struct marshal_cmd_Normal3d *cmd)
{
   const GLdouble nx = cmd->nx;
   const GLdouble ny = cmd->ny;
   const GLdouble nz = cmd->nz;
   CALL_Normal3d(ctx->CurrentServerDispatch, (nx, ny, nz));
}
static void GLAPIENTRY
_mesa_marshal_Normal3d(GLdouble nx, GLdouble ny, GLdouble nz)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Normal3d);
   struct marshal_cmd_Normal3d *cmd;
   debug_print_marshal("Normal3d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Normal3d, cmd_size);
      cmd->nx = nx;
      cmd->ny = ny;
      cmd->nz = nz;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Normal3d");
   CALL_Normal3d(ctx->CurrentServerDispatch, (nx, ny, nz));
}


/* Normal3f: marshalled asynchronously */
struct marshal_cmd_Normal3f
{
   struct marshal_cmd_base cmd_base;
   GLfloat nx;
   GLfloat ny;
   GLfloat nz;
};
static inline void
_mesa_unmarshal_Normal3f(struct gl_context *ctx, const struct marshal_cmd_Normal3f *cmd)
{
   const GLfloat nx = cmd->nx;
   const GLfloat ny = cmd->ny;
   const GLfloat nz = cmd->nz;
   CALL_Normal3f(ctx->CurrentServerDispatch, (nx, ny, nz));
}
static void GLAPIENTRY
_mesa_marshal_Normal3f(GLfloat nx, GLfloat ny, GLfloat nz)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Normal3f);
   struct marshal_cmd_Normal3f *cmd;
   debug_print_marshal("Normal3f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Normal3f, cmd_size);
      cmd->nx = nx;
      cmd->ny = ny;
      cmd->nz = nz;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Normal3f");
   CALL_Normal3f(ctx->CurrentServerDispatch, (nx, ny, nz));
}


/* Indexi: marshalled asynchronously */
struct marshal_cmd_Indexi
{
   struct marshal_cmd_base cmd_base;
   GLint c;
};
static inline void
_mesa_unmarshal_Indexi(struct gl_context *ctx, const struct marshal_cmd_Indexi *cmd)
{
   const GLint c = cmd->c;
   CALL_Indexi(ctx->CurrentServerDispatch, (c));
}
static void GLAPIENTRY
_mesa_marshal_Indexi(GLint c)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Indexi);
   struct marshal_cmd_Indexi *cmd;
   debug_print_marshal("Indexi");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Indexi, cmd_size);
      cmd->c = c;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Indexi");
   CALL_Indexi(ctx->CurrentServerDispatch, (c));
}


/* Uniform1uiv: marshalled asynchronously */
struct marshal_cmd_Uniform1uiv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 4) bytes are GLuint value[count] */
};
static inline void
_mesa_unmarshal_Uniform1uiv(struct gl_context *ctx, const struct marshal_cmd_Uniform1uiv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLuint * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLuint *) variable_data;
   variable_data += count * 4;
   CALL_Uniform1uiv(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform1uiv(GLint location, GLsizei count, const GLuint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform1uiv) + safe_mul(count, 4);
   struct marshal_cmd_Uniform1uiv *cmd;
   debug_print_marshal("Uniform1uiv");
   if (unlikely(safe_mul(count, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform1uiv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 4);
      variable_data += count * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform1uiv");
   CALL_Uniform1uiv(ctx->CurrentServerDispatch, (location, count, value));
}


/* VertexAttribI2uiEXT: marshalled asynchronously */
struct marshal_cmd_VertexAttribI2uiEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLuint x;
   GLuint y;
};
static inline void
_mesa_unmarshal_VertexAttribI2uiEXT(struct gl_context *ctx, const struct marshal_cmd_VertexAttribI2uiEXT *cmd)
{
   const GLuint index = cmd->index;
   const GLuint x = cmd->x;
   const GLuint y = cmd->y;
   CALL_VertexAttribI2uiEXT(ctx->CurrentServerDispatch, (index, x, y));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribI2uiEXT(GLuint index, GLuint x, GLuint y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribI2uiEXT);
   struct marshal_cmd_VertexAttribI2uiEXT *cmd;
   debug_print_marshal("VertexAttribI2uiEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribI2uiEXT, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribI2uiEXT");
   CALL_VertexAttribI2uiEXT(ctx->CurrentServerDispatch, (index, x, y));
}


/* IsRenderbuffer: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsRenderbuffer(GLuint renderbuffer)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsRenderbuffer");
   return CALL_IsRenderbuffer(ctx->CurrentServerDispatch, (renderbuffer));
}


/* NormalP3uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_NormalP3uiv(GLenum type, const GLuint * coords)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("NormalP3uiv");
   CALL_NormalP3uiv(ctx->CurrentServerDispatch, (type, coords));
}


/* Indexf: marshalled asynchronously */
struct marshal_cmd_Indexf
{
   struct marshal_cmd_base cmd_base;
   GLfloat c;
};
static inline void
_mesa_unmarshal_Indexf(struct gl_context *ctx, const struct marshal_cmd_Indexf *cmd)
{
   const GLfloat c = cmd->c;
   CALL_Indexf(ctx->CurrentServerDispatch, (c));
}
static void GLAPIENTRY
_mesa_marshal_Indexf(GLfloat c)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Indexf);
   struct marshal_cmd_Indexf *cmd;
   debug_print_marshal("Indexf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Indexf, cmd_size);
      cmd->c = c;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Indexf");
   CALL_Indexf(ctx->CurrentServerDispatch, (c));
}


/* Indexd: marshalled asynchronously */
struct marshal_cmd_Indexd
{
   struct marshal_cmd_base cmd_base;
   GLdouble c;
};
static inline void
_mesa_unmarshal_Indexd(struct gl_context *ctx, const struct marshal_cmd_Indexd *cmd)
{
   const GLdouble c = cmd->c;
   CALL_Indexd(ctx->CurrentServerDispatch, (c));
}
static void GLAPIENTRY
_mesa_marshal_Indexd(GLdouble c)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Indexd);
   struct marshal_cmd_Indexd *cmd;
   debug_print_marshal("Indexd");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Indexd, cmd_size);
      cmd->c = c;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Indexd");
   CALL_Indexd(ctx->CurrentServerDispatch, (c));
}


/* GetMaterialiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetMaterialiv(GLenum face, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetMaterialiv");
   CALL_GetMaterialiv(ctx->CurrentServerDispatch, (face, pname, params));
}


/* Indexs: marshalled asynchronously */
struct marshal_cmd_Indexs
{
   struct marshal_cmd_base cmd_base;
   GLshort c;
};
static inline void
_mesa_unmarshal_Indexs(struct gl_context *ctx, const struct marshal_cmd_Indexs *cmd)
{
   const GLshort c = cmd->c;
   CALL_Indexs(ctx->CurrentServerDispatch, (c));
}
static void GLAPIENTRY
_mesa_marshal_Indexs(GLshort c)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Indexs);
   struct marshal_cmd_Indexs *cmd;
   debug_print_marshal("Indexs");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Indexs, cmd_size);
      cmd->c = c;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Indexs");
   CALL_Indexs(ctx->CurrentServerDispatch, (c));
}


/* MultiTexCoordP1uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_MultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint * coords)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MultiTexCoordP1uiv");
   CALL_MultiTexCoordP1uiv(ctx->CurrentServerDispatch, (texture, type, coords));
}


/* ConvolutionFilter2D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * image)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ConvolutionFilter2D");
   CALL_ConvolutionFilter2D(ctx->CurrentServerDispatch, (target, internalformat, width, height, format, type, image));
}


/* Vertex2d: marshalled asynchronously */
struct marshal_cmd_Vertex2d
{
   struct marshal_cmd_base cmd_base;
   GLdouble x;
   GLdouble y;
};
static inline void
_mesa_unmarshal_Vertex2d(struct gl_context *ctx, const struct marshal_cmd_Vertex2d *cmd)
{
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   CALL_Vertex2d(ctx->CurrentServerDispatch, (x, y));
}
static void GLAPIENTRY
_mesa_marshal_Vertex2d(GLdouble x, GLdouble y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex2d);
   struct marshal_cmd_Vertex2d *cmd;
   debug_print_marshal("Vertex2d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex2d, cmd_size);
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex2d");
   CALL_Vertex2d(ctx->CurrentServerDispatch, (x, y));
}


/* Vertex2f: marshalled asynchronously */
struct marshal_cmd_Vertex2f
{
   struct marshal_cmd_base cmd_base;
   GLfloat x;
   GLfloat y;
};
static inline void
_mesa_unmarshal_Vertex2f(struct gl_context *ctx, const struct marshal_cmd_Vertex2f *cmd)
{
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   CALL_Vertex2f(ctx->CurrentServerDispatch, (x, y));
}
static void GLAPIENTRY
_mesa_marshal_Vertex2f(GLfloat x, GLfloat y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex2f);
   struct marshal_cmd_Vertex2f *cmd;
   debug_print_marshal("Vertex2f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex2f, cmd_size);
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex2f");
   CALL_Vertex2f(ctx->CurrentServerDispatch, (x, y));
}


/* Color4bv: marshalled asynchronously */
struct marshal_cmd_Color4bv
{
   struct marshal_cmd_base cmd_base;
   GLbyte v[4];
};
static inline void
_mesa_unmarshal_Color4bv(struct gl_context *ctx, const struct marshal_cmd_Color4bv *cmd)
{
   const GLbyte * v = cmd->v;
   CALL_Color4bv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Color4bv(const GLbyte * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color4bv);
   struct marshal_cmd_Color4bv *cmd;
   debug_print_marshal("Color4bv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color4bv, cmd_size);
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color4bv");
   CALL_Color4bv(ctx->CurrentServerDispatch, (v));
}


/* ProgramUniformMatrix3x2dv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix3x2dv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 48) bytes are GLdouble value[count][6] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix3x2dv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix3x2dv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 48;
   CALL_ProgramUniformMatrix3x2dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix3x2dv) + safe_mul(count, 48);
   struct marshal_cmd_ProgramUniformMatrix3x2dv *cmd;
   debug_print_marshal("ProgramUniformMatrix3x2dv");
   if (unlikely(safe_mul(count, 48) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix3x2dv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 48);
      variable_data += count * 48;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix3x2dv");
   CALL_ProgramUniformMatrix3x2dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* VertexAttrib2fvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib2fvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat v[2];
};
static inline void
_mesa_unmarshal_VertexAttrib2fvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib2fvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat * v = cmd->v;
   CALL_VertexAttrib2fvNV(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib2fvNV(GLuint index, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib2fvNV);
   struct marshal_cmd_VertexAttrib2fvNV *cmd;
   debug_print_marshal("VertexAttrib2fvNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib2fvNV, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib2fvNV");
   CALL_VertexAttrib2fvNV(ctx->CurrentServerDispatch, (index, v));
}


/* Vertex2s: marshalled asynchronously */
struct marshal_cmd_Vertex2s
{
   struct marshal_cmd_base cmd_base;
   GLshort x;
   GLshort y;
};
static inline void
_mesa_unmarshal_Vertex2s(struct gl_context *ctx, const struct marshal_cmd_Vertex2s *cmd)
{
   const GLshort x = cmd->x;
   const GLshort y = cmd->y;
   CALL_Vertex2s(ctx->CurrentServerDispatch, (x, y));
}
static void GLAPIENTRY
_mesa_marshal_Vertex2s(GLshort x, GLshort y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex2s);
   struct marshal_cmd_Vertex2s *cmd;
   debug_print_marshal("Vertex2s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex2s, cmd_size);
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex2s");
   CALL_Vertex2s(ctx->CurrentServerDispatch, (x, y));
}


/* ActiveTexture: marshalled asynchronously */
struct marshal_cmd_ActiveTexture
{
   struct marshal_cmd_base cmd_base;
   GLenum texture;
};
static inline void
_mesa_unmarshal_ActiveTexture(struct gl_context *ctx, const struct marshal_cmd_ActiveTexture *cmd)
{
   const GLenum texture = cmd->texture;
   CALL_ActiveTexture(ctx->CurrentServerDispatch, (texture));
}
static void GLAPIENTRY
_mesa_marshal_ActiveTexture(GLenum texture)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ActiveTexture);
   struct marshal_cmd_ActiveTexture *cmd;
   debug_print_marshal("ActiveTexture");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ActiveTexture, cmd_size);
      cmd->texture = texture;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ActiveTexture");
   CALL_ActiveTexture(ctx->CurrentServerDispatch, (texture));
}


/* InvalidateNamedFramebufferSubData: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_InvalidateNamedFramebufferSubData(GLuint framebuffer, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("InvalidateNamedFramebufferSubData");
   CALL_InvalidateNamedFramebufferSubData(ctx->CurrentServerDispatch, (framebuffer, numAttachments, attachments, x, y, width, height));
}


/* ColorP4uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ColorP4uiv(GLenum type, const GLuint * color)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ColorP4uiv");
   CALL_ColorP4uiv(ctx->CurrentServerDispatch, (type, color));
}


/* DrawTexxOES: marshalled asynchronously */
struct marshal_cmd_DrawTexxOES
{
   struct marshal_cmd_base cmd_base;
   GLfixed x;
   GLfixed y;
   GLfixed z;
   GLfixed width;
   GLfixed height;
};
static inline void
_mesa_unmarshal_DrawTexxOES(struct gl_context *ctx, const struct marshal_cmd_DrawTexxOES *cmd)
{
   const GLfixed x = cmd->x;
   const GLfixed y = cmd->y;
   const GLfixed z = cmd->z;
   const GLfixed width = cmd->width;
   const GLfixed height = cmd->height;
   CALL_DrawTexxOES(ctx->CurrentServerDispatch, (x, y, z, width, height));
}
static void GLAPIENTRY
_mesa_marshal_DrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawTexxOES);
   struct marshal_cmd_DrawTexxOES *cmd;
   debug_print_marshal("DrawTexxOES");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawTexxOES, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawTexxOES");
   CALL_DrawTexxOES(ctx->CurrentServerDispatch, (x, y, z, width, height));
}


/* MultiTexCoordP3ui: marshalled asynchronously */
struct marshal_cmd_MultiTexCoordP3ui
{
   struct marshal_cmd_base cmd_base;
   GLenum texture;
   GLenum type;
   GLuint coords;
};
static inline void
_mesa_unmarshal_MultiTexCoordP3ui(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoordP3ui *cmd)
{
   const GLenum texture = cmd->texture;
   const GLenum type = cmd->type;
   const GLuint coords = cmd->coords;
   CALL_MultiTexCoordP3ui(ctx->CurrentServerDispatch, (texture, type, coords));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoordP3ui);
   struct marshal_cmd_MultiTexCoordP3ui *cmd;
   debug_print_marshal("MultiTexCoordP3ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoordP3ui, cmd_size);
      cmd->texture = texture;
      cmd->type = type;
      cmd->coords = coords;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoordP3ui");
   CALL_MultiTexCoordP3ui(ctx->CurrentServerDispatch, (texture, type, coords));
}


/* GetAttribLocation: marshalled synchronously */
static GLint GLAPIENTRY
_mesa_marshal_GetAttribLocation(GLuint program, const GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetAttribLocation");
   return CALL_GetAttribLocation(ctx->CurrentServerDispatch, (program, name));
}


/* DrawBuffer: marshalled asynchronously */
struct marshal_cmd_DrawBuffer
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
};
static inline void
_mesa_unmarshal_DrawBuffer(struct gl_context *ctx, const struct marshal_cmd_DrawBuffer *cmd)
{
   const GLenum mode = cmd->mode;
   CALL_DrawBuffer(ctx->CurrentServerDispatch, (mode));
}
static void GLAPIENTRY
_mesa_marshal_DrawBuffer(GLenum mode)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawBuffer);
   struct marshal_cmd_DrawBuffer *cmd;
   debug_print_marshal("DrawBuffer");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawBuffer, cmd_size);
      cmd->mode = mode;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawBuffer");
   CALL_DrawBuffer(ctx->CurrentServerDispatch, (mode));
}


/* GetPointerv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetPointerv(GLenum pname, GLvoid ** params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetPointerv");
   CALL_GetPointerv(ctx->CurrentServerDispatch, (pname, params));
}


/* MultiTexCoord2dv: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord2dv
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLdouble v[2];
};
static inline void
_mesa_unmarshal_MultiTexCoord2dv(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord2dv *cmd)
{
   const GLenum target = cmd->target;
   const GLdouble * v = cmd->v;
   CALL_MultiTexCoord2dv(ctx->CurrentServerDispatch, (target, v));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord2dv(GLenum target, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord2dv);
   struct marshal_cmd_MultiTexCoord2dv *cmd;
   debug_print_marshal("MultiTexCoord2dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord2dv, cmd_size);
      cmd->target = target;
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord2dv");
   CALL_MultiTexCoord2dv(ctx->CurrentServerDispatch, (target, v));
}


/* IsSampler: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsSampler(GLuint sampler)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsSampler");
   return CALL_IsSampler(ctx->CurrentServerDispatch, (sampler));
}


/* BlendFunc: marshalled asynchronously */
struct marshal_cmd_BlendFunc
{
   struct marshal_cmd_base cmd_base;
   GLenum sfactor;
   GLenum dfactor;
};
static inline void
_mesa_unmarshal_BlendFunc(struct gl_context *ctx, const struct marshal_cmd_BlendFunc *cmd)
{
   const GLenum sfactor = cmd->sfactor;
   const GLenum dfactor = cmd->dfactor;
   CALL_BlendFunc(ctx->CurrentServerDispatch, (sfactor, dfactor));
}
static void GLAPIENTRY
_mesa_marshal_BlendFunc(GLenum sfactor, GLenum dfactor)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BlendFunc);
   struct marshal_cmd_BlendFunc *cmd;
   debug_print_marshal("BlendFunc");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BlendFunc, cmd_size);
      cmd->sfactor = sfactor;
      cmd->dfactor = dfactor;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BlendFunc");
   CALL_BlendFunc(ctx->CurrentServerDispatch, (sfactor, dfactor));
}


/* NamedRenderbufferStorageMultisample: marshalled asynchronously */
struct marshal_cmd_NamedRenderbufferStorageMultisample
{
   struct marshal_cmd_base cmd_base;
   GLuint renderbuffer;
   GLsizei samples;
   GLenum internalformat;
   GLsizei width;
   GLsizei height;
};
static inline void
_mesa_unmarshal_NamedRenderbufferStorageMultisample(struct gl_context *ctx, const struct marshal_cmd_NamedRenderbufferStorageMultisample *cmd)
{
   const GLuint renderbuffer = cmd->renderbuffer;
   const GLsizei samples = cmd->samples;
   const GLenum internalformat = cmd->internalformat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   CALL_NamedRenderbufferStorageMultisample(ctx->CurrentServerDispatch, (renderbuffer, samples, internalformat, width, height));
}
static void GLAPIENTRY
_mesa_marshal_NamedRenderbufferStorageMultisample(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_NamedRenderbufferStorageMultisample);
   struct marshal_cmd_NamedRenderbufferStorageMultisample *cmd;
   debug_print_marshal("NamedRenderbufferStorageMultisample");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_NamedRenderbufferStorageMultisample, cmd_size);
      cmd->renderbuffer = renderbuffer;
      cmd->samples = samples;
      cmd->internalformat = internalformat;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("NamedRenderbufferStorageMultisample");
   CALL_NamedRenderbufferStorageMultisample(ctx->CurrentServerDispatch, (renderbuffer, samples, internalformat, width, height));
}


/* ColorMaterial: marshalled asynchronously */
struct marshal_cmd_ColorMaterial
{
   struct marshal_cmd_base cmd_base;
   GLenum face;
   GLenum mode;
};
static inline void
_mesa_unmarshal_ColorMaterial(struct gl_context *ctx, const struct marshal_cmd_ColorMaterial *cmd)
{
   const GLenum face = cmd->face;
   const GLenum mode = cmd->mode;
   CALL_ColorMaterial(ctx->CurrentServerDispatch, (face, mode));
}
static void GLAPIENTRY
_mesa_marshal_ColorMaterial(GLenum face, GLenum mode)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ColorMaterial);
   struct marshal_cmd_ColorMaterial *cmd;
   debug_print_marshal("ColorMaterial");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ColorMaterial, cmd_size);
      cmd->face = face;
      cmd->mode = mode;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ColorMaterial");
   CALL_ColorMaterial(ctx->CurrentServerDispatch, (face, mode));
}


/* RasterPos3sv: marshalled asynchronously */
struct marshal_cmd_RasterPos3sv
{
   struct marshal_cmd_base cmd_base;
   GLshort v[3];
};
static inline void
_mesa_unmarshal_RasterPos3sv(struct gl_context *ctx, const struct marshal_cmd_RasterPos3sv *cmd)
{
   const GLshort * v = cmd->v;
   CALL_RasterPos3sv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos3sv(const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos3sv);
   struct marshal_cmd_RasterPos3sv *cmd;
   debug_print_marshal("RasterPos3sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos3sv, cmd_size);
      memcpy(cmd->v, v, 6);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos3sv");
   CALL_RasterPos3sv(ctx->CurrentServerDispatch, (v));
}


/* TexCoordP2ui: marshalled asynchronously */
struct marshal_cmd_TexCoordP2ui
{
   struct marshal_cmd_base cmd_base;
   GLenum type;
   GLuint coords;
};
static inline void
_mesa_unmarshal_TexCoordP2ui(struct gl_context *ctx, const struct marshal_cmd_TexCoordP2ui *cmd)
{
   const GLenum type = cmd->type;
   const GLuint coords = cmd->coords;
   CALL_TexCoordP2ui(ctx->CurrentServerDispatch, (type, coords));
}
static void GLAPIENTRY
_mesa_marshal_TexCoordP2ui(GLenum type, GLuint coords)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoordP2ui);
   struct marshal_cmd_TexCoordP2ui *cmd;
   debug_print_marshal("TexCoordP2ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoordP2ui, cmd_size);
      cmd->type = type;
      cmd->coords = coords;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoordP2ui");
   CALL_TexCoordP2ui(ctx->CurrentServerDispatch, (type, coords));
}


/* TexParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexParameteriv(GLenum target, GLenum pname, const GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexParameteriv");
   CALL_TexParameteriv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* WaitSemaphoreEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_WaitSemaphoreEXT(GLuint semaphore, GLuint numBufferBarriers, const GLuint * buffers, GLuint numTextureBarriers, const GLuint * textures, const GLenum * srcLayouts)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("WaitSemaphoreEXT");
   CALL_WaitSemaphoreEXT(ctx->CurrentServerDispatch, (semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, srcLayouts));
}


/* VertexAttrib3fvARB: marshalled asynchronously */
struct marshal_cmd_VertexAttrib3fvARB
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat v[3];
};
static inline void
_mesa_unmarshal_VertexAttrib3fvARB(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib3fvARB *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat * v = cmd->v;
   CALL_VertexAttrib3fvARB(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib3fvARB(GLuint index, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib3fvARB);
   struct marshal_cmd_VertexAttrib3fvARB *cmd;
   debug_print_marshal("VertexAttrib3fvARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib3fvARB, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib3fvARB");
   CALL_VertexAttrib3fvARB(ctx->CurrentServerDispatch, (index, v));
}


/* ProgramUniformMatrix3x4fv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix3x4fv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 48) bytes are GLfloat value[count][12] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix3x4fv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix3x4fv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 48;
   CALL_ProgramUniformMatrix3x4fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix3x4fv) + safe_mul(count, 48);
   struct marshal_cmd_ProgramUniformMatrix3x4fv *cmd;
   debug_print_marshal("ProgramUniformMatrix3x4fv");
   if (unlikely(safe_mul(count, 48) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix3x4fv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 48);
      variable_data += count * 48;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix3x4fv");
   CALL_ProgramUniformMatrix3x4fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* GetColorTable: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetColorTable(GLenum target, GLenum format, GLenum type, GLvoid * table)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetColorTable");
   CALL_GetColorTable(ctx->CurrentServerDispatch, (target, format, type, table));
}


/* TexCoord3i: marshalled asynchronously */
struct marshal_cmd_TexCoord3i
{
   struct marshal_cmd_base cmd_base;
   GLint s;
   GLint t;
   GLint r;
};
static inline void
_mesa_unmarshal_TexCoord3i(struct gl_context *ctx, const struct marshal_cmd_TexCoord3i *cmd)
{
   const GLint s = cmd->s;
   const GLint t = cmd->t;
   const GLint r = cmd->r;
   CALL_TexCoord3i(ctx->CurrentServerDispatch, (s, t, r));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord3i(GLint s, GLint t, GLint r)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord3i);
   struct marshal_cmd_TexCoord3i *cmd;
   debug_print_marshal("TexCoord3i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord3i, cmd_size);
      cmd->s = s;
      cmd->t = t;
      cmd->r = r;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord3i");
   CALL_TexCoord3i(ctx->CurrentServerDispatch, (s, t, r));
}


/* CopyColorTable: marshalled asynchronously */
struct marshal_cmd_CopyColorTable
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum internalformat;
   GLint x;
   GLint y;
   GLsizei width;
};
static inline void
_mesa_unmarshal_CopyColorTable(struct gl_context *ctx, const struct marshal_cmd_CopyColorTable *cmd)
{
   const GLenum target = cmd->target;
   const GLenum internalformat = cmd->internalformat;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLsizei width = cmd->width;
   CALL_CopyColorTable(ctx->CurrentServerDispatch, (target, internalformat, x, y, width));
}
static void GLAPIENTRY
_mesa_marshal_CopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CopyColorTable);
   struct marshal_cmd_CopyColorTable *cmd;
   debug_print_marshal("CopyColorTable");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CopyColorTable, cmd_size);
      cmd->target = target;
      cmd->internalformat = internalformat;
      cmd->x = x;
      cmd->y = y;
      cmd->width = width;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CopyColorTable");
   CALL_CopyColorTable(ctx->CurrentServerDispatch, (target, internalformat, x, y, width));
}


/* Frustum: marshalled asynchronously */
struct marshal_cmd_Frustum
{
   struct marshal_cmd_base cmd_base;
   GLdouble left;
   GLdouble right;
   GLdouble bottom;
   GLdouble top;
   GLdouble zNear;
   GLdouble zFar;
};
static inline void
_mesa_unmarshal_Frustum(struct gl_context *ctx, const struct marshal_cmd_Frustum *cmd)
{
   const GLdouble left = cmd->left;
   const GLdouble right = cmd->right;
   const GLdouble bottom = cmd->bottom;
   const GLdouble top = cmd->top;
   const GLdouble zNear = cmd->zNear;
   const GLdouble zFar = cmd->zFar;
   CALL_Frustum(ctx->CurrentServerDispatch, (left, right, bottom, top, zNear, zFar));
}
static void GLAPIENTRY
_mesa_marshal_Frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Frustum);
   struct marshal_cmd_Frustum *cmd;
   debug_print_marshal("Frustum");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Frustum, cmd_size);
      cmd->left = left;
      cmd->right = right;
      cmd->bottom = bottom;
      cmd->top = top;
      cmd->zNear = zNear;
      cmd->zFar = zFar;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Frustum");
   CALL_Frustum(ctx->CurrentServerDispatch, (left, right, bottom, top, zNear, zFar));
}


/* TexCoord3d: marshalled asynchronously */
struct marshal_cmd_TexCoord3d
{
   struct marshal_cmd_base cmd_base;
   GLdouble s;
   GLdouble t;
   GLdouble r;
};
static inline void
_mesa_unmarshal_TexCoord3d(struct gl_context *ctx, const struct marshal_cmd_TexCoord3d *cmd)
{
   const GLdouble s = cmd->s;
   const GLdouble t = cmd->t;
   const GLdouble r = cmd->r;
   CALL_TexCoord3d(ctx->CurrentServerDispatch, (s, t, r));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord3d(GLdouble s, GLdouble t, GLdouble r)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord3d);
   struct marshal_cmd_TexCoord3d *cmd;
   debug_print_marshal("TexCoord3d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord3d, cmd_size);
      cmd->s = s;
      cmd->t = t;
      cmd->r = r;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord3d");
   CALL_TexCoord3d(ctx->CurrentServerDispatch, (s, t, r));
}


/* GetTextureParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTextureParameteriv(GLuint texture, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTextureParameteriv");
   CALL_GetTextureParameteriv(ctx->CurrentServerDispatch, (texture, pname, params));
}


/* TexCoord3f: marshalled asynchronously */
struct marshal_cmd_TexCoord3f
{
   struct marshal_cmd_base cmd_base;
   GLfloat s;
   GLfloat t;
   GLfloat r;
};
static inline void
_mesa_unmarshal_TexCoord3f(struct gl_context *ctx, const struct marshal_cmd_TexCoord3f *cmd)
{
   const GLfloat s = cmd->s;
   const GLfloat t = cmd->t;
   const GLfloat r = cmd->r;
   CALL_TexCoord3f(ctx->CurrentServerDispatch, (s, t, r));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord3f(GLfloat s, GLfloat t, GLfloat r)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord3f);
   struct marshal_cmd_TexCoord3f *cmd;
   debug_print_marshal("TexCoord3f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord3f, cmd_size);
      cmd->s = s;
      cmd->t = t;
      cmd->r = r;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord3f");
   CALL_TexCoord3f(ctx->CurrentServerDispatch, (s, t, r));
}


/* DepthRangeArrayv: marshalled asynchronously */
struct marshal_cmd_DepthRangeArrayv
{
   struct marshal_cmd_base cmd_base;
   GLuint first;
   GLsizei count;
   /* Next safe_mul(count, 16) bytes are GLclampd v[count][2] */
};
static inline void
_mesa_unmarshal_DepthRangeArrayv(struct gl_context *ctx, const struct marshal_cmd_DepthRangeArrayv *cmd)
{
   const GLuint first = cmd->first;
   const GLsizei count = cmd->count;
   const GLclampd * v;
   const char *variable_data = (const char *) (cmd + 1);
   v = (const GLclampd *) variable_data;
   variable_data += count * 16;
   CALL_DepthRangeArrayv(ctx->CurrentServerDispatch, (first, count, v));
}
static void GLAPIENTRY
_mesa_marshal_DepthRangeArrayv(GLuint first, GLsizei count, const GLclampd * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DepthRangeArrayv) + safe_mul(count, 16);
   struct marshal_cmd_DepthRangeArrayv *cmd;
   debug_print_marshal("DepthRangeArrayv");
   if (unlikely(safe_mul(count, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DepthRangeArrayv, cmd_size);
      cmd->first = first;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, v, count * 16);
      variable_data += count * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DepthRangeArrayv");
   CALL_DepthRangeArrayv(ctx->CurrentServerDispatch, (first, count, v));
}


/* DeleteTextures: marshalled asynchronously */
struct marshal_cmd_DeleteTextures
{
   struct marshal_cmd_base cmd_base;
   GLsizei n;
   /* Next safe_mul(n, 4) bytes are GLuint textures[n] */
};
static inline void
_mesa_unmarshal_DeleteTextures(struct gl_context *ctx, const struct marshal_cmd_DeleteTextures *cmd)
{
   const GLsizei n = cmd->n;
   const GLuint * textures;
   const char *variable_data = (const char *) (cmd + 1);
   textures = (const GLuint *) variable_data;
   variable_data += n * 4;
   CALL_DeleteTextures(ctx->CurrentServerDispatch, (n, textures));
}
static void GLAPIENTRY
_mesa_marshal_DeleteTextures(GLsizei n, const GLuint * textures)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DeleteTextures) + safe_mul(n, 4);
   struct marshal_cmd_DeleteTextures *cmd;
   debug_print_marshal("DeleteTextures");
   if (unlikely(safe_mul(n, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DeleteTextures, cmd_size);
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, textures, n * 4);
      variable_data += n * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DeleteTextures");
   CALL_DeleteTextures(ctx->CurrentServerDispatch, (n, textures));
}


/* TexCoordPointerEXT: marshalled asynchronously */
struct marshal_cmd_TexCoordPointerEXT
{
   struct marshal_cmd_base cmd_base;
   GLint size;
   GLenum type;
   GLsizei stride;
   GLsizei count;
   const GLvoid * pointer;
};
static inline void
_mesa_unmarshal_TexCoordPointerEXT(struct gl_context *ctx, const struct marshal_cmd_TexCoordPointerEXT *cmd)
{
   const GLint size = cmd->size;
   const GLenum type = cmd->type;
   const GLsizei stride = cmd->stride;
   const GLsizei count = cmd->count;
   const GLvoid * pointer = cmd->pointer;
   CALL_TexCoordPointerEXT(ctx->CurrentServerDispatch, (size, type, stride, count, pointer));
}
static void GLAPIENTRY
_mesa_marshal_TexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoordPointerEXT);
   struct marshal_cmd_TexCoordPointerEXT *cmd;
   debug_print_marshal("TexCoordPointerEXT");
   if (_mesa_glthread_is_non_vbo_vertex_attrib_pointer(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("TexCoordPointerEXT");
      CALL_TexCoordPointerEXT(ctx->CurrentServerDispatch, (size, type, stride, count, pointer));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoordPointerEXT, cmd_size);
      cmd->size = size;
      cmd->type = type;
      cmd->stride = stride;
      cmd->count = count;
      cmd->pointer = pointer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoordPointerEXT");
   CALL_TexCoordPointerEXT(ctx->CurrentServerDispatch, (size, type, stride, count, pointer));
}


/* TexCoord3s: marshalled asynchronously */
struct marshal_cmd_TexCoord3s
{
   struct marshal_cmd_base cmd_base;
   GLshort s;
   GLshort t;
   GLshort r;
};
static inline void
_mesa_unmarshal_TexCoord3s(struct gl_context *ctx, const struct marshal_cmd_TexCoord3s *cmd)
{
   const GLshort s = cmd->s;
   const GLshort t = cmd->t;
   const GLshort r = cmd->r;
   CALL_TexCoord3s(ctx->CurrentServerDispatch, (s, t, r));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord3s(GLshort s, GLshort t, GLshort r)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord3s);
   struct marshal_cmd_TexCoord3s *cmd;
   debug_print_marshal("TexCoord3s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord3s, cmd_size);
      cmd->s = s;
      cmd->t = t;
      cmd->r = r;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord3s");
   CALL_TexCoord3s(ctx->CurrentServerDispatch, (s, t, r));
}


/* GetTexLevelParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTexLevelParameteriv");
   CALL_GetTexLevelParameteriv(ctx->CurrentServerDispatch, (target, level, pname, params));
}


/* TextureParameterIuiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TextureParameterIuiv(GLuint texture, GLenum pname, const GLuint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TextureParameterIuiv");
   CALL_TextureParameterIuiv(ctx->CurrentServerDispatch, (texture, pname, params));
}


/* GenPerfMonitorsAMD: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GenPerfMonitorsAMD(GLsizei n, GLuint * monitors)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GenPerfMonitorsAMD");
   CALL_GenPerfMonitorsAMD(ctx->CurrentServerDispatch, (n, monitors));
}


/* ClearAccum: marshalled asynchronously */
struct marshal_cmd_ClearAccum
{
   struct marshal_cmd_base cmd_base;
   GLfloat red;
   GLfloat green;
   GLfloat blue;
   GLfloat alpha;
};
static inline void
_mesa_unmarshal_ClearAccum(struct gl_context *ctx, const struct marshal_cmd_ClearAccum *cmd)
{
   const GLfloat red = cmd->red;
   const GLfloat green = cmd->green;
   const GLfloat blue = cmd->blue;
   const GLfloat alpha = cmd->alpha;
   CALL_ClearAccum(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}
static void GLAPIENTRY
_mesa_marshal_ClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ClearAccum);
   struct marshal_cmd_ClearAccum *cmd;
   debug_print_marshal("ClearAccum");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ClearAccum, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      cmd->alpha = alpha;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ClearAccum");
   CALL_ClearAccum(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}


/* TexCoord4iv: marshalled asynchronously */
struct marshal_cmd_TexCoord4iv
{
   struct marshal_cmd_base cmd_base;
   GLint v[4];
};
static inline void
_mesa_unmarshal_TexCoord4iv(struct gl_context *ctx, const struct marshal_cmd_TexCoord4iv *cmd)
{
   const GLint * v = cmd->v;
   CALL_TexCoord4iv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord4iv(const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord4iv);
   struct marshal_cmd_TexCoord4iv *cmd;
   debug_print_marshal("TexCoord4iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord4iv, cmd_size);
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord4iv");
   CALL_TexCoord4iv(ctx->CurrentServerDispatch, (v));
}


/* TexStorage3D: marshalled asynchronously */
struct marshal_cmd_TexStorage3D
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei levels;
   GLenum internalFormat;
   GLsizei width;
   GLsizei height;
   GLsizei depth;
};
static inline void
_mesa_unmarshal_TexStorage3D(struct gl_context *ctx, const struct marshal_cmd_TexStorage3D *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei levels = cmd->levels;
   const GLenum internalFormat = cmd->internalFormat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLsizei depth = cmd->depth;
   CALL_TexStorage3D(ctx->CurrentServerDispatch, (target, levels, internalFormat, width, height, depth));
}
static void GLAPIENTRY
_mesa_marshal_TexStorage3D(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexStorage3D);
   struct marshal_cmd_TexStorage3D *cmd;
   debug_print_marshal("TexStorage3D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexStorage3D, cmd_size);
      cmd->target = target;
      cmd->levels = levels;
      cmd->internalFormat = internalFormat;
      cmd->width = width;
      cmd->height = height;
      cmd->depth = depth;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexStorage3D");
   CALL_TexStorage3D(ctx->CurrentServerDispatch, (target, levels, internalFormat, width, height, depth));
}


/* Uniform2i64ARB: marshalled asynchronously */
struct marshal_cmd_Uniform2i64ARB
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLint64 x;
   GLint64 y;
};
static inline void
_mesa_unmarshal_Uniform2i64ARB(struct gl_context *ctx, const struct marshal_cmd_Uniform2i64ARB *cmd)
{
   const GLint location = cmd->location;
   const GLint64 x = cmd->x;
   const GLint64 y = cmd->y;
   CALL_Uniform2i64ARB(ctx->CurrentServerDispatch, (location, x, y));
}
static void GLAPIENTRY
_mesa_marshal_Uniform2i64ARB(GLint location, GLint64 x, GLint64 y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform2i64ARB);
   struct marshal_cmd_Uniform2i64ARB *cmd;
   debug_print_marshal("Uniform2i64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform2i64ARB, cmd_size);
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform2i64ARB");
   CALL_Uniform2i64ARB(ctx->CurrentServerDispatch, (location, x, y));
}


/* FramebufferTexture3D: marshalled asynchronously */
struct marshal_cmd_FramebufferTexture3D
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum attachment;
   GLenum textarget;
   GLuint texture;
   GLint level;
   GLint layer;
};
static inline void
_mesa_unmarshal_FramebufferTexture3D(struct gl_context *ctx, const struct marshal_cmd_FramebufferTexture3D *cmd)
{
   const GLenum target = cmd->target;
   const GLenum attachment = cmd->attachment;
   const GLenum textarget = cmd->textarget;
   const GLuint texture = cmd->texture;
   const GLint level = cmd->level;
   const GLint layer = cmd->layer;
   CALL_FramebufferTexture3D(ctx->CurrentServerDispatch, (target, attachment, textarget, texture, level, layer));
}
static void GLAPIENTRY
_mesa_marshal_FramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint layer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_FramebufferTexture3D);
   struct marshal_cmd_FramebufferTexture3D *cmd;
   debug_print_marshal("FramebufferTexture3D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_FramebufferTexture3D, cmd_size);
      cmd->target = target;
      cmd->attachment = attachment;
      cmd->textarget = textarget;
      cmd->texture = texture;
      cmd->level = level;
      cmd->layer = layer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("FramebufferTexture3D");
   CALL_FramebufferTexture3D(ctx->CurrentServerDispatch, (target, attachment, textarget, texture, level, layer));
}


/* GetBufferParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetBufferParameteriv(GLenum target, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetBufferParameteriv");
   CALL_GetBufferParameteriv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* VertexAttrib2fNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib2fNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat x;
   GLfloat y;
};
static inline void
_mesa_unmarshal_VertexAttrib2fNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib2fNV *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   CALL_VertexAttrib2fNV(ctx->CurrentServerDispatch, (index, x, y));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib2fNV);
   struct marshal_cmd_VertexAttrib2fNV *cmd;
   debug_print_marshal("VertexAttrib2fNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib2fNV, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib2fNV");
   CALL_VertexAttrib2fNV(ctx->CurrentServerDispatch, (index, x, y));
}


/* CopyTexImage2D: marshalled asynchronously */
struct marshal_cmd_CopyTexImage2D
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLint level;
   GLenum internalformat;
   GLint x;
   GLint y;
   GLsizei width;
   GLsizei height;
   GLint border;
};
static inline void
_mesa_unmarshal_CopyTexImage2D(struct gl_context *ctx, const struct marshal_cmd_CopyTexImage2D *cmd)
{
   const GLenum target = cmd->target;
   const GLint level = cmd->level;
   const GLenum internalformat = cmd->internalformat;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLint border = cmd->border;
   CALL_CopyTexImage2D(ctx->CurrentServerDispatch, (target, level, internalformat, x, y, width, height, border));
}
static void GLAPIENTRY
_mesa_marshal_CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CopyTexImage2D);
   struct marshal_cmd_CopyTexImage2D *cmd;
   debug_print_marshal("CopyTexImage2D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CopyTexImage2D, cmd_size);
      cmd->target = target;
      cmd->level = level;
      cmd->internalformat = internalformat;
      cmd->x = x;
      cmd->y = y;
      cmd->width = width;
      cmd->height = height;
      cmd->border = border;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CopyTexImage2D");
   CALL_CopyTexImage2D(ctx->CurrentServerDispatch, (target, level, internalformat, x, y, width, height, border));
}


/* Vertex3fv: marshalled asynchronously */
struct marshal_cmd_Vertex3fv
{
   struct marshal_cmd_base cmd_base;
   GLfloat v[3];
};
static inline void
_mesa_unmarshal_Vertex3fv(struct gl_context *ctx, const struct marshal_cmd_Vertex3fv *cmd)
{
   const GLfloat * v = cmd->v;
   CALL_Vertex3fv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Vertex3fv(const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex3fv);
   struct marshal_cmd_Vertex3fv *cmd;
   debug_print_marshal("Vertex3fv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex3fv, cmd_size);
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex3fv");
   CALL_Vertex3fv(ctx->CurrentServerDispatch, (v));
}


/* WindowPos4dvMESA: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_WindowPos4dvMESA(const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("WindowPos4dvMESA");
   CALL_WindowPos4dvMESA(ctx->CurrentServerDispatch, (v));
}


/* ProgramUniform2i64vARB: marshalled asynchronously */
struct marshal_cmd_ProgramUniform2i64vARB
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 16) bytes are GLint64 value[count][2] */
};
static inline void
_mesa_unmarshal_ProgramUniform2i64vARB(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform2i64vARB *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLint64 * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLint64 *) variable_data;
   variable_data += count * 16;
   CALL_ProgramUniform2i64vARB(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform2i64vARB(GLuint program, GLint location, GLsizei count, const GLint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform2i64vARB) + safe_mul(count, 16);
   struct marshal_cmd_ProgramUniform2i64vARB *cmd;
   debug_print_marshal("ProgramUniform2i64vARB");
   if (unlikely(safe_mul(count, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform2i64vARB, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 16);
      variable_data += count * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform2i64vARB");
   CALL_ProgramUniform2i64vARB(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* MultiTexCoordP2ui: marshalled asynchronously */
struct marshal_cmd_MultiTexCoordP2ui
{
   struct marshal_cmd_base cmd_base;
   GLenum texture;
   GLenum type;
   GLuint coords;
};
static inline void
_mesa_unmarshal_MultiTexCoordP2ui(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoordP2ui *cmd)
{
   const GLenum texture = cmd->texture;
   const GLenum type = cmd->type;
   const GLuint coords = cmd->coords;
   CALL_MultiTexCoordP2ui(ctx->CurrentServerDispatch, (texture, type, coords));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoordP2ui);
   struct marshal_cmd_MultiTexCoordP2ui *cmd;
   debug_print_marshal("MultiTexCoordP2ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoordP2ui, cmd_size);
      cmd->texture = texture;
      cmd->type = type;
      cmd->coords = coords;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoordP2ui");
   CALL_MultiTexCoordP2ui(ctx->CurrentServerDispatch, (texture, type, coords));
}


/* VertexAttribs1dvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttribs1dvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLsizei n;
   /* Next safe_mul(n, 8) bytes are GLdouble v[n] */
};
static inline void
_mesa_unmarshal_VertexAttribs1dvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttribs1dvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLsizei n = cmd->n;
   const GLdouble * v;
   const char *variable_data = (const char *) (cmd + 1);
   v = (const GLdouble *) variable_data;
   variable_data += n * 8;
   CALL_VertexAttribs1dvNV(ctx->CurrentServerDispatch, (index, n, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribs1dvNV(GLuint index, GLsizei n, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribs1dvNV) + safe_mul(n, 8);
   struct marshal_cmd_VertexAttribs1dvNV *cmd;
   debug_print_marshal("VertexAttribs1dvNV");
   if (unlikely(safe_mul(n, 8) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribs1dvNV, cmd_size);
      cmd->index = index;
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, v, n * 8);
      variable_data += n * 8;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribs1dvNV");
   CALL_VertexAttribs1dvNV(ctx->CurrentServerDispatch, (index, n, v));
}


/* ImportSemaphoreFdEXT: marshalled asynchronously */
struct marshal_cmd_ImportSemaphoreFdEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint semaphore;
   GLenum handleType;
   GLint fd;
};
static inline void
_mesa_unmarshal_ImportSemaphoreFdEXT(struct gl_context *ctx, const struct marshal_cmd_ImportSemaphoreFdEXT *cmd)
{
   const GLuint semaphore = cmd->semaphore;
   const GLenum handleType = cmd->handleType;
   const GLint fd = cmd->fd;
   CALL_ImportSemaphoreFdEXT(ctx->CurrentServerDispatch, (semaphore, handleType, fd));
}
static void GLAPIENTRY
_mesa_marshal_ImportSemaphoreFdEXT(GLuint semaphore, GLenum handleType, GLint fd)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ImportSemaphoreFdEXT);
   struct marshal_cmd_ImportSemaphoreFdEXT *cmd;
   debug_print_marshal("ImportSemaphoreFdEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ImportSemaphoreFdEXT, cmd_size);
      cmd->semaphore = semaphore;
      cmd->handleType = handleType;
      cmd->fd = fd;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ImportSemaphoreFdEXT");
   CALL_ImportSemaphoreFdEXT(ctx->CurrentServerDispatch, (semaphore, handleType, fd));
}


/* IsQuery: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsQuery(GLuint id)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsQuery");
   return CALL_IsQuery(ctx->CurrentServerDispatch, (id));
}


/* EdgeFlagPointerEXT: marshalled asynchronously */
struct marshal_cmd_EdgeFlagPointerEXT
{
   struct marshal_cmd_base cmd_base;
   GLsizei stride;
   GLsizei count;
   const GLboolean * pointer;
};
static inline void
_mesa_unmarshal_EdgeFlagPointerEXT(struct gl_context *ctx, const struct marshal_cmd_EdgeFlagPointerEXT *cmd)
{
   const GLsizei stride = cmd->stride;
   const GLsizei count = cmd->count;
   const GLboolean * pointer = cmd->pointer;
   CALL_EdgeFlagPointerEXT(ctx->CurrentServerDispatch, (stride, count, pointer));
}
static void GLAPIENTRY
_mesa_marshal_EdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EdgeFlagPointerEXT);
   struct marshal_cmd_EdgeFlagPointerEXT *cmd;
   debug_print_marshal("EdgeFlagPointerEXT");
   if (_mesa_glthread_is_non_vbo_vertex_attrib_pointer(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("EdgeFlagPointerEXT");
      CALL_EdgeFlagPointerEXT(ctx->CurrentServerDispatch, (stride, count, pointer));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EdgeFlagPointerEXT, cmd_size);
      cmd->stride = stride;
      cmd->count = count;
      cmd->pointer = pointer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EdgeFlagPointerEXT");
   CALL_EdgeFlagPointerEXT(ctx->CurrentServerDispatch, (stride, count, pointer));
}


/* VertexAttribs2svNV: marshalled asynchronously */
struct marshal_cmd_VertexAttribs2svNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLsizei n;
   /* Next safe_mul(n, 4) bytes are GLshort v[n][2] */
};
static inline void
_mesa_unmarshal_VertexAttribs2svNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttribs2svNV *cmd)
{
   const GLuint index = cmd->index;
   const GLsizei n = cmd->n;
   const GLshort * v;
   const char *variable_data = (const char *) (cmd + 1);
   v = (const GLshort *) variable_data;
   variable_data += n * 4;
   CALL_VertexAttribs2svNV(ctx->CurrentServerDispatch, (index, n, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribs2svNV(GLuint index, GLsizei n, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribs2svNV) + safe_mul(n, 4);
   struct marshal_cmd_VertexAttribs2svNV *cmd;
   debug_print_marshal("VertexAttribs2svNV");
   if (unlikely(safe_mul(n, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribs2svNV, cmd_size);
      cmd->index = index;
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, v, n * 4);
      variable_data += n * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribs2svNV");
   CALL_VertexAttribs2svNV(ctx->CurrentServerDispatch, (index, n, v));
}


/* CreateShaderProgramv: marshalled synchronously */
static GLuint GLAPIENTRY
_mesa_marshal_CreateShaderProgramv(GLenum type, GLsizei count, const GLchar * const * strings)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CreateShaderProgramv");
   return CALL_CreateShaderProgramv(ctx->CurrentServerDispatch, (type, count, strings));
}


/* BlendEquationiARB: marshalled asynchronously */
struct marshal_cmd_BlendEquationiARB
{
   struct marshal_cmd_base cmd_base;
   GLuint buf;
   GLenum mode;
};
static inline void
_mesa_unmarshal_BlendEquationiARB(struct gl_context *ctx, const struct marshal_cmd_BlendEquationiARB *cmd)
{
   const GLuint buf = cmd->buf;
   const GLenum mode = cmd->mode;
   CALL_BlendEquationiARB(ctx->CurrentServerDispatch, (buf, mode));
}
static void GLAPIENTRY
_mesa_marshal_BlendEquationiARB(GLuint buf, GLenum mode)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BlendEquationiARB);
   struct marshal_cmd_BlendEquationiARB *cmd;
   debug_print_marshal("BlendEquationiARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BlendEquationiARB, cmd_size);
      cmd->buf = buf;
      cmd->mode = mode;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BlendEquationiARB");
   CALL_BlendEquationiARB(ctx->CurrentServerDispatch, (buf, mode));
}


/* VertexAttribI4uivEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribI4uivEXT(GLuint index, const GLuint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribI4uivEXT");
   CALL_VertexAttribI4uivEXT(ctx->CurrentServerDispatch, (index, v));
}


/* PointSizex: marshalled asynchronously */
struct marshal_cmd_PointSizex
{
   struct marshal_cmd_base cmd_base;
   GLfixed size;
};
static inline void
_mesa_unmarshal_PointSizex(struct gl_context *ctx, const struct marshal_cmd_PointSizex *cmd)
{
   const GLfixed size = cmd->size;
   CALL_PointSizex(ctx->CurrentServerDispatch, (size));
}
static void GLAPIENTRY
_mesa_marshal_PointSizex(GLfixed size)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PointSizex);
   struct marshal_cmd_PointSizex *cmd;
   debug_print_marshal("PointSizex");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PointSizex, cmd_size);
      cmd->size = size;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PointSizex");
   CALL_PointSizex(ctx->CurrentServerDispatch, (size));
}


/* PolygonMode: marshalled asynchronously */
struct marshal_cmd_PolygonMode
{
   struct marshal_cmd_base cmd_base;
   GLenum face;
   GLenum mode;
};
static inline void
_mesa_unmarshal_PolygonMode(struct gl_context *ctx, const struct marshal_cmd_PolygonMode *cmd)
{
   const GLenum face = cmd->face;
   const GLenum mode = cmd->mode;
   CALL_PolygonMode(ctx->CurrentServerDispatch, (face, mode));
}
static void GLAPIENTRY
_mesa_marshal_PolygonMode(GLenum face, GLenum mode)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PolygonMode);
   struct marshal_cmd_PolygonMode *cmd;
   debug_print_marshal("PolygonMode");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PolygonMode, cmd_size);
      cmd->face = face;
      cmd->mode = mode;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PolygonMode");
   CALL_PolygonMode(ctx->CurrentServerDispatch, (face, mode));
}


/* SecondaryColor3iv: marshalled asynchronously */
struct marshal_cmd_SecondaryColor3iv
{
   struct marshal_cmd_base cmd_base;
   GLint v[3];
};
static inline void
_mesa_unmarshal_SecondaryColor3iv(struct gl_context *ctx, const struct marshal_cmd_SecondaryColor3iv *cmd)
{
   const GLint * v = cmd->v;
   CALL_SecondaryColor3iv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColor3iv(const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColor3iv);
   struct marshal_cmd_SecondaryColor3iv *cmd;
   debug_print_marshal("SecondaryColor3iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColor3iv, cmd_size);
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColor3iv");
   CALL_SecondaryColor3iv(ctx->CurrentServerDispatch, (v));
}


/* VertexAttribI1iEXT: marshalled asynchronously */
struct marshal_cmd_VertexAttribI1iEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLint x;
};
static inline void
_mesa_unmarshal_VertexAttribI1iEXT(struct gl_context *ctx, const struct marshal_cmd_VertexAttribI1iEXT *cmd)
{
   const GLuint index = cmd->index;
   const GLint x = cmd->x;
   CALL_VertexAttribI1iEXT(ctx->CurrentServerDispatch, (index, x));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribI1iEXT(GLuint index, GLint x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribI1iEXT);
   struct marshal_cmd_VertexAttribI1iEXT *cmd;
   debug_print_marshal("VertexAttribI1iEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribI1iEXT, cmd_size);
      cmd->index = index;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribI1iEXT");
   CALL_VertexAttribI1iEXT(ctx->CurrentServerDispatch, (index, x));
}


/* VertexAttrib4Niv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4Niv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLint v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4Niv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4Niv *cmd)
{
   const GLuint index = cmd->index;
   const GLint * v = cmd->v;
   CALL_VertexAttrib4Niv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4Niv(GLuint index, const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4Niv);
   struct marshal_cmd_VertexAttrib4Niv *cmd;
   debug_print_marshal("VertexAttrib4Niv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4Niv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4Niv");
   CALL_VertexAttrib4Niv(ctx->CurrentServerDispatch, (index, v));
}


/* GetnUniformdvARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnUniformdvARB(GLuint program, GLint location, GLsizei bufSize, GLdouble * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnUniformdvARB");
   CALL_GetnUniformdvARB(ctx->CurrentServerDispatch, (program, location, bufSize, params));
}


/* LinkProgram: marshalled asynchronously */
struct marshal_cmd_LinkProgram
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
};
static inline void
_mesa_unmarshal_LinkProgram(struct gl_context *ctx, const struct marshal_cmd_LinkProgram *cmd)
{
   const GLuint program = cmd->program;
   CALL_LinkProgram(ctx->CurrentServerDispatch, (program));
}
static void GLAPIENTRY
_mesa_marshal_LinkProgram(GLuint program)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_LinkProgram);
   struct marshal_cmd_LinkProgram *cmd;
   debug_print_marshal("LinkProgram");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_LinkProgram, cmd_size);
      cmd->program = program;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("LinkProgram");
   CALL_LinkProgram(ctx->CurrentServerDispatch, (program));
}


/* ProgramUniform4d: marshalled asynchronously */
struct marshal_cmd_ProgramUniform4d
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLdouble x;
   GLdouble y;
   GLdouble z;
   GLdouble w;
};
static inline void
_mesa_unmarshal_ProgramUniform4d(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform4d *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   const GLdouble w = cmd->w;
   CALL_ProgramUniform4d(ctx->CurrentServerDispatch, (program, location, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform4d(GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform4d);
   struct marshal_cmd_ProgramUniform4d *cmd;
   debug_print_marshal("ProgramUniform4d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform4d, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform4d");
   CALL_ProgramUniform4d(ctx->CurrentServerDispatch, (program, location, x, y, z, w));
}


/* ProgramUniform4f: marshalled asynchronously */
struct marshal_cmd_ProgramUniform4f
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLfloat x;
   GLfloat y;
   GLfloat z;
   GLfloat w;
};
static inline void
_mesa_unmarshal_ProgramUniform4f(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform4f *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   const GLfloat w = cmd->w;
   CALL_ProgramUniform4f(ctx->CurrentServerDispatch, (program, location, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform4f(GLuint program, GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform4f);
   struct marshal_cmd_ProgramUniform4f *cmd;
   debug_print_marshal("ProgramUniform4f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform4f, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform4f");
   CALL_ProgramUniform4f(ctx->CurrentServerDispatch, (program, location, x, y, z, w));
}


/* ProgramUniform4i: marshalled asynchronously */
struct marshal_cmd_ProgramUniform4i
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLint x;
   GLint y;
   GLint z;
   GLint w;
};
static inline void
_mesa_unmarshal_ProgramUniform4i(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform4i *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLint z = cmd->z;
   const GLint w = cmd->w;
   CALL_ProgramUniform4i(ctx->CurrentServerDispatch, (program, location, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform4i(GLuint program, GLint location, GLint x, GLint y, GLint z, GLint w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform4i);
   struct marshal_cmd_ProgramUniform4i *cmd;
   debug_print_marshal("ProgramUniform4i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform4i, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform4i");
   CALL_ProgramUniform4i(ctx->CurrentServerDispatch, (program, location, x, y, z, w));
}


/* GetFramebufferParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetFramebufferParameteriv(GLenum target, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetFramebufferParameteriv");
   CALL_GetFramebufferParameteriv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* GetNamedBufferPointerv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetNamedBufferPointerv(GLuint buffer, GLenum pname, GLvoid ** params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetNamedBufferPointerv");
   CALL_GetNamedBufferPointerv(ctx->CurrentServerDispatch, (buffer, pname, params));
}


/* VertexAttrib4d: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4d
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble x;
   GLdouble y;
   GLdouble z;
   GLdouble w;
};
static inline void
_mesa_unmarshal_VertexAttrib4d(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4d *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   const GLdouble w = cmd->w;
   CALL_VertexAttrib4d(ctx->CurrentServerDispatch, (index, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4d);
   struct marshal_cmd_VertexAttrib4d *cmd;
   debug_print_marshal("VertexAttrib4d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4d, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4d");
   CALL_VertexAttrib4d(ctx->CurrentServerDispatch, (index, x, y, z, w));
}


/* ProgramUniform4ui64vARB: marshalled asynchronously */
struct marshal_cmd_ProgramUniform4ui64vARB
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 32) bytes are GLuint64 value[count][4] */
};
static inline void
_mesa_unmarshal_ProgramUniform4ui64vARB(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform4ui64vARB *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLuint64 * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLuint64 *) variable_data;
   variable_data += count * 32;
   CALL_ProgramUniform4ui64vARB(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform4ui64vARB(GLuint program, GLint location, GLsizei count, const GLuint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform4ui64vARB) + safe_mul(count, 32);
   struct marshal_cmd_ProgramUniform4ui64vARB *cmd;
   debug_print_marshal("ProgramUniform4ui64vARB");
   if (unlikely(safe_mul(count, 32) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform4ui64vARB, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 32);
      variable_data += count * 32;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform4ui64vARB");
   CALL_ProgramUniform4ui64vARB(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* WindowPos4sMESA: marshalled asynchronously */
struct marshal_cmd_WindowPos4sMESA
{
   struct marshal_cmd_base cmd_base;
   GLshort x;
   GLshort y;
   GLshort z;
   GLshort w;
};
static inline void
_mesa_unmarshal_WindowPos4sMESA(struct gl_context *ctx, const struct marshal_cmd_WindowPos4sMESA *cmd)
{
   const GLshort x = cmd->x;
   const GLshort y = cmd->y;
   const GLshort z = cmd->z;
   const GLshort w = cmd->w;
   CALL_WindowPos4sMESA(ctx->CurrentServerDispatch, (x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_WindowPos4sMESA(GLshort x, GLshort y, GLshort z, GLshort w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_WindowPos4sMESA);
   struct marshal_cmd_WindowPos4sMESA *cmd;
   debug_print_marshal("WindowPos4sMESA");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_WindowPos4sMESA, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("WindowPos4sMESA");
   CALL_WindowPos4sMESA(ctx->CurrentServerDispatch, (x, y, z, w));
}


/* VertexAttrib4s: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4s
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLshort x;
   GLshort y;
   GLshort z;
   GLshort w;
};
static inline void
_mesa_unmarshal_VertexAttrib4s(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4s *cmd)
{
   const GLuint index = cmd->index;
   const GLshort x = cmd->x;
   const GLshort y = cmd->y;
   const GLshort z = cmd->z;
   const GLshort w = cmd->w;
   CALL_VertexAttrib4s(ctx->CurrentServerDispatch, (index, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4s);
   struct marshal_cmd_VertexAttrib4s *cmd;
   debug_print_marshal("VertexAttrib4s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4s, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4s");
   CALL_VertexAttrib4s(ctx->CurrentServerDispatch, (index, x, y, z, w));
}


/* ProgramUniform1i64vARB: marshalled asynchronously */
struct marshal_cmd_ProgramUniform1i64vARB
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 8) bytes are GLint64 value[count] */
};
static inline void
_mesa_unmarshal_ProgramUniform1i64vARB(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform1i64vARB *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLint64 * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLint64 *) variable_data;
   variable_data += count * 8;
   CALL_ProgramUniform1i64vARB(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform1i64vARB(GLuint program, GLint location, GLsizei count, const GLint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform1i64vARB) + safe_mul(count, 8);
   struct marshal_cmd_ProgramUniform1i64vARB *cmd;
   debug_print_marshal("ProgramUniform1i64vARB");
   if (unlikely(safe_mul(count, 8) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform1i64vARB, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 8);
      variable_data += count * 8;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform1i64vARB");
   CALL_ProgramUniform1i64vARB(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* VertexAttrib1dvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib1dvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble v[1];
};
static inline void
_mesa_unmarshal_VertexAttrib1dvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib1dvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble * v = cmd->v;
   CALL_VertexAttrib1dvNV(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib1dvNV(GLuint index, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib1dvNV);
   struct marshal_cmd_VertexAttrib1dvNV *cmd;
   debug_print_marshal("VertexAttrib1dvNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib1dvNV, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib1dvNV");
   CALL_VertexAttrib1dvNV(ctx->CurrentServerDispatch, (index, v));
}


/* GetSemaphoreParameterui64vEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetSemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname, GLuint64 * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetSemaphoreParameterui64vEXT");
   CALL_GetSemaphoreParameterui64vEXT(ctx->CurrentServerDispatch, (semaphore, pname, params));
}


/* TexStorage3DMultisample: marshalled asynchronously */
struct marshal_cmd_TexStorage3DMultisample
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei samples;
   GLenum internalformat;
   GLsizei width;
   GLsizei height;
   GLsizei depth;
   GLboolean fixedsamplelocations;
};
static inline void
_mesa_unmarshal_TexStorage3DMultisample(struct gl_context *ctx, const struct marshal_cmd_TexStorage3DMultisample *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei samples = cmd->samples;
   const GLenum internalformat = cmd->internalformat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLsizei depth = cmd->depth;
   const GLboolean fixedsamplelocations = cmd->fixedsamplelocations;
   CALL_TexStorage3DMultisample(ctx->CurrentServerDispatch, (target, samples, internalformat, width, height, depth, fixedsamplelocations));
}
static void GLAPIENTRY
_mesa_marshal_TexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexStorage3DMultisample);
   struct marshal_cmd_TexStorage3DMultisample *cmd;
   debug_print_marshal("TexStorage3DMultisample");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexStorage3DMultisample, cmd_size);
      cmd->target = target;
      cmd->samples = samples;
      cmd->internalformat = internalformat;
      cmd->width = width;
      cmd->height = height;
      cmd->depth = depth;
      cmd->fixedsamplelocations = fixedsamplelocations;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexStorage3DMultisample");
   CALL_TexStorage3DMultisample(ctx->CurrentServerDispatch, (target, samples, internalformat, width, height, depth, fixedsamplelocations));
}


/* SamplerParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_SamplerParameteriv(GLuint sampler, GLenum pname, const GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("SamplerParameteriv");
   CALL_SamplerParameteriv(ctx->CurrentServerDispatch, (sampler, pname, params));
}


/* VertexAttribP3uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribP3uiv");
   CALL_VertexAttribP3uiv(ctx->CurrentServerDispatch, (index, type, normalized, value));
}


/* ScissorIndexedv: marshalled asynchronously */
struct marshal_cmd_ScissorIndexedv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLint v[4];
};
static inline void
_mesa_unmarshal_ScissorIndexedv(struct gl_context *ctx, const struct marshal_cmd_ScissorIndexedv *cmd)
{
   const GLuint index = cmd->index;
   const GLint * v = cmd->v;
   CALL_ScissorIndexedv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_ScissorIndexedv(GLuint index, const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ScissorIndexedv);
   struct marshal_cmd_ScissorIndexedv *cmd;
   debug_print_marshal("ScissorIndexedv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ScissorIndexedv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ScissorIndexedv");
   CALL_ScissorIndexedv(ctx->CurrentServerDispatch, (index, v));
}


/* GetStringi: marshalled synchronously */
static const GLubyte * GLAPIENTRY
_mesa_marshal_GetStringi(GLenum name, GLuint index)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetStringi");
   return CALL_GetStringi(ctx->CurrentServerDispatch, (name, index));
}


/* Uniform2dv: marshalled asynchronously */
struct marshal_cmd_Uniform2dv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 16) bytes are GLdouble value[count][2] */
};
static inline void
_mesa_unmarshal_Uniform2dv(struct gl_context *ctx, const struct marshal_cmd_Uniform2dv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 16;
   CALL_Uniform2dv(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform2dv(GLint location, GLsizei count, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform2dv) + safe_mul(count, 16);
   struct marshal_cmd_Uniform2dv *cmd;
   debug_print_marshal("Uniform2dv");
   if (unlikely(safe_mul(count, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform2dv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 16);
      variable_data += count * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform2dv");
   CALL_Uniform2dv(ctx->CurrentServerDispatch, (location, count, value));
}


/* VertexAttrib4dv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4dv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4dv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4dv *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble * v = cmd->v;
   CALL_VertexAttrib4dv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4dv(GLuint index, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4dv);
   struct marshal_cmd_VertexAttrib4dv *cmd;
   debug_print_marshal("VertexAttrib4dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4dv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 32);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4dv");
   CALL_VertexAttrib4dv(ctx->CurrentServerDispatch, (index, v));
}


/* CreateTextures: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CreateTextures(GLenum target, GLsizei n, GLuint * textures)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CreateTextures");
   CALL_CreateTextures(ctx->CurrentServerDispatch, (target, n, textures));
}


/* EvalCoord2dv: marshalled asynchronously */
struct marshal_cmd_EvalCoord2dv
{
   struct marshal_cmd_base cmd_base;
   GLdouble u[2];
};
static inline void
_mesa_unmarshal_EvalCoord2dv(struct gl_context *ctx, const struct marshal_cmd_EvalCoord2dv *cmd)
{
   const GLdouble * u = cmd->u;
   CALL_EvalCoord2dv(ctx->CurrentServerDispatch, (u));
}
static void GLAPIENTRY
_mesa_marshal_EvalCoord2dv(const GLdouble * u)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EvalCoord2dv);
   struct marshal_cmd_EvalCoord2dv *cmd;
   debug_print_marshal("EvalCoord2dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EvalCoord2dv, cmd_size);
      memcpy(cmd->u, u, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EvalCoord2dv");
   CALL_EvalCoord2dv(ctx->CurrentServerDispatch, (u));
}


/* VertexAttrib1fNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib1fNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat x;
};
static inline void
_mesa_unmarshal_VertexAttrib1fNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib1fNV *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat x = cmd->x;
   CALL_VertexAttrib1fNV(ctx->CurrentServerDispatch, (index, x));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib1fNV(GLuint index, GLfloat x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib1fNV);
   struct marshal_cmd_VertexAttrib1fNV *cmd;
   debug_print_marshal("VertexAttrib1fNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib1fNV, cmd_size);
      cmd->index = index;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib1fNV");
   CALL_VertexAttrib1fNV(ctx->CurrentServerDispatch, (index, x));
}


/* CompressedTexSubImage1D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CompressedTexSubImage1D");
   CALL_CompressedTexSubImage1D(ctx->CurrentServerDispatch, (target, level, xoffset, width, format, imageSize, data));
}


/* GetSeparableFilter: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid * row, GLvoid * column, GLvoid * span)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetSeparableFilter");
   CALL_GetSeparableFilter(ctx->CurrentServerDispatch, (target, format, type, row, column, span));
}


/* FeedbackBuffer: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_FeedbackBuffer(GLsizei size, GLenum type, GLfloat * buffer)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("FeedbackBuffer");
   CALL_FeedbackBuffer(ctx->CurrentServerDispatch, (size, type, buffer));
}


/* RasterPos2iv: marshalled asynchronously */
struct marshal_cmd_RasterPos2iv
{
   struct marshal_cmd_base cmd_base;
   GLint v[2];
};
static inline void
_mesa_unmarshal_RasterPos2iv(struct gl_context *ctx, const struct marshal_cmd_RasterPos2iv *cmd)
{
   const GLint * v = cmd->v;
   CALL_RasterPos2iv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos2iv(const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos2iv);
   struct marshal_cmd_RasterPos2iv *cmd;
   debug_print_marshal("RasterPos2iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos2iv, cmd_size);
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos2iv");
   CALL_RasterPos2iv(ctx->CurrentServerDispatch, (v));
}


/* TexImage1D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexImage1D");
   CALL_TexImage1D(ctx->CurrentServerDispatch, (target, level, internalformat, width, border, format, type, pixels));
}


/* MultiDrawElementsEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_MultiDrawElementsEXT(GLenum mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MultiDrawElementsEXT");
   CALL_MultiDrawElementsEXT(ctx->CurrentServerDispatch, (mode, count, type, indices, primcount));
}


/* GetnSeparableFilterARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnSeparableFilterARB(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, GLvoid * row, GLsizei columnBufSize, GLvoid * column, GLvoid * span)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnSeparableFilterARB");
   CALL_GetnSeparableFilterARB(ctx->CurrentServerDispatch, (target, format, type, rowBufSize, row, columnBufSize, column, span));
}


/* FrontFace: marshalled asynchronously */
struct marshal_cmd_FrontFace
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
};
static inline void
_mesa_unmarshal_FrontFace(struct gl_context *ctx, const struct marshal_cmd_FrontFace *cmd)
{
   const GLenum mode = cmd->mode;
   CALL_FrontFace(ctx->CurrentServerDispatch, (mode));
}
static void GLAPIENTRY
_mesa_marshal_FrontFace(GLenum mode)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_FrontFace);
   struct marshal_cmd_FrontFace *cmd;
   debug_print_marshal("FrontFace");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_FrontFace, cmd_size);
      cmd->mode = mode;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("FrontFace");
   CALL_FrontFace(ctx->CurrentServerDispatch, (mode));
}


/* MultiModeDrawArraysIBM: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_MultiModeDrawArraysIBM(const GLenum * mode, const GLint * first, const GLsizei * count, GLsizei primcount, GLint modestride)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MultiModeDrawArraysIBM");
   CALL_MultiModeDrawArraysIBM(ctx->CurrentServerDispatch, (mode, first, count, primcount, modestride));
}


/* Normal3dv: marshalled asynchronously */
struct marshal_cmd_Normal3dv
{
   struct marshal_cmd_base cmd_base;
   GLdouble v[3];
};
static inline void
_mesa_unmarshal_Normal3dv(struct gl_context *ctx, const struct marshal_cmd_Normal3dv *cmd)
{
   const GLdouble * v = cmd->v;
   CALL_Normal3dv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Normal3dv(const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Normal3dv);
   struct marshal_cmd_Normal3dv *cmd;
   debug_print_marshal("Normal3dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Normal3dv, cmd_size);
      memcpy(cmd->v, v, 24);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Normal3dv");
   CALL_Normal3dv(ctx->CurrentServerDispatch, (v));
}


/* Lightf: marshalled asynchronously */
struct marshal_cmd_Lightf
{
   struct marshal_cmd_base cmd_base;
   GLenum light;
   GLenum pname;
   GLfloat param;
};
static inline void
_mesa_unmarshal_Lightf(struct gl_context *ctx, const struct marshal_cmd_Lightf *cmd)
{
   const GLenum light = cmd->light;
   const GLenum pname = cmd->pname;
   const GLfloat param = cmd->param;
   CALL_Lightf(ctx->CurrentServerDispatch, (light, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_Lightf(GLenum light, GLenum pname, GLfloat param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Lightf);
   struct marshal_cmd_Lightf *cmd;
   debug_print_marshal("Lightf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Lightf, cmd_size);
      cmd->light = light;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Lightf");
   CALL_Lightf(ctx->CurrentServerDispatch, (light, pname, param));
}


/* MatrixMode: marshalled asynchronously */
struct marshal_cmd_MatrixMode
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
};
static inline void
_mesa_unmarshal_MatrixMode(struct gl_context *ctx, const struct marshal_cmd_MatrixMode *cmd)
{
   const GLenum mode = cmd->mode;
   CALL_MatrixMode(ctx->CurrentServerDispatch, (mode));
}
static void GLAPIENTRY
_mesa_marshal_MatrixMode(GLenum mode)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MatrixMode);
   struct marshal_cmd_MatrixMode *cmd;
   debug_print_marshal("MatrixMode");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MatrixMode, cmd_size);
      cmd->mode = mode;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MatrixMode");
   CALL_MatrixMode(ctx->CurrentServerDispatch, (mode));
}


/* GetPixelMapusv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetPixelMapusv(GLenum map, GLushort * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetPixelMapusv");
   CALL_GetPixelMapusv(ctx->CurrentServerDispatch, (map, values));
}


/* Lighti: marshalled asynchronously */
struct marshal_cmd_Lighti
{
   struct marshal_cmd_base cmd_base;
   GLenum light;
   GLenum pname;
   GLint param;
};
static inline void
_mesa_unmarshal_Lighti(struct gl_context *ctx, const struct marshal_cmd_Lighti *cmd)
{
   const GLenum light = cmd->light;
   const GLenum pname = cmd->pname;
   const GLint param = cmd->param;
   CALL_Lighti(ctx->CurrentServerDispatch, (light, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_Lighti(GLenum light, GLenum pname, GLint param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Lighti);
   struct marshal_cmd_Lighti *cmd;
   debug_print_marshal("Lighti");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Lighti, cmd_size);
      cmd->light = light;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Lighti");
   CALL_Lighti(ctx->CurrentServerDispatch, (light, pname, param));
}


/* GetFragDataIndex: marshalled synchronously */
static GLint GLAPIENTRY
_mesa_marshal_GetFragDataIndex(GLuint program, const GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetFragDataIndex");
   return CALL_GetFragDataIndex(ctx->CurrentServerDispatch, (program, name));
}


/* Lightx: marshalled asynchronously */
struct marshal_cmd_Lightx
{
   struct marshal_cmd_base cmd_base;
   GLenum light;
   GLenum pname;
   GLfixed param;
};
static inline void
_mesa_unmarshal_Lightx(struct gl_context *ctx, const struct marshal_cmd_Lightx *cmd)
{
   const GLenum light = cmd->light;
   const GLenum pname = cmd->pname;
   const GLfixed param = cmd->param;
   CALL_Lightx(ctx->CurrentServerDispatch, (light, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_Lightx(GLenum light, GLenum pname, GLfixed param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Lightx);
   struct marshal_cmd_Lightx *cmd;
   debug_print_marshal("Lightx");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Lightx, cmd_size);
      cmd->light = light;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Lightx");
   CALL_Lightx(ctx->CurrentServerDispatch, (light, pname, param));
}


/* ProgramUniform3fv: marshalled asynchronously */
struct marshal_cmd_ProgramUniform3fv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 12) bytes are GLfloat value[count][3] */
};
static inline void
_mesa_unmarshal_ProgramUniform3fv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform3fv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 12;
   CALL_ProgramUniform3fv(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform3fv) + safe_mul(count, 12);
   struct marshal_cmd_ProgramUniform3fv *cmd;
   debug_print_marshal("ProgramUniform3fv");
   if (unlikely(safe_mul(count, 12) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform3fv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 12);
      variable_data += count * 12;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform3fv");
   CALL_ProgramUniform3fv(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* MultMatrixd: marshalled asynchronously */
struct marshal_cmd_MultMatrixd
{
   struct marshal_cmd_base cmd_base;
   GLdouble m[16];
};
static inline void
_mesa_unmarshal_MultMatrixd(struct gl_context *ctx, const struct marshal_cmd_MultMatrixd *cmd)
{
   const GLdouble * m = cmd->m;
   CALL_MultMatrixd(ctx->CurrentServerDispatch, (m));
}
static void GLAPIENTRY
_mesa_marshal_MultMatrixd(const GLdouble * m)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultMatrixd);
   struct marshal_cmd_MultMatrixd *cmd;
   debug_print_marshal("MultMatrixd");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultMatrixd, cmd_size);
      memcpy(cmd->m, m, 128);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultMatrixd");
   CALL_MultMatrixd(ctx->CurrentServerDispatch, (m));
}


/* MultMatrixf: marshalled asynchronously */
struct marshal_cmd_MultMatrixf
{
   struct marshal_cmd_base cmd_base;
   GLfloat m[16];
};
static inline void
_mesa_unmarshal_MultMatrixf(struct gl_context *ctx, const struct marshal_cmd_MultMatrixf *cmd)
{
   const GLfloat * m = cmd->m;
   CALL_MultMatrixf(ctx->CurrentServerDispatch, (m));
}
static void GLAPIENTRY
_mesa_marshal_MultMatrixf(const GLfloat * m)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultMatrixf);
   struct marshal_cmd_MultMatrixf *cmd;
   debug_print_marshal("MultMatrixf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultMatrixf, cmd_size);
      memcpy(cmd->m, m, 64);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultMatrixf");
   CALL_MultMatrixf(ctx->CurrentServerDispatch, (m));
}


/* Uniform4ui64vARB: marshalled asynchronously */
struct marshal_cmd_Uniform4ui64vARB
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 32) bytes are GLuint64 value[count][4] */
};
static inline void
_mesa_unmarshal_Uniform4ui64vARB(struct gl_context *ctx, const struct marshal_cmd_Uniform4ui64vARB *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLuint64 * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLuint64 *) variable_data;
   variable_data += count * 32;
   CALL_Uniform4ui64vARB(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform4ui64vARB(GLint location, GLsizei count, const GLuint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform4ui64vARB) + safe_mul(count, 32);
   struct marshal_cmd_Uniform4ui64vARB *cmd;
   debug_print_marshal("Uniform4ui64vARB");
   if (unlikely(safe_mul(count, 32) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform4ui64vARB, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 32);
      variable_data += count * 32;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform4ui64vARB");
   CALL_Uniform4ui64vARB(ctx->CurrentServerDispatch, (location, count, value));
}


/* MultiTexCoord4fvARB: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord4fvARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLfloat v[4];
};
static inline void
_mesa_unmarshal_MultiTexCoord4fvARB(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord4fvARB *cmd)
{
   const GLenum target = cmd->target;
   const GLfloat * v = cmd->v;
   CALL_MultiTexCoord4fvARB(ctx->CurrentServerDispatch, (target, v));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord4fvARB(GLenum target, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord4fvARB);
   struct marshal_cmd_MultiTexCoord4fvARB *cmd;
   debug_print_marshal("MultiTexCoord4fvARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord4fvARB, cmd_size);
      cmd->target = target;
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord4fvARB");
   CALL_MultiTexCoord4fvARB(ctx->CurrentServerDispatch, (target, v));
}


/* UniformMatrix2x3fv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix2x3fv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 24) bytes are GLfloat value[count][6] */
};
static inline void
_mesa_unmarshal_UniformMatrix2x3fv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix2x3fv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 24;
   CALL_UniformMatrix2x3fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix2x3fv) + safe_mul(count, 24);
   struct marshal_cmd_UniformMatrix2x3fv *cmd;
   debug_print_marshal("UniformMatrix2x3fv");
   if (unlikely(safe_mul(count, 24) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix2x3fv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 24);
      variable_data += count * 24;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix2x3fv");
   CALL_UniformMatrix2x3fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* SamplerParameterf: marshalled asynchronously */
struct marshal_cmd_SamplerParameterf
{
   struct marshal_cmd_base cmd_base;
   GLuint sampler;
   GLenum pname;
   GLfloat param;
};
static inline void
_mesa_unmarshal_SamplerParameterf(struct gl_context *ctx, const struct marshal_cmd_SamplerParameterf *cmd)
{
   const GLuint sampler = cmd->sampler;
   const GLenum pname = cmd->pname;
   const GLfloat param = cmd->param;
   CALL_SamplerParameterf(ctx->CurrentServerDispatch, (sampler, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SamplerParameterf);
   struct marshal_cmd_SamplerParameterf *cmd;
   debug_print_marshal("SamplerParameterf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SamplerParameterf, cmd_size);
      cmd->sampler = sampler;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SamplerParameterf");
   CALL_SamplerParameterf(ctx->CurrentServerDispatch, (sampler, pname, param));
}


/* UniformMatrix3dv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix3dv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 72) bytes are GLdouble value[count][9] */
};
static inline void
_mesa_unmarshal_UniformMatrix3dv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix3dv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 72;
   CALL_UniformMatrix3dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix3dv) + safe_mul(count, 72);
   struct marshal_cmd_UniformMatrix3dv *cmd;
   debug_print_marshal("UniformMatrix3dv");
   if (unlikely(safe_mul(count, 72) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix3dv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 72);
      variable_data += count * 72;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix3dv");
   CALL_UniformMatrix3dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* PointParameterx: marshalled asynchronously */
struct marshal_cmd_PointParameterx
{
   struct marshal_cmd_base cmd_base;
   GLenum pname;
   GLfixed param;
};
static inline void
_mesa_unmarshal_PointParameterx(struct gl_context *ctx, const struct marshal_cmd_PointParameterx *cmd)
{
   const GLenum pname = cmd->pname;
   const GLfixed param = cmd->param;
   CALL_PointParameterx(ctx->CurrentServerDispatch, (pname, param));
}
static void GLAPIENTRY
_mesa_marshal_PointParameterx(GLenum pname, GLfixed param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PointParameterx);
   struct marshal_cmd_PointParameterx *cmd;
   debug_print_marshal("PointParameterx");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PointParameterx, cmd_size);
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PointParameterx");
   CALL_PointParameterx(ctx->CurrentServerDispatch, (pname, param));
}


/* DrawArrays: marshalled asynchronously */
struct marshal_cmd_DrawArrays
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLint first;
   GLsizei count;
};
static inline void
_mesa_unmarshal_DrawArrays(struct gl_context *ctx, const struct marshal_cmd_DrawArrays *cmd)
{
   const GLenum mode = cmd->mode;
   const GLint first = cmd->first;
   const GLsizei count = cmd->count;
   CALL_DrawArrays(ctx->CurrentServerDispatch, (mode, first, count));
}
static void GLAPIENTRY
_mesa_marshal_DrawArrays(GLenum mode, GLint first, GLsizei count)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawArrays);
   struct marshal_cmd_DrawArrays *cmd;
   debug_print_marshal("DrawArrays");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawArrays, cmd_size);
      cmd->mode = mode;
      cmd->first = first;
      cmd->count = count;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawArrays");
   CALL_DrawArrays(ctx->CurrentServerDispatch, (mode, first, count));
}


/* Uniform3dv: marshalled asynchronously */
struct marshal_cmd_Uniform3dv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 24) bytes are GLdouble value[count][3] */
};
static inline void
_mesa_unmarshal_Uniform3dv(struct gl_context *ctx, const struct marshal_cmd_Uniform3dv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 24;
   CALL_Uniform3dv(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform3dv(GLint location, GLsizei count, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform3dv) + safe_mul(count, 24);
   struct marshal_cmd_Uniform3dv *cmd;
   debug_print_marshal("Uniform3dv");
   if (unlikely(safe_mul(count, 24) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform3dv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 24);
      variable_data += count * 24;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform3dv");
   CALL_Uniform3dv(ctx->CurrentServerDispatch, (location, count, value));
}


/* PointParameteri: marshalled asynchronously */
struct marshal_cmd_PointParameteri
{
   struct marshal_cmd_base cmd_base;
   GLenum pname;
   GLint param;
};
static inline void
_mesa_unmarshal_PointParameteri(struct gl_context *ctx, const struct marshal_cmd_PointParameteri *cmd)
{
   const GLenum pname = cmd->pname;
   const GLint param = cmd->param;
   CALL_PointParameteri(ctx->CurrentServerDispatch, (pname, param));
}
static void GLAPIENTRY
_mesa_marshal_PointParameteri(GLenum pname, GLint param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PointParameteri);
   struct marshal_cmd_PointParameteri *cmd;
   debug_print_marshal("PointParameteri");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PointParameteri, cmd_size);
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PointParameteri");
   CALL_PointParameteri(ctx->CurrentServerDispatch, (pname, param));
}


/* PointParameterf: marshalled asynchronously */
struct marshal_cmd_PointParameterf
{
   struct marshal_cmd_base cmd_base;
   GLenum pname;
   GLfloat param;
};
static inline void
_mesa_unmarshal_PointParameterf(struct gl_context *ctx, const struct marshal_cmd_PointParameterf *cmd)
{
   const GLenum pname = cmd->pname;
   const GLfloat param = cmd->param;
   CALL_PointParameterf(ctx->CurrentServerDispatch, (pname, param));
}
static void GLAPIENTRY
_mesa_marshal_PointParameterf(GLenum pname, GLfloat param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PointParameterf);
   struct marshal_cmd_PointParameterf *cmd;
   debug_print_marshal("PointParameterf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PointParameterf, cmd_size);
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PointParameterf");
   CALL_PointParameterf(ctx->CurrentServerDispatch, (pname, param));
}


/* VertexAttribBinding: marshalled asynchronously */
struct marshal_cmd_VertexAttribBinding
{
   struct marshal_cmd_base cmd_base;
   GLuint attribindex;
   GLuint bindingindex;
};
static inline void
_mesa_unmarshal_VertexAttribBinding(struct gl_context *ctx, const struct marshal_cmd_VertexAttribBinding *cmd)
{
   const GLuint attribindex = cmd->attribindex;
   const GLuint bindingindex = cmd->bindingindex;
   CALL_VertexAttribBinding(ctx->CurrentServerDispatch, (attribindex, bindingindex));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribBinding(GLuint attribindex, GLuint bindingindex)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribBinding);
   struct marshal_cmd_VertexAttribBinding *cmd;
   debug_print_marshal("VertexAttribBinding");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribBinding, cmd_size);
      cmd->attribindex = attribindex;
      cmd->bindingindex = bindingindex;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribBinding");
   CALL_VertexAttribBinding(ctx->CurrentServerDispatch, (attribindex, bindingindex));
}


/* TextureSubImage2D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TextureSubImage2D");
   CALL_TextureSubImage2D(ctx->CurrentServerDispatch, (texture, level, xoffset, yoffset, width, height, format, type, pixels));
}


/* CreateShader: marshalled synchronously */
static GLuint GLAPIENTRY
_mesa_marshal_CreateShader(GLenum type)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CreateShader");
   return CALL_CreateShader(ctx->CurrentServerDispatch, (type));
}


/* ProgramUniform1dv: marshalled asynchronously */
struct marshal_cmd_ProgramUniform1dv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 8) bytes are GLdouble value[count] */
};
static inline void
_mesa_unmarshal_ProgramUniform1dv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform1dv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 8;
   CALL_ProgramUniform1dv(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform1dv) + safe_mul(count, 8);
   struct marshal_cmd_ProgramUniform1dv *cmd;
   debug_print_marshal("ProgramUniform1dv");
   if (unlikely(safe_mul(count, 8) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform1dv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 8);
      variable_data += count * 8;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform1dv");
   CALL_ProgramUniform1dv(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* GetProgramEnvParameterfvARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramEnvParameterfvARB");
   CALL_GetProgramEnvParameterfvARB(ctx->CurrentServerDispatch, (target, index, params));
}


/* DeleteBuffers: marshalled asynchronously */
struct marshal_cmd_DeleteBuffers
{
   struct marshal_cmd_base cmd_base;
   GLsizei n;
   /* Next safe_mul(n, 4) bytes are GLuint buffer[n] */
};
static inline void
_mesa_unmarshal_DeleteBuffers(struct gl_context *ctx, const struct marshal_cmd_DeleteBuffers *cmd)
{
   const GLsizei n = cmd->n;
   const GLuint * buffer;
   const char *variable_data = (const char *) (cmd + 1);
   buffer = (const GLuint *) variable_data;
   variable_data += n * 4;
   CALL_DeleteBuffers(ctx->CurrentServerDispatch, (n, buffer));
}
static void GLAPIENTRY
_mesa_marshal_DeleteBuffers(GLsizei n, const GLuint * buffer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DeleteBuffers) + safe_mul(n, 4);
   struct marshal_cmd_DeleteBuffers *cmd;
   debug_print_marshal("DeleteBuffers");
   if (unlikely(safe_mul(n, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DeleteBuffers, cmd_size);
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, buffer, n * 4);
      variable_data += n * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DeleteBuffers");
   CALL_DeleteBuffers(ctx->CurrentServerDispatch, (n, buffer));
}


/* GetBufferSubData: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetBufferSubData");
   CALL_GetBufferSubData(ctx->CurrentServerDispatch, (target, offset, size, data));
}


/* GetNamedRenderbufferParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetNamedRenderbufferParameteriv(GLuint renderbuffer, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetNamedRenderbufferParameteriv");
   CALL_GetNamedRenderbufferParameteriv(ctx->CurrentServerDispatch, (renderbuffer, pname, params));
}


/* GetPerfMonitorGroupsAMD: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetPerfMonitorGroupsAMD(GLint * numGroups, GLsizei groupsSize, GLuint * groups)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetPerfMonitorGroupsAMD");
   CALL_GetPerfMonitorGroupsAMD(ctx->CurrentServerDispatch, (numGroups, groupsSize, groups));
}


/* VertexAttribP2ui: marshalled asynchronously */
struct marshal_cmd_VertexAttribP2ui
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLenum type;
   GLboolean normalized;
   GLuint value;
};
static inline void
_mesa_unmarshal_VertexAttribP2ui(struct gl_context *ctx, const struct marshal_cmd_VertexAttribP2ui *cmd)
{
   const GLuint index = cmd->index;
   const GLenum type = cmd->type;
   const GLboolean normalized = cmd->normalized;
   const GLuint value = cmd->value;
   CALL_VertexAttribP2ui(ctx->CurrentServerDispatch, (index, type, normalized, value));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribP2ui);
   struct marshal_cmd_VertexAttribP2ui *cmd;
   debug_print_marshal("VertexAttribP2ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribP2ui, cmd_size);
      cmd->index = index;
      cmd->type = type;
      cmd->normalized = normalized;
      cmd->value = value;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribP2ui");
   CALL_VertexAttribP2ui(ctx->CurrentServerDispatch, (index, type, normalized, value));
}


/* ProgramUniform4dv: marshalled asynchronously */
struct marshal_cmd_ProgramUniform4dv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 32) bytes are GLdouble value[count][4] */
};
static inline void
_mesa_unmarshal_ProgramUniform4dv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform4dv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 32;
   CALL_ProgramUniform4dv(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform4dv) + safe_mul(count, 32);
   struct marshal_cmd_ProgramUniform4dv *cmd;
   debug_print_marshal("ProgramUniform4dv");
   if (unlikely(safe_mul(count, 32) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform4dv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 32);
      variable_data += count * 32;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform4dv");
   CALL_ProgramUniform4dv(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* GetMinmaxParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetMinmaxParameteriv(GLenum target, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetMinmaxParameteriv");
   CALL_GetMinmaxParameteriv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* DrawTexivOES: marshalled asynchronously */
struct marshal_cmd_DrawTexivOES
{
   struct marshal_cmd_base cmd_base;
   GLint coords[5];
};
static inline void
_mesa_unmarshal_DrawTexivOES(struct gl_context *ctx, const struct marshal_cmd_DrawTexivOES *cmd)
{
   const GLint * coords = cmd->coords;
   CALL_DrawTexivOES(ctx->CurrentServerDispatch, (coords));
}
static void GLAPIENTRY
_mesa_marshal_DrawTexivOES(const GLint * coords)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawTexivOES);
   struct marshal_cmd_DrawTexivOES *cmd;
   debug_print_marshal("DrawTexivOES");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawTexivOES, cmd_size);
      memcpy(cmd->coords, coords, 20);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawTexivOES");
   CALL_DrawTexivOES(ctx->CurrentServerDispatch, (coords));
}


/* CopyTexImage1D: marshalled asynchronously */
struct marshal_cmd_CopyTexImage1D
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLint level;
   GLenum internalformat;
   GLint x;
   GLint y;
   GLsizei width;
   GLint border;
};
static inline void
_mesa_unmarshal_CopyTexImage1D(struct gl_context *ctx, const struct marshal_cmd_CopyTexImage1D *cmd)
{
   const GLenum target = cmd->target;
   const GLint level = cmd->level;
   const GLenum internalformat = cmd->internalformat;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLsizei width = cmd->width;
   const GLint border = cmd->border;
   CALL_CopyTexImage1D(ctx->CurrentServerDispatch, (target, level, internalformat, x, y, width, border));
}
static void GLAPIENTRY
_mesa_marshal_CopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CopyTexImage1D);
   struct marshal_cmd_CopyTexImage1D *cmd;
   debug_print_marshal("CopyTexImage1D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CopyTexImage1D, cmd_size);
      cmd->target = target;
      cmd->level = level;
      cmd->internalformat = internalformat;
      cmd->x = x;
      cmd->y = y;
      cmd->width = width;
      cmd->border = border;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CopyTexImage1D");
   CALL_CopyTexImage1D(ctx->CurrentServerDispatch, (target, level, internalformat, x, y, width, border));
}


/* InvalidateNamedFramebufferData: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_InvalidateNamedFramebufferData(GLuint framebuffer, GLsizei numAttachments, const GLenum * attachments)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("InvalidateNamedFramebufferData");
   CALL_InvalidateNamedFramebufferData(ctx->CurrentServerDispatch, (framebuffer, numAttachments, attachments));
}


/* SemaphoreParameterui64vEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_SemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname, const GLuint64 * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("SemaphoreParameterui64vEXT");
   CALL_SemaphoreParameterui64vEXT(ctx->CurrentServerDispatch, (semaphore, pname, params));
}


/* GetnColorTableARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnColorTableARB(GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid * table)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnColorTableARB");
   CALL_GetnColorTableARB(ctx->CurrentServerDispatch, (target, format, type, bufSize, table));
}


/* VertexAttribFormat: marshalled asynchronously */
struct marshal_cmd_VertexAttribFormat
{
   struct marshal_cmd_base cmd_base;
   GLuint attribindex;
   GLint size;
   GLenum type;
   GLboolean normalized;
   GLuint relativeoffset;
};
static inline void
_mesa_unmarshal_VertexAttribFormat(struct gl_context *ctx, const struct marshal_cmd_VertexAttribFormat *cmd)
{
   const GLuint attribindex = cmd->attribindex;
   const GLint size = cmd->size;
   const GLenum type = cmd->type;
   const GLboolean normalized = cmd->normalized;
   const GLuint relativeoffset = cmd->relativeoffset;
   CALL_VertexAttribFormat(ctx->CurrentServerDispatch, (attribindex, size, type, normalized, relativeoffset));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribFormat);
   struct marshal_cmd_VertexAttribFormat *cmd;
   debug_print_marshal("VertexAttribFormat");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribFormat, cmd_size);
      cmd->attribindex = attribindex;
      cmd->size = size;
      cmd->type = type;
      cmd->normalized = normalized;
      cmd->relativeoffset = relativeoffset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribFormat");
   CALL_VertexAttribFormat(ctx->CurrentServerDispatch, (attribindex, size, type, normalized, relativeoffset));
}


/* Vertex3i: marshalled asynchronously */
struct marshal_cmd_Vertex3i
{
   struct marshal_cmd_base cmd_base;
   GLint x;
   GLint y;
   GLint z;
};
static inline void
_mesa_unmarshal_Vertex3i(struct gl_context *ctx, const struct marshal_cmd_Vertex3i *cmd)
{
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLint z = cmd->z;
   CALL_Vertex3i(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_Vertex3i(GLint x, GLint y, GLint z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex3i);
   struct marshal_cmd_Vertex3i *cmd;
   debug_print_marshal("Vertex3i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex3i, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex3i");
   CALL_Vertex3i(ctx->CurrentServerDispatch, (x, y, z));
}


/* Vertex3f: marshalled asynchronously */
struct marshal_cmd_Vertex3f
{
   struct marshal_cmd_base cmd_base;
   GLfloat x;
   GLfloat y;
   GLfloat z;
};
static inline void
_mesa_unmarshal_Vertex3f(struct gl_context *ctx, const struct marshal_cmd_Vertex3f *cmd)
{
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   CALL_Vertex3f(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_Vertex3f(GLfloat x, GLfloat y, GLfloat z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex3f);
   struct marshal_cmd_Vertex3f *cmd;
   debug_print_marshal("Vertex3f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex3f, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex3f");
   CALL_Vertex3f(ctx->CurrentServerDispatch, (x, y, z));
}


/* Vertex3d: marshalled asynchronously */
struct marshal_cmd_Vertex3d
{
   struct marshal_cmd_base cmd_base;
   GLdouble x;
   GLdouble y;
   GLdouble z;
};
static inline void
_mesa_unmarshal_Vertex3d(struct gl_context *ctx, const struct marshal_cmd_Vertex3d *cmd)
{
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   CALL_Vertex3d(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_Vertex3d(GLdouble x, GLdouble y, GLdouble z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex3d);
   struct marshal_cmd_Vertex3d *cmd;
   debug_print_marshal("Vertex3d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex3d, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex3d");
   CALL_Vertex3d(ctx->CurrentServerDispatch, (x, y, z));
}


/* GetProgramPipelineiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramPipelineiv");
   CALL_GetProgramPipelineiv(ctx->CurrentServerDispatch, (pipeline, pname, params));
}


/* ReadBuffer: marshalled asynchronously */
struct marshal_cmd_ReadBuffer
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
};
static inline void
_mesa_unmarshal_ReadBuffer(struct gl_context *ctx, const struct marshal_cmd_ReadBuffer *cmd)
{
   const GLenum mode = cmd->mode;
   CALL_ReadBuffer(ctx->CurrentServerDispatch, (mode));
}
static void GLAPIENTRY
_mesa_marshal_ReadBuffer(GLenum mode)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ReadBuffer);
   struct marshal_cmd_ReadBuffer *cmd;
   debug_print_marshal("ReadBuffer");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ReadBuffer, cmd_size);
      cmd->mode = mode;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ReadBuffer");
   CALL_ReadBuffer(ctx->CurrentServerDispatch, (mode));
}


/* ConvolutionParameteri: marshalled asynchronously */
struct marshal_cmd_ConvolutionParameteri
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum pname;
   GLint params;
};
static inline void
_mesa_unmarshal_ConvolutionParameteri(struct gl_context *ctx, const struct marshal_cmd_ConvolutionParameteri *cmd)
{
   const GLenum target = cmd->target;
   const GLenum pname = cmd->pname;
   const GLint params = cmd->params;
   CALL_ConvolutionParameteri(ctx->CurrentServerDispatch, (target, pname, params));
}
static void GLAPIENTRY
_mesa_marshal_ConvolutionParameteri(GLenum target, GLenum pname, GLint params)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ConvolutionParameteri);
   struct marshal_cmd_ConvolutionParameteri *cmd;
   debug_print_marshal("ConvolutionParameteri");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ConvolutionParameteri, cmd_size);
      cmd->target = target;
      cmd->pname = pname;
      cmd->params = params;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ConvolutionParameteri");
   CALL_ConvolutionParameteri(ctx->CurrentServerDispatch, (target, pname, params));
}


/* GetTexParameterIiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTexParameterIiv(GLenum target, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTexParameterIiv");
   CALL_GetTexParameterIiv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* Vertex3s: marshalled asynchronously */
struct marshal_cmd_Vertex3s
{
   struct marshal_cmd_base cmd_base;
   GLshort x;
   GLshort y;
   GLshort z;
};
static inline void
_mesa_unmarshal_Vertex3s(struct gl_context *ctx, const struct marshal_cmd_Vertex3s *cmd)
{
   const GLshort x = cmd->x;
   const GLshort y = cmd->y;
   const GLshort z = cmd->z;
   CALL_Vertex3s(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_Vertex3s(GLshort x, GLshort y, GLshort z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex3s);
   struct marshal_cmd_Vertex3s *cmd;
   debug_print_marshal("Vertex3s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex3s, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex3s");
   CALL_Vertex3s(ctx->CurrentServerDispatch, (x, y, z));
}


/* ConvolutionParameterf: marshalled asynchronously */
struct marshal_cmd_ConvolutionParameterf
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum pname;
   GLfloat params;
};
static inline void
_mesa_unmarshal_ConvolutionParameterf(struct gl_context *ctx, const struct marshal_cmd_ConvolutionParameterf *cmd)
{
   const GLenum target = cmd->target;
   const GLenum pname = cmd->pname;
   const GLfloat params = cmd->params;
   CALL_ConvolutionParameterf(ctx->CurrentServerDispatch, (target, pname, params));
}
static void GLAPIENTRY
_mesa_marshal_ConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ConvolutionParameterf);
   struct marshal_cmd_ConvolutionParameterf *cmd;
   debug_print_marshal("ConvolutionParameterf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ConvolutionParameterf, cmd_size);
      cmd->target = target;
      cmd->pname = pname;
      cmd->params = params;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ConvolutionParameterf");
   CALL_ConvolutionParameterf(ctx->CurrentServerDispatch, (target, pname, params));
}


/* GetColorTableParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetColorTableParameteriv(GLenum target, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetColorTableParameteriv");
   CALL_GetColorTableParameteriv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* GetTransformFeedbackVarying: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTransformFeedbackVarying");
   CALL_GetTransformFeedbackVarying(ctx->CurrentServerDispatch, (program, index, bufSize, length, size, type, name));
}


/* GetNextPerfQueryIdINTEL: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetNextPerfQueryIdINTEL(GLuint queryId, GLuint * nextQueryId)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetNextPerfQueryIdINTEL");
   CALL_GetNextPerfQueryIdINTEL(ctx->CurrentServerDispatch, (queryId, nextQueryId));
}


/* TexCoord3fv: marshalled asynchronously */
struct marshal_cmd_TexCoord3fv
{
   struct marshal_cmd_base cmd_base;
   GLfloat v[3];
};
static inline void
_mesa_unmarshal_TexCoord3fv(struct gl_context *ctx, const struct marshal_cmd_TexCoord3fv *cmd)
{
   const GLfloat * v = cmd->v;
   CALL_TexCoord3fv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord3fv(const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord3fv);
   struct marshal_cmd_TexCoord3fv *cmd;
   debug_print_marshal("TexCoord3fv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord3fv, cmd_size);
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord3fv");
   CALL_TexCoord3fv(ctx->CurrentServerDispatch, (v));
}


/* TextureBarrierNV: marshalled asynchronously */
struct marshal_cmd_TextureBarrierNV
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_TextureBarrierNV(struct gl_context *ctx, const struct marshal_cmd_TextureBarrierNV *cmd)
{
   CALL_TextureBarrierNV(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_TextureBarrierNV(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureBarrierNV);
   struct marshal_cmd_TextureBarrierNV *cmd;
   debug_print_marshal("TextureBarrierNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureBarrierNV, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureBarrierNV");
   CALL_TextureBarrierNV(ctx->CurrentServerDispatch, ());
}


/* GetProgramInterfaceiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramInterfaceiv");
   CALL_GetProgramInterfaceiv(ctx->CurrentServerDispatch, (program, programInterface, pname, params));
}


/* VertexAttribL1ui64vARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribL1ui64vARB(GLuint index, const GLuint64EXT * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribL1ui64vARB");
   CALL_VertexAttribL1ui64vARB(ctx->CurrentServerDispatch, (index, v));
}


/* ProgramLocalParameter4fARB: marshalled asynchronously */
struct marshal_cmd_ProgramLocalParameter4fARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint index;
   GLfloat x;
   GLfloat y;
   GLfloat z;
   GLfloat w;
};
static inline void
_mesa_unmarshal_ProgramLocalParameter4fARB(struct gl_context *ctx, const struct marshal_cmd_ProgramLocalParameter4fARB *cmd)
{
   const GLenum target = cmd->target;
   const GLuint index = cmd->index;
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   const GLfloat w = cmd->w;
   CALL_ProgramLocalParameter4fARB(ctx->CurrentServerDispatch, (target, index, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_ProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramLocalParameter4fARB);
   struct marshal_cmd_ProgramLocalParameter4fARB *cmd;
   debug_print_marshal("ProgramLocalParameter4fARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramLocalParameter4fARB, cmd_size);
      cmd->target = target;
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramLocalParameter4fARB");
   CALL_ProgramLocalParameter4fARB(ctx->CurrentServerDispatch, (target, index, x, y, z, w));
}


/* PauseTransformFeedback: marshalled asynchronously */
struct marshal_cmd_PauseTransformFeedback
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_PauseTransformFeedback(struct gl_context *ctx, const struct marshal_cmd_PauseTransformFeedback *cmd)
{
   CALL_PauseTransformFeedback(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_PauseTransformFeedback(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PauseTransformFeedback);
   struct marshal_cmd_PauseTransformFeedback *cmd;
   debug_print_marshal("PauseTransformFeedback");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PauseTransformFeedback, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PauseTransformFeedback");
   CALL_PauseTransformFeedback(ctx->CurrentServerDispatch, ());
}


/* DeleteShader: marshalled asynchronously */
struct marshal_cmd_DeleteShader
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
};
static inline void
_mesa_unmarshal_DeleteShader(struct gl_context *ctx, const struct marshal_cmd_DeleteShader *cmd)
{
   const GLuint program = cmd->program;
   CALL_DeleteShader(ctx->CurrentServerDispatch, (program));
}
static void GLAPIENTRY
_mesa_marshal_DeleteShader(GLuint program)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DeleteShader);
   struct marshal_cmd_DeleteShader *cmd;
   debug_print_marshal("DeleteShader");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DeleteShader, cmd_size);
      cmd->program = program;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DeleteShader");
   CALL_DeleteShader(ctx->CurrentServerDispatch, (program));
}


/* NamedFramebufferRenderbuffer: marshalled asynchronously */
struct marshal_cmd_NamedFramebufferRenderbuffer
{
   struct marshal_cmd_base cmd_base;
   GLuint framebuffer;
   GLenum attachment;
   GLenum renderbuffertarget;
   GLuint renderbuffer;
};
static inline void
_mesa_unmarshal_NamedFramebufferRenderbuffer(struct gl_context *ctx, const struct marshal_cmd_NamedFramebufferRenderbuffer *cmd)
{
   const GLuint framebuffer = cmd->framebuffer;
   const GLenum attachment = cmd->attachment;
   const GLenum renderbuffertarget = cmd->renderbuffertarget;
   const GLuint renderbuffer = cmd->renderbuffer;
   CALL_NamedFramebufferRenderbuffer(ctx->CurrentServerDispatch, (framebuffer, attachment, renderbuffertarget, renderbuffer));
}
static void GLAPIENTRY
_mesa_marshal_NamedFramebufferRenderbuffer(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_NamedFramebufferRenderbuffer);
   struct marshal_cmd_NamedFramebufferRenderbuffer *cmd;
   debug_print_marshal("NamedFramebufferRenderbuffer");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_NamedFramebufferRenderbuffer, cmd_size);
      cmd->framebuffer = framebuffer;
      cmd->attachment = attachment;
      cmd->renderbuffertarget = renderbuffertarget;
      cmd->renderbuffer = renderbuffer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("NamedFramebufferRenderbuffer");
   CALL_NamedFramebufferRenderbuffer(ctx->CurrentServerDispatch, (framebuffer, attachment, renderbuffertarget, renderbuffer));
}


/* CompileShader: marshalled asynchronously */
struct marshal_cmd_CompileShader
{
   struct marshal_cmd_base cmd_base;
   GLuint shader;
};
static inline void
_mesa_unmarshal_CompileShader(struct gl_context *ctx, const struct marshal_cmd_CompileShader *cmd)
{
   const GLuint shader = cmd->shader;
   CALL_CompileShader(ctx->CurrentServerDispatch, (shader));
}
static void GLAPIENTRY
_mesa_marshal_CompileShader(GLuint shader)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CompileShader);
   struct marshal_cmd_CompileShader *cmd;
   debug_print_marshal("CompileShader");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CompileShader, cmd_size);
      cmd->shader = shader;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CompileShader");
   CALL_CompileShader(ctx->CurrentServerDispatch, (shader));
}


/* Vertex2iv: marshalled asynchronously */
struct marshal_cmd_Vertex2iv
{
   struct marshal_cmd_base cmd_base;
   GLint v[2];
};
static inline void
_mesa_unmarshal_Vertex2iv(struct gl_context *ctx, const struct marshal_cmd_Vertex2iv *cmd)
{
   const GLint * v = cmd->v;
   CALL_Vertex2iv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Vertex2iv(const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex2iv);
   struct marshal_cmd_Vertex2iv *cmd;
   debug_print_marshal("Vertex2iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex2iv, cmd_size);
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex2iv");
   CALL_Vertex2iv(ctx->CurrentServerDispatch, (v));
}


/* GetVertexArrayIndexediv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetVertexArrayIndexediv(GLuint vaobj, GLuint index, GLenum pname, GLint * param)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetVertexArrayIndexediv");
   CALL_GetVertexArrayIndexediv(ctx->CurrentServerDispatch, (vaobj, index, pname, param));
}


/* TexParameterIiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexParameterIiv(GLenum target, GLenum pname, const GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexParameterIiv");
   CALL_TexParameterIiv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* TexGendv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexGendv(GLenum coord, GLenum pname, const GLdouble * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexGendv");
   CALL_TexGendv(ctx->CurrentServerDispatch, (coord, pname, params));
}


/* ResetMinmax: marshalled asynchronously */
struct marshal_cmd_ResetMinmax
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
};
static inline void
_mesa_unmarshal_ResetMinmax(struct gl_context *ctx, const struct marshal_cmd_ResetMinmax *cmd)
{
   const GLenum target = cmd->target;
   CALL_ResetMinmax(ctx->CurrentServerDispatch, (target));
}
static void GLAPIENTRY
_mesa_marshal_ResetMinmax(GLenum target)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ResetMinmax);
   struct marshal_cmd_ResetMinmax *cmd;
   debug_print_marshal("ResetMinmax");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ResetMinmax, cmd_size);
      cmd->target = target;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ResetMinmax");
   CALL_ResetMinmax(ctx->CurrentServerDispatch, (target));
}


/* SampleCoverage: marshalled asynchronously */
struct marshal_cmd_SampleCoverage
{
   struct marshal_cmd_base cmd_base;
   GLclampf value;
   GLboolean invert;
};
static inline void
_mesa_unmarshal_SampleCoverage(struct gl_context *ctx, const struct marshal_cmd_SampleCoverage *cmd)
{
   const GLclampf value = cmd->value;
   const GLboolean invert = cmd->invert;
   CALL_SampleCoverage(ctx->CurrentServerDispatch, (value, invert));
}
static void GLAPIENTRY
_mesa_marshal_SampleCoverage(GLclampf value, GLboolean invert)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SampleCoverage);
   struct marshal_cmd_SampleCoverage *cmd;
   debug_print_marshal("SampleCoverage");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SampleCoverage, cmd_size);
      cmd->value = value;
      cmd->invert = invert;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SampleCoverage");
   CALL_SampleCoverage(ctx->CurrentServerDispatch, (value, invert));
}


/* GenerateTextureMipmap: marshalled asynchronously */
struct marshal_cmd_GenerateTextureMipmap
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
};
static inline void
_mesa_unmarshal_GenerateTextureMipmap(struct gl_context *ctx, const struct marshal_cmd_GenerateTextureMipmap *cmd)
{
   const GLuint texture = cmd->texture;
   CALL_GenerateTextureMipmap(ctx->CurrentServerDispatch, (texture));
}
static void GLAPIENTRY
_mesa_marshal_GenerateTextureMipmap(GLuint texture)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_GenerateTextureMipmap);
   struct marshal_cmd_GenerateTextureMipmap *cmd;
   debug_print_marshal("GenerateTextureMipmap");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_GenerateTextureMipmap, cmd_size);
      cmd->texture = texture;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("GenerateTextureMipmap");
   CALL_GenerateTextureMipmap(ctx->CurrentServerDispatch, (texture));
}


/* DeleteProgramsARB: marshalled asynchronously */
struct marshal_cmd_DeleteProgramsARB
{
   struct marshal_cmd_base cmd_base;
   GLsizei n;
   /* Next safe_mul(n, 4) bytes are GLuint programs[n] */
};
static inline void
_mesa_unmarshal_DeleteProgramsARB(struct gl_context *ctx, const struct marshal_cmd_DeleteProgramsARB *cmd)
{
   const GLsizei n = cmd->n;
   const GLuint * programs;
   const char *variable_data = (const char *) (cmd + 1);
   programs = (const GLuint *) variable_data;
   variable_data += n * 4;
   CALL_DeleteProgramsARB(ctx->CurrentServerDispatch, (n, programs));
}
static void GLAPIENTRY
_mesa_marshal_DeleteProgramsARB(GLsizei n, const GLuint * programs)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DeleteProgramsARB) + safe_mul(n, 4);
   struct marshal_cmd_DeleteProgramsARB *cmd;
   debug_print_marshal("DeleteProgramsARB");
   if (unlikely(safe_mul(n, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DeleteProgramsARB, cmd_size);
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, programs, n * 4);
      variable_data += n * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DeleteProgramsARB");
   CALL_DeleteProgramsARB(ctx->CurrentServerDispatch, (n, programs));
}


/* ShadeModel: marshalled asynchronously */
struct marshal_cmd_ShadeModel
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
};
static inline void
_mesa_unmarshal_ShadeModel(struct gl_context *ctx, const struct marshal_cmd_ShadeModel *cmd)
{
   const GLenum mode = cmd->mode;
   CALL_ShadeModel(ctx->CurrentServerDispatch, (mode));
}
static void GLAPIENTRY
_mesa_marshal_ShadeModel(GLenum mode)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ShadeModel);
   struct marshal_cmd_ShadeModel *cmd;
   debug_print_marshal("ShadeModel");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ShadeModel, cmd_size);
      cmd->mode = mode;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ShadeModel");
   CALL_ShadeModel(ctx->CurrentServerDispatch, (mode));
}


/* CreateQueries: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CreateQueries(GLenum target, GLsizei n, GLuint * ids)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CreateQueries");
   CALL_CreateQueries(ctx->CurrentServerDispatch, (target, n, ids));
}


/* MultiDrawArrays: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_MultiDrawArrays(GLenum mode, const GLint * first, const GLsizei * count, GLsizei primcount)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MultiDrawArrays");
   CALL_MultiDrawArrays(ctx->CurrentServerDispatch, (mode, first, count, primcount));
}


/* GetProgramLocalParameterdvARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramLocalParameterdvARB");
   CALL_GetProgramLocalParameterdvARB(ctx->CurrentServerDispatch, (target, index, params));
}


/* MapBufferRange: marshalled synchronously */
static GLvoid * GLAPIENTRY
_mesa_marshal_MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MapBufferRange");
   return CALL_MapBufferRange(ctx->CurrentServerDispatch, (target, offset, length, access));
}


/* DispatchCompute: marshalled asynchronously */
struct marshal_cmd_DispatchCompute
{
   struct marshal_cmd_base cmd_base;
   GLuint num_groups_x;
   GLuint num_groups_y;
   GLuint num_groups_z;
};
static inline void
_mesa_unmarshal_DispatchCompute(struct gl_context *ctx, const struct marshal_cmd_DispatchCompute *cmd)
{
   const GLuint num_groups_x = cmd->num_groups_x;
   const GLuint num_groups_y = cmd->num_groups_y;
   const GLuint num_groups_z = cmd->num_groups_z;
   CALL_DispatchCompute(ctx->CurrentServerDispatch, (num_groups_x, num_groups_y, num_groups_z));
}
static void GLAPIENTRY
_mesa_marshal_DispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DispatchCompute);
   struct marshal_cmd_DispatchCompute *cmd;
   debug_print_marshal("DispatchCompute");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DispatchCompute, cmd_size);
      cmd->num_groups_x = num_groups_x;
      cmd->num_groups_y = num_groups_y;
      cmd->num_groups_z = num_groups_z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DispatchCompute");
   CALL_DispatchCompute(ctx->CurrentServerDispatch, (num_groups_x, num_groups_y, num_groups_z));
}


/* UseProgramStages: marshalled asynchronously */
struct marshal_cmd_UseProgramStages
{
   struct marshal_cmd_base cmd_base;
   GLuint pipeline;
   GLbitfield stages;
   GLuint program;
};
static inline void
_mesa_unmarshal_UseProgramStages(struct gl_context *ctx, const struct marshal_cmd_UseProgramStages *cmd)
{
   const GLuint pipeline = cmd->pipeline;
   const GLbitfield stages = cmd->stages;
   const GLuint program = cmd->program;
   CALL_UseProgramStages(ctx->CurrentServerDispatch, (pipeline, stages, program));
}
static void GLAPIENTRY
_mesa_marshal_UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UseProgramStages);
   struct marshal_cmd_UseProgramStages *cmd;
   debug_print_marshal("UseProgramStages");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UseProgramStages, cmd_size);
      cmd->pipeline = pipeline;
      cmd->stages = stages;
      cmd->program = program;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UseProgramStages");
   CALL_UseProgramStages(ctx->CurrentServerDispatch, (pipeline, stages, program));
}


/* ProgramUniformMatrix4fv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix4fv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 64) bytes are GLfloat value[count][16] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix4fv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix4fv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 64;
   CALL_ProgramUniformMatrix4fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix4fv) + safe_mul(count, 64);
   struct marshal_cmd_ProgramUniformMatrix4fv *cmd;
   debug_print_marshal("ProgramUniformMatrix4fv");
   if (unlikely(safe_mul(count, 64) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix4fv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 64);
      variable_data += count * 64;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix4fv");
   CALL_ProgramUniformMatrix4fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* FramebufferRenderbuffer: marshalled asynchronously */
struct marshal_cmd_FramebufferRenderbuffer
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum attachment;
   GLenum renderbuffertarget;
   GLuint renderbuffer;
};
static inline void
_mesa_unmarshal_FramebufferRenderbuffer(struct gl_context *ctx, const struct marshal_cmd_FramebufferRenderbuffer *cmd)
{
   const GLenum target = cmd->target;
   const GLenum attachment = cmd->attachment;
   const GLenum renderbuffertarget = cmd->renderbuffertarget;
   const GLuint renderbuffer = cmd->renderbuffer;
   CALL_FramebufferRenderbuffer(ctx->CurrentServerDispatch, (target, attachment, renderbuffertarget, renderbuffer));
}
static void GLAPIENTRY
_mesa_marshal_FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_FramebufferRenderbuffer);
   struct marshal_cmd_FramebufferRenderbuffer *cmd;
   debug_print_marshal("FramebufferRenderbuffer");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_FramebufferRenderbuffer, cmd_size);
      cmd->target = target;
      cmd->attachment = attachment;
      cmd->renderbuffertarget = renderbuffertarget;
      cmd->renderbuffer = renderbuffer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("FramebufferRenderbuffer");
   CALL_FramebufferRenderbuffer(ctx->CurrentServerDispatch, (target, attachment, renderbuffertarget, renderbuffer));
}


/* IsProgramARB: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsProgramARB(GLuint program)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsProgramARB");
   return CALL_IsProgramARB(ctx->CurrentServerDispatch, (program));
}


/* Map2d: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_Map2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("Map2d");
   CALL_Map2d(ctx->CurrentServerDispatch, (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points));
}


/* Map2f: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_Map2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("Map2f");
   CALL_Map2f(ctx->CurrentServerDispatch, (target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points));
}


/* ProgramStringARB: marshalled asynchronously */
struct marshal_cmd_ProgramStringARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum format;
   GLsizei len;
   /* Next len bytes are GLvoid string[len] */
};
static inline void
_mesa_unmarshal_ProgramStringARB(struct gl_context *ctx, const struct marshal_cmd_ProgramStringARB *cmd)
{
   const GLenum target = cmd->target;
   const GLenum format = cmd->format;
   const GLsizei len = cmd->len;
   const GLvoid * string;
   const char *variable_data = (const char *) (cmd + 1);
   string = (const GLvoid *) variable_data;
   variable_data += len;
   CALL_ProgramStringARB(ctx->CurrentServerDispatch, (target, format, len, string));
}
static void GLAPIENTRY
_mesa_marshal_ProgramStringARB(GLenum target, GLenum format, GLsizei len, const GLvoid * string)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramStringARB) + len;
   struct marshal_cmd_ProgramStringARB *cmd;
   debug_print_marshal("ProgramStringARB");
   if (unlikely(len < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramStringARB, cmd_size);
      cmd->target = target;
      cmd->format = format;
      cmd->len = len;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, string, len);
      variable_data += len;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramStringARB");
   CALL_ProgramStringARB(ctx->CurrentServerDispatch, (target, format, len, string));
}


/* CopyTextureSubImage2D: marshalled asynchronously */
struct marshal_cmd_CopyTextureSubImage2D
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLint level;
   GLint xoffset;
   GLint yoffset;
   GLint x;
   GLint y;
   GLsizei width;
   GLsizei height;
};
static inline void
_mesa_unmarshal_CopyTextureSubImage2D(struct gl_context *ctx, const struct marshal_cmd_CopyTextureSubImage2D *cmd)
{
   const GLuint texture = cmd->texture;
   const GLint level = cmd->level;
   const GLint xoffset = cmd->xoffset;
   const GLint yoffset = cmd->yoffset;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   CALL_CopyTextureSubImage2D(ctx->CurrentServerDispatch, (texture, level, xoffset, yoffset, x, y, width, height));
}
static void GLAPIENTRY
_mesa_marshal_CopyTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CopyTextureSubImage2D);
   struct marshal_cmd_CopyTextureSubImage2D *cmd;
   debug_print_marshal("CopyTextureSubImage2D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CopyTextureSubImage2D, cmd_size);
      cmd->texture = texture;
      cmd->level = level;
      cmd->xoffset = xoffset;
      cmd->yoffset = yoffset;
      cmd->x = x;
      cmd->y = y;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CopyTextureSubImage2D");
   CALL_CopyTextureSubImage2D(ctx->CurrentServerDispatch, (texture, level, xoffset, yoffset, x, y, width, height));
}


/* MultiTexCoord4s: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord4s
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLshort s;
   GLshort t;
   GLshort r;
   GLshort q;
};
static inline void
_mesa_unmarshal_MultiTexCoord4s(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord4s *cmd)
{
   const GLenum target = cmd->target;
   const GLshort s = cmd->s;
   const GLshort t = cmd->t;
   const GLshort r = cmd->r;
   const GLshort q = cmd->q;
   CALL_MultiTexCoord4s(ctx->CurrentServerDispatch, (target, s, t, r, q));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord4s);
   struct marshal_cmd_MultiTexCoord4s *cmd;
   debug_print_marshal("MultiTexCoord4s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord4s, cmd_size);
      cmd->target = target;
      cmd->s = s;
      cmd->t = t;
      cmd->r = r;
      cmd->q = q;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord4s");
   CALL_MultiTexCoord4s(ctx->CurrentServerDispatch, (target, s, t, r, q));
}


/* ViewportIndexedf: marshalled asynchronously */
struct marshal_cmd_ViewportIndexedf
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat x;
   GLfloat y;
   GLfloat w;
   GLfloat h;
};
static inline void
_mesa_unmarshal_ViewportIndexedf(struct gl_context *ctx, const struct marshal_cmd_ViewportIndexedf *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat w = cmd->w;
   const GLfloat h = cmd->h;
   CALL_ViewportIndexedf(ctx->CurrentServerDispatch, (index, x, y, w, h));
}
static void GLAPIENTRY
_mesa_marshal_ViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ViewportIndexedf);
   struct marshal_cmd_ViewportIndexedf *cmd;
   debug_print_marshal("ViewportIndexedf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ViewportIndexedf, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->w = w;
      cmd->h = h;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ViewportIndexedf");
   CALL_ViewportIndexedf(ctx->CurrentServerDispatch, (index, x, y, w, h));
}


/* MultiTexCoord4i: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord4i
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLint s;
   GLint t;
   GLint r;
   GLint q;
};
static inline void
_mesa_unmarshal_MultiTexCoord4i(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord4i *cmd)
{
   const GLenum target = cmd->target;
   const GLint s = cmd->s;
   const GLint t = cmd->t;
   const GLint r = cmd->r;
   const GLint q = cmd->q;
   CALL_MultiTexCoord4i(ctx->CurrentServerDispatch, (target, s, t, r, q));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord4i);
   struct marshal_cmd_MultiTexCoord4i *cmd;
   debug_print_marshal("MultiTexCoord4i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord4i, cmd_size);
      cmd->target = target;
      cmd->s = s;
      cmd->t = t;
      cmd->r = r;
      cmd->q = q;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord4i");
   CALL_MultiTexCoord4i(ctx->CurrentServerDispatch, (target, s, t, r, q));
}


/* DebugMessageControl: marshalled asynchronously */
struct marshal_cmd_DebugMessageControl
{
   struct marshal_cmd_base cmd_base;
   GLenum source;
   GLenum type;
   GLenum severity;
   GLsizei count;
   GLboolean enabled;
   /* Next safe_mul(count, 4) bytes are GLuint ids[count] */
};
static inline void
_mesa_unmarshal_DebugMessageControl(struct gl_context *ctx, const struct marshal_cmd_DebugMessageControl *cmd)
{
   const GLenum source = cmd->source;
   const GLenum type = cmd->type;
   const GLenum severity = cmd->severity;
   const GLsizei count = cmd->count;
   const GLboolean enabled = cmd->enabled;
   const GLuint * ids;
   const char *variable_data = (const char *) (cmd + 1);
   ids = (const GLuint *) variable_data;
   variable_data += count * 4;
   CALL_DebugMessageControl(ctx->CurrentServerDispatch, (source, type, severity, count, ids, enabled));
}
static void GLAPIENTRY
_mesa_marshal_DebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DebugMessageControl) + safe_mul(count, 4);
   struct marshal_cmd_DebugMessageControl *cmd;
   debug_print_marshal("DebugMessageControl");
   if (unlikely(safe_mul(count, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DebugMessageControl, cmd_size);
      cmd->source = source;
      cmd->type = type;
      cmd->severity = severity;
      cmd->count = count;
      cmd->enabled = enabled;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, ids, count * 4);
      variable_data += count * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DebugMessageControl");
   CALL_DebugMessageControl(ctx->CurrentServerDispatch, (source, type, severity, count, ids, enabled));
}


/* MultiTexCoord4d: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord4d
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLdouble s;
   GLdouble t;
   GLdouble r;
   GLdouble q;
};
static inline void
_mesa_unmarshal_MultiTexCoord4d(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord4d *cmd)
{
   const GLenum target = cmd->target;
   const GLdouble s = cmd->s;
   const GLdouble t = cmd->t;
   const GLdouble r = cmd->r;
   const GLdouble q = cmd->q;
   CALL_MultiTexCoord4d(ctx->CurrentServerDispatch, (target, s, t, r, q));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord4d);
   struct marshal_cmd_MultiTexCoord4d *cmd;
   debug_print_marshal("MultiTexCoord4d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord4d, cmd_size);
      cmd->target = target;
      cmd->s = s;
      cmd->t = t;
      cmd->r = r;
      cmd->q = q;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord4d");
   CALL_MultiTexCoord4d(ctx->CurrentServerDispatch, (target, s, t, r, q));
}


/* GetHistogram: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetHistogram");
   CALL_GetHistogram(ctx->CurrentServerDispatch, (target, reset, format, type, values));
}


/* Translatex: marshalled asynchronously */
struct marshal_cmd_Translatex
{
   struct marshal_cmd_base cmd_base;
   GLfixed x;
   GLfixed y;
   GLfixed z;
};
static inline void
_mesa_unmarshal_Translatex(struct gl_context *ctx, const struct marshal_cmd_Translatex *cmd)
{
   const GLfixed x = cmd->x;
   const GLfixed y = cmd->y;
   const GLfixed z = cmd->z;
   CALL_Translatex(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_Translatex(GLfixed x, GLfixed y, GLfixed z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Translatex);
   struct marshal_cmd_Translatex *cmd;
   debug_print_marshal("Translatex");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Translatex, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Translatex");
   CALL_Translatex(ctx->CurrentServerDispatch, (x, y, z));
}


/* MultiDrawElementsIndirectCountARB: marshalled asynchronously */
struct marshal_cmd_MultiDrawElementsIndirectCountARB
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLenum type;
   GLintptr indirect;
   GLintptr drawcount;
   GLsizei maxdrawcount;
   GLsizei stride;
};
static inline void
_mesa_unmarshal_MultiDrawElementsIndirectCountARB(struct gl_context *ctx, const struct marshal_cmd_MultiDrawElementsIndirectCountARB *cmd)
{
   const GLenum mode = cmd->mode;
   const GLenum type = cmd->type;
   const GLintptr indirect = cmd->indirect;
   const GLintptr drawcount = cmd->drawcount;
   const GLsizei maxdrawcount = cmd->maxdrawcount;
   const GLsizei stride = cmd->stride;
   CALL_MultiDrawElementsIndirectCountARB(ctx->CurrentServerDispatch, (mode, type, indirect, drawcount, maxdrawcount, stride));
}
static void GLAPIENTRY
_mesa_marshal_MultiDrawElementsIndirectCountARB(GLenum mode, GLenum type, GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiDrawElementsIndirectCountARB);
   struct marshal_cmd_MultiDrawElementsIndirectCountARB *cmd;
   debug_print_marshal("MultiDrawElementsIndirectCountARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiDrawElementsIndirectCountARB, cmd_size);
      cmd->mode = mode;
      cmd->type = type;
      cmd->indirect = indirect;
      cmd->drawcount = drawcount;
      cmd->maxdrawcount = maxdrawcount;
      cmd->stride = stride;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiDrawElementsIndirectCountARB");
   CALL_MultiDrawElementsIndirectCountARB(ctx->CurrentServerDispatch, (mode, type, indirect, drawcount, maxdrawcount, stride));
}


/* Indexsv: marshalled asynchronously */
struct marshal_cmd_Indexsv
{
   struct marshal_cmd_base cmd_base;
   GLshort c[1];
};
static inline void
_mesa_unmarshal_Indexsv(struct gl_context *ctx, const struct marshal_cmd_Indexsv *cmd)
{
   const GLshort * c = cmd->c;
   CALL_Indexsv(ctx->CurrentServerDispatch, (c));
}
static void GLAPIENTRY
_mesa_marshal_Indexsv(const GLshort * c)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Indexsv);
   struct marshal_cmd_Indexsv *cmd;
   debug_print_marshal("Indexsv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Indexsv, cmd_size);
      memcpy(cmd->c, c, 2);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Indexsv");
   CALL_Indexsv(ctx->CurrentServerDispatch, (c));
}


/* VertexAttrib1fvARB: marshalled asynchronously */
struct marshal_cmd_VertexAttrib1fvARB
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat v[1];
};
static inline void
_mesa_unmarshal_VertexAttrib1fvARB(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib1fvARB *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat * v = cmd->v;
   CALL_VertexAttrib1fvARB(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib1fvARB(GLuint index, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib1fvARB);
   struct marshal_cmd_VertexAttrib1fvARB *cmd;
   debug_print_marshal("VertexAttrib1fvARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib1fvARB, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib1fvARB");
   CALL_VertexAttrib1fvARB(ctx->CurrentServerDispatch, (index, v));
}


/* TexCoord2dv: marshalled asynchronously */
struct marshal_cmd_TexCoord2dv
{
   struct marshal_cmd_base cmd_base;
   GLdouble v[2];
};
static inline void
_mesa_unmarshal_TexCoord2dv(struct gl_context *ctx, const struct marshal_cmd_TexCoord2dv *cmd)
{
   const GLdouble * v = cmd->v;
   CALL_TexCoord2dv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord2dv(const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord2dv);
   struct marshal_cmd_TexCoord2dv *cmd;
   debug_print_marshal("TexCoord2dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord2dv, cmd_size);
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord2dv");
   CALL_TexCoord2dv(ctx->CurrentServerDispatch, (v));
}


/* Translated: marshalled asynchronously */
struct marshal_cmd_Translated
{
   struct marshal_cmd_base cmd_base;
   GLdouble x;
   GLdouble y;
   GLdouble z;
};
static inline void
_mesa_unmarshal_Translated(struct gl_context *ctx, const struct marshal_cmd_Translated *cmd)
{
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   CALL_Translated(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_Translated(GLdouble x, GLdouble y, GLdouble z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Translated);
   struct marshal_cmd_Translated *cmd;
   debug_print_marshal("Translated");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Translated, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Translated");
   CALL_Translated(ctx->CurrentServerDispatch, (x, y, z));
}


/* Translatef: marshalled asynchronously */
struct marshal_cmd_Translatef
{
   struct marshal_cmd_base cmd_base;
   GLfloat x;
   GLfloat y;
   GLfloat z;
};
static inline void
_mesa_unmarshal_Translatef(struct gl_context *ctx, const struct marshal_cmd_Translatef *cmd)
{
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   CALL_Translatef(ctx->CurrentServerDispatch, (x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_Translatef(GLfloat x, GLfloat y, GLfloat z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Translatef);
   struct marshal_cmd_Translatef *cmd;
   debug_print_marshal("Translatef");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Translatef, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Translatef");
   CALL_Translatef(ctx->CurrentServerDispatch, (x, y, z));
}


/* MultTransposeMatrixd: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_MultTransposeMatrixd(const GLdouble * m)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MultTransposeMatrixd");
   CALL_MultTransposeMatrixd(ctx->CurrentServerDispatch, (m));
}


/* ProgramUniform4uiv: marshalled asynchronously */
struct marshal_cmd_ProgramUniform4uiv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 16) bytes are GLuint value[count][4] */
};
static inline void
_mesa_unmarshal_ProgramUniform4uiv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform4uiv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLuint * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLuint *) variable_data;
   variable_data += count * 16;
   CALL_ProgramUniform4uiv(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform4uiv) + safe_mul(count, 16);
   struct marshal_cmd_ProgramUniform4uiv *cmd;
   debug_print_marshal("ProgramUniform4uiv");
   if (unlikely(safe_mul(count, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform4uiv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 16);
      variable_data += count * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform4uiv");
   CALL_ProgramUniform4uiv(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* GetPerfCounterInfoINTEL: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetPerfCounterInfoINTEL(GLuint queryId, GLuint counterId, GLuint counterNameLength, GLchar * counterName, GLuint counterDescLength, GLchar * counterDesc, GLuint * counterOffset, GLuint * counterDataSize, GLuint * counterTypeEnum, GLuint * counterDataTypeEnum, GLuint64 * rawCounterMaxValue)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetPerfCounterInfoINTEL");
   CALL_GetPerfCounterInfoINTEL(ctx->CurrentServerDispatch, (queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue));
}


/* RenderMode: marshalled synchronously */
static GLint GLAPIENTRY
_mesa_marshal_RenderMode(GLenum mode)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("RenderMode");
   return CALL_RenderMode(ctx->CurrentServerDispatch, (mode));
}


/* MultiTexCoord1fARB: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord1fARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLfloat s;
};
static inline void
_mesa_unmarshal_MultiTexCoord1fARB(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord1fARB *cmd)
{
   const GLenum target = cmd->target;
   const GLfloat s = cmd->s;
   CALL_MultiTexCoord1fARB(ctx->CurrentServerDispatch, (target, s));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord1fARB(GLenum target, GLfloat s)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord1fARB);
   struct marshal_cmd_MultiTexCoord1fARB *cmd;
   debug_print_marshal("MultiTexCoord1fARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord1fARB, cmd_size);
      cmd->target = target;
      cmd->s = s;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord1fARB");
   CALL_MultiTexCoord1fARB(ctx->CurrentServerDispatch, (target, s));
}


/* SecondaryColor3d: marshalled asynchronously */
struct marshal_cmd_SecondaryColor3d
{
   struct marshal_cmd_base cmd_base;
   GLdouble red;
   GLdouble green;
   GLdouble blue;
};
static inline void
_mesa_unmarshal_SecondaryColor3d(struct gl_context *ctx, const struct marshal_cmd_SecondaryColor3d *cmd)
{
   const GLdouble red = cmd->red;
   const GLdouble green = cmd->green;
   const GLdouble blue = cmd->blue;
   CALL_SecondaryColor3d(ctx->CurrentServerDispatch, (red, green, blue));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColor3d);
   struct marshal_cmd_SecondaryColor3d *cmd;
   debug_print_marshal("SecondaryColor3d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColor3d, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColor3d");
   CALL_SecondaryColor3d(ctx->CurrentServerDispatch, (red, green, blue));
}


/* FramebufferParameteri: marshalled asynchronously */
struct marshal_cmd_FramebufferParameteri
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum pname;
   GLint param;
};
static inline void
_mesa_unmarshal_FramebufferParameteri(struct gl_context *ctx, const struct marshal_cmd_FramebufferParameteri *cmd)
{
   const GLenum target = cmd->target;
   const GLenum pname = cmd->pname;
   const GLint param = cmd->param;
   CALL_FramebufferParameteri(ctx->CurrentServerDispatch, (target, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_FramebufferParameteri(GLenum target, GLenum pname, GLint param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_FramebufferParameteri);
   struct marshal_cmd_FramebufferParameteri *cmd;
   debug_print_marshal("FramebufferParameteri");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_FramebufferParameteri, cmd_size);
      cmd->target = target;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("FramebufferParameteri");
   CALL_FramebufferParameteri(ctx->CurrentServerDispatch, (target, pname, param));
}


/* VertexAttribs4ubvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttribs4ubvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLsizei n;
   /* Next safe_mul(n, 4) bytes are GLubyte v[n][4] */
};
static inline void
_mesa_unmarshal_VertexAttribs4ubvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttribs4ubvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLsizei n = cmd->n;
   const GLubyte * v;
   const char *variable_data = (const char *) (cmd + 1);
   v = (const GLubyte *) variable_data;
   variable_data += n * 4;
   CALL_VertexAttribs4ubvNV(ctx->CurrentServerDispatch, (index, n, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribs4ubvNV(GLuint index, GLsizei n, const GLubyte * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribs4ubvNV) + safe_mul(n, 4);
   struct marshal_cmd_VertexAttribs4ubvNV *cmd;
   debug_print_marshal("VertexAttribs4ubvNV");
   if (unlikely(safe_mul(n, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribs4ubvNV, cmd_size);
      cmd->index = index;
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, v, n * 4);
      variable_data += n * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribs4ubvNV");
   CALL_VertexAttribs4ubvNV(ctx->CurrentServerDispatch, (index, n, v));
}


/* LightModelxv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_LightModelxv(GLenum pname, const GLfixed * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("LightModelxv");
   CALL_LightModelxv(ctx->CurrentServerDispatch, (pname, params));
}


/* CopyTexSubImage1D: marshalled asynchronously */
struct marshal_cmd_CopyTexSubImage1D
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLint level;
   GLint xoffset;
   GLint x;
   GLint y;
   GLsizei width;
};
static inline void
_mesa_unmarshal_CopyTexSubImage1D(struct gl_context *ctx, const struct marshal_cmd_CopyTexSubImage1D *cmd)
{
   const GLenum target = cmd->target;
   const GLint level = cmd->level;
   const GLint xoffset = cmd->xoffset;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLsizei width = cmd->width;
   CALL_CopyTexSubImage1D(ctx->CurrentServerDispatch, (target, level, xoffset, x, y, width));
}
static void GLAPIENTRY
_mesa_marshal_CopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CopyTexSubImage1D);
   struct marshal_cmd_CopyTexSubImage1D *cmd;
   debug_print_marshal("CopyTexSubImage1D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CopyTexSubImage1D, cmd_size);
      cmd->target = target;
      cmd->level = level;
      cmd->xoffset = xoffset;
      cmd->x = x;
      cmd->y = y;
      cmd->width = width;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CopyTexSubImage1D");
   CALL_CopyTexSubImage1D(ctx->CurrentServerDispatch, (target, level, xoffset, x, y, width));
}


/* TextureSubImage3D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TextureSubImage3D");
   CALL_TextureSubImage3D(ctx->CurrentServerDispatch, (texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels));
}


/* StencilFunc: marshalled asynchronously */
struct marshal_cmd_StencilFunc
{
   struct marshal_cmd_base cmd_base;
   GLenum func;
   GLint ref;
   GLuint mask;
};
static inline void
_mesa_unmarshal_StencilFunc(struct gl_context *ctx, const struct marshal_cmd_StencilFunc *cmd)
{
   const GLenum func = cmd->func;
   const GLint ref = cmd->ref;
   const GLuint mask = cmd->mask;
   CALL_StencilFunc(ctx->CurrentServerDispatch, (func, ref, mask));
}
static void GLAPIENTRY
_mesa_marshal_StencilFunc(GLenum func, GLint ref, GLuint mask)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_StencilFunc);
   struct marshal_cmd_StencilFunc *cmd;
   debug_print_marshal("StencilFunc");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_StencilFunc, cmd_size);
      cmd->func = func;
      cmd->ref = ref;
      cmd->mask = mask;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("StencilFunc");
   CALL_StencilFunc(ctx->CurrentServerDispatch, (func, ref, mask));
}


/* CopyPixels: marshalled asynchronously */
struct marshal_cmd_CopyPixels
{
   struct marshal_cmd_base cmd_base;
   GLint x;
   GLint y;
   GLsizei width;
   GLsizei height;
   GLenum type;
};
static inline void
_mesa_unmarshal_CopyPixels(struct gl_context *ctx, const struct marshal_cmd_CopyPixels *cmd)
{
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLenum type = cmd->type;
   CALL_CopyPixels(ctx->CurrentServerDispatch, (x, y, width, height, type));
}
static void GLAPIENTRY
_mesa_marshal_CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CopyPixels);
   struct marshal_cmd_CopyPixels *cmd;
   debug_print_marshal("CopyPixels");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CopyPixels, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->width = width;
      cmd->height = height;
      cmd->type = type;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CopyPixels");
   CALL_CopyPixels(ctx->CurrentServerDispatch, (x, y, width, height, type));
}


/* TexGenxvOES: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexGenxvOES(GLenum coord, GLenum pname, const GLfixed * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexGenxvOES");
   CALL_TexGenxvOES(ctx->CurrentServerDispatch, (coord, pname, params));
}


/* GetTextureLevelParameterfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTextureLevelParameterfv(GLuint texture, GLint level, GLenum pname, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTextureLevelParameterfv");
   CALL_GetTextureLevelParameterfv(ctx->CurrentServerDispatch, (texture, level, pname, params));
}


/* VertexAttrib4Nubv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4Nubv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLubyte v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4Nubv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4Nubv *cmd)
{
   const GLuint index = cmd->index;
   const GLubyte * v = cmd->v;
   CALL_VertexAttrib4Nubv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4Nubv(GLuint index, const GLubyte * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4Nubv);
   struct marshal_cmd_VertexAttrib4Nubv *cmd;
   debug_print_marshal("VertexAttrib4Nubv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4Nubv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4Nubv");
   CALL_VertexAttrib4Nubv(ctx->CurrentServerDispatch, (index, v));
}


/* UniformMatrix4x2dv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix4x2dv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 64) bytes are GLdouble value[count][8] */
};
static inline void
_mesa_unmarshal_UniformMatrix4x2dv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix4x2dv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 64;
   CALL_UniformMatrix4x2dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix4x2dv) + safe_mul(count, 64);
   struct marshal_cmd_UniformMatrix4x2dv *cmd;
   debug_print_marshal("UniformMatrix4x2dv");
   if (unlikely(safe_mul(count, 64) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix4x2dv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 64);
      variable_data += count * 64;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix4x2dv");
   CALL_UniformMatrix4x2dv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* VertexAttribPointer: marshalled asynchronously */
struct marshal_cmd_VertexAttribPointer
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLint size;
   GLenum type;
   GLboolean normalized;
   GLsizei stride;
   const GLvoid * pointer;
};
static inline void
_mesa_unmarshal_VertexAttribPointer(struct gl_context *ctx, const struct marshal_cmd_VertexAttribPointer *cmd)
{
   const GLuint index = cmd->index;
   const GLint size = cmd->size;
   const GLenum type = cmd->type;
   const GLboolean normalized = cmd->normalized;
   const GLsizei stride = cmd->stride;
   const GLvoid * pointer = cmd->pointer;
   CALL_VertexAttribPointer(ctx->CurrentServerDispatch, (index, size, type, normalized, stride, pointer));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribPointer);
   struct marshal_cmd_VertexAttribPointer *cmd;
   debug_print_marshal("VertexAttribPointer");
   if (_mesa_glthread_is_non_vbo_vertex_attrib_pointer(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("VertexAttribPointer");
      CALL_VertexAttribPointer(ctx->CurrentServerDispatch, (index, size, type, normalized, stride, pointer));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribPointer, cmd_size);
      cmd->index = index;
      cmd->size = size;
      cmd->type = type;
      cmd->normalized = normalized;
      cmd->stride = stride;
      cmd->pointer = pointer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribPointer");
   CALL_VertexAttribPointer(ctx->CurrentServerDispatch, (index, size, type, normalized, stride, pointer));
}


/* IndexMask: marshalled asynchronously */
struct marshal_cmd_IndexMask
{
   struct marshal_cmd_base cmd_base;
   GLuint mask;
};
static inline void
_mesa_unmarshal_IndexMask(struct gl_context *ctx, const struct marshal_cmd_IndexMask *cmd)
{
   const GLuint mask = cmd->mask;
   CALL_IndexMask(ctx->CurrentServerDispatch, (mask));
}
static void GLAPIENTRY
_mesa_marshal_IndexMask(GLuint mask)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_IndexMask);
   struct marshal_cmd_IndexMask *cmd;
   debug_print_marshal("IndexMask");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_IndexMask, cmd_size);
      cmd->mask = mask;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("IndexMask");
   CALL_IndexMask(ctx->CurrentServerDispatch, (mask));
}


/* VertexAttribIFormat: marshalled asynchronously */
struct marshal_cmd_VertexAttribIFormat
{
   struct marshal_cmd_base cmd_base;
   GLuint attribindex;
   GLint size;
   GLenum type;
   GLuint relativeoffset;
};
static inline void
_mesa_unmarshal_VertexAttribIFormat(struct gl_context *ctx, const struct marshal_cmd_VertexAttribIFormat *cmd)
{
   const GLuint attribindex = cmd->attribindex;
   const GLint size = cmd->size;
   const GLenum type = cmd->type;
   const GLuint relativeoffset = cmd->relativeoffset;
   CALL_VertexAttribIFormat(ctx->CurrentServerDispatch, (attribindex, size, type, relativeoffset));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribIFormat);
   struct marshal_cmd_VertexAttribIFormat *cmd;
   debug_print_marshal("VertexAttribIFormat");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribIFormat, cmd_size);
      cmd->attribindex = attribindex;
      cmd->size = size;
      cmd->type = type;
      cmd->relativeoffset = relativeoffset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribIFormat");
   CALL_VertexAttribIFormat(ctx->CurrentServerDispatch, (attribindex, size, type, relativeoffset));
}


/* DrawArraysInstancedBaseInstance: marshalled asynchronously */
struct marshal_cmd_DrawArraysInstancedBaseInstance
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLint first;
   GLsizei count;
   GLsizei primcount;
   GLuint baseinstance;
};
static inline void
_mesa_unmarshal_DrawArraysInstancedBaseInstance(struct gl_context *ctx, const struct marshal_cmd_DrawArraysInstancedBaseInstance *cmd)
{
   const GLenum mode = cmd->mode;
   const GLint first = cmd->first;
   const GLsizei count = cmd->count;
   const GLsizei primcount = cmd->primcount;
   const GLuint baseinstance = cmd->baseinstance;
   CALL_DrawArraysInstancedBaseInstance(ctx->CurrentServerDispatch, (mode, first, count, primcount, baseinstance));
}
static void GLAPIENTRY
_mesa_marshal_DrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei primcount, GLuint baseinstance)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawArraysInstancedBaseInstance);
   struct marshal_cmd_DrawArraysInstancedBaseInstance *cmd;
   debug_print_marshal("DrawArraysInstancedBaseInstance");
   if (_mesa_glthread_is_non_vbo_draw_elements(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("DrawArraysInstancedBaseInstance");
      CALL_DrawArraysInstancedBaseInstance(ctx->CurrentServerDispatch, (mode, first, count, primcount, baseinstance));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawArraysInstancedBaseInstance, cmd_size);
      cmd->mode = mode;
      cmd->first = first;
      cmd->count = count;
      cmd->primcount = primcount;
      cmd->baseinstance = baseinstance;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawArraysInstancedBaseInstance");
   CALL_DrawArraysInstancedBaseInstance(ctx->CurrentServerDispatch, (mode, first, count, primcount, baseinstance));
}


/* TextureStorageMem3DMultisampleEXT: marshalled asynchronously */
struct marshal_cmd_TextureStorageMem3DMultisampleEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLsizei samples;
   GLenum internalFormat;
   GLsizei width;
   GLsizei height;
   GLsizei depth;
   GLboolean fixedSampleLocations;
   GLuint memory;
   GLuint64 offset;
};
static inline void
_mesa_unmarshal_TextureStorageMem3DMultisampleEXT(struct gl_context *ctx, const struct marshal_cmd_TextureStorageMem3DMultisampleEXT *cmd)
{
   const GLuint texture = cmd->texture;
   const GLsizei samples = cmd->samples;
   const GLenum internalFormat = cmd->internalFormat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLsizei depth = cmd->depth;
   const GLboolean fixedSampleLocations = cmd->fixedSampleLocations;
   const GLuint memory = cmd->memory;
   const GLuint64 offset = cmd->offset;
   CALL_TextureStorageMem3DMultisampleEXT(ctx->CurrentServerDispatch, (texture, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset));
}
static void GLAPIENTRY
_mesa_marshal_TextureStorageMem3DMultisampleEXT(GLuint texture, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureStorageMem3DMultisampleEXT);
   struct marshal_cmd_TextureStorageMem3DMultisampleEXT *cmd;
   debug_print_marshal("TextureStorageMem3DMultisampleEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureStorageMem3DMultisampleEXT, cmd_size);
      cmd->texture = texture;
      cmd->samples = samples;
      cmd->internalFormat = internalFormat;
      cmd->width = width;
      cmd->height = height;
      cmd->depth = depth;
      cmd->fixedSampleLocations = fixedSampleLocations;
      cmd->memory = memory;
      cmd->offset = offset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureStorageMem3DMultisampleEXT");
   CALL_TextureStorageMem3DMultisampleEXT(ctx->CurrentServerDispatch, (texture, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset));
}


/* CompressedTextureSubImage3D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CompressedTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CompressedTextureSubImage3D");
   CALL_CompressedTextureSubImage3D(ctx->CurrentServerDispatch, (texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data));
}


/* PopAttrib: marshalled asynchronously */
struct marshal_cmd_PopAttrib
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_PopAttrib(struct gl_context *ctx, const struct marshal_cmd_PopAttrib *cmd)
{
   CALL_PopAttrib(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_PopAttrib(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PopAttrib);
   struct marshal_cmd_PopAttrib *cmd;
   debug_print_marshal("PopAttrib");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PopAttrib, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PopAttrib");
   CALL_PopAttrib(ctx->CurrentServerDispatch, ());
}


/* Uniform3ui: marshalled asynchronously */
struct marshal_cmd_Uniform3ui
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLuint x;
   GLuint y;
   GLuint z;
};
static inline void
_mesa_unmarshal_Uniform3ui(struct gl_context *ctx, const struct marshal_cmd_Uniform3ui *cmd)
{
   const GLint location = cmd->location;
   const GLuint x = cmd->x;
   const GLuint y = cmd->y;
   const GLuint z = cmd->z;
   CALL_Uniform3ui(ctx->CurrentServerDispatch, (location, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_Uniform3ui(GLint location, GLuint x, GLuint y, GLuint z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform3ui);
   struct marshal_cmd_Uniform3ui *cmd;
   debug_print_marshal("Uniform3ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform3ui, cmd_size);
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform3ui");
   CALL_Uniform3ui(ctx->CurrentServerDispatch, (location, x, y, z));
}


/* DeletePerfMonitorsAMD: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_DeletePerfMonitorsAMD(GLsizei n, GLuint * monitors)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("DeletePerfMonitorsAMD");
   CALL_DeletePerfMonitorsAMD(ctx->CurrentServerDispatch, (n, monitors));
}


/* Color4dv: marshalled asynchronously */
struct marshal_cmd_Color4dv
{
   struct marshal_cmd_base cmd_base;
   GLdouble v[4];
};
static inline void
_mesa_unmarshal_Color4dv(struct gl_context *ctx, const struct marshal_cmd_Color4dv *cmd)
{
   const GLdouble * v = cmd->v;
   CALL_Color4dv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Color4dv(const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color4dv);
   struct marshal_cmd_Color4dv *cmd;
   debug_print_marshal("Color4dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color4dv, cmd_size);
      memcpy(cmd->v, v, 32);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color4dv");
   CALL_Color4dv(ctx->CurrentServerDispatch, (v));
}


/* DisableVertexAttribArray: marshalled asynchronously */
struct marshal_cmd_DisableVertexAttribArray
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
};
static inline void
_mesa_unmarshal_DisableVertexAttribArray(struct gl_context *ctx, const struct marshal_cmd_DisableVertexAttribArray *cmd)
{
   const GLuint index = cmd->index;
   CALL_DisableVertexAttribArray(ctx->CurrentServerDispatch, (index));
}
static void GLAPIENTRY
_mesa_marshal_DisableVertexAttribArray(GLuint index)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DisableVertexAttribArray);
   struct marshal_cmd_DisableVertexAttribArray *cmd;
   debug_print_marshal("DisableVertexAttribArray");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DisableVertexAttribArray, cmd_size);
      cmd->index = index;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DisableVertexAttribArray");
   CALL_DisableVertexAttribArray(ctx->CurrentServerDispatch, (index));
}


/* ProgramUniformMatrix3x2fv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix3x2fv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 24) bytes are GLfloat value[count][6] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix3x2fv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix3x2fv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 24;
   CALL_ProgramUniformMatrix3x2fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix3x2fv) + safe_mul(count, 24);
   struct marshal_cmd_ProgramUniformMatrix3x2fv *cmd;
   debug_print_marshal("ProgramUniformMatrix3x2fv");
   if (unlikely(safe_mul(count, 24) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix3x2fv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 24);
      variable_data += count * 24;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix3x2fv");
   CALL_ProgramUniformMatrix3x2fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* GetDoublei_v: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetDoublei_v(GLenum target, GLuint index, GLdouble * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetDoublei_v");
   CALL_GetDoublei_v(ctx->CurrentServerDispatch, (target, index, data));
}


/* IsTransformFeedback: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsTransformFeedback(GLuint id)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsTransformFeedback");
   return CALL_IsTransformFeedback(ctx->CurrentServerDispatch, (id));
}


/* GetMemoryObjectParameterivEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetMemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetMemoryObjectParameterivEXT");
   CALL_GetMemoryObjectParameterivEXT(ctx->CurrentServerDispatch, (memoryObject, pname, params));
}


/* ClipPlanex: marshalled asynchronously */
struct marshal_cmd_ClipPlanex
{
   struct marshal_cmd_base cmd_base;
   GLenum plane;
   GLfixed equation[4];
};
static inline void
_mesa_unmarshal_ClipPlanex(struct gl_context *ctx, const struct marshal_cmd_ClipPlanex *cmd)
{
   const GLenum plane = cmd->plane;
   const GLfixed * equation = cmd->equation;
   CALL_ClipPlanex(ctx->CurrentServerDispatch, (plane, equation));
}
static void GLAPIENTRY
_mesa_marshal_ClipPlanex(GLenum plane, const GLfixed * equation)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ClipPlanex);
   struct marshal_cmd_ClipPlanex *cmd;
   debug_print_marshal("ClipPlanex");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ClipPlanex, cmd_size);
      cmd->plane = plane;
      memcpy(cmd->equation, equation, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ClipPlanex");
   CALL_ClipPlanex(ctx->CurrentServerDispatch, (plane, equation));
}


/* GetLightfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetLightfv(GLenum light, GLenum pname, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetLightfv");
   CALL_GetLightfv(ctx->CurrentServerDispatch, (light, pname, params));
}


/* ClipPlanef: marshalled asynchronously */
struct marshal_cmd_ClipPlanef
{
   struct marshal_cmd_base cmd_base;
   GLenum plane;
   GLfloat equation[4];
};
static inline void
_mesa_unmarshal_ClipPlanef(struct gl_context *ctx, const struct marshal_cmd_ClipPlanef *cmd)
{
   const GLenum plane = cmd->plane;
   const GLfloat * equation = cmd->equation;
   CALL_ClipPlanef(ctx->CurrentServerDispatch, (plane, equation));
}
static void GLAPIENTRY
_mesa_marshal_ClipPlanef(GLenum plane, const GLfloat * equation)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ClipPlanef);
   struct marshal_cmd_ClipPlanef *cmd;
   debug_print_marshal("ClipPlanef");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ClipPlanef, cmd_size);
      cmd->plane = plane;
      memcpy(cmd->equation, equation, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ClipPlanef");
   CALL_ClipPlanef(ctx->CurrentServerDispatch, (plane, equation));
}


/* ProgramUniform1ui: marshalled asynchronously */
struct marshal_cmd_ProgramUniform1ui
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLuint x;
};
static inline void
_mesa_unmarshal_ProgramUniform1ui(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform1ui *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLuint x = cmd->x;
   CALL_ProgramUniform1ui(ctx->CurrentServerDispatch, (program, location, x));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform1ui(GLuint program, GLint location, GLuint x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform1ui);
   struct marshal_cmd_ProgramUniform1ui *cmd;
   debug_print_marshal("ProgramUniform1ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform1ui, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform1ui");
   CALL_ProgramUniform1ui(ctx->CurrentServerDispatch, (program, location, x));
}


/* SecondaryColorPointer: marshalled asynchronously */
struct marshal_cmd_SecondaryColorPointer
{
   struct marshal_cmd_base cmd_base;
   GLint size;
   GLenum type;
   GLsizei stride;
   const GLvoid * pointer;
};
static inline void
_mesa_unmarshal_SecondaryColorPointer(struct gl_context *ctx, const struct marshal_cmd_SecondaryColorPointer *cmd)
{
   const GLint size = cmd->size;
   const GLenum type = cmd->type;
   const GLsizei stride = cmd->stride;
   const GLvoid * pointer = cmd->pointer;
   CALL_SecondaryColorPointer(ctx->CurrentServerDispatch, (size, type, stride, pointer));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColorPointer);
   struct marshal_cmd_SecondaryColorPointer *cmd;
   debug_print_marshal("SecondaryColorPointer");
   if (_mesa_glthread_is_non_vbo_vertex_attrib_pointer(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("SecondaryColorPointer");
      CALL_SecondaryColorPointer(ctx->CurrentServerDispatch, (size, type, stride, pointer));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColorPointer, cmd_size);
      cmd->size = size;
      cmd->type = type;
      cmd->stride = stride;
      cmd->pointer = pointer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColorPointer");
   CALL_SecondaryColorPointer(ctx->CurrentServerDispatch, (size, type, stride, pointer));
}


/* LineStipple: marshalled asynchronously */
struct marshal_cmd_LineStipple
{
   struct marshal_cmd_base cmd_base;
   GLint factor;
   GLushort pattern;
};
static inline void
_mesa_unmarshal_LineStipple(struct gl_context *ctx, const struct marshal_cmd_LineStipple *cmd)
{
   const GLint factor = cmd->factor;
   const GLushort pattern = cmd->pattern;
   CALL_LineStipple(ctx->CurrentServerDispatch, (factor, pattern));
}
static void GLAPIENTRY
_mesa_marshal_LineStipple(GLint factor, GLushort pattern)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_LineStipple);
   struct marshal_cmd_LineStipple *cmd;
   debug_print_marshal("LineStipple");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_LineStipple, cmd_size);
      cmd->factor = factor;
      cmd->pattern = pattern;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("LineStipple");
   CALL_LineStipple(ctx->CurrentServerDispatch, (factor, pattern));
}


/* BeginFragmentShaderATI: marshalled asynchronously */
struct marshal_cmd_BeginFragmentShaderATI
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_BeginFragmentShaderATI(struct gl_context *ctx, const struct marshal_cmd_BeginFragmentShaderATI *cmd)
{
   CALL_BeginFragmentShaderATI(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_BeginFragmentShaderATI(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BeginFragmentShaderATI);
   struct marshal_cmd_BeginFragmentShaderATI *cmd;
   debug_print_marshal("BeginFragmentShaderATI");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BeginFragmentShaderATI, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BeginFragmentShaderATI");
   CALL_BeginFragmentShaderATI(ctx->CurrentServerDispatch, ());
}


/* GenRenderbuffers: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GenRenderbuffers(GLsizei n, GLuint * renderbuffers)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GenRenderbuffers");
   CALL_GenRenderbuffers(ctx->CurrentServerDispatch, (n, renderbuffers));
}


/* GetMinmaxParameterfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetMinmaxParameterfv");
   CALL_GetMinmaxParameterfv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* TextureStorageMem2DEXT: marshalled asynchronously */
struct marshal_cmd_TextureStorageMem2DEXT
{
   struct marshal_cmd_base cmd_base;
   GLenum texture;
   GLsizei levels;
   GLenum internalFormat;
   GLsizei width;
   GLsizei height;
   GLuint memory;
   GLuint64 offset;
};
static inline void
_mesa_unmarshal_TextureStorageMem2DEXT(struct gl_context *ctx, const struct marshal_cmd_TextureStorageMem2DEXT *cmd)
{
   const GLenum texture = cmd->texture;
   const GLsizei levels = cmd->levels;
   const GLenum internalFormat = cmd->internalFormat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLuint memory = cmd->memory;
   const GLuint64 offset = cmd->offset;
   CALL_TextureStorageMem2DEXT(ctx->CurrentServerDispatch, (texture, levels, internalFormat, width, height, memory, offset));
}
static void GLAPIENTRY
_mesa_marshal_TextureStorageMem2DEXT(GLenum texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLuint memory, GLuint64 offset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureStorageMem2DEXT);
   struct marshal_cmd_TextureStorageMem2DEXT *cmd;
   debug_print_marshal("TextureStorageMem2DEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureStorageMem2DEXT, cmd_size);
      cmd->texture = texture;
      cmd->levels = levels;
      cmd->internalFormat = internalFormat;
      cmd->width = width;
      cmd->height = height;
      cmd->memory = memory;
      cmd->offset = offset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureStorageMem2DEXT");
   CALL_TextureStorageMem2DEXT(ctx->CurrentServerDispatch, (texture, levels, internalFormat, width, height, memory, offset));
}


/* IsEnabledi: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsEnabledi(GLenum target, GLuint index)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsEnabledi");
   return CALL_IsEnabledi(ctx->CurrentServerDispatch, (target, index));
}


/* WaitSync: marshalled asynchronously */
struct marshal_cmd_WaitSync
{
   struct marshal_cmd_base cmd_base;
   GLsync sync;
   GLbitfield flags;
   GLuint64 timeout;
};
static inline void
_mesa_unmarshal_WaitSync(struct gl_context *ctx, const struct marshal_cmd_WaitSync *cmd)
{
   const GLsync sync = cmd->sync;
   const GLbitfield flags = cmd->flags;
   const GLuint64 timeout = cmd->timeout;
   CALL_WaitSync(ctx->CurrentServerDispatch, (sync, flags, timeout));
}
static void GLAPIENTRY
_mesa_marshal_WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_WaitSync);
   struct marshal_cmd_WaitSync *cmd;
   debug_print_marshal("WaitSync");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_WaitSync, cmd_size);
      cmd->sync = sync;
      cmd->flags = flags;
      cmd->timeout = timeout;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("WaitSync");
   CALL_WaitSync(ctx->CurrentServerDispatch, (sync, flags, timeout));
}


/* GetVertexAttribPointerv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid ** pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetVertexAttribPointerv");
   CALL_GetVertexAttribPointerv(ctx->CurrentServerDispatch, (index, pname, pointer));
}


/* Uniform1i64vARB: marshalled asynchronously */
struct marshal_cmd_Uniform1i64vARB
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 8) bytes are GLint64 value[count] */
};
static inline void
_mesa_unmarshal_Uniform1i64vARB(struct gl_context *ctx, const struct marshal_cmd_Uniform1i64vARB *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLint64 * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLint64 *) variable_data;
   variable_data += count * 8;
   CALL_Uniform1i64vARB(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform1i64vARB(GLint location, GLsizei count, const GLint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform1i64vARB) + safe_mul(count, 8);
   struct marshal_cmd_Uniform1i64vARB *cmd;
   debug_print_marshal("Uniform1i64vARB");
   if (unlikely(safe_mul(count, 8) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform1i64vARB, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 8);
      variable_data += count * 8;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform1i64vARB");
   CALL_Uniform1i64vARB(ctx->CurrentServerDispatch, (location, count, value));
}


/* CreatePerfQueryINTEL: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CreatePerfQueryINTEL(GLuint queryId, GLuint * queryHandle)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CreatePerfQueryINTEL");
   CALL_CreatePerfQueryINTEL(ctx->CurrentServerDispatch, (queryId, queryHandle));
}


/* NewList: marshalled asynchronously */
struct marshal_cmd_NewList
{
   struct marshal_cmd_base cmd_base;
   GLuint list;
   GLenum mode;
};
static inline void
_mesa_unmarshal_NewList(struct gl_context *ctx, const struct marshal_cmd_NewList *cmd)
{
   const GLuint list = cmd->list;
   const GLenum mode = cmd->mode;
   CALL_NewList(ctx->CurrentServerDispatch, (list, mode));
}
static void GLAPIENTRY
_mesa_marshal_NewList(GLuint list, GLenum mode)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_NewList);
   struct marshal_cmd_NewList *cmd;
   debug_print_marshal("NewList");
   if (true) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("NewList");
      CALL_NewList(ctx->CurrentServerDispatch, (list, mode));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_NewList, cmd_size);
      cmd->list = list;
      cmd->mode = mode;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("NewList");
   CALL_NewList(ctx->CurrentServerDispatch, (list, mode));
}


/* TexBuffer: marshalled asynchronously */
struct marshal_cmd_TexBuffer
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum internalFormat;
   GLuint buffer;
};
static inline void
_mesa_unmarshal_TexBuffer(struct gl_context *ctx, const struct marshal_cmd_TexBuffer *cmd)
{
   const GLenum target = cmd->target;
   const GLenum internalFormat = cmd->internalFormat;
   const GLuint buffer = cmd->buffer;
   CALL_TexBuffer(ctx->CurrentServerDispatch, (target, internalFormat, buffer));
}
static void GLAPIENTRY
_mesa_marshal_TexBuffer(GLenum target, GLenum internalFormat, GLuint buffer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexBuffer);
   struct marshal_cmd_TexBuffer *cmd;
   debug_print_marshal("TexBuffer");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexBuffer, cmd_size);
      cmd->target = target;
      cmd->internalFormat = internalFormat;
      cmd->buffer = buffer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexBuffer");
   CALL_TexBuffer(ctx->CurrentServerDispatch, (target, internalFormat, buffer));
}


/* TexCoord4sv: marshalled asynchronously */
struct marshal_cmd_TexCoord4sv
{
   struct marshal_cmd_base cmd_base;
   GLshort v[4];
};
static inline void
_mesa_unmarshal_TexCoord4sv(struct gl_context *ctx, const struct marshal_cmd_TexCoord4sv *cmd)
{
   const GLshort * v = cmd->v;
   CALL_TexCoord4sv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord4sv(const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord4sv);
   struct marshal_cmd_TexCoord4sv *cmd;
   debug_print_marshal("TexCoord4sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord4sv, cmd_size);
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord4sv");
   CALL_TexCoord4sv(ctx->CurrentServerDispatch, (v));
}


/* TexCoord1f: marshalled asynchronously */
struct marshal_cmd_TexCoord1f
{
   struct marshal_cmd_base cmd_base;
   GLfloat s;
};
static inline void
_mesa_unmarshal_TexCoord1f(struct gl_context *ctx, const struct marshal_cmd_TexCoord1f *cmd)
{
   const GLfloat s = cmd->s;
   CALL_TexCoord1f(ctx->CurrentServerDispatch, (s));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord1f(GLfloat s)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord1f);
   struct marshal_cmd_TexCoord1f *cmd;
   debug_print_marshal("TexCoord1f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord1f, cmd_size);
      cmd->s = s;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord1f");
   CALL_TexCoord1f(ctx->CurrentServerDispatch, (s));
}


/* TexCoord1d: marshalled asynchronously */
struct marshal_cmd_TexCoord1d
{
   struct marshal_cmd_base cmd_base;
   GLdouble s;
};
static inline void
_mesa_unmarshal_TexCoord1d(struct gl_context *ctx, const struct marshal_cmd_TexCoord1d *cmd)
{
   const GLdouble s = cmd->s;
   CALL_TexCoord1d(ctx->CurrentServerDispatch, (s));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord1d(GLdouble s)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord1d);
   struct marshal_cmd_TexCoord1d *cmd;
   debug_print_marshal("TexCoord1d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord1d, cmd_size);
      cmd->s = s;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord1d");
   CALL_TexCoord1d(ctx->CurrentServerDispatch, (s));
}


/* TexCoord1i: marshalled asynchronously */
struct marshal_cmd_TexCoord1i
{
   struct marshal_cmd_base cmd_base;
   GLint s;
};
static inline void
_mesa_unmarshal_TexCoord1i(struct gl_context *ctx, const struct marshal_cmd_TexCoord1i *cmd)
{
   const GLint s = cmd->s;
   CALL_TexCoord1i(ctx->CurrentServerDispatch, (s));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord1i(GLint s)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord1i);
   struct marshal_cmd_TexCoord1i *cmd;
   debug_print_marshal("TexCoord1i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord1i, cmd_size);
      cmd->s = s;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord1i");
   CALL_TexCoord1i(ctx->CurrentServerDispatch, (s));
}


/* GetnUniformfvARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnUniformfvARB(GLuint program, GLint location, GLsizei bufSize, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnUniformfvARB");
   CALL_GetnUniformfvARB(ctx->CurrentServerDispatch, (program, location, bufSize, params));
}


/* TexCoord1s: marshalled asynchronously */
struct marshal_cmd_TexCoord1s
{
   struct marshal_cmd_base cmd_base;
   GLshort s;
};
static inline void
_mesa_unmarshal_TexCoord1s(struct gl_context *ctx, const struct marshal_cmd_TexCoord1s *cmd)
{
   const GLshort s = cmd->s;
   CALL_TexCoord1s(ctx->CurrentServerDispatch, (s));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord1s(GLshort s)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord1s);
   struct marshal_cmd_TexCoord1s *cmd;
   debug_print_marshal("TexCoord1s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord1s, cmd_size);
      cmd->s = s;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord1s");
   CALL_TexCoord1s(ctx->CurrentServerDispatch, (s));
}


/* Uniform1ui: marshalled asynchronously */
struct marshal_cmd_Uniform1ui
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLuint x;
};
static inline void
_mesa_unmarshal_Uniform1ui(struct gl_context *ctx, const struct marshal_cmd_Uniform1ui *cmd)
{
   const GLint location = cmd->location;
   const GLuint x = cmd->x;
   CALL_Uniform1ui(ctx->CurrentServerDispatch, (location, x));
}
static void GLAPIENTRY
_mesa_marshal_Uniform1ui(GLint location, GLuint x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform1ui);
   struct marshal_cmd_Uniform1ui *cmd;
   debug_print_marshal("Uniform1ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform1ui, cmd_size);
      cmd->location = location;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform1ui");
   CALL_Uniform1ui(ctx->CurrentServerDispatch, (location, x));
}


/* TexStorage1D: marshalled asynchronously */
struct marshal_cmd_TexStorage1D
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei levels;
   GLenum internalFormat;
   GLsizei width;
};
static inline void
_mesa_unmarshal_TexStorage1D(struct gl_context *ctx, const struct marshal_cmd_TexStorage1D *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei levels = cmd->levels;
   const GLenum internalFormat = cmd->internalFormat;
   const GLsizei width = cmd->width;
   CALL_TexStorage1D(ctx->CurrentServerDispatch, (target, levels, internalFormat, width));
}
static void GLAPIENTRY
_mesa_marshal_TexStorage1D(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexStorage1D);
   struct marshal_cmd_TexStorage1D *cmd;
   debug_print_marshal("TexStorage1D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexStorage1D, cmd_size);
      cmd->target = target;
      cmd->levels = levels;
      cmd->internalFormat = internalFormat;
      cmd->width = width;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexStorage1D");
   CALL_TexStorage1D(ctx->CurrentServerDispatch, (target, levels, internalFormat, width));
}


/* BlitFramebuffer: marshalled asynchronously */
struct marshal_cmd_BlitFramebuffer
{
   struct marshal_cmd_base cmd_base;
   GLint srcX0;
   GLint srcY0;
   GLint srcX1;
   GLint srcY1;
   GLint dstX0;
   GLint dstY0;
   GLint dstX1;
   GLint dstY1;
   GLbitfield mask;
   GLenum filter;
};
static inline void
_mesa_unmarshal_BlitFramebuffer(struct gl_context *ctx, const struct marshal_cmd_BlitFramebuffer *cmd)
{
   const GLint srcX0 = cmd->srcX0;
   const GLint srcY0 = cmd->srcY0;
   const GLint srcX1 = cmd->srcX1;
   const GLint srcY1 = cmd->srcY1;
   const GLint dstX0 = cmd->dstX0;
   const GLint dstY0 = cmd->dstY0;
   const GLint dstX1 = cmd->dstX1;
   const GLint dstY1 = cmd->dstY1;
   const GLbitfield mask = cmd->mask;
   const GLenum filter = cmd->filter;
   CALL_BlitFramebuffer(ctx->CurrentServerDispatch, (srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter));
}
static void GLAPIENTRY
_mesa_marshal_BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BlitFramebuffer);
   struct marshal_cmd_BlitFramebuffer *cmd;
   debug_print_marshal("BlitFramebuffer");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BlitFramebuffer, cmd_size);
      cmd->srcX0 = srcX0;
      cmd->srcY0 = srcY0;
      cmd->srcX1 = srcX1;
      cmd->srcY1 = srcY1;
      cmd->dstX0 = dstX0;
      cmd->dstY0 = dstY0;
      cmd->dstX1 = dstX1;
      cmd->dstY1 = dstY1;
      cmd->mask = mask;
      cmd->filter = filter;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BlitFramebuffer");
   CALL_BlitFramebuffer(ctx->CurrentServerDispatch, (srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter));
}


/* TextureParameterf: marshalled asynchronously */
struct marshal_cmd_TextureParameterf
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLenum pname;
   GLfloat param;
};
static inline void
_mesa_unmarshal_TextureParameterf(struct gl_context *ctx, const struct marshal_cmd_TextureParameterf *cmd)
{
   const GLuint texture = cmd->texture;
   const GLenum pname = cmd->pname;
   const GLfloat param = cmd->param;
   CALL_TextureParameterf(ctx->CurrentServerDispatch, (texture, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_TextureParameterf(GLuint texture, GLenum pname, GLfloat param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureParameterf);
   struct marshal_cmd_TextureParameterf *cmd;
   debug_print_marshal("TextureParameterf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureParameterf, cmd_size);
      cmd->texture = texture;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureParameterf");
   CALL_TextureParameterf(ctx->CurrentServerDispatch, (texture, pname, param));
}


/* FramebufferTexture1D: marshalled asynchronously */
struct marshal_cmd_FramebufferTexture1D
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum attachment;
   GLenum textarget;
   GLuint texture;
   GLint level;
};
static inline void
_mesa_unmarshal_FramebufferTexture1D(struct gl_context *ctx, const struct marshal_cmd_FramebufferTexture1D *cmd)
{
   const GLenum target = cmd->target;
   const GLenum attachment = cmd->attachment;
   const GLenum textarget = cmd->textarget;
   const GLuint texture = cmd->texture;
   const GLint level = cmd->level;
   CALL_FramebufferTexture1D(ctx->CurrentServerDispatch, (target, attachment, textarget, texture, level));
}
static void GLAPIENTRY
_mesa_marshal_FramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_FramebufferTexture1D);
   struct marshal_cmd_FramebufferTexture1D *cmd;
   debug_print_marshal("FramebufferTexture1D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_FramebufferTexture1D, cmd_size);
      cmd->target = target;
      cmd->attachment = attachment;
      cmd->textarget = textarget;
      cmd->texture = texture;
      cmd->level = level;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("FramebufferTexture1D");
   CALL_FramebufferTexture1D(ctx->CurrentServerDispatch, (target, attachment, textarget, texture, level));
}


/* TextureParameteri: marshalled asynchronously */
struct marshal_cmd_TextureParameteri
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLenum pname;
   GLint param;
};
static inline void
_mesa_unmarshal_TextureParameteri(struct gl_context *ctx, const struct marshal_cmd_TextureParameteri *cmd)
{
   const GLuint texture = cmd->texture;
   const GLenum pname = cmd->pname;
   const GLint param = cmd->param;
   CALL_TextureParameteri(ctx->CurrentServerDispatch, (texture, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_TextureParameteri(GLuint texture, GLenum pname, GLint param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureParameteri);
   struct marshal_cmd_TextureParameteri *cmd;
   debug_print_marshal("TextureParameteri");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureParameteri, cmd_size);
      cmd->texture = texture;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureParameteri");
   CALL_TextureParameteri(ctx->CurrentServerDispatch, (texture, pname, param));
}


/* GetMapiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetMapiv(GLenum target, GLenum query, GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetMapiv");
   CALL_GetMapiv(ctx->CurrentServerDispatch, (target, query, v));
}


/* GetUniformui64vARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetUniformui64vARB(GLuint program, GLint location, GLuint64 * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetUniformui64vARB");
   CALL_GetUniformui64vARB(ctx->CurrentServerDispatch, (program, location, params));
}


/* TexCoordP4ui: marshalled asynchronously */
struct marshal_cmd_TexCoordP4ui
{
   struct marshal_cmd_base cmd_base;
   GLenum type;
   GLuint coords;
};
static inline void
_mesa_unmarshal_TexCoordP4ui(struct gl_context *ctx, const struct marshal_cmd_TexCoordP4ui *cmd)
{
   const GLenum type = cmd->type;
   const GLuint coords = cmd->coords;
   CALL_TexCoordP4ui(ctx->CurrentServerDispatch, (type, coords));
}
static void GLAPIENTRY
_mesa_marshal_TexCoordP4ui(GLenum type, GLuint coords)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoordP4ui);
   struct marshal_cmd_TexCoordP4ui *cmd;
   debug_print_marshal("TexCoordP4ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoordP4ui, cmd_size);
      cmd->type = type;
      cmd->coords = coords;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoordP4ui");
   CALL_TexCoordP4ui(ctx->CurrentServerDispatch, (type, coords));
}


/* VertexAttrib1sv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib1sv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLshort v[1];
};
static inline void
_mesa_unmarshal_VertexAttrib1sv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib1sv *cmd)
{
   const GLuint index = cmd->index;
   const GLshort * v = cmd->v;
   CALL_VertexAttrib1sv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib1sv(GLuint index, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib1sv);
   struct marshal_cmd_VertexAttrib1sv *cmd;
   debug_print_marshal("VertexAttrib1sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib1sv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 2);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib1sv");
   CALL_VertexAttrib1sv(ctx->CurrentServerDispatch, (index, v));
}


/* WindowPos4dMESA: marshalled asynchronously */
struct marshal_cmd_WindowPos4dMESA
{
   struct marshal_cmd_base cmd_base;
   GLdouble x;
   GLdouble y;
   GLdouble z;
   GLdouble w;
};
static inline void
_mesa_unmarshal_WindowPos4dMESA(struct gl_context *ctx, const struct marshal_cmd_WindowPos4dMESA *cmd)
{
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   const GLdouble w = cmd->w;
   CALL_WindowPos4dMESA(ctx->CurrentServerDispatch, (x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_WindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_WindowPos4dMESA);
   struct marshal_cmd_WindowPos4dMESA *cmd;
   debug_print_marshal("WindowPos4dMESA");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_WindowPos4dMESA, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("WindowPos4dMESA");
   CALL_WindowPos4dMESA(ctx->CurrentServerDispatch, (x, y, z, w));
}


/* Vertex3dv: marshalled asynchronously */
struct marshal_cmd_Vertex3dv
{
   struct marshal_cmd_base cmd_base;
   GLdouble v[3];
};
static inline void
_mesa_unmarshal_Vertex3dv(struct gl_context *ctx, const struct marshal_cmd_Vertex3dv *cmd)
{
   const GLdouble * v = cmd->v;
   CALL_Vertex3dv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Vertex3dv(const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex3dv);
   struct marshal_cmd_Vertex3dv *cmd;
   debug_print_marshal("Vertex3dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex3dv, cmd_size);
      memcpy(cmd->v, v, 24);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex3dv");
   CALL_Vertex3dv(ctx->CurrentServerDispatch, (v));
}


/* VertexAttribL2d: marshalled asynchronously */
struct marshal_cmd_VertexAttribL2d
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble x;
   GLdouble y;
};
static inline void
_mesa_unmarshal_VertexAttribL2d(struct gl_context *ctx, const struct marshal_cmd_VertexAttribL2d *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   CALL_VertexAttribL2d(ctx->CurrentServerDispatch, (index, x, y));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribL2d);
   struct marshal_cmd_VertexAttribL2d *cmd;
   debug_print_marshal("VertexAttribL2d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribL2d, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribL2d");
   CALL_VertexAttribL2d(ctx->CurrentServerDispatch, (index, x, y));
}


/* GetnMapivARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnMapivARB(GLenum target, GLenum query, GLsizei bufSize, GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnMapivARB");
   CALL_GetnMapivARB(ctx->CurrentServerDispatch, (target, query, bufSize, v));
}


/* GetVertexAttribfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetVertexAttribfv(GLuint index, GLenum pname, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetVertexAttribfv");
   CALL_GetVertexAttribfv(ctx->CurrentServerDispatch, (index, pname, params));
}


/* MultiTexCoordP4uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_MultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint * coords)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MultiTexCoordP4uiv");
   CALL_MultiTexCoordP4uiv(ctx->CurrentServerDispatch, (texture, type, coords));
}


/* TexGeniv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexGeniv(GLenum coord, GLenum pname, const GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexGeniv");
   CALL_TexGeniv(ctx->CurrentServerDispatch, (coord, pname, params));
}


/* IsMemoryObjectEXT: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsMemoryObjectEXT(GLuint memoryObject)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsMemoryObjectEXT");
   return CALL_IsMemoryObjectEXT(ctx->CurrentServerDispatch, (memoryObject));
}


/* BlendColor: marshalled asynchronously */
struct marshal_cmd_BlendColor
{
   struct marshal_cmd_base cmd_base;
   GLclampf red;
   GLclampf green;
   GLclampf blue;
   GLclampf alpha;
};
static inline void
_mesa_unmarshal_BlendColor(struct gl_context *ctx, const struct marshal_cmd_BlendColor *cmd)
{
   const GLclampf red = cmd->red;
   const GLclampf green = cmd->green;
   const GLclampf blue = cmd->blue;
   const GLclampf alpha = cmd->alpha;
   CALL_BlendColor(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}
static void GLAPIENTRY
_mesa_marshal_BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BlendColor);
   struct marshal_cmd_BlendColor *cmd;
   debug_print_marshal("BlendColor");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BlendColor, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      cmd->alpha = alpha;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BlendColor");
   CALL_BlendColor(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}


/* VertexAttribs2dvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttribs2dvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLsizei n;
   /* Next safe_mul(n, 16) bytes are GLdouble v[n][2] */
};
static inline void
_mesa_unmarshal_VertexAttribs2dvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttribs2dvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLsizei n = cmd->n;
   const GLdouble * v;
   const char *variable_data = (const char *) (cmd + 1);
   v = (const GLdouble *) variable_data;
   variable_data += n * 16;
   CALL_VertexAttribs2dvNV(ctx->CurrentServerDispatch, (index, n, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribs2dvNV(GLuint index, GLsizei n, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribs2dvNV) + safe_mul(n, 16);
   struct marshal_cmd_VertexAttribs2dvNV *cmd;
   debug_print_marshal("VertexAttribs2dvNV");
   if (unlikely(safe_mul(n, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribs2dvNV, cmd_size);
      cmd->index = index;
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, v, n * 16);
      variable_data += n * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribs2dvNV");
   CALL_VertexAttribs2dvNV(ctx->CurrentServerDispatch, (index, n, v));
}


/* VertexAttrib2dvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib2dvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble v[2];
};
static inline void
_mesa_unmarshal_VertexAttrib2dvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib2dvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble * v = cmd->v;
   CALL_VertexAttrib2dvNV(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib2dvNV(GLuint index, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib2dvNV);
   struct marshal_cmd_VertexAttrib2dvNV *cmd;
   debug_print_marshal("VertexAttrib2dvNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib2dvNV, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib2dvNV");
   CALL_VertexAttrib2dvNV(ctx->CurrentServerDispatch, (index, v));
}


/* NamedFramebufferDrawBuffers: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_NamedFramebufferDrawBuffers(GLuint framebuffer, GLsizei n, const GLenum * bufs)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("NamedFramebufferDrawBuffers");
   CALL_NamedFramebufferDrawBuffers(ctx->CurrentServerDispatch, (framebuffer, n, bufs));
}


/* ResetHistogram: marshalled asynchronously */
struct marshal_cmd_ResetHistogram
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
};
static inline void
_mesa_unmarshal_ResetHistogram(struct gl_context *ctx, const struct marshal_cmd_ResetHistogram *cmd)
{
   const GLenum target = cmd->target;
   CALL_ResetHistogram(ctx->CurrentServerDispatch, (target));
}
static void GLAPIENTRY
_mesa_marshal_ResetHistogram(GLenum target)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ResetHistogram);
   struct marshal_cmd_ResetHistogram *cmd;
   debug_print_marshal("ResetHistogram");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ResetHistogram, cmd_size);
      cmd->target = target;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ResetHistogram");
   CALL_ResetHistogram(ctx->CurrentServerDispatch, (target));
}


/* CompressedTexSubImage2D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CompressedTexSubImage2D");
   CALL_CompressedTexSubImage2D(ctx->CurrentServerDispatch, (target, level, xoffset, yoffset, width, height, format, imageSize, data));
}


/* TexCoord2sv: marshalled asynchronously */
struct marshal_cmd_TexCoord2sv
{
   struct marshal_cmd_base cmd_base;
   GLshort v[2];
};
static inline void
_mesa_unmarshal_TexCoord2sv(struct gl_context *ctx, const struct marshal_cmd_TexCoord2sv *cmd)
{
   const GLshort * v = cmd->v;
   CALL_TexCoord2sv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord2sv(const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord2sv);
   struct marshal_cmd_TexCoord2sv *cmd;
   debug_print_marshal("TexCoord2sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord2sv, cmd_size);
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord2sv");
   CALL_TexCoord2sv(ctx->CurrentServerDispatch, (v));
}


/* StencilMaskSeparate: marshalled asynchronously */
struct marshal_cmd_StencilMaskSeparate
{
   struct marshal_cmd_base cmd_base;
   GLenum face;
   GLuint mask;
};
static inline void
_mesa_unmarshal_StencilMaskSeparate(struct gl_context *ctx, const struct marshal_cmd_StencilMaskSeparate *cmd)
{
   const GLenum face = cmd->face;
   const GLuint mask = cmd->mask;
   CALL_StencilMaskSeparate(ctx->CurrentServerDispatch, (face, mask));
}
static void GLAPIENTRY
_mesa_marshal_StencilMaskSeparate(GLenum face, GLuint mask)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_StencilMaskSeparate);
   struct marshal_cmd_StencilMaskSeparate *cmd;
   debug_print_marshal("StencilMaskSeparate");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_StencilMaskSeparate, cmd_size);
      cmd->face = face;
      cmd->mask = mask;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("StencilMaskSeparate");
   CALL_StencilMaskSeparate(ctx->CurrentServerDispatch, (face, mask));
}


/* MultiTexCoord3sv: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord3sv
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLshort v[3];
};
static inline void
_mesa_unmarshal_MultiTexCoord3sv(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord3sv *cmd)
{
   const GLenum target = cmd->target;
   const GLshort * v = cmd->v;
   CALL_MultiTexCoord3sv(ctx->CurrentServerDispatch, (target, v));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord3sv(GLenum target, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord3sv);
   struct marshal_cmd_MultiTexCoord3sv *cmd;
   debug_print_marshal("MultiTexCoord3sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord3sv, cmd_size);
      cmd->target = target;
      memcpy(cmd->v, v, 6);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord3sv");
   CALL_MultiTexCoord3sv(ctx->CurrentServerDispatch, (target, v));
}


/* TexCoord3iv: marshalled asynchronously */
struct marshal_cmd_TexCoord3iv
{
   struct marshal_cmd_base cmd_base;
   GLint v[3];
};
static inline void
_mesa_unmarshal_TexCoord3iv(struct gl_context *ctx, const struct marshal_cmd_TexCoord3iv *cmd)
{
   const GLint * v = cmd->v;
   CALL_TexCoord3iv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord3iv(const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord3iv);
   struct marshal_cmd_TexCoord3iv *cmd;
   debug_print_marshal("TexCoord3iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord3iv, cmd_size);
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord3iv");
   CALL_TexCoord3iv(ctx->CurrentServerDispatch, (v));
}


/* MultiTexCoord4sv: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord4sv
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLshort v[4];
};
static inline void
_mesa_unmarshal_MultiTexCoord4sv(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord4sv *cmd)
{
   const GLenum target = cmd->target;
   const GLshort * v = cmd->v;
   CALL_MultiTexCoord4sv(ctx->CurrentServerDispatch, (target, v));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord4sv(GLenum target, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord4sv);
   struct marshal_cmd_MultiTexCoord4sv *cmd;
   debug_print_marshal("MultiTexCoord4sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord4sv, cmd_size);
      cmd->target = target;
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord4sv");
   CALL_MultiTexCoord4sv(ctx->CurrentServerDispatch, (target, v));
}


/* VertexBindingDivisor: marshalled asynchronously */
struct marshal_cmd_VertexBindingDivisor
{
   struct marshal_cmd_base cmd_base;
   GLuint attribindex;
   GLuint divisor;
};
static inline void
_mesa_unmarshal_VertexBindingDivisor(struct gl_context *ctx, const struct marshal_cmd_VertexBindingDivisor *cmd)
{
   const GLuint attribindex = cmd->attribindex;
   const GLuint divisor = cmd->divisor;
   CALL_VertexBindingDivisor(ctx->CurrentServerDispatch, (attribindex, divisor));
}
static void GLAPIENTRY
_mesa_marshal_VertexBindingDivisor(GLuint attribindex, GLuint divisor)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexBindingDivisor);
   struct marshal_cmd_VertexBindingDivisor *cmd;
   debug_print_marshal("VertexBindingDivisor");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexBindingDivisor, cmd_size);
      cmd->attribindex = attribindex;
      cmd->divisor = divisor;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexBindingDivisor");
   CALL_VertexBindingDivisor(ctx->CurrentServerDispatch, (attribindex, divisor));
}


/* PrimitiveBoundingBox: marshalled asynchronously */
struct marshal_cmd_PrimitiveBoundingBox
{
   struct marshal_cmd_base cmd_base;
   GLfloat minX;
   GLfloat minY;
   GLfloat minZ;
   GLfloat minW;
   GLfloat maxX;
   GLfloat maxY;
   GLfloat maxZ;
   GLfloat maxW;
};
static inline void
_mesa_unmarshal_PrimitiveBoundingBox(struct gl_context *ctx, const struct marshal_cmd_PrimitiveBoundingBox *cmd)
{
   const GLfloat minX = cmd->minX;
   const GLfloat minY = cmd->minY;
   const GLfloat minZ = cmd->minZ;
   const GLfloat minW = cmd->minW;
   const GLfloat maxX = cmd->maxX;
   const GLfloat maxY = cmd->maxY;
   const GLfloat maxZ = cmd->maxZ;
   const GLfloat maxW = cmd->maxW;
   CALL_PrimitiveBoundingBox(ctx->CurrentServerDispatch, (minX, minY, minZ, minW, maxX, maxY, maxZ, maxW));
}
static void GLAPIENTRY
_mesa_marshal_PrimitiveBoundingBox(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PrimitiveBoundingBox);
   struct marshal_cmd_PrimitiveBoundingBox *cmd;
   debug_print_marshal("PrimitiveBoundingBox");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PrimitiveBoundingBox, cmd_size);
      cmd->minX = minX;
      cmd->minY = minY;
      cmd->minZ = minZ;
      cmd->minW = minW;
      cmd->maxX = maxX;
      cmd->maxY = maxY;
      cmd->maxZ = maxZ;
      cmd->maxW = maxW;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PrimitiveBoundingBox");
   CALL_PrimitiveBoundingBox(ctx->CurrentServerDispatch, (minX, minY, minZ, minW, maxX, maxY, maxZ, maxW));
}


/* GetPerfMonitorCounterInfoAMD: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetPerfMonitorCounterInfoAMD");
   CALL_GetPerfMonitorCounterInfoAMD(ctx->CurrentServerDispatch, (group, counter, pname, data));
}


/* UniformBlockBinding: marshalled asynchronously */
struct marshal_cmd_UniformBlockBinding
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLuint uniformBlockIndex;
   GLuint uniformBlockBinding;
};
static inline void
_mesa_unmarshal_UniformBlockBinding(struct gl_context *ctx, const struct marshal_cmd_UniformBlockBinding *cmd)
{
   const GLuint program = cmd->program;
   const GLuint uniformBlockIndex = cmd->uniformBlockIndex;
   const GLuint uniformBlockBinding = cmd->uniformBlockBinding;
   CALL_UniformBlockBinding(ctx->CurrentServerDispatch, (program, uniformBlockIndex, uniformBlockBinding));
}
static void GLAPIENTRY
_mesa_marshal_UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformBlockBinding);
   struct marshal_cmd_UniformBlockBinding *cmd;
   debug_print_marshal("UniformBlockBinding");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformBlockBinding, cmd_size);
      cmd->program = program;
      cmd->uniformBlockIndex = uniformBlockIndex;
      cmd->uniformBlockBinding = uniformBlockBinding;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformBlockBinding");
   CALL_UniformBlockBinding(ctx->CurrentServerDispatch, (program, uniformBlockIndex, uniformBlockBinding));
}


/* FenceSync: marshalled synchronously */
static GLsync GLAPIENTRY
_mesa_marshal_FenceSync(GLenum condition, GLbitfield flags)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("FenceSync");
   return CALL_FenceSync(ctx->CurrentServerDispatch, (condition, flags));
}


/* CompressedTextureSubImage2D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CompressedTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CompressedTextureSubImage2D");
   CALL_CompressedTextureSubImage2D(ctx->CurrentServerDispatch, (texture, level, xoffset, yoffset, width, height, format, imageSize, data));
}


/* VertexAttrib4Nusv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4Nusv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLushort v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4Nusv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4Nusv *cmd)
{
   const GLuint index = cmd->index;
   const GLushort * v = cmd->v;
   CALL_VertexAttrib4Nusv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4Nusv(GLuint index, const GLushort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4Nusv);
   struct marshal_cmd_VertexAttrib4Nusv *cmd;
   debug_print_marshal("VertexAttrib4Nusv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4Nusv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4Nusv");
   CALL_VertexAttrib4Nusv(ctx->CurrentServerDispatch, (index, v));
}


/* SetFragmentShaderConstantATI: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_SetFragmentShaderConstantATI(GLuint dst, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("SetFragmentShaderConstantATI");
   CALL_SetFragmentShaderConstantATI(ctx->CurrentServerDispatch, (dst, value));
}


/* VertexP2ui: marshalled asynchronously */
struct marshal_cmd_VertexP2ui
{
   struct marshal_cmd_base cmd_base;
   GLenum type;
   GLuint value;
};
static inline void
_mesa_unmarshal_VertexP2ui(struct gl_context *ctx, const struct marshal_cmd_VertexP2ui *cmd)
{
   const GLenum type = cmd->type;
   const GLuint value = cmd->value;
   CALL_VertexP2ui(ctx->CurrentServerDispatch, (type, value));
}
static void GLAPIENTRY
_mesa_marshal_VertexP2ui(GLenum type, GLuint value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexP2ui);
   struct marshal_cmd_VertexP2ui *cmd;
   debug_print_marshal("VertexP2ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexP2ui, cmd_size);
      cmd->type = type;
      cmd->value = value;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexP2ui");
   CALL_VertexP2ui(ctx->CurrentServerDispatch, (type, value));
}


/* ProgramUniform2fv: marshalled asynchronously */
struct marshal_cmd_ProgramUniform2fv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 8) bytes are GLfloat value[count][2] */
};
static inline void
_mesa_unmarshal_ProgramUniform2fv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform2fv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 8;
   CALL_ProgramUniform2fv(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform2fv) + safe_mul(count, 8);
   struct marshal_cmd_ProgramUniform2fv *cmd;
   debug_print_marshal("ProgramUniform2fv");
   if (unlikely(safe_mul(count, 8) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform2fv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 8);
      variable_data += count * 8;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform2fv");
   CALL_ProgramUniform2fv(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* GetTextureLevelParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTextureLevelParameteriv(GLuint texture, GLint level, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTextureLevelParameteriv");
   CALL_GetTextureLevelParameteriv(ctx->CurrentServerDispatch, (texture, level, pname, params));
}


/* GetTexEnvfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTexEnvfv(GLenum target, GLenum pname, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTexEnvfv");
   CALL_GetTexEnvfv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* BindAttribLocation: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_BindAttribLocation(GLuint program, GLuint index, const GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("BindAttribLocation");
   CALL_BindAttribLocation(ctx->CurrentServerDispatch, (program, index, name));
}


/* TextureStorage2DEXT: marshalled asynchronously */
struct marshal_cmd_TextureStorage2DEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLenum target;
   GLsizei levels;
   GLenum internalFormat;
   GLsizei width;
   GLsizei height;
};
static inline void
_mesa_unmarshal_TextureStorage2DEXT(struct gl_context *ctx, const struct marshal_cmd_TextureStorage2DEXT *cmd)
{
   const GLuint texture = cmd->texture;
   const GLenum target = cmd->target;
   const GLsizei levels = cmd->levels;
   const GLenum internalFormat = cmd->internalFormat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   CALL_TextureStorage2DEXT(ctx->CurrentServerDispatch, (texture, target, levels, internalFormat, width, height));
}
static void GLAPIENTRY
_mesa_marshal_TextureStorage2DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureStorage2DEXT);
   struct marshal_cmd_TextureStorage2DEXT *cmd;
   debug_print_marshal("TextureStorage2DEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureStorage2DEXT, cmd_size);
      cmd->texture = texture;
      cmd->target = target;
      cmd->levels = levels;
      cmd->internalFormat = internalFormat;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureStorage2DEXT");
   CALL_TextureStorage2DEXT(ctx->CurrentServerDispatch, (texture, target, levels, internalFormat, width, height));
}


/* TextureParameterIiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TextureParameterIiv(GLuint texture, GLenum pname, const GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TextureParameterIiv");
   CALL_TextureParameterIiv(ctx->CurrentServerDispatch, (texture, pname, params));
}


/* DrawTransformFeedbackInstanced: marshalled asynchronously */
struct marshal_cmd_DrawTransformFeedbackInstanced
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLuint id;
   GLsizei primcount;
};
static inline void
_mesa_unmarshal_DrawTransformFeedbackInstanced(struct gl_context *ctx, const struct marshal_cmd_DrawTransformFeedbackInstanced *cmd)
{
   const GLenum mode = cmd->mode;
   const GLuint id = cmd->id;
   const GLsizei primcount = cmd->primcount;
   CALL_DrawTransformFeedbackInstanced(ctx->CurrentServerDispatch, (mode, id, primcount));
}
static void GLAPIENTRY
_mesa_marshal_DrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei primcount)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawTransformFeedbackInstanced);
   struct marshal_cmd_DrawTransformFeedbackInstanced *cmd;
   debug_print_marshal("DrawTransformFeedbackInstanced");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawTransformFeedbackInstanced, cmd_size);
      cmd->mode = mode;
      cmd->id = id;
      cmd->primcount = primcount;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawTransformFeedbackInstanced");
   CALL_DrawTransformFeedbackInstanced(ctx->CurrentServerDispatch, (mode, id, primcount));
}


/* CopyTextureSubImage1D: marshalled asynchronously */
struct marshal_cmd_CopyTextureSubImage1D
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLint level;
   GLint xoffset;
   GLint x;
   GLint y;
   GLsizei width;
};
static inline void
_mesa_unmarshal_CopyTextureSubImage1D(struct gl_context *ctx, const struct marshal_cmd_CopyTextureSubImage1D *cmd)
{
   const GLuint texture = cmd->texture;
   const GLint level = cmd->level;
   const GLint xoffset = cmd->xoffset;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLsizei width = cmd->width;
   CALL_CopyTextureSubImage1D(ctx->CurrentServerDispatch, (texture, level, xoffset, x, y, width));
}
static void GLAPIENTRY
_mesa_marshal_CopyTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CopyTextureSubImage1D);
   struct marshal_cmd_CopyTextureSubImage1D *cmd;
   debug_print_marshal("CopyTextureSubImage1D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CopyTextureSubImage1D, cmd_size);
      cmd->texture = texture;
      cmd->level = level;
      cmd->xoffset = xoffset;
      cmd->x = x;
      cmd->y = y;
      cmd->width = width;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CopyTextureSubImage1D");
   CALL_CopyTextureSubImage1D(ctx->CurrentServerDispatch, (texture, level, xoffset, x, y, width));
}


/* ResumeTransformFeedback: marshalled asynchronously */
struct marshal_cmd_ResumeTransformFeedback
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_ResumeTransformFeedback(struct gl_context *ctx, const struct marshal_cmd_ResumeTransformFeedback *cmd)
{
   CALL_ResumeTransformFeedback(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_ResumeTransformFeedback(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ResumeTransformFeedback);
   struct marshal_cmd_ResumeTransformFeedback *cmd;
   debug_print_marshal("ResumeTransformFeedback");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ResumeTransformFeedback, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ResumeTransformFeedback");
   CALL_ResumeTransformFeedback(ctx->CurrentServerDispatch, ());
}


/* VertexAttribI1iv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribI1iv(GLuint index, const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribI1iv");
   CALL_VertexAttribI1iv(ctx->CurrentServerDispatch, (index, v));
}


/* Vertex2dv: marshalled asynchronously */
struct marshal_cmd_Vertex2dv
{
   struct marshal_cmd_base cmd_base;
   GLdouble v[2];
};
static inline void
_mesa_unmarshal_Vertex2dv(struct gl_context *ctx, const struct marshal_cmd_Vertex2dv *cmd)
{
   const GLdouble * v = cmd->v;
   CALL_Vertex2dv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Vertex2dv(const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex2dv);
   struct marshal_cmd_Vertex2dv *cmd;
   debug_print_marshal("Vertex2dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex2dv, cmd_size);
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex2dv");
   CALL_Vertex2dv(ctx->CurrentServerDispatch, (v));
}


/* VertexAttribI2uivEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribI2uivEXT(GLuint index, const GLuint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribI2uivEXT");
   CALL_VertexAttribI2uivEXT(ctx->CurrentServerDispatch, (index, v));
}


/* SampleMaski: marshalled asynchronously */
struct marshal_cmd_SampleMaski
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLbitfield mask;
};
static inline void
_mesa_unmarshal_SampleMaski(struct gl_context *ctx, const struct marshal_cmd_SampleMaski *cmd)
{
   const GLuint index = cmd->index;
   const GLbitfield mask = cmd->mask;
   CALL_SampleMaski(ctx->CurrentServerDispatch, (index, mask));
}
static void GLAPIENTRY
_mesa_marshal_SampleMaski(GLuint index, GLbitfield mask)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SampleMaski);
   struct marshal_cmd_SampleMaski *cmd;
   debug_print_marshal("SampleMaski");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SampleMaski, cmd_size);
      cmd->index = index;
      cmd->mask = mask;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SampleMaski");
   CALL_SampleMaski(ctx->CurrentServerDispatch, (index, mask));
}


/* GetFloati_v: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetFloati_v(GLenum target, GLuint index, GLfloat * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetFloati_v");
   CALL_GetFloati_v(ctx->CurrentServerDispatch, (target, index, data));
}


/* MultiTexCoord2iv: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord2iv
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLint v[2];
};
static inline void
_mesa_unmarshal_MultiTexCoord2iv(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord2iv *cmd)
{
   const GLenum target = cmd->target;
   const GLint * v = cmd->v;
   CALL_MultiTexCoord2iv(ctx->CurrentServerDispatch, (target, v));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord2iv(GLenum target, const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord2iv);
   struct marshal_cmd_MultiTexCoord2iv *cmd;
   debug_print_marshal("MultiTexCoord2iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord2iv, cmd_size);
      cmd->target = target;
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord2iv");
   CALL_MultiTexCoord2iv(ctx->CurrentServerDispatch, (target, v));
}


/* DrawPixels: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_DrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("DrawPixels");
   CALL_DrawPixels(ctx->CurrentServerDispatch, (width, height, format, type, pixels));
}


/* CreateFramebuffers: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CreateFramebuffers(GLsizei n, GLuint * framebuffers)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CreateFramebuffers");
   CALL_CreateFramebuffers(ctx->CurrentServerDispatch, (n, framebuffers));
}


/* DrawTransformFeedback: marshalled asynchronously */
struct marshal_cmd_DrawTransformFeedback
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLuint id;
};
static inline void
_mesa_unmarshal_DrawTransformFeedback(struct gl_context *ctx, const struct marshal_cmd_DrawTransformFeedback *cmd)
{
   const GLenum mode = cmd->mode;
   const GLuint id = cmd->id;
   CALL_DrawTransformFeedback(ctx->CurrentServerDispatch, (mode, id));
}
static void GLAPIENTRY
_mesa_marshal_DrawTransformFeedback(GLenum mode, GLuint id)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawTransformFeedback);
   struct marshal_cmd_DrawTransformFeedback *cmd;
   debug_print_marshal("DrawTransformFeedback");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawTransformFeedback, cmd_size);
      cmd->mode = mode;
      cmd->id = id;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawTransformFeedback");
   CALL_DrawTransformFeedback(ctx->CurrentServerDispatch, (mode, id));
}


/* VertexAttribs3fvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttribs3fvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLsizei n;
   /* Next safe_mul(n, 12) bytes are GLfloat v[n][3] */
};
static inline void
_mesa_unmarshal_VertexAttribs3fvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttribs3fvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLsizei n = cmd->n;
   const GLfloat * v;
   const char *variable_data = (const char *) (cmd + 1);
   v = (const GLfloat *) variable_data;
   variable_data += n * 12;
   CALL_VertexAttribs3fvNV(ctx->CurrentServerDispatch, (index, n, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribs3fvNV(GLuint index, GLsizei n, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribs3fvNV) + safe_mul(n, 12);
   struct marshal_cmd_VertexAttribs3fvNV *cmd;
   debug_print_marshal("VertexAttribs3fvNV");
   if (unlikely(safe_mul(n, 12) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribs3fvNV, cmd_size);
      cmd->index = index;
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, v, n * 12);
      variable_data += n * 12;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribs3fvNV");
   CALL_VertexAttribs3fvNV(ctx->CurrentServerDispatch, (index, n, v));
}


/* GenLists: marshalled synchronously */
static GLuint GLAPIENTRY
_mesa_marshal_GenLists(GLsizei range)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GenLists");
   return CALL_GenLists(ctx->CurrentServerDispatch, (range));
}


/* ProgramUniform2ui64vARB: marshalled asynchronously */
struct marshal_cmd_ProgramUniform2ui64vARB
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 16) bytes are GLuint64 value[count][2] */
};
static inline void
_mesa_unmarshal_ProgramUniform2ui64vARB(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform2ui64vARB *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLuint64 * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLuint64 *) variable_data;
   variable_data += count * 16;
   CALL_ProgramUniform2ui64vARB(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform2ui64vARB(GLuint program, GLint location, GLsizei count, const GLuint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform2ui64vARB) + safe_mul(count, 16);
   struct marshal_cmd_ProgramUniform2ui64vARB *cmd;
   debug_print_marshal("ProgramUniform2ui64vARB");
   if (unlikely(safe_mul(count, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform2ui64vARB, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 16);
      variable_data += count * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform2ui64vARB");
   CALL_ProgramUniform2ui64vARB(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* MapGrid2d: marshalled asynchronously */
struct marshal_cmd_MapGrid2d
{
   struct marshal_cmd_base cmd_base;
   GLint un;
   GLdouble u1;
   GLdouble u2;
   GLint vn;
   GLdouble v1;
   GLdouble v2;
};
static inline void
_mesa_unmarshal_MapGrid2d(struct gl_context *ctx, const struct marshal_cmd_MapGrid2d *cmd)
{
   const GLint un = cmd->un;
   const GLdouble u1 = cmd->u1;
   const GLdouble u2 = cmd->u2;
   const GLint vn = cmd->vn;
   const GLdouble v1 = cmd->v1;
   const GLdouble v2 = cmd->v2;
   CALL_MapGrid2d(ctx->CurrentServerDispatch, (un, u1, u2, vn, v1, v2));
}
static void GLAPIENTRY
_mesa_marshal_MapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MapGrid2d);
   struct marshal_cmd_MapGrid2d *cmd;
   debug_print_marshal("MapGrid2d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MapGrid2d, cmd_size);
      cmd->un = un;
      cmd->u1 = u1;
      cmd->u2 = u2;
      cmd->vn = vn;
      cmd->v1 = v1;
      cmd->v2 = v2;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MapGrid2d");
   CALL_MapGrid2d(ctx->CurrentServerDispatch, (un, u1, u2, vn, v1, v2));
}


/* MapGrid2f: marshalled asynchronously */
struct marshal_cmd_MapGrid2f
{
   struct marshal_cmd_base cmd_base;
   GLint un;
   GLfloat u1;
   GLfloat u2;
   GLint vn;
   GLfloat v1;
   GLfloat v2;
};
static inline void
_mesa_unmarshal_MapGrid2f(struct gl_context *ctx, const struct marshal_cmd_MapGrid2f *cmd)
{
   const GLint un = cmd->un;
   const GLfloat u1 = cmd->u1;
   const GLfloat u2 = cmd->u2;
   const GLint vn = cmd->vn;
   const GLfloat v1 = cmd->v1;
   const GLfloat v2 = cmd->v2;
   CALL_MapGrid2f(ctx->CurrentServerDispatch, (un, u1, u2, vn, v1, v2));
}
static void GLAPIENTRY
_mesa_marshal_MapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MapGrid2f);
   struct marshal_cmd_MapGrid2f *cmd;
   debug_print_marshal("MapGrid2f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MapGrid2f, cmd_size);
      cmd->un = un;
      cmd->u1 = u1;
      cmd->u2 = u2;
      cmd->vn = vn;
      cmd->v1 = v1;
      cmd->v2 = v2;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MapGrid2f");
   CALL_MapGrid2f(ctx->CurrentServerDispatch, (un, u1, u2, vn, v1, v2));
}


/* SampleMapATI: marshalled asynchronously */
struct marshal_cmd_SampleMapATI
{
   struct marshal_cmd_base cmd_base;
   GLuint dst;
   GLuint interp;
   GLenum swizzle;
};
static inline void
_mesa_unmarshal_SampleMapATI(struct gl_context *ctx, const struct marshal_cmd_SampleMapATI *cmd)
{
   const GLuint dst = cmd->dst;
   const GLuint interp = cmd->interp;
   const GLenum swizzle = cmd->swizzle;
   CALL_SampleMapATI(ctx->CurrentServerDispatch, (dst, interp, swizzle));
}
static void GLAPIENTRY
_mesa_marshal_SampleMapATI(GLuint dst, GLuint interp, GLenum swizzle)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SampleMapATI);
   struct marshal_cmd_SampleMapATI *cmd;
   debug_print_marshal("SampleMapATI");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SampleMapATI, cmd_size);
      cmd->dst = dst;
      cmd->interp = interp;
      cmd->swizzle = swizzle;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SampleMapATI");
   CALL_SampleMapATI(ctx->CurrentServerDispatch, (dst, interp, swizzle));
}


/* GetActiveAttrib: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetActiveAttrib(GLuint program, GLuint index, GLsizei  bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetActiveAttrib");
   CALL_GetActiveAttrib(ctx->CurrentServerDispatch, (program, index, bufSize, length, size, type, name));
}


/* PixelMapfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_PixelMapfv(GLenum map, GLsizei mapsize, const GLfloat * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("PixelMapfv");
   CALL_PixelMapfv(ctx->CurrentServerDispatch, (map, mapsize, values));
}


/* ClearBufferData: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ClearBufferData");
   CALL_ClearBufferData(ctx->CurrentServerDispatch, (target, internalformat, format, type, data));
}


/* Color3usv: marshalled asynchronously */
struct marshal_cmd_Color3usv
{
   struct marshal_cmd_base cmd_base;
   GLushort v[3];
};
static inline void
_mesa_unmarshal_Color3usv(struct gl_context *ctx, const struct marshal_cmd_Color3usv *cmd)
{
   const GLushort * v = cmd->v;
   CALL_Color3usv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Color3usv(const GLushort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color3usv);
   struct marshal_cmd_Color3usv *cmd;
   debug_print_marshal("Color3usv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color3usv, cmd_size);
      memcpy(cmd->v, v, 6);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color3usv");
   CALL_Color3usv(ctx->CurrentServerDispatch, (v));
}


/* CopyImageSubData: marshalled asynchronously */
struct marshal_cmd_CopyImageSubData
{
   struct marshal_cmd_base cmd_base;
   GLuint srcName;
   GLenum srcTarget;
   GLint srcLevel;
   GLint srcX;
   GLint srcY;
   GLint srcZ;
   GLuint dstName;
   GLenum dstTarget;
   GLint dstLevel;
   GLint dstX;
   GLint dstY;
   GLint dstZ;
   GLsizei srcWidth;
   GLsizei srcHeight;
   GLsizei srcDepth;
};
static inline void
_mesa_unmarshal_CopyImageSubData(struct gl_context *ctx, const struct marshal_cmd_CopyImageSubData *cmd)
{
   const GLuint srcName = cmd->srcName;
   const GLenum srcTarget = cmd->srcTarget;
   const GLint srcLevel = cmd->srcLevel;
   const GLint srcX = cmd->srcX;
   const GLint srcY = cmd->srcY;
   const GLint srcZ = cmd->srcZ;
   const GLuint dstName = cmd->dstName;
   const GLenum dstTarget = cmd->dstTarget;
   const GLint dstLevel = cmd->dstLevel;
   const GLint dstX = cmd->dstX;
   const GLint dstY = cmd->dstY;
   const GLint dstZ = cmd->dstZ;
   const GLsizei srcWidth = cmd->srcWidth;
   const GLsizei srcHeight = cmd->srcHeight;
   const GLsizei srcDepth = cmd->srcDepth;
   CALL_CopyImageSubData(ctx->CurrentServerDispatch, (srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth));
}
static void GLAPIENTRY
_mesa_marshal_CopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CopyImageSubData);
   struct marshal_cmd_CopyImageSubData *cmd;
   debug_print_marshal("CopyImageSubData");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CopyImageSubData, cmd_size);
      cmd->srcName = srcName;
      cmd->srcTarget = srcTarget;
      cmd->srcLevel = srcLevel;
      cmd->srcX = srcX;
      cmd->srcY = srcY;
      cmd->srcZ = srcZ;
      cmd->dstName = dstName;
      cmd->dstTarget = dstTarget;
      cmd->dstLevel = dstLevel;
      cmd->dstX = dstX;
      cmd->dstY = dstY;
      cmd->dstZ = dstZ;
      cmd->srcWidth = srcWidth;
      cmd->srcHeight = srcHeight;
      cmd->srcDepth = srcDepth;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CopyImageSubData");
   CALL_CopyImageSubData(ctx->CurrentServerDispatch, (srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth));
}


/* StencilOpSeparate: marshalled asynchronously */
struct marshal_cmd_StencilOpSeparate
{
   struct marshal_cmd_base cmd_base;
   GLenum face;
   GLenum sfail;
   GLenum zfail;
   GLenum zpass;
};
static inline void
_mesa_unmarshal_StencilOpSeparate(struct gl_context *ctx, const struct marshal_cmd_StencilOpSeparate *cmd)
{
   const GLenum face = cmd->face;
   const GLenum sfail = cmd->sfail;
   const GLenum zfail = cmd->zfail;
   const GLenum zpass = cmd->zpass;
   CALL_StencilOpSeparate(ctx->CurrentServerDispatch, (face, sfail, zfail, zpass));
}
static void GLAPIENTRY
_mesa_marshal_StencilOpSeparate(GLenum face, GLenum sfail, GLenum zfail, GLenum zpass)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_StencilOpSeparate);
   struct marshal_cmd_StencilOpSeparate *cmd;
   debug_print_marshal("StencilOpSeparate");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_StencilOpSeparate, cmd_size);
      cmd->face = face;
      cmd->sfail = sfail;
      cmd->zfail = zfail;
      cmd->zpass = zpass;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("StencilOpSeparate");
   CALL_StencilOpSeparate(ctx->CurrentServerDispatch, (face, sfail, zfail, zpass));
}


/* GenSamplers: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GenSamplers(GLsizei count, GLuint * samplers)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GenSamplers");
   CALL_GenSamplers(ctx->CurrentServerDispatch, (count, samplers));
}


/* ClipControl: marshalled asynchronously */
struct marshal_cmd_ClipControl
{
   struct marshal_cmd_base cmd_base;
   GLenum origin;
   GLenum depth;
};
static inline void
_mesa_unmarshal_ClipControl(struct gl_context *ctx, const struct marshal_cmd_ClipControl *cmd)
{
   const GLenum origin = cmd->origin;
   const GLenum depth = cmd->depth;
   CALL_ClipControl(ctx->CurrentServerDispatch, (origin, depth));
}
static void GLAPIENTRY
_mesa_marshal_ClipControl(GLenum origin, GLenum depth)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ClipControl);
   struct marshal_cmd_ClipControl *cmd;
   debug_print_marshal("ClipControl");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ClipControl, cmd_size);
      cmd->origin = origin;
      cmd->depth = depth;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ClipControl");
   CALL_ClipControl(ctx->CurrentServerDispatch, (origin, depth));
}


/* DrawTexfOES: marshalled asynchronously */
struct marshal_cmd_DrawTexfOES
{
   struct marshal_cmd_base cmd_base;
   GLfloat x;
   GLfloat y;
   GLfloat z;
   GLfloat width;
   GLfloat height;
};
static inline void
_mesa_unmarshal_DrawTexfOES(struct gl_context *ctx, const struct marshal_cmd_DrawTexfOES *cmd)
{
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   const GLfloat width = cmd->width;
   const GLfloat height = cmd->height;
   CALL_DrawTexfOES(ctx->CurrentServerDispatch, (x, y, z, width, height));
}
static void GLAPIENTRY
_mesa_marshal_DrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawTexfOES);
   struct marshal_cmd_DrawTexfOES *cmd;
   debug_print_marshal("DrawTexfOES");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawTexfOES, cmd_size);
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawTexfOES");
   CALL_DrawTexfOES(ctx->CurrentServerDispatch, (x, y, z, width, height));
}


/* Uniform4i64vARB: marshalled asynchronously */
struct marshal_cmd_Uniform4i64vARB
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 32) bytes are GLint64 value[count][4] */
};
static inline void
_mesa_unmarshal_Uniform4i64vARB(struct gl_context *ctx, const struct marshal_cmd_Uniform4i64vARB *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLint64 * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLint64 *) variable_data;
   variable_data += count * 32;
   CALL_Uniform4i64vARB(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform4i64vARB(GLint location, GLsizei count, const GLint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform4i64vARB) + safe_mul(count, 32);
   struct marshal_cmd_Uniform4i64vARB *cmd;
   debug_print_marshal("Uniform4i64vARB");
   if (unlikely(safe_mul(count, 32) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform4i64vARB, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 32);
      variable_data += count * 32;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform4i64vARB");
   CALL_Uniform4i64vARB(ctx->CurrentServerDispatch, (location, count, value));
}


/* AttachObjectARB: marshalled asynchronously */
struct marshal_cmd_AttachObjectARB
{
   struct marshal_cmd_base cmd_base;
   GLhandleARB containerObj;
   GLhandleARB obj;
};
static inline void
_mesa_unmarshal_AttachObjectARB(struct gl_context *ctx, const struct marshal_cmd_AttachObjectARB *cmd)
{
   const GLhandleARB containerObj = cmd->containerObj;
   const GLhandleARB obj = cmd->obj;
   CALL_AttachObjectARB(ctx->CurrentServerDispatch, (containerObj, obj));
}
static void GLAPIENTRY
_mesa_marshal_AttachObjectARB(GLhandleARB containerObj, GLhandleARB obj)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_AttachObjectARB);
   struct marshal_cmd_AttachObjectARB *cmd;
   debug_print_marshal("AttachObjectARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_AttachObjectARB, cmd_size);
      cmd->containerObj = containerObj;
      cmd->obj = obj;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("AttachObjectARB");
   CALL_AttachObjectARB(ctx->CurrentServerDispatch, (containerObj, obj));
}


/* Accum: marshalled asynchronously */
struct marshal_cmd_Accum
{
   struct marshal_cmd_base cmd_base;
   GLenum op;
   GLfloat value;
};
static inline void
_mesa_unmarshal_Accum(struct gl_context *ctx, const struct marshal_cmd_Accum *cmd)
{
   const GLenum op = cmd->op;
   const GLfloat value = cmd->value;
   CALL_Accum(ctx->CurrentServerDispatch, (op, value));
}
static void GLAPIENTRY
_mesa_marshal_Accum(GLenum op, GLfloat value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Accum);
   struct marshal_cmd_Accum *cmd;
   debug_print_marshal("Accum");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Accum, cmd_size);
      cmd->op = op;
      cmd->value = value;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Accum");
   CALL_Accum(ctx->CurrentServerDispatch, (op, value));
}


/* GetTexImage: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid * pixels)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTexImage");
   CALL_GetTexImage(ctx->CurrentServerDispatch, (target, level, format, type, pixels));
}


/* Color4x: marshalled asynchronously */
struct marshal_cmd_Color4x
{
   struct marshal_cmd_base cmd_base;
   GLfixed red;
   GLfixed green;
   GLfixed blue;
   GLfixed alpha;
};
static inline void
_mesa_unmarshal_Color4x(struct gl_context *ctx, const struct marshal_cmd_Color4x *cmd)
{
   const GLfixed red = cmd->red;
   const GLfixed green = cmd->green;
   const GLfixed blue = cmd->blue;
   const GLfixed alpha = cmd->alpha;
   CALL_Color4x(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}
static void GLAPIENTRY
_mesa_marshal_Color4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color4x);
   struct marshal_cmd_Color4x *cmd;
   debug_print_marshal("Color4x");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color4x, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      cmd->alpha = alpha;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color4x");
   CALL_Color4x(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}


/* ConvolutionParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ConvolutionParameteriv(GLenum target, GLenum pname, const GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ConvolutionParameteriv");
   CALL_ConvolutionParameteriv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* Color4s: marshalled asynchronously */
struct marshal_cmd_Color4s
{
   struct marshal_cmd_base cmd_base;
   GLshort red;
   GLshort green;
   GLshort blue;
   GLshort alpha;
};
static inline void
_mesa_unmarshal_Color4s(struct gl_context *ctx, const struct marshal_cmd_Color4s *cmd)
{
   const GLshort red = cmd->red;
   const GLshort green = cmd->green;
   const GLshort blue = cmd->blue;
   const GLshort alpha = cmd->alpha;
   CALL_Color4s(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}
static void GLAPIENTRY
_mesa_marshal_Color4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color4s);
   struct marshal_cmd_Color4s *cmd;
   debug_print_marshal("Color4s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color4s, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      cmd->alpha = alpha;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color4s");
   CALL_Color4s(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}


/* EnableVertexAttribArray: marshalled asynchronously */
struct marshal_cmd_EnableVertexAttribArray
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
};
static inline void
_mesa_unmarshal_EnableVertexAttribArray(struct gl_context *ctx, const struct marshal_cmd_EnableVertexAttribArray *cmd)
{
   const GLuint index = cmd->index;
   CALL_EnableVertexAttribArray(ctx->CurrentServerDispatch, (index));
}
static void GLAPIENTRY
_mesa_marshal_EnableVertexAttribArray(GLuint index)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EnableVertexAttribArray);
   struct marshal_cmd_EnableVertexAttribArray *cmd;
   debug_print_marshal("EnableVertexAttribArray");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EnableVertexAttribArray, cmd_size);
      cmd->index = index;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EnableVertexAttribArray");
   CALL_EnableVertexAttribArray(ctx->CurrentServerDispatch, (index));
}


/* Color4i: marshalled asynchronously */
struct marshal_cmd_Color4i
{
   struct marshal_cmd_base cmd_base;
   GLint red;
   GLint green;
   GLint blue;
   GLint alpha;
};
static inline void
_mesa_unmarshal_Color4i(struct gl_context *ctx, const struct marshal_cmd_Color4i *cmd)
{
   const GLint red = cmd->red;
   const GLint green = cmd->green;
   const GLint blue = cmd->blue;
   const GLint alpha = cmd->alpha;
   CALL_Color4i(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}
static void GLAPIENTRY
_mesa_marshal_Color4i(GLint red, GLint green, GLint blue, GLint alpha)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color4i);
   struct marshal_cmd_Color4i *cmd;
   debug_print_marshal("Color4i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color4i, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      cmd->alpha = alpha;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color4i");
   CALL_Color4i(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}


/* Color4f: marshalled asynchronously */
struct marshal_cmd_Color4f
{
   struct marshal_cmd_base cmd_base;
   GLfloat red;
   GLfloat green;
   GLfloat blue;
   GLfloat alpha;
};
static inline void
_mesa_unmarshal_Color4f(struct gl_context *ctx, const struct marshal_cmd_Color4f *cmd)
{
   const GLfloat red = cmd->red;
   const GLfloat green = cmd->green;
   const GLfloat blue = cmd->blue;
   const GLfloat alpha = cmd->alpha;
   CALL_Color4f(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}
static void GLAPIENTRY
_mesa_marshal_Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color4f);
   struct marshal_cmd_Color4f *cmd;
   debug_print_marshal("Color4f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color4f, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      cmd->alpha = alpha;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color4f");
   CALL_Color4f(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}


/* ShaderStorageBlockBinding: marshalled asynchronously */
struct marshal_cmd_ShaderStorageBlockBinding
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLuint shaderStorageBlockIndex;
   GLuint shaderStorageBlockBinding;
};
static inline void
_mesa_unmarshal_ShaderStorageBlockBinding(struct gl_context *ctx, const struct marshal_cmd_ShaderStorageBlockBinding *cmd)
{
   const GLuint program = cmd->program;
   const GLuint shaderStorageBlockIndex = cmd->shaderStorageBlockIndex;
   const GLuint shaderStorageBlockBinding = cmd->shaderStorageBlockBinding;
   CALL_ShaderStorageBlockBinding(ctx->CurrentServerDispatch, (program, shaderStorageBlockIndex, shaderStorageBlockBinding));
}
static void GLAPIENTRY
_mesa_marshal_ShaderStorageBlockBinding(GLuint program, GLuint shaderStorageBlockIndex, GLuint shaderStorageBlockBinding)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ShaderStorageBlockBinding);
   struct marshal_cmd_ShaderStorageBlockBinding *cmd;
   debug_print_marshal("ShaderStorageBlockBinding");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ShaderStorageBlockBinding, cmd_size);
      cmd->program = program;
      cmd->shaderStorageBlockIndex = shaderStorageBlockIndex;
      cmd->shaderStorageBlockBinding = shaderStorageBlockBinding;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ShaderStorageBlockBinding");
   CALL_ShaderStorageBlockBinding(ctx->CurrentServerDispatch, (program, shaderStorageBlockIndex, shaderStorageBlockBinding));
}


/* Color4d: marshalled asynchronously */
struct marshal_cmd_Color4d
{
   struct marshal_cmd_base cmd_base;
   GLdouble red;
   GLdouble green;
   GLdouble blue;
   GLdouble alpha;
};
static inline void
_mesa_unmarshal_Color4d(struct gl_context *ctx, const struct marshal_cmd_Color4d *cmd)
{
   const GLdouble red = cmd->red;
   const GLdouble green = cmd->green;
   const GLdouble blue = cmd->blue;
   const GLdouble alpha = cmd->alpha;
   CALL_Color4d(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}
static void GLAPIENTRY
_mesa_marshal_Color4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color4d);
   struct marshal_cmd_Color4d *cmd;
   debug_print_marshal("Color4d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color4d, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      cmd->alpha = alpha;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color4d");
   CALL_Color4d(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}


/* Color4b: marshalled asynchronously */
struct marshal_cmd_Color4b
{
   struct marshal_cmd_base cmd_base;
   GLbyte red;
   GLbyte green;
   GLbyte blue;
   GLbyte alpha;
};
static inline void
_mesa_unmarshal_Color4b(struct gl_context *ctx, const struct marshal_cmd_Color4b *cmd)
{
   const GLbyte red = cmd->red;
   const GLbyte green = cmd->green;
   const GLbyte blue = cmd->blue;
   const GLbyte alpha = cmd->alpha;
   CALL_Color4b(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}
static void GLAPIENTRY
_mesa_marshal_Color4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color4b);
   struct marshal_cmd_Color4b *cmd;
   debug_print_marshal("Color4b");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color4b, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      cmd->alpha = alpha;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color4b");
   CALL_Color4b(ctx->CurrentServerDispatch, (red, green, blue, alpha));
}


/* MemoryObjectParameterivEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_MemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname, const GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MemoryObjectParameterivEXT");
   CALL_MemoryObjectParameterivEXT(ctx->CurrentServerDispatch, (memoryObject, pname, params));
}


/* GetAttachedObjectsARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxLength, GLsizei * length, GLhandleARB * infoLog)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetAttachedObjectsARB");
   CALL_GetAttachedObjectsARB(ctx->CurrentServerDispatch, (containerObj, maxLength, length, infoLog));
}


/* EvalCoord1fv: marshalled asynchronously */
struct marshal_cmd_EvalCoord1fv
{
   struct marshal_cmd_base cmd_base;
   GLfloat u[1];
};
static inline void
_mesa_unmarshal_EvalCoord1fv(struct gl_context *ctx, const struct marshal_cmd_EvalCoord1fv *cmd)
{
   const GLfloat * u = cmd->u;
   CALL_EvalCoord1fv(ctx->CurrentServerDispatch, (u));
}
static void GLAPIENTRY
_mesa_marshal_EvalCoord1fv(const GLfloat * u)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EvalCoord1fv);
   struct marshal_cmd_EvalCoord1fv *cmd;
   debug_print_marshal("EvalCoord1fv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EvalCoord1fv, cmd_size);
      memcpy(cmd->u, u, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EvalCoord1fv");
   CALL_EvalCoord1fv(ctx->CurrentServerDispatch, (u));
}


/* VertexAttribLFormat: marshalled asynchronously */
struct marshal_cmd_VertexAttribLFormat
{
   struct marshal_cmd_base cmd_base;
   GLuint attribindex;
   GLint size;
   GLenum type;
   GLuint relativeoffset;
};
static inline void
_mesa_unmarshal_VertexAttribLFormat(struct gl_context *ctx, const struct marshal_cmd_VertexAttribLFormat *cmd)
{
   const GLuint attribindex = cmd->attribindex;
   const GLint size = cmd->size;
   const GLenum type = cmd->type;
   const GLuint relativeoffset = cmd->relativeoffset;
   CALL_VertexAttribLFormat(ctx->CurrentServerDispatch, (attribindex, size, type, relativeoffset));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribLFormat);
   struct marshal_cmd_VertexAttribLFormat *cmd;
   debug_print_marshal("VertexAttribLFormat");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribLFormat, cmd_size);
      cmd->attribindex = attribindex;
      cmd->size = size;
      cmd->type = type;
      cmd->relativeoffset = relativeoffset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribLFormat");
   CALL_VertexAttribLFormat(ctx->CurrentServerDispatch, (attribindex, size, type, relativeoffset));
}


/* VertexAttribL3d: marshalled asynchronously */
struct marshal_cmd_VertexAttribL3d
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble x;
   GLdouble y;
   GLdouble z;
};
static inline void
_mesa_unmarshal_VertexAttribL3d(struct gl_context *ctx, const struct marshal_cmd_VertexAttribL3d *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   CALL_VertexAttribL3d(ctx->CurrentServerDispatch, (index, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribL3d);
   struct marshal_cmd_VertexAttribL3d *cmd;
   debug_print_marshal("VertexAttribL3d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribL3d, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribL3d");
   CALL_VertexAttribL3d(ctx->CurrentServerDispatch, (index, x, y, z));
}


/* ClearNamedFramebufferuiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ClearNamedFramebufferuiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ClearNamedFramebufferuiv");
   CALL_ClearNamedFramebufferuiv(ctx->CurrentServerDispatch, (framebuffer, buffer, drawbuffer, value));
}


/* StencilFuncSeparate: marshalled asynchronously */
struct marshal_cmd_StencilFuncSeparate
{
   struct marshal_cmd_base cmd_base;
   GLenum face;
   GLenum func;
   GLint ref;
   GLuint mask;
};
static inline void
_mesa_unmarshal_StencilFuncSeparate(struct gl_context *ctx, const struct marshal_cmd_StencilFuncSeparate *cmd)
{
   const GLenum face = cmd->face;
   const GLenum func = cmd->func;
   const GLint ref = cmd->ref;
   const GLuint mask = cmd->mask;
   CALL_StencilFuncSeparate(ctx->CurrentServerDispatch, (face, func, ref, mask));
}
static void GLAPIENTRY
_mesa_marshal_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_StencilFuncSeparate);
   struct marshal_cmd_StencilFuncSeparate *cmd;
   debug_print_marshal("StencilFuncSeparate");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_StencilFuncSeparate, cmd_size);
      cmd->face = face;
      cmd->func = func;
      cmd->ref = ref;
      cmd->mask = mask;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("StencilFuncSeparate");
   CALL_StencilFuncSeparate(ctx->CurrentServerDispatch, (face, func, ref, mask));
}


/* Normal3fv: marshalled asynchronously */
struct marshal_cmd_Normal3fv
{
   struct marshal_cmd_base cmd_base;
   GLfloat v[3];
};
static inline void
_mesa_unmarshal_Normal3fv(struct gl_context *ctx, const struct marshal_cmd_Normal3fv *cmd)
{
   const GLfloat * v = cmd->v;
   CALL_Normal3fv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Normal3fv(const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Normal3fv);
   struct marshal_cmd_Normal3fv *cmd;
   debug_print_marshal("Normal3fv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Normal3fv, cmd_size);
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Normal3fv");
   CALL_Normal3fv(ctx->CurrentServerDispatch, (v));
}


/* NormalP3ui: marshalled asynchronously */
struct marshal_cmd_NormalP3ui
{
   struct marshal_cmd_base cmd_base;
   GLenum type;
   GLuint coords;
};
static inline void
_mesa_unmarshal_NormalP3ui(struct gl_context *ctx, const struct marshal_cmd_NormalP3ui *cmd)
{
   const GLenum type = cmd->type;
   const GLuint coords = cmd->coords;
   CALL_NormalP3ui(ctx->CurrentServerDispatch, (type, coords));
}
static void GLAPIENTRY
_mesa_marshal_NormalP3ui(GLenum type, GLuint coords)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_NormalP3ui);
   struct marshal_cmd_NormalP3ui *cmd;
   debug_print_marshal("NormalP3ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_NormalP3ui, cmd_size);
      cmd->type = type;
      cmd->coords = coords;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("NormalP3ui");
   CALL_NormalP3ui(ctx->CurrentServerDispatch, (type, coords));
}


/* CreateSamplers: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CreateSamplers(GLsizei n, GLuint * samplers)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CreateSamplers");
   CALL_CreateSamplers(ctx->CurrentServerDispatch, (n, samplers));
}


/* MultiTexCoord3fvARB: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord3fvARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLfloat v[3];
};
static inline void
_mesa_unmarshal_MultiTexCoord3fvARB(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord3fvARB *cmd)
{
   const GLenum target = cmd->target;
   const GLfloat * v = cmd->v;
   CALL_MultiTexCoord3fvARB(ctx->CurrentServerDispatch, (target, v));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord3fvARB(GLenum target, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord3fvARB);
   struct marshal_cmd_MultiTexCoord3fvARB *cmd;
   debug_print_marshal("MultiTexCoord3fvARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord3fvARB, cmd_size);
      cmd->target = target;
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord3fvARB");
   CALL_MultiTexCoord3fvARB(ctx->CurrentServerDispatch, (target, v));
}


/* TexSubImage2D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexSubImage2D");
   CALL_TexSubImage2D(ctx->CurrentServerDispatch, (target, level, xoffset, yoffset, width, height, format, type, pixels));
}


/* TexGenfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexGenfv(GLenum coord, GLenum pname, const GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexGenfv");
   CALL_TexGenfv(ctx->CurrentServerDispatch, (coord, pname, params));
}


/* GetVertexAttribiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetVertexAttribiv(GLuint index, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetVertexAttribiv");
   CALL_GetVertexAttribiv(ctx->CurrentServerDispatch, (index, pname, params));
}


/* TexCoordP2uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexCoordP2uiv(GLenum type, const GLuint * coords)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexCoordP2uiv");
   CALL_TexCoordP2uiv(ctx->CurrentServerDispatch, (type, coords));
}


/* Uniform3fv: marshalled asynchronously */
struct marshal_cmd_Uniform3fv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 12) bytes are GLfloat value[count][3] */
};
static inline void
_mesa_unmarshal_Uniform3fv(struct gl_context *ctx, const struct marshal_cmd_Uniform3fv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 12;
   CALL_Uniform3fv(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform3fv(GLint location, GLsizei count, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform3fv) + safe_mul(count, 12);
   struct marshal_cmd_Uniform3fv *cmd;
   debug_print_marshal("Uniform3fv");
   if (unlikely(safe_mul(count, 12) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform3fv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 12);
      variable_data += count * 12;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform3fv");
   CALL_Uniform3fv(ctx->CurrentServerDispatch, (location, count, value));
}


/* BlendEquation: marshalled asynchronously */
struct marshal_cmd_BlendEquation
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
};
static inline void
_mesa_unmarshal_BlendEquation(struct gl_context *ctx, const struct marshal_cmd_BlendEquation *cmd)
{
   const GLenum mode = cmd->mode;
   CALL_BlendEquation(ctx->CurrentServerDispatch, (mode));
}
static void GLAPIENTRY
_mesa_marshal_BlendEquation(GLenum mode)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BlendEquation);
   struct marshal_cmd_BlendEquation *cmd;
   debug_print_marshal("BlendEquation");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BlendEquation, cmd_size);
      cmd->mode = mode;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BlendEquation");
   CALL_BlendEquation(ctx->CurrentServerDispatch, (mode));
}


/* VertexAttrib3dNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib3dNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble x;
   GLdouble y;
   GLdouble z;
};
static inline void
_mesa_unmarshal_VertexAttrib3dNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib3dNV *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   CALL_VertexAttrib3dNV(ctx->CurrentServerDispatch, (index, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib3dNV);
   struct marshal_cmd_VertexAttrib3dNV *cmd;
   debug_print_marshal("VertexAttrib3dNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib3dNV, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib3dNV");
   CALL_VertexAttrib3dNV(ctx->CurrentServerDispatch, (index, x, y, z));
}


/* PushName: marshalled asynchronously */
struct marshal_cmd_PushName
{
   struct marshal_cmd_base cmd_base;
   GLuint name;
};
static inline void
_mesa_unmarshal_PushName(struct gl_context *ctx, const struct marshal_cmd_PushName *cmd)
{
   const GLuint name = cmd->name;
   CALL_PushName(ctx->CurrentServerDispatch, (name));
}
static void GLAPIENTRY
_mesa_marshal_PushName(GLuint name)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PushName);
   struct marshal_cmd_PushName *cmd;
   debug_print_marshal("PushName");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PushName, cmd_size);
      cmd->name = name;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PushName");
   CALL_PushName(ctx->CurrentServerDispatch, (name));
}


/* DeleteRenderbuffers: marshalled asynchronously */
struct marshal_cmd_DeleteRenderbuffers
{
   struct marshal_cmd_base cmd_base;
   GLsizei n;
   /* Next safe_mul(n, 4) bytes are GLuint renderbuffers[n] */
};
static inline void
_mesa_unmarshal_DeleteRenderbuffers(struct gl_context *ctx, const struct marshal_cmd_DeleteRenderbuffers *cmd)
{
   const GLsizei n = cmd->n;
   const GLuint * renderbuffers;
   const char *variable_data = (const char *) (cmd + 1);
   renderbuffers = (const GLuint *) variable_data;
   variable_data += n * 4;
   CALL_DeleteRenderbuffers(ctx->CurrentServerDispatch, (n, renderbuffers));
}
static void GLAPIENTRY
_mesa_marshal_DeleteRenderbuffers(GLsizei n, const GLuint * renderbuffers)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DeleteRenderbuffers) + safe_mul(n, 4);
   struct marshal_cmd_DeleteRenderbuffers *cmd;
   debug_print_marshal("DeleteRenderbuffers");
   if (unlikely(safe_mul(n, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DeleteRenderbuffers, cmd_size);
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, renderbuffers, n * 4);
      variable_data += n * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DeleteRenderbuffers");
   CALL_DeleteRenderbuffers(ctx->CurrentServerDispatch, (n, renderbuffers));
}


/* VertexAttrib1dv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib1dv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble v[1];
};
static inline void
_mesa_unmarshal_VertexAttrib1dv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib1dv *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble * v = cmd->v;
   CALL_VertexAttrib1dv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib1dv(GLuint index, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib1dv);
   struct marshal_cmd_VertexAttrib1dv *cmd;
   debug_print_marshal("VertexAttrib1dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib1dv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib1dv");
   CALL_VertexAttrib1dv(ctx->CurrentServerDispatch, (index, v));
}


/* IsShader: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsShader(GLuint shader)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsShader");
   return CALL_IsShader(ctx->CurrentServerDispatch, (shader));
}


/* Rotated: marshalled asynchronously */
struct marshal_cmd_Rotated
{
   struct marshal_cmd_base cmd_base;
   GLdouble angle;
   GLdouble x;
   GLdouble y;
   GLdouble z;
};
static inline void
_mesa_unmarshal_Rotated(struct gl_context *ctx, const struct marshal_cmd_Rotated *cmd)
{
   const GLdouble angle = cmd->angle;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   const GLdouble z = cmd->z;
   CALL_Rotated(ctx->CurrentServerDispatch, (angle, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_Rotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Rotated);
   struct marshal_cmd_Rotated *cmd;
   debug_print_marshal("Rotated");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Rotated, cmd_size);
      cmd->angle = angle;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Rotated");
   CALL_Rotated(ctx->CurrentServerDispatch, (angle, x, y, z));
}


/* Color4iv: marshalled asynchronously */
struct marshal_cmd_Color4iv
{
   struct marshal_cmd_base cmd_base;
   GLint v[4];
};
static inline void
_mesa_unmarshal_Color4iv(struct gl_context *ctx, const struct marshal_cmd_Color4iv *cmd)
{
   const GLint * v = cmd->v;
   CALL_Color4iv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Color4iv(const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color4iv);
   struct marshal_cmd_Color4iv *cmd;
   debug_print_marshal("Color4iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color4iv, cmd_size);
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color4iv");
   CALL_Color4iv(ctx->CurrentServerDispatch, (v));
}


/* PointParameterxv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_PointParameterxv(GLenum pname, const GLfixed * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("PointParameterxv");
   CALL_PointParameterxv(ctx->CurrentServerDispatch, (pname, params));
}


/* Rotatex: marshalled asynchronously */
struct marshal_cmd_Rotatex
{
   struct marshal_cmd_base cmd_base;
   GLfixed angle;
   GLfixed x;
   GLfixed y;
   GLfixed z;
};
static inline void
_mesa_unmarshal_Rotatex(struct gl_context *ctx, const struct marshal_cmd_Rotatex *cmd)
{
   const GLfixed angle = cmd->angle;
   const GLfixed x = cmd->x;
   const GLfixed y = cmd->y;
   const GLfixed z = cmd->z;
   CALL_Rotatex(ctx->CurrentServerDispatch, (angle, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_Rotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Rotatex);
   struct marshal_cmd_Rotatex *cmd;
   debug_print_marshal("Rotatex");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Rotatex, cmd_size);
      cmd->angle = angle;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Rotatex");
   CALL_Rotatex(ctx->CurrentServerDispatch, (angle, x, y, z));
}


/* FramebufferTextureLayer: marshalled asynchronously */
struct marshal_cmd_FramebufferTextureLayer
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum attachment;
   GLuint texture;
   GLint level;
   GLint layer;
};
static inline void
_mesa_unmarshal_FramebufferTextureLayer(struct gl_context *ctx, const struct marshal_cmd_FramebufferTextureLayer *cmd)
{
   const GLenum target = cmd->target;
   const GLenum attachment = cmd->attachment;
   const GLuint texture = cmd->texture;
   const GLint level = cmd->level;
   const GLint layer = cmd->layer;
   CALL_FramebufferTextureLayer(ctx->CurrentServerDispatch, (target, attachment, texture, level, layer));
}
static void GLAPIENTRY
_mesa_marshal_FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_FramebufferTextureLayer);
   struct marshal_cmd_FramebufferTextureLayer *cmd;
   debug_print_marshal("FramebufferTextureLayer");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_FramebufferTextureLayer, cmd_size);
      cmd->target = target;
      cmd->attachment = attachment;
      cmd->texture = texture;
      cmd->level = level;
      cmd->layer = layer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("FramebufferTextureLayer");
   CALL_FramebufferTextureLayer(ctx->CurrentServerDispatch, (target, attachment, texture, level, layer));
}


/* TexEnvfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexEnvfv(GLenum target, GLenum pname, const GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexEnvfv");
   CALL_TexEnvfv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* ProgramUniformMatrix3fv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix3fv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 36) bytes are GLfloat value[count][9] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix3fv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix3fv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 36;
   CALL_ProgramUniformMatrix3fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix3fv) + safe_mul(count, 36);
   struct marshal_cmd_ProgramUniformMatrix3fv *cmd;
   debug_print_marshal("ProgramUniformMatrix3fv");
   if (unlikely(safe_mul(count, 36) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix3fv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 36);
      variable_data += count * 36;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix3fv");
   CALL_ProgramUniformMatrix3fv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* DeleteMemoryObjectsEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_DeleteMemoryObjectsEXT(GLsizei n, const GLuint * memoryObjects)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("DeleteMemoryObjectsEXT");
   CALL_DeleteMemoryObjectsEXT(ctx->CurrentServerDispatch, (n, memoryObjects));
}


/* LoadMatrixf: marshalled asynchronously */
struct marshal_cmd_LoadMatrixf
{
   struct marshal_cmd_base cmd_base;
   GLfloat m[16];
};
static inline void
_mesa_unmarshal_LoadMatrixf(struct gl_context *ctx, const struct marshal_cmd_LoadMatrixf *cmd)
{
   const GLfloat * m = cmd->m;
   CALL_LoadMatrixf(ctx->CurrentServerDispatch, (m));
}
static void GLAPIENTRY
_mesa_marshal_LoadMatrixf(const GLfloat * m)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_LoadMatrixf);
   struct marshal_cmd_LoadMatrixf *cmd;
   debug_print_marshal("LoadMatrixf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_LoadMatrixf, cmd_size);
      memcpy(cmd->m, m, 64);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("LoadMatrixf");
   CALL_LoadMatrixf(ctx->CurrentServerDispatch, (m));
}


/* GetProgramLocalParameterfvARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramLocalParameterfvARB");
   CALL_GetProgramLocalParameterfvARB(ctx->CurrentServerDispatch, (target, index, params));
}


/* MakeTextureHandleResidentARB: marshalled asynchronously */
struct marshal_cmd_MakeTextureHandleResidentARB
{
   struct marshal_cmd_base cmd_base;
   GLuint64 handle;
};
static inline void
_mesa_unmarshal_MakeTextureHandleResidentARB(struct gl_context *ctx, const struct marshal_cmd_MakeTextureHandleResidentARB *cmd)
{
   const GLuint64 handle = cmd->handle;
   CALL_MakeTextureHandleResidentARB(ctx->CurrentServerDispatch, (handle));
}
static void GLAPIENTRY
_mesa_marshal_MakeTextureHandleResidentARB(GLuint64 handle)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MakeTextureHandleResidentARB);
   struct marshal_cmd_MakeTextureHandleResidentARB *cmd;
   debug_print_marshal("MakeTextureHandleResidentARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MakeTextureHandleResidentARB, cmd_size);
      cmd->handle = handle;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MakeTextureHandleResidentARB");
   CALL_MakeTextureHandleResidentARB(ctx->CurrentServerDispatch, (handle));
}


/* MultiDrawArraysIndirect: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_MultiDrawArraysIndirect(GLenum mode, const GLvoid * indirect, GLsizei primcount, GLsizei stride)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MultiDrawArraysIndirect");
   CALL_MultiDrawArraysIndirect(ctx->CurrentServerDispatch, (mode, indirect, primcount, stride));
}


/* DrawRangeElementsBaseVertex: marshalled asynchronously */
struct marshal_cmd_DrawRangeElementsBaseVertex
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLuint start;
   GLuint end;
   GLsizei count;
   GLenum type;
   const GLvoid * indices;
   GLint basevertex;
};
static inline void
_mesa_unmarshal_DrawRangeElementsBaseVertex(struct gl_context *ctx, const struct marshal_cmd_DrawRangeElementsBaseVertex *cmd)
{
   const GLenum mode = cmd->mode;
   const GLuint start = cmd->start;
   const GLuint end = cmd->end;
   const GLsizei count = cmd->count;
   const GLenum type = cmd->type;
   const GLvoid * indices = cmd->indices;
   const GLint basevertex = cmd->basevertex;
   CALL_DrawRangeElementsBaseVertex(ctx->CurrentServerDispatch, (mode, start, end, count, type, indices, basevertex));
}
static void GLAPIENTRY
_mesa_marshal_DrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid * indices, GLint basevertex)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawRangeElementsBaseVertex);
   struct marshal_cmd_DrawRangeElementsBaseVertex *cmd;
   debug_print_marshal("DrawRangeElementsBaseVertex");
   if (_mesa_glthread_is_non_vbo_draw_elements(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("DrawRangeElementsBaseVertex");
      CALL_DrawRangeElementsBaseVertex(ctx->CurrentServerDispatch, (mode, start, end, count, type, indices, basevertex));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawRangeElementsBaseVertex, cmd_size);
      cmd->mode = mode;
      cmd->start = start;
      cmd->end = end;
      cmd->count = count;
      cmd->type = type;
      cmd->indices = indices;
      cmd->basevertex = basevertex;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawRangeElementsBaseVertex");
   CALL_DrawRangeElementsBaseVertex(ctx->CurrentServerDispatch, (mode, start, end, count, type, indices, basevertex));
}


/* ProgramUniformMatrix4dv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix4dv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 128) bytes are GLdouble value[count][16] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix4dv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix4dv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 128;
   CALL_ProgramUniformMatrix4dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix4dv) + safe_mul(count, 128);
   struct marshal_cmd_ProgramUniformMatrix4dv *cmd;
   debug_print_marshal("ProgramUniformMatrix4dv");
   if (unlikely(safe_mul(count, 128) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix4dv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 128);
      variable_data += count * 128;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix4dv");
   CALL_ProgramUniformMatrix4dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* SecondaryColor3bv: marshalled asynchronously */
struct marshal_cmd_SecondaryColor3bv
{
   struct marshal_cmd_base cmd_base;
   GLbyte v[3];
};
static inline void
_mesa_unmarshal_SecondaryColor3bv(struct gl_context *ctx, const struct marshal_cmd_SecondaryColor3bv *cmd)
{
   const GLbyte * v = cmd->v;
   CALL_SecondaryColor3bv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColor3bv(const GLbyte * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColor3bv);
   struct marshal_cmd_SecondaryColor3bv *cmd;
   debug_print_marshal("SecondaryColor3bv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColor3bv, cmd_size);
      memcpy(cmd->v, v, 3);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColor3bv");
   CALL_SecondaryColor3bv(ctx->CurrentServerDispatch, (v));
}


/* DrawTexxvOES: marshalled asynchronously */
struct marshal_cmd_DrawTexxvOES
{
   struct marshal_cmd_base cmd_base;
   GLfixed coords[5];
};
static inline void
_mesa_unmarshal_DrawTexxvOES(struct gl_context *ctx, const struct marshal_cmd_DrawTexxvOES *cmd)
{
   const GLfixed * coords = cmd->coords;
   CALL_DrawTexxvOES(ctx->CurrentServerDispatch, (coords));
}
static void GLAPIENTRY
_mesa_marshal_DrawTexxvOES(const GLfixed * coords)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawTexxvOES);
   struct marshal_cmd_DrawTexxvOES *cmd;
   debug_print_marshal("DrawTexxvOES");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawTexxvOES, cmd_size);
      memcpy(cmd->coords, coords, 20);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawTexxvOES");
   CALL_DrawTexxvOES(ctx->CurrentServerDispatch, (coords));
}


/* TexParameterfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexParameterfv(GLenum target, GLenum pname, const GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexParameterfv");
   CALL_TexParameterfv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* Color4ubv: marshalled asynchronously */
struct marshal_cmd_Color4ubv
{
   struct marshal_cmd_base cmd_base;
   GLubyte v[4];
};
static inline void
_mesa_unmarshal_Color4ubv(struct gl_context *ctx, const struct marshal_cmd_Color4ubv *cmd)
{
   const GLubyte * v = cmd->v;
   CALL_Color4ubv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Color4ubv(const GLubyte * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color4ubv);
   struct marshal_cmd_Color4ubv *cmd;
   debug_print_marshal("Color4ubv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color4ubv, cmd_size);
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color4ubv");
   CALL_Color4ubv(ctx->CurrentServerDispatch, (v));
}


/* TexCoord2fv: marshalled asynchronously */
struct marshal_cmd_TexCoord2fv
{
   struct marshal_cmd_base cmd_base;
   GLfloat v[2];
};
static inline void
_mesa_unmarshal_TexCoord2fv(struct gl_context *ctx, const struct marshal_cmd_TexCoord2fv *cmd)
{
   const GLfloat * v = cmd->v;
   CALL_TexCoord2fv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord2fv(const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord2fv);
   struct marshal_cmd_TexCoord2fv *cmd;
   debug_print_marshal("TexCoord2fv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord2fv, cmd_size);
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord2fv");
   CALL_TexCoord2fv(ctx->CurrentServerDispatch, (v));
}


/* FogCoorddv: marshalled asynchronously */
struct marshal_cmd_FogCoorddv
{
   struct marshal_cmd_base cmd_base;
   GLdouble coord[1];
};
static inline void
_mesa_unmarshal_FogCoorddv(struct gl_context *ctx, const struct marshal_cmd_FogCoorddv *cmd)
{
   const GLdouble * coord = cmd->coord;
   CALL_FogCoorddv(ctx->CurrentServerDispatch, (coord));
}
static void GLAPIENTRY
_mesa_marshal_FogCoorddv(const GLdouble * coord)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_FogCoorddv);
   struct marshal_cmd_FogCoorddv *cmd;
   debug_print_marshal("FogCoorddv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_FogCoorddv, cmd_size);
      memcpy(cmd->coord, coord, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("FogCoorddv");
   CALL_FogCoorddv(ctx->CurrentServerDispatch, (coord));
}


/* VDPAUUnregisterSurfaceNV: marshalled asynchronously */
struct marshal_cmd_VDPAUUnregisterSurfaceNV
{
   struct marshal_cmd_base cmd_base;
   GLintptr surface;
};
static inline void
_mesa_unmarshal_VDPAUUnregisterSurfaceNV(struct gl_context *ctx, const struct marshal_cmd_VDPAUUnregisterSurfaceNV *cmd)
{
   const GLintptr surface = cmd->surface;
   CALL_VDPAUUnregisterSurfaceNV(ctx->CurrentServerDispatch, (surface));
}
static void GLAPIENTRY
_mesa_marshal_VDPAUUnregisterSurfaceNV(GLintptr surface)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VDPAUUnregisterSurfaceNV);
   struct marshal_cmd_VDPAUUnregisterSurfaceNV *cmd;
   debug_print_marshal("VDPAUUnregisterSurfaceNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VDPAUUnregisterSurfaceNV, cmd_size);
      cmd->surface = surface;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VDPAUUnregisterSurfaceNV");
   CALL_VDPAUUnregisterSurfaceNV(ctx->CurrentServerDispatch, (surface));
}


/* ColorP3ui: marshalled asynchronously */
struct marshal_cmd_ColorP3ui
{
   struct marshal_cmd_base cmd_base;
   GLenum type;
   GLuint color;
};
static inline void
_mesa_unmarshal_ColorP3ui(struct gl_context *ctx, const struct marshal_cmd_ColorP3ui *cmd)
{
   const GLenum type = cmd->type;
   const GLuint color = cmd->color;
   CALL_ColorP3ui(ctx->CurrentServerDispatch, (type, color));
}
static void GLAPIENTRY
_mesa_marshal_ColorP3ui(GLenum type, GLuint color)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ColorP3ui);
   struct marshal_cmd_ColorP3ui *cmd;
   debug_print_marshal("ColorP3ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ColorP3ui, cmd_size);
      cmd->type = type;
      cmd->color = color;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ColorP3ui");
   CALL_ColorP3ui(ctx->CurrentServerDispatch, (type, color));
}


/* GetUnsignedBytei_vEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetUnsignedBytei_vEXT");
   CALL_GetUnsignedBytei_vEXT(ctx->CurrentServerDispatch, (target, index, data));
}


/* GetShaderPrecisionFormat: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint * range, GLint * precision)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetShaderPrecisionFormat");
   CALL_GetShaderPrecisionFormat(ctx->CurrentServerDispatch, (shadertype, precisiontype, range, precision));
}


/* MakeTextureHandleNonResidentARB: marshalled asynchronously */
struct marshal_cmd_MakeTextureHandleNonResidentARB
{
   struct marshal_cmd_base cmd_base;
   GLuint64 handle;
};
static inline void
_mesa_unmarshal_MakeTextureHandleNonResidentARB(struct gl_context *ctx, const struct marshal_cmd_MakeTextureHandleNonResidentARB *cmd)
{
   const GLuint64 handle = cmd->handle;
   CALL_MakeTextureHandleNonResidentARB(ctx->CurrentServerDispatch, (handle));
}
static void GLAPIENTRY
_mesa_marshal_MakeTextureHandleNonResidentARB(GLuint64 handle)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MakeTextureHandleNonResidentARB);
   struct marshal_cmd_MakeTextureHandleNonResidentARB *cmd;
   debug_print_marshal("MakeTextureHandleNonResidentARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MakeTextureHandleNonResidentARB, cmd_size);
      cmd->handle = handle;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MakeTextureHandleNonResidentARB");
   CALL_MakeTextureHandleNonResidentARB(ctx->CurrentServerDispatch, (handle));
}


/* VertexAttribI4iEXT: marshalled asynchronously */
struct marshal_cmd_VertexAttribI4iEXT
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLint x;
   GLint y;
   GLint z;
   GLint w;
};
static inline void
_mesa_unmarshal_VertexAttribI4iEXT(struct gl_context *ctx, const struct marshal_cmd_VertexAttribI4iEXT *cmd)
{
   const GLuint index = cmd->index;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLint z = cmd->z;
   const GLint w = cmd->w;
   CALL_VertexAttribI4iEXT(ctx->CurrentServerDispatch, (index, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribI4iEXT(GLuint index, GLint x, GLint y, GLint z, GLint w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribI4iEXT);
   struct marshal_cmd_VertexAttribI4iEXT *cmd;
   debug_print_marshal("VertexAttribI4iEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribI4iEXT, cmd_size);
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribI4iEXT");
   CALL_VertexAttribI4iEXT(ctx->CurrentServerDispatch, (index, x, y, z, w));
}


/* VertexAttribI3uivEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribI3uivEXT(GLuint index, const GLuint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribI3uivEXT");
   CALL_VertexAttribI3uivEXT(ctx->CurrentServerDispatch, (index, v));
}


/* FogCoordd: marshalled asynchronously */
struct marshal_cmd_FogCoordd
{
   struct marshal_cmd_base cmd_base;
   GLdouble coord;
};
static inline void
_mesa_unmarshal_FogCoordd(struct gl_context *ctx, const struct marshal_cmd_FogCoordd *cmd)
{
   const GLdouble coord = cmd->coord;
   CALL_FogCoordd(ctx->CurrentServerDispatch, (coord));
}
static void GLAPIENTRY
_mesa_marshal_FogCoordd(GLdouble coord)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_FogCoordd);
   struct marshal_cmd_FogCoordd *cmd;
   debug_print_marshal("FogCoordd");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_FogCoordd, cmd_size);
      cmd->coord = coord;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("FogCoordd");
   CALL_FogCoordd(ctx->CurrentServerDispatch, (coord));
}


/* BindFramebufferEXT: marshalled asynchronously */
struct marshal_cmd_BindFramebufferEXT
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint framebuffer;
};
static inline void
_mesa_unmarshal_BindFramebufferEXT(struct gl_context *ctx, const struct marshal_cmd_BindFramebufferEXT *cmd)
{
   const GLenum target = cmd->target;
   const GLuint framebuffer = cmd->framebuffer;
   CALL_BindFramebufferEXT(ctx->CurrentServerDispatch, (target, framebuffer));
}
static void GLAPIENTRY
_mesa_marshal_BindFramebufferEXT(GLenum target, GLuint framebuffer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BindFramebufferEXT);
   struct marshal_cmd_BindFramebufferEXT *cmd;
   debug_print_marshal("BindFramebufferEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BindFramebufferEXT, cmd_size);
      cmd->target = target;
      cmd->framebuffer = framebuffer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BindFramebufferEXT");
   CALL_BindFramebufferEXT(ctx->CurrentServerDispatch, (target, framebuffer));
}


/* Uniform3iv: marshalled asynchronously */
struct marshal_cmd_Uniform3iv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 12) bytes are GLint value[count][3] */
};
static inline void
_mesa_unmarshal_Uniform3iv(struct gl_context *ctx, const struct marshal_cmd_Uniform3iv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLint * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLint *) variable_data;
   variable_data += count * 12;
   CALL_Uniform3iv(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform3iv(GLint location, GLsizei count, const GLint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform3iv) + safe_mul(count, 12);
   struct marshal_cmd_Uniform3iv *cmd;
   debug_print_marshal("Uniform3iv");
   if (unlikely(safe_mul(count, 12) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform3iv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 12);
      variable_data += count * 12;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform3iv");
   CALL_Uniform3iv(ctx->CurrentServerDispatch, (location, count, value));
}


/* TexStorage2DMultisample: marshalled asynchronously */
struct marshal_cmd_TexStorage2DMultisample
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei samples;
   GLenum internalformat;
   GLsizei width;
   GLsizei height;
   GLboolean fixedsamplelocations;
};
static inline void
_mesa_unmarshal_TexStorage2DMultisample(struct gl_context *ctx, const struct marshal_cmd_TexStorage2DMultisample *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei samples = cmd->samples;
   const GLenum internalformat = cmd->internalformat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLboolean fixedsamplelocations = cmd->fixedsamplelocations;
   CALL_TexStorage2DMultisample(ctx->CurrentServerDispatch, (target, samples, internalformat, width, height, fixedsamplelocations));
}
static void GLAPIENTRY
_mesa_marshal_TexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexStorage2DMultisample);
   struct marshal_cmd_TexStorage2DMultisample *cmd;
   debug_print_marshal("TexStorage2DMultisample");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexStorage2DMultisample, cmd_size);
      cmd->target = target;
      cmd->samples = samples;
      cmd->internalformat = internalformat;
      cmd->width = width;
      cmd->height = height;
      cmd->fixedsamplelocations = fixedsamplelocations;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexStorage2DMultisample");
   CALL_TexStorage2DMultisample(ctx->CurrentServerDispatch, (target, samples, internalformat, width, height, fixedsamplelocations));
}


/* UnlockArraysEXT: marshalled asynchronously */
struct marshal_cmd_UnlockArraysEXT
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_UnlockArraysEXT(struct gl_context *ctx, const struct marshal_cmd_UnlockArraysEXT *cmd)
{
   CALL_UnlockArraysEXT(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_UnlockArraysEXT(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UnlockArraysEXT);
   struct marshal_cmd_UnlockArraysEXT *cmd;
   debug_print_marshal("UnlockArraysEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UnlockArraysEXT, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UnlockArraysEXT");
   CALL_UnlockArraysEXT(ctx->CurrentServerDispatch, ());
}


/* GetVertexAttribLui64vARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetVertexAttribLui64vARB(GLuint index, GLenum pname, GLuint64EXT * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetVertexAttribLui64vARB");
   CALL_GetVertexAttribLui64vARB(ctx->CurrentServerDispatch, (index, pname, params));
}


/* VertexAttrib4iv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4iv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLint v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4iv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4iv *cmd)
{
   const GLuint index = cmd->index;
   const GLint * v = cmd->v;
   CALL_VertexAttrib4iv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4iv(GLuint index, const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4iv);
   struct marshal_cmd_VertexAttrib4iv *cmd;
   debug_print_marshal("VertexAttrib4iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4iv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4iv");
   CALL_VertexAttrib4iv(ctx->CurrentServerDispatch, (index, v));
}


/* CopyTexSubImage3D: marshalled asynchronously */
struct marshal_cmd_CopyTexSubImage3D
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLint level;
   GLint xoffset;
   GLint yoffset;
   GLint zoffset;
   GLint x;
   GLint y;
   GLsizei width;
   GLsizei height;
};
static inline void
_mesa_unmarshal_CopyTexSubImage3D(struct gl_context *ctx, const struct marshal_cmd_CopyTexSubImage3D *cmd)
{
   const GLenum target = cmd->target;
   const GLint level = cmd->level;
   const GLint xoffset = cmd->xoffset;
   const GLint yoffset = cmd->yoffset;
   const GLint zoffset = cmd->zoffset;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   CALL_CopyTexSubImage3D(ctx->CurrentServerDispatch, (target, level, xoffset, yoffset, zoffset, x, y, width, height));
}
static void GLAPIENTRY
_mesa_marshal_CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CopyTexSubImage3D);
   struct marshal_cmd_CopyTexSubImage3D *cmd;
   debug_print_marshal("CopyTexSubImage3D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CopyTexSubImage3D, cmd_size);
      cmd->target = target;
      cmd->level = level;
      cmd->xoffset = xoffset;
      cmd->yoffset = yoffset;
      cmd->zoffset = zoffset;
      cmd->x = x;
      cmd->y = y;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CopyTexSubImage3D");
   CALL_CopyTexSubImage3D(ctx->CurrentServerDispatch, (target, level, xoffset, yoffset, zoffset, x, y, width, height));
}


/* PolygonOffsetClampEXT: marshalled asynchronously */
struct marshal_cmd_PolygonOffsetClampEXT
{
   struct marshal_cmd_base cmd_base;
   GLfloat factor;
   GLfloat units;
   GLfloat clamp;
};
static inline void
_mesa_unmarshal_PolygonOffsetClampEXT(struct gl_context *ctx, const struct marshal_cmd_PolygonOffsetClampEXT *cmd)
{
   const GLfloat factor = cmd->factor;
   const GLfloat units = cmd->units;
   const GLfloat clamp = cmd->clamp;
   CALL_PolygonOffsetClampEXT(ctx->CurrentServerDispatch, (factor, units, clamp));
}
static void GLAPIENTRY
_mesa_marshal_PolygonOffsetClampEXT(GLfloat factor, GLfloat units, GLfloat clamp)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PolygonOffsetClampEXT);
   struct marshal_cmd_PolygonOffsetClampEXT *cmd;
   debug_print_marshal("PolygonOffsetClampEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PolygonOffsetClampEXT, cmd_size);
      cmd->factor = factor;
      cmd->units = units;
      cmd->clamp = clamp;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PolygonOffsetClampEXT");
   CALL_PolygonOffsetClampEXT(ctx->CurrentServerDispatch, (factor, units, clamp));
}


/* GetInteger64v: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetInteger64v(GLenum pname, GLint64 * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetInteger64v");
   CALL_GetInteger64v(ctx->CurrentServerDispatch, (pname, params));
}


/* DetachObjectARB: marshalled asynchronously */
struct marshal_cmd_DetachObjectARB
{
   struct marshal_cmd_base cmd_base;
   GLhandleARB containerObj;
   GLhandleARB attachedObj;
};
static inline void
_mesa_unmarshal_DetachObjectARB(struct gl_context *ctx, const struct marshal_cmd_DetachObjectARB *cmd)
{
   const GLhandleARB containerObj = cmd->containerObj;
   const GLhandleARB attachedObj = cmd->attachedObj;
   CALL_DetachObjectARB(ctx->CurrentServerDispatch, (containerObj, attachedObj));
}
static void GLAPIENTRY
_mesa_marshal_DetachObjectARB(GLhandleARB containerObj, GLhandleARB attachedObj)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DetachObjectARB);
   struct marshal_cmd_DetachObjectARB *cmd;
   debug_print_marshal("DetachObjectARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DetachObjectARB, cmd_size);
      cmd->containerObj = containerObj;
      cmd->attachedObj = attachedObj;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DetachObjectARB");
   CALL_DetachObjectARB(ctx->CurrentServerDispatch, (containerObj, attachedObj));
}


/* Indexiv: marshalled asynchronously */
struct marshal_cmd_Indexiv
{
   struct marshal_cmd_base cmd_base;
   GLint c[1];
};
static inline void
_mesa_unmarshal_Indexiv(struct gl_context *ctx, const struct marshal_cmd_Indexiv *cmd)
{
   const GLint * c = cmd->c;
   CALL_Indexiv(ctx->CurrentServerDispatch, (c));
}
static void GLAPIENTRY
_mesa_marshal_Indexiv(const GLint * c)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Indexiv);
   struct marshal_cmd_Indexiv *cmd;
   debug_print_marshal("Indexiv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Indexiv, cmd_size);
      memcpy(cmd->c, c, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Indexiv");
   CALL_Indexiv(ctx->CurrentServerDispatch, (c));
}


/* TexEnvi: marshalled asynchronously */
struct marshal_cmd_TexEnvi
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum pname;
   GLint param;
};
static inline void
_mesa_unmarshal_TexEnvi(struct gl_context *ctx, const struct marshal_cmd_TexEnvi *cmd)
{
   const GLenum target = cmd->target;
   const GLenum pname = cmd->pname;
   const GLint param = cmd->param;
   CALL_TexEnvi(ctx->CurrentServerDispatch, (target, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_TexEnvi(GLenum target, GLenum pname, GLint param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexEnvi);
   struct marshal_cmd_TexEnvi *cmd;
   debug_print_marshal("TexEnvi");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexEnvi, cmd_size);
      cmd->target = target;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexEnvi");
   CALL_TexEnvi(ctx->CurrentServerDispatch, (target, pname, param));
}


/* TexEnvf: marshalled asynchronously */
struct marshal_cmd_TexEnvf
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum pname;
   GLfloat param;
};
static inline void
_mesa_unmarshal_TexEnvf(struct gl_context *ctx, const struct marshal_cmd_TexEnvf *cmd)
{
   const GLenum target = cmd->target;
   const GLenum pname = cmd->pname;
   const GLfloat param = cmd->param;
   CALL_TexEnvf(ctx->CurrentServerDispatch, (target, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_TexEnvf(GLenum target, GLenum pname, GLfloat param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexEnvf);
   struct marshal_cmd_TexEnvf *cmd;
   debug_print_marshal("TexEnvf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexEnvf, cmd_size);
      cmd->target = target;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexEnvf");
   CALL_TexEnvf(ctx->CurrentServerDispatch, (target, pname, param));
}


/* TexEnvx: marshalled asynchronously */
struct marshal_cmd_TexEnvx
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum pname;
   GLfixed param;
};
static inline void
_mesa_unmarshal_TexEnvx(struct gl_context *ctx, const struct marshal_cmd_TexEnvx *cmd)
{
   const GLenum target = cmd->target;
   const GLenum pname = cmd->pname;
   const GLfixed param = cmd->param;
   CALL_TexEnvx(ctx->CurrentServerDispatch, (target, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_TexEnvx(GLenum target, GLenum pname, GLfixed param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexEnvx);
   struct marshal_cmd_TexEnvx *cmd;
   debug_print_marshal("TexEnvx");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexEnvx, cmd_size);
      cmd->target = target;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexEnvx");
   CALL_TexEnvx(ctx->CurrentServerDispatch, (target, pname, param));
}


/* InvalidateBufferSubData: marshalled asynchronously */
struct marshal_cmd_InvalidateBufferSubData
{
   struct marshal_cmd_base cmd_base;
   GLuint buffer;
   GLintptr offset;
   GLsizeiptr length;
};
static inline void
_mesa_unmarshal_InvalidateBufferSubData(struct gl_context *ctx, const struct marshal_cmd_InvalidateBufferSubData *cmd)
{
   const GLuint buffer = cmd->buffer;
   const GLintptr offset = cmd->offset;
   const GLsizeiptr length = cmd->length;
   CALL_InvalidateBufferSubData(ctx->CurrentServerDispatch, (buffer, offset, length));
}
static void GLAPIENTRY
_mesa_marshal_InvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_InvalidateBufferSubData);
   struct marshal_cmd_InvalidateBufferSubData *cmd;
   debug_print_marshal("InvalidateBufferSubData");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_InvalidateBufferSubData, cmd_size);
      cmd->buffer = buffer;
      cmd->offset = offset;
      cmd->length = length;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("InvalidateBufferSubData");
   CALL_InvalidateBufferSubData(ctx->CurrentServerDispatch, (buffer, offset, length));
}


/* UniformMatrix4x2fv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix4x2fv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 32) bytes are GLfloat value[count][8] */
};
static inline void
_mesa_unmarshal_UniformMatrix4x2fv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix4x2fv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 32;
   CALL_UniformMatrix4x2fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix4x2fv) + safe_mul(count, 32);
   struct marshal_cmd_UniformMatrix4x2fv *cmd;
   debug_print_marshal("UniformMatrix4x2fv");
   if (unlikely(safe_mul(count, 32) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix4x2fv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 32);
      variable_data += count * 32;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix4x2fv");
   CALL_UniformMatrix4x2fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* ClearTexImage: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ClearTexImage");
   CALL_ClearTexImage(ctx->CurrentServerDispatch, (texture, level, format, type, data));
}


/* PolygonOffset: marshalled asynchronously */
struct marshal_cmd_PolygonOffset
{
   struct marshal_cmd_base cmd_base;
   GLfloat factor;
   GLfloat units;
};
static inline void
_mesa_unmarshal_PolygonOffset(struct gl_context *ctx, const struct marshal_cmd_PolygonOffset *cmd)
{
   const GLfloat factor = cmd->factor;
   const GLfloat units = cmd->units;
   CALL_PolygonOffset(ctx->CurrentServerDispatch, (factor, units));
}
static void GLAPIENTRY
_mesa_marshal_PolygonOffset(GLfloat factor, GLfloat units)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PolygonOffset);
   struct marshal_cmd_PolygonOffset *cmd;
   debug_print_marshal("PolygonOffset");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PolygonOffset, cmd_size);
      cmd->factor = factor;
      cmd->units = units;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PolygonOffset");
   CALL_PolygonOffset(ctx->CurrentServerDispatch, (factor, units));
}


/* SamplerParameterfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("SamplerParameterfv");
   CALL_SamplerParameterfv(ctx->CurrentServerDispatch, (sampler, pname, params));
}


/* CompressedTextureSubImage1D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CompressedTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CompressedTextureSubImage1D");
   CALL_CompressedTextureSubImage1D(ctx->CurrentServerDispatch, (texture, level, xoffset, width, format, imageSize, data));
}


/* ProgramUniformMatrix4x2dv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix4x2dv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 64) bytes are GLdouble value[count][8] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix4x2dv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix4x2dv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 64;
   CALL_ProgramUniformMatrix4x2dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix4x2dv) + safe_mul(count, 64);
   struct marshal_cmd_ProgramUniformMatrix4x2dv *cmd;
   debug_print_marshal("ProgramUniformMatrix4x2dv");
   if (unlikely(safe_mul(count, 64) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix4x2dv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 64);
      variable_data += count * 64;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix4x2dv");
   CALL_ProgramUniformMatrix4x2dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* ProgramEnvParameter4fARB: marshalled asynchronously */
struct marshal_cmd_ProgramEnvParameter4fARB
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint index;
   GLfloat x;
   GLfloat y;
   GLfloat z;
   GLfloat w;
};
static inline void
_mesa_unmarshal_ProgramEnvParameter4fARB(struct gl_context *ctx, const struct marshal_cmd_ProgramEnvParameter4fARB *cmd)
{
   const GLenum target = cmd->target;
   const GLuint index = cmd->index;
   const GLfloat x = cmd->x;
   const GLfloat y = cmd->y;
   const GLfloat z = cmd->z;
   const GLfloat w = cmd->w;
   CALL_ProgramEnvParameter4fARB(ctx->CurrentServerDispatch, (target, index, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_ProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramEnvParameter4fARB);
   struct marshal_cmd_ProgramEnvParameter4fARB *cmd;
   debug_print_marshal("ProgramEnvParameter4fARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramEnvParameter4fARB, cmd_size);
      cmd->target = target;
      cmd->index = index;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramEnvParameter4fARB");
   CALL_ProgramEnvParameter4fARB(ctx->CurrentServerDispatch, (target, index, x, y, z, w));
}


/* ClearDepth: marshalled asynchronously */
struct marshal_cmd_ClearDepth
{
   struct marshal_cmd_base cmd_base;
   GLclampd depth;
};
static inline void
_mesa_unmarshal_ClearDepth(struct gl_context *ctx, const struct marshal_cmd_ClearDepth *cmd)
{
   const GLclampd depth = cmd->depth;
   CALL_ClearDepth(ctx->CurrentServerDispatch, (depth));
}
static void GLAPIENTRY
_mesa_marshal_ClearDepth(GLclampd depth)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ClearDepth);
   struct marshal_cmd_ClearDepth *cmd;
   debug_print_marshal("ClearDepth");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ClearDepth, cmd_size);
      cmd->depth = depth;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ClearDepth");
   CALL_ClearDepth(ctx->CurrentServerDispatch, (depth));
}


/* VertexAttrib3dvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib3dvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble v[3];
};
static inline void
_mesa_unmarshal_VertexAttrib3dvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib3dvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble * v = cmd->v;
   CALL_VertexAttrib3dvNV(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib3dvNV(GLuint index, const GLdouble * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib3dvNV);
   struct marshal_cmd_VertexAttrib3dvNV *cmd;
   debug_print_marshal("VertexAttrib3dvNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib3dvNV, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 24);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib3dvNV");
   CALL_VertexAttrib3dvNV(ctx->CurrentServerDispatch, (index, v));
}


/* Color4fv: marshalled asynchronously */
struct marshal_cmd_Color4fv
{
   struct marshal_cmd_base cmd_base;
   GLfloat v[4];
};
static inline void
_mesa_unmarshal_Color4fv(struct gl_context *ctx, const struct marshal_cmd_Color4fv *cmd)
{
   const GLfloat * v = cmd->v;
   CALL_Color4fv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Color4fv(const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color4fv);
   struct marshal_cmd_Color4fv *cmd;
   debug_print_marshal("Color4fv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color4fv, cmd_size);
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color4fv");
   CALL_Color4fv(ctx->CurrentServerDispatch, (v));
}


/* GetnMinmaxARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetnMinmaxARB(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetnMinmaxARB");
   CALL_GetnMinmaxARB(ctx->CurrentServerDispatch, (target, reset, format, type, bufSize, values));
}


/* IsImageHandleResidentARB: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsImageHandleResidentARB(GLuint64 handle)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsImageHandleResidentARB");
   return CALL_IsImageHandleResidentARB(ctx->CurrentServerDispatch, (handle));
}


/* ColorPointer: marshalled asynchronously */
struct marshal_cmd_ColorPointer
{
   struct marshal_cmd_base cmd_base;
   GLint size;
   GLenum type;
   GLsizei stride;
   const GLvoid * pointer;
};
static inline void
_mesa_unmarshal_ColorPointer(struct gl_context *ctx, const struct marshal_cmd_ColorPointer *cmd)
{
   const GLint size = cmd->size;
   const GLenum type = cmd->type;
   const GLsizei stride = cmd->stride;
   const GLvoid * pointer = cmd->pointer;
   CALL_ColorPointer(ctx->CurrentServerDispatch, (size, type, stride, pointer));
}
static void GLAPIENTRY
_mesa_marshal_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ColorPointer);
   struct marshal_cmd_ColorPointer *cmd;
   debug_print_marshal("ColorPointer");
   if (_mesa_glthread_is_non_vbo_vertex_attrib_pointer(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("ColorPointer");
      CALL_ColorPointer(ctx->CurrentServerDispatch, (size, type, stride, pointer));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ColorPointer, cmd_size);
      cmd->size = size;
      cmd->type = type;
      cmd->stride = stride;
      cmd->pointer = pointer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ColorPointer");
   CALL_ColorPointer(ctx->CurrentServerDispatch, (size, type, stride, pointer));
}


/* ProgramUniform2ui64ARB: marshalled asynchronously */
struct marshal_cmd_ProgramUniform2ui64ARB
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLuint64 x;
   GLuint64 y;
};
static inline void
_mesa_unmarshal_ProgramUniform2ui64ARB(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform2ui64ARB *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLuint64 x = cmd->x;
   const GLuint64 y = cmd->y;
   CALL_ProgramUniform2ui64ARB(ctx->CurrentServerDispatch, (program, location, x, y));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform2ui64ARB(GLuint program, GLint location, GLuint64 x, GLuint64 y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform2ui64ARB);
   struct marshal_cmd_ProgramUniform2ui64ARB *cmd;
   debug_print_marshal("ProgramUniform2ui64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform2ui64ARB, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform2ui64ARB");
   CALL_ProgramUniform2ui64ARB(ctx->CurrentServerDispatch, (program, location, x, y));
}


/* Lightiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_Lightiv(GLenum light, GLenum pname, const GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("Lightiv");
   CALL_Lightiv(ctx->CurrentServerDispatch, (light, pname, params));
}


/* GetTexParameterIuiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTexParameterIuiv(GLenum target, GLenum pname, GLuint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTexParameterIuiv");
   CALL_GetTexParameterIuiv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* TransformFeedbackVaryings: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar * const * varyings, GLenum bufferMode)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TransformFeedbackVaryings");
   CALL_TransformFeedbackVaryings(ctx->CurrentServerDispatch, (program, count, varyings, bufferMode));
}


/* VertexAttrib3sv: marshalled asynchronously */
struct marshal_cmd_VertexAttrib3sv
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLshort v[3];
};
static inline void
_mesa_unmarshal_VertexAttrib3sv(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib3sv *cmd)
{
   const GLuint index = cmd->index;
   const GLshort * v = cmd->v;
   CALL_VertexAttrib3sv(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib3sv(GLuint index, const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib3sv);
   struct marshal_cmd_VertexAttrib3sv *cmd;
   debug_print_marshal("VertexAttrib3sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib3sv, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 6);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib3sv");
   CALL_VertexAttrib3sv(ctx->CurrentServerDispatch, (index, v));
}


/* Uniform4i64ARB: marshalled asynchronously */
struct marshal_cmd_Uniform4i64ARB
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLint64 x;
   GLint64 y;
   GLint64 z;
   GLint64 w;
};
static inline void
_mesa_unmarshal_Uniform4i64ARB(struct gl_context *ctx, const struct marshal_cmd_Uniform4i64ARB *cmd)
{
   const GLint location = cmd->location;
   const GLint64 x = cmd->x;
   const GLint64 y = cmd->y;
   const GLint64 z = cmd->z;
   const GLint64 w = cmd->w;
   CALL_Uniform4i64ARB(ctx->CurrentServerDispatch, (location, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_Uniform4i64ARB(GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform4i64ARB);
   struct marshal_cmd_Uniform4i64ARB *cmd;
   debug_print_marshal("Uniform4i64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform4i64ARB, cmd_size);
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform4i64ARB");
   CALL_Uniform4i64ARB(ctx->CurrentServerDispatch, (location, x, y, z, w));
}


/* IsVertexArray: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsVertexArray(GLuint array)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsVertexArray");
   return CALL_IsVertexArray(ctx->CurrentServerDispatch, (array));
}


/* ProgramUniform3ui64ARB: marshalled asynchronously */
struct marshal_cmd_ProgramUniform3ui64ARB
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLuint64 x;
   GLuint64 y;
   GLuint64 z;
};
static inline void
_mesa_unmarshal_ProgramUniform3ui64ARB(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform3ui64ARB *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLuint64 x = cmd->x;
   const GLuint64 y = cmd->y;
   const GLuint64 z = cmd->z;
   CALL_ProgramUniform3ui64ARB(ctx->CurrentServerDispatch, (program, location, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform3ui64ARB(GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform3ui64ARB);
   struct marshal_cmd_ProgramUniform3ui64ARB *cmd;
   debug_print_marshal("ProgramUniform3ui64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform3ui64ARB, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform3ui64ARB");
   CALL_ProgramUniform3ui64ARB(ctx->CurrentServerDispatch, (program, location, x, y, z));
}


/* PushClientAttrib: marshalled asynchronously */
struct marshal_cmd_PushClientAttrib
{
   struct marshal_cmd_base cmd_base;
   GLbitfield mask;
};
static inline void
_mesa_unmarshal_PushClientAttrib(struct gl_context *ctx, const struct marshal_cmd_PushClientAttrib *cmd)
{
   const GLbitfield mask = cmd->mask;
   CALL_PushClientAttrib(ctx->CurrentServerDispatch, (mask));
}
static void GLAPIENTRY
_mesa_marshal_PushClientAttrib(GLbitfield mask)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PushClientAttrib);
   struct marshal_cmd_PushClientAttrib *cmd;
   debug_print_marshal("PushClientAttrib");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PushClientAttrib, cmd_size);
      cmd->mask = mask;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PushClientAttrib");
   CALL_PushClientAttrib(ctx->CurrentServerDispatch, (mask));
}


/* ProgramUniform4ui: marshalled asynchronously */
struct marshal_cmd_ProgramUniform4ui
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLuint x;
   GLuint y;
   GLuint z;
   GLuint w;
};
static inline void
_mesa_unmarshal_ProgramUniform4ui(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform4ui *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLuint x = cmd->x;
   const GLuint y = cmd->y;
   const GLuint z = cmd->z;
   const GLuint w = cmd->w;
   CALL_ProgramUniform4ui(ctx->CurrentServerDispatch, (program, location, x, y, z, w));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform4ui(GLuint program, GLint location, GLuint x, GLuint y, GLuint z, GLuint w)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform4ui);
   struct marshal_cmd_ProgramUniform4ui *cmd;
   debug_print_marshal("ProgramUniform4ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform4ui, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      cmd->w = w;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform4ui");
   CALL_ProgramUniform4ui(ctx->CurrentServerDispatch, (program, location, x, y, z, w));
}


/* Uniform1f: marshalled asynchronously */
struct marshal_cmd_Uniform1f
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLfloat v0;
};
static inline void
_mesa_unmarshal_Uniform1f(struct gl_context *ctx, const struct marshal_cmd_Uniform1f *cmd)
{
   const GLint location = cmd->location;
   const GLfloat v0 = cmd->v0;
   CALL_Uniform1f(ctx->CurrentServerDispatch, (location, v0));
}
static void GLAPIENTRY
_mesa_marshal_Uniform1f(GLint location, GLfloat v0)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform1f);
   struct marshal_cmd_Uniform1f *cmd;
   debug_print_marshal("Uniform1f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform1f, cmd_size);
      cmd->location = location;
      cmd->v0 = v0;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform1f");
   CALL_Uniform1f(ctx->CurrentServerDispatch, (location, v0));
}


/* Uniform1d: marshalled asynchronously */
struct marshal_cmd_Uniform1d
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLdouble x;
};
static inline void
_mesa_unmarshal_Uniform1d(struct gl_context *ctx, const struct marshal_cmd_Uniform1d *cmd)
{
   const GLint location = cmd->location;
   const GLdouble x = cmd->x;
   CALL_Uniform1d(ctx->CurrentServerDispatch, (location, x));
}
static void GLAPIENTRY
_mesa_marshal_Uniform1d(GLint location, GLdouble x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform1d);
   struct marshal_cmd_Uniform1d *cmd;
   debug_print_marshal("Uniform1d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform1d, cmd_size);
      cmd->location = location;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform1d");
   CALL_Uniform1d(ctx->CurrentServerDispatch, (location, x));
}


/* Uniform1i: marshalled asynchronously */
struct marshal_cmd_Uniform1i
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLint v0;
};
static inline void
_mesa_unmarshal_Uniform1i(struct gl_context *ctx, const struct marshal_cmd_Uniform1i *cmd)
{
   const GLint location = cmd->location;
   const GLint v0 = cmd->v0;
   CALL_Uniform1i(ctx->CurrentServerDispatch, (location, v0));
}
static void GLAPIENTRY
_mesa_marshal_Uniform1i(GLint location, GLint v0)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform1i);
   struct marshal_cmd_Uniform1i *cmd;
   debug_print_marshal("Uniform1i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform1i, cmd_size);
      cmd->location = location;
      cmd->v0 = v0;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform1i");
   CALL_Uniform1i(ctx->CurrentServerDispatch, (location, v0));
}


/* GetPolygonStipple: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetPolygonStipple(GLubyte * mask)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetPolygonStipple");
   CALL_GetPolygonStipple(ctx->CurrentServerDispatch, (mask));
}


/* BlitNamedFramebuffer: marshalled asynchronously */
struct marshal_cmd_BlitNamedFramebuffer
{
   struct marshal_cmd_base cmd_base;
   GLuint readFramebuffer;
   GLuint drawFramebuffer;
   GLint srcX0;
   GLint srcY0;
   GLint srcX1;
   GLint srcY1;
   GLint dstX0;
   GLint dstY0;
   GLint dstX1;
   GLint dstY1;
   GLbitfield mask;
   GLenum filter;
};
static inline void
_mesa_unmarshal_BlitNamedFramebuffer(struct gl_context *ctx, const struct marshal_cmd_BlitNamedFramebuffer *cmd)
{
   const GLuint readFramebuffer = cmd->readFramebuffer;
   const GLuint drawFramebuffer = cmd->drawFramebuffer;
   const GLint srcX0 = cmd->srcX0;
   const GLint srcY0 = cmd->srcY0;
   const GLint srcX1 = cmd->srcX1;
   const GLint srcY1 = cmd->srcY1;
   const GLint dstX0 = cmd->dstX0;
   const GLint dstY0 = cmd->dstY0;
   const GLint dstX1 = cmd->dstX1;
   const GLint dstY1 = cmd->dstY1;
   const GLbitfield mask = cmd->mask;
   const GLenum filter = cmd->filter;
   CALL_BlitNamedFramebuffer(ctx->CurrentServerDispatch, (readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter));
}
static void GLAPIENTRY
_mesa_marshal_BlitNamedFramebuffer(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BlitNamedFramebuffer);
   struct marshal_cmd_BlitNamedFramebuffer *cmd;
   debug_print_marshal("BlitNamedFramebuffer");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BlitNamedFramebuffer, cmd_size);
      cmd->readFramebuffer = readFramebuffer;
      cmd->drawFramebuffer = drawFramebuffer;
      cmd->srcX0 = srcX0;
      cmd->srcY0 = srcY0;
      cmd->srcX1 = srcX1;
      cmd->srcY1 = srcY1;
      cmd->dstX0 = dstX0;
      cmd->dstY0 = dstY0;
      cmd->dstX1 = dstX1;
      cmd->dstY1 = dstY1;
      cmd->mask = mask;
      cmd->filter = filter;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BlitNamedFramebuffer");
   CALL_BlitNamedFramebuffer(ctx->CurrentServerDispatch, (readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter));
}


/* UseProgram: marshalled asynchronously */
struct marshal_cmd_UseProgram
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
};
static inline void
_mesa_unmarshal_UseProgram(struct gl_context *ctx, const struct marshal_cmd_UseProgram *cmd)
{
   const GLuint program = cmd->program;
   CALL_UseProgram(ctx->CurrentServerDispatch, (program));
}
static void GLAPIENTRY
_mesa_marshal_UseProgram(GLuint program)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UseProgram);
   struct marshal_cmd_UseProgram *cmd;
   debug_print_marshal("UseProgram");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UseProgram, cmd_size);
      cmd->program = program;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UseProgram");
   CALL_UseProgram(ctx->CurrentServerDispatch, (program));
}


/* GetFragDataLocation: marshalled synchronously */
static GLint GLAPIENTRY
_mesa_marshal_GetFragDataLocation(GLuint program, const GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetFragDataLocation");
   return CALL_GetFragDataLocation(ctx->CurrentServerDispatch, (program, name));
}


/* PixelMapuiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_PixelMapuiv(GLenum map, GLsizei mapsize, const GLuint * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("PixelMapuiv");
   CALL_PixelMapuiv(ctx->CurrentServerDispatch, (map, mapsize, values));
}


/* ClearNamedBufferSubData: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ClearNamedBufferSubData(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const GLvoid * data)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ClearNamedBufferSubData");
   CALL_ClearNamedBufferSubData(ctx->CurrentServerDispatch, (buffer, internalformat, offset, size, format, type, data));
}


/* GetNamedFramebufferAttachmentParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetNamedFramebufferAttachmentParameteriv(GLuint framebuffer, GLenum attachment, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetNamedFramebufferAttachmentParameteriv");
   CALL_GetNamedFramebufferAttachmentParameteriv(ctx->CurrentServerDispatch, (framebuffer, attachment, pname, params));
}


/* GenVertexArrays: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GenVertexArrays(GLsizei n, GLuint * arrays)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GenVertexArrays");
   CALL_GenVertexArrays(ctx->CurrentServerDispatch, (n, arrays));
}


/* TexStorageMem2DMultisampleEXT: marshalled asynchronously */
struct marshal_cmd_TexStorageMem2DMultisampleEXT
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei samples;
   GLenum internalFormat;
   GLsizei width;
   GLsizei height;
   GLboolean fixedSampleLocations;
   GLuint memory;
   GLuint64 offset;
};
static inline void
_mesa_unmarshal_TexStorageMem2DMultisampleEXT(struct gl_context *ctx, const struct marshal_cmd_TexStorageMem2DMultisampleEXT *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei samples = cmd->samples;
   const GLenum internalFormat = cmd->internalFormat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLboolean fixedSampleLocations = cmd->fixedSampleLocations;
   const GLuint memory = cmd->memory;
   const GLuint64 offset = cmd->offset;
   CALL_TexStorageMem2DMultisampleEXT(ctx->CurrentServerDispatch, (target, samples, internalFormat, width, height, fixedSampleLocations, memory, offset));
}
static void GLAPIENTRY
_mesa_marshal_TexStorageMem2DMultisampleEXT(GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexStorageMem2DMultisampleEXT);
   struct marshal_cmd_TexStorageMem2DMultisampleEXT *cmd;
   debug_print_marshal("TexStorageMem2DMultisampleEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexStorageMem2DMultisampleEXT, cmd_size);
      cmd->target = target;
      cmd->samples = samples;
      cmd->internalFormat = internalFormat;
      cmd->width = width;
      cmd->height = height;
      cmd->fixedSampleLocations = fixedSampleLocations;
      cmd->memory = memory;
      cmd->offset = offset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexStorageMem2DMultisampleEXT");
   CALL_TexStorageMem2DMultisampleEXT(ctx->CurrentServerDispatch, (target, samples, internalFormat, width, height, fixedSampleLocations, memory, offset));
}


/* Color3s: marshalled asynchronously */
struct marshal_cmd_Color3s
{
   struct marshal_cmd_base cmd_base;
   GLshort red;
   GLshort green;
   GLshort blue;
};
static inline void
_mesa_unmarshal_Color3s(struct gl_context *ctx, const struct marshal_cmd_Color3s *cmd)
{
   const GLshort red = cmd->red;
   const GLshort green = cmd->green;
   const GLshort blue = cmd->blue;
   CALL_Color3s(ctx->CurrentServerDispatch, (red, green, blue));
}
static void GLAPIENTRY
_mesa_marshal_Color3s(GLshort red, GLshort green, GLshort blue)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color3s);
   struct marshal_cmd_Color3s *cmd;
   debug_print_marshal("Color3s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color3s, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color3s");
   CALL_Color3s(ctx->CurrentServerDispatch, (red, green, blue));
}


/* TextureStorage2DMultisample: marshalled asynchronously */
struct marshal_cmd_TextureStorage2DMultisample
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLsizei samples;
   GLenum internalformat;
   GLsizei width;
   GLsizei height;
   GLboolean fixedsamplelocations;
};
static inline void
_mesa_unmarshal_TextureStorage2DMultisample(struct gl_context *ctx, const struct marshal_cmd_TextureStorage2DMultisample *cmd)
{
   const GLuint texture = cmd->texture;
   const GLsizei samples = cmd->samples;
   const GLenum internalformat = cmd->internalformat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLboolean fixedsamplelocations = cmd->fixedsamplelocations;
   CALL_TextureStorage2DMultisample(ctx->CurrentServerDispatch, (texture, samples, internalformat, width, height, fixedsamplelocations));
}
static void GLAPIENTRY
_mesa_marshal_TextureStorage2DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureStorage2DMultisample);
   struct marshal_cmd_TextureStorage2DMultisample *cmd;
   debug_print_marshal("TextureStorage2DMultisample");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureStorage2DMultisample, cmd_size);
      cmd->texture = texture;
      cmd->samples = samples;
      cmd->internalformat = internalformat;
      cmd->width = width;
      cmd->height = height;
      cmd->fixedsamplelocations = fixedsamplelocations;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureStorage2DMultisample");
   CALL_TextureStorage2DMultisample(ctx->CurrentServerDispatch, (texture, samples, internalformat, width, height, fixedsamplelocations));
}


/* TexCoordPointer: marshalled asynchronously */
struct marshal_cmd_TexCoordPointer
{
   struct marshal_cmd_base cmd_base;
   GLint size;
   GLenum type;
   GLsizei stride;
   const GLvoid * pointer;
};
static inline void
_mesa_unmarshal_TexCoordPointer(struct gl_context *ctx, const struct marshal_cmd_TexCoordPointer *cmd)
{
   const GLint size = cmd->size;
   const GLenum type = cmd->type;
   const GLsizei stride = cmd->stride;
   const GLvoid * pointer = cmd->pointer;
   CALL_TexCoordPointer(ctx->CurrentServerDispatch, (size, type, stride, pointer));
}
static void GLAPIENTRY
_mesa_marshal_TexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoordPointer);
   struct marshal_cmd_TexCoordPointer *cmd;
   debug_print_marshal("TexCoordPointer");
   if (_mesa_glthread_is_non_vbo_vertex_attrib_pointer(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("TexCoordPointer");
      CALL_TexCoordPointer(ctx->CurrentServerDispatch, (size, type, stride, pointer));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoordPointer, cmd_size);
      cmd->size = size;
      cmd->type = type;
      cmd->stride = stride;
      cmd->pointer = pointer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoordPointer");
   CALL_TexCoordPointer(ctx->CurrentServerDispatch, (size, type, stride, pointer));
}


/* Color3i: marshalled asynchronously */
struct marshal_cmd_Color3i
{
   struct marshal_cmd_base cmd_base;
   GLint red;
   GLint green;
   GLint blue;
};
static inline void
_mesa_unmarshal_Color3i(struct gl_context *ctx, const struct marshal_cmd_Color3i *cmd)
{
   const GLint red = cmd->red;
   const GLint green = cmd->green;
   const GLint blue = cmd->blue;
   CALL_Color3i(ctx->CurrentServerDispatch, (red, green, blue));
}
static void GLAPIENTRY
_mesa_marshal_Color3i(GLint red, GLint green, GLint blue)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color3i);
   struct marshal_cmd_Color3i *cmd;
   debug_print_marshal("Color3i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color3i, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color3i");
   CALL_Color3i(ctx->CurrentServerDispatch, (red, green, blue));
}


/* EvalCoord2d: marshalled asynchronously */
struct marshal_cmd_EvalCoord2d
{
   struct marshal_cmd_base cmd_base;
   GLdouble u;
   GLdouble v;
};
static inline void
_mesa_unmarshal_EvalCoord2d(struct gl_context *ctx, const struct marshal_cmd_EvalCoord2d *cmd)
{
   const GLdouble u = cmd->u;
   const GLdouble v = cmd->v;
   CALL_EvalCoord2d(ctx->CurrentServerDispatch, (u, v));
}
static void GLAPIENTRY
_mesa_marshal_EvalCoord2d(GLdouble u, GLdouble v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EvalCoord2d);
   struct marshal_cmd_EvalCoord2d *cmd;
   debug_print_marshal("EvalCoord2d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EvalCoord2d, cmd_size);
      cmd->u = u;
      cmd->v = v;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EvalCoord2d");
   CALL_EvalCoord2d(ctx->CurrentServerDispatch, (u, v));
}


/* EvalCoord2f: marshalled asynchronously */
struct marshal_cmd_EvalCoord2f
{
   struct marshal_cmd_base cmd_base;
   GLfloat u;
   GLfloat v;
};
static inline void
_mesa_unmarshal_EvalCoord2f(struct gl_context *ctx, const struct marshal_cmd_EvalCoord2f *cmd)
{
   const GLfloat u = cmd->u;
   const GLfloat v = cmd->v;
   CALL_EvalCoord2f(ctx->CurrentServerDispatch, (u, v));
}
static void GLAPIENTRY
_mesa_marshal_EvalCoord2f(GLfloat u, GLfloat v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EvalCoord2f);
   struct marshal_cmd_EvalCoord2f *cmd;
   debug_print_marshal("EvalCoord2f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EvalCoord2f, cmd_size);
      cmd->u = u;
      cmd->v = v;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EvalCoord2f");
   CALL_EvalCoord2f(ctx->CurrentServerDispatch, (u, v));
}


/* Color3b: marshalled asynchronously */
struct marshal_cmd_Color3b
{
   struct marshal_cmd_base cmd_base;
   GLbyte red;
   GLbyte green;
   GLbyte blue;
};
static inline void
_mesa_unmarshal_Color3b(struct gl_context *ctx, const struct marshal_cmd_Color3b *cmd)
{
   const GLbyte red = cmd->red;
   const GLbyte green = cmd->green;
   const GLbyte blue = cmd->blue;
   CALL_Color3b(ctx->CurrentServerDispatch, (red, green, blue));
}
static void GLAPIENTRY
_mesa_marshal_Color3b(GLbyte red, GLbyte green, GLbyte blue)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color3b);
   struct marshal_cmd_Color3b *cmd;
   debug_print_marshal("Color3b");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color3b, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color3b");
   CALL_Color3b(ctx->CurrentServerDispatch, (red, green, blue));
}


/* Color3f: marshalled asynchronously */
struct marshal_cmd_Color3f
{
   struct marshal_cmd_base cmd_base;
   GLfloat red;
   GLfloat green;
   GLfloat blue;
};
static inline void
_mesa_unmarshal_Color3f(struct gl_context *ctx, const struct marshal_cmd_Color3f *cmd)
{
   const GLfloat red = cmd->red;
   const GLfloat green = cmd->green;
   const GLfloat blue = cmd->blue;
   CALL_Color3f(ctx->CurrentServerDispatch, (red, green, blue));
}
static void GLAPIENTRY
_mesa_marshal_Color3f(GLfloat red, GLfloat green, GLfloat blue)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color3f);
   struct marshal_cmd_Color3f *cmd;
   debug_print_marshal("Color3f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color3f, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color3f");
   CALL_Color3f(ctx->CurrentServerDispatch, (red, green, blue));
}


/* Color3d: marshalled asynchronously */
struct marshal_cmd_Color3d
{
   struct marshal_cmd_base cmd_base;
   GLdouble red;
   GLdouble green;
   GLdouble blue;
};
static inline void
_mesa_unmarshal_Color3d(struct gl_context *ctx, const struct marshal_cmd_Color3d *cmd)
{
   const GLdouble red = cmd->red;
   const GLdouble green = cmd->green;
   const GLdouble blue = cmd->blue;
   CALL_Color3d(ctx->CurrentServerDispatch, (red, green, blue));
}
static void GLAPIENTRY
_mesa_marshal_Color3d(GLdouble red, GLdouble green, GLdouble blue)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color3d);
   struct marshal_cmd_Color3d *cmd;
   debug_print_marshal("Color3d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color3d, cmd_size);
      cmd->red = red;
      cmd->green = green;
      cmd->blue = blue;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color3d");
   CALL_Color3d(ctx->CurrentServerDispatch, (red, green, blue));
}


/* GetVertexAttribdv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetVertexAttribdv(GLuint index, GLenum pname, GLdouble * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetVertexAttribdv");
   CALL_GetVertexAttribdv(ctx->CurrentServerDispatch, (index, pname, params));
}


/* GetBufferPointerv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetBufferPointerv(GLenum target, GLenum pname, GLvoid ** params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetBufferPointerv");
   CALL_GetBufferPointerv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* GenFramebuffers: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GenFramebuffers(GLsizei n, GLuint * framebuffers)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GenFramebuffers");
   CALL_GenFramebuffers(ctx->CurrentServerDispatch, (n, framebuffers));
}


/* IsTextureHandleResidentARB: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_IsTextureHandleResidentARB(GLuint64 handle)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("IsTextureHandleResidentARB");
   return CALL_IsTextureHandleResidentARB(ctx->CurrentServerDispatch, (handle));
}


/* GenBuffers: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GenBuffers(GLsizei n, GLuint * buffer)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GenBuffers");
   CALL_GenBuffers(ctx->CurrentServerDispatch, (n, buffer));
}


/* ClearDepthx: marshalled asynchronously */
struct marshal_cmd_ClearDepthx
{
   struct marshal_cmd_base cmd_base;
   GLclampx depth;
};
static inline void
_mesa_unmarshal_ClearDepthx(struct gl_context *ctx, const struct marshal_cmd_ClearDepthx *cmd)
{
   const GLclampx depth = cmd->depth;
   CALL_ClearDepthx(ctx->CurrentServerDispatch, (depth));
}
static void GLAPIENTRY
_mesa_marshal_ClearDepthx(GLclampx depth)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ClearDepthx);
   struct marshal_cmd_ClearDepthx *cmd;
   debug_print_marshal("ClearDepthx");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ClearDepthx, cmd_size);
      cmd->depth = depth;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ClearDepthx");
   CALL_ClearDepthx(ctx->CurrentServerDispatch, (depth));
}


/* EnableVertexArrayAttrib: marshalled asynchronously */
struct marshal_cmd_EnableVertexArrayAttrib
{
   struct marshal_cmd_base cmd_base;
   GLuint vaobj;
   GLuint index;
};
static inline void
_mesa_unmarshal_EnableVertexArrayAttrib(struct gl_context *ctx, const struct marshal_cmd_EnableVertexArrayAttrib *cmd)
{
   const GLuint vaobj = cmd->vaobj;
   const GLuint index = cmd->index;
   CALL_EnableVertexArrayAttrib(ctx->CurrentServerDispatch, (vaobj, index));
}
static void GLAPIENTRY
_mesa_marshal_EnableVertexArrayAttrib(GLuint vaobj, GLuint index)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EnableVertexArrayAttrib);
   struct marshal_cmd_EnableVertexArrayAttrib *cmd;
   debug_print_marshal("EnableVertexArrayAttrib");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EnableVertexArrayAttrib, cmd_size);
      cmd->vaobj = vaobj;
      cmd->index = index;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EnableVertexArrayAttrib");
   CALL_EnableVertexArrayAttrib(ctx->CurrentServerDispatch, (vaobj, index));
}


/* BlendEquationSeparate: marshalled asynchronously */
struct marshal_cmd_BlendEquationSeparate
{
   struct marshal_cmd_base cmd_base;
   GLenum modeRGB;
   GLenum modeA;
};
static inline void
_mesa_unmarshal_BlendEquationSeparate(struct gl_context *ctx, const struct marshal_cmd_BlendEquationSeparate *cmd)
{
   const GLenum modeRGB = cmd->modeRGB;
   const GLenum modeA = cmd->modeA;
   CALL_BlendEquationSeparate(ctx->CurrentServerDispatch, (modeRGB, modeA));
}
static void GLAPIENTRY
_mesa_marshal_BlendEquationSeparate(GLenum modeRGB, GLenum modeA)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BlendEquationSeparate);
   struct marshal_cmd_BlendEquationSeparate *cmd;
   debug_print_marshal("BlendEquationSeparate");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BlendEquationSeparate, cmd_size);
      cmd->modeRGB = modeRGB;
      cmd->modeA = modeA;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BlendEquationSeparate");
   CALL_BlendEquationSeparate(ctx->CurrentServerDispatch, (modeRGB, modeA));
}


/* MultiTexCoordP4ui: marshalled asynchronously */
struct marshal_cmd_MultiTexCoordP4ui
{
   struct marshal_cmd_base cmd_base;
   GLenum texture;
   GLenum type;
   GLuint coords;
};
static inline void
_mesa_unmarshal_MultiTexCoordP4ui(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoordP4ui *cmd)
{
   const GLenum texture = cmd->texture;
   const GLenum type = cmd->type;
   const GLuint coords = cmd->coords;
   CALL_MultiTexCoordP4ui(ctx->CurrentServerDispatch, (texture, type, coords));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoordP4ui);
   struct marshal_cmd_MultiTexCoordP4ui *cmd;
   debug_print_marshal("MultiTexCoordP4ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoordP4ui, cmd_size);
      cmd->texture = texture;
      cmd->type = type;
      cmd->coords = coords;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoordP4ui");
   CALL_MultiTexCoordP4ui(ctx->CurrentServerDispatch, (texture, type, coords));
}


/* VertexAttribs1fvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttribs1fvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLsizei n;
   /* Next safe_mul(n, 4) bytes are GLfloat v[n] */
};
static inline void
_mesa_unmarshal_VertexAttribs1fvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttribs1fvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLsizei n = cmd->n;
   const GLfloat * v;
   const char *variable_data = (const char *) (cmd + 1);
   v = (const GLfloat *) variable_data;
   variable_data += n * 4;
   CALL_VertexAttribs1fvNV(ctx->CurrentServerDispatch, (index, n, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribs1fvNV(GLuint index, GLsizei n, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribs1fvNV) + safe_mul(n, 4);
   struct marshal_cmd_VertexAttribs1fvNV *cmd;
   debug_print_marshal("VertexAttribs1fvNV");
   if (unlikely(safe_mul(n, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribs1fvNV, cmd_size);
      cmd->index = index;
      cmd->n = n;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, v, n * 4);
      variable_data += n * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribs1fvNV");
   CALL_VertexAttribs1fvNV(ctx->CurrentServerDispatch, (index, n, v));
}


/* VertexAttribIPointer: marshalled asynchronously */
struct marshal_cmd_VertexAttribIPointer
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLint size;
   GLenum type;
   GLsizei stride;
   const GLvoid * pointer;
};
static inline void
_mesa_unmarshal_VertexAttribIPointer(struct gl_context *ctx, const struct marshal_cmd_VertexAttribIPointer *cmd)
{
   const GLuint index = cmd->index;
   const GLint size = cmd->size;
   const GLenum type = cmd->type;
   const GLsizei stride = cmd->stride;
   const GLvoid * pointer = cmd->pointer;
   CALL_VertexAttribIPointer(ctx->CurrentServerDispatch, (index, size, type, stride, pointer));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribIPointer);
   struct marshal_cmd_VertexAttribIPointer *cmd;
   debug_print_marshal("VertexAttribIPointer");
   if (_mesa_glthread_is_non_vbo_vertex_attrib_pointer(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("VertexAttribIPointer");
      CALL_VertexAttribIPointer(ctx->CurrentServerDispatch, (index, size, type, stride, pointer));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribIPointer, cmd_size);
      cmd->index = index;
      cmd->size = size;
      cmd->type = type;
      cmd->stride = stride;
      cmd->pointer = pointer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribIPointer");
   CALL_VertexAttribIPointer(ctx->CurrentServerDispatch, (index, size, type, stride, pointer));
}


/* ProgramUniform4fv: marshalled asynchronously */
struct marshal_cmd_ProgramUniform4fv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 16) bytes are GLfloat value[count][4] */
};
static inline void
_mesa_unmarshal_ProgramUniform4fv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform4fv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 16;
   CALL_ProgramUniform4fv(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform4fv) + safe_mul(count, 16);
   struct marshal_cmd_ProgramUniform4fv *cmd;
   debug_print_marshal("ProgramUniform4fv");
   if (unlikely(safe_mul(count, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform4fv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 16);
      variable_data += count * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform4fv");
   CALL_ProgramUniform4fv(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* RasterPos4sv: marshalled asynchronously */
struct marshal_cmd_RasterPos4sv
{
   struct marshal_cmd_base cmd_base;
   GLshort v[4];
};
static inline void
_mesa_unmarshal_RasterPos4sv(struct gl_context *ctx, const struct marshal_cmd_RasterPos4sv *cmd)
{
   const GLshort * v = cmd->v;
   CALL_RasterPos4sv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_RasterPos4sv(const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_RasterPos4sv);
   struct marshal_cmd_RasterPos4sv *cmd;
   debug_print_marshal("RasterPos4sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_RasterPos4sv, cmd_size);
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("RasterPos4sv");
   CALL_RasterPos4sv(ctx->CurrentServerDispatch, (v));
}


/* CopyTextureSubImage3D: marshalled asynchronously */
struct marshal_cmd_CopyTextureSubImage3D
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLint level;
   GLint xoffset;
   GLint yoffset;
   GLint zoffset;
   GLint x;
   GLint y;
   GLsizei width;
   GLsizei height;
};
static inline void
_mesa_unmarshal_CopyTextureSubImage3D(struct gl_context *ctx, const struct marshal_cmd_CopyTextureSubImage3D *cmd)
{
   const GLuint texture = cmd->texture;
   const GLint level = cmd->level;
   const GLint xoffset = cmd->xoffset;
   const GLint yoffset = cmd->yoffset;
   const GLint zoffset = cmd->zoffset;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   CALL_CopyTextureSubImage3D(ctx->CurrentServerDispatch, (texture, level, xoffset, yoffset, zoffset, x, y, width, height));
}
static void GLAPIENTRY
_mesa_marshal_CopyTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CopyTextureSubImage3D);
   struct marshal_cmd_CopyTextureSubImage3D *cmd;
   debug_print_marshal("CopyTextureSubImage3D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CopyTextureSubImage3D, cmd_size);
      cmd->texture = texture;
      cmd->level = level;
      cmd->xoffset = xoffset;
      cmd->yoffset = yoffset;
      cmd->zoffset = zoffset;
      cmd->x = x;
      cmd->y = y;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CopyTextureSubImage3D");
   CALL_CopyTextureSubImage3D(ctx->CurrentServerDispatch, (texture, level, xoffset, yoffset, zoffset, x, y, width, height));
}


/* SelectBuffer: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_SelectBuffer(GLsizei size, GLuint * buffer)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("SelectBuffer");
   CALL_SelectBuffer(ctx->CurrentServerDispatch, (size, buffer));
}


/* GetSynciv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei * length, GLint * values)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetSynciv");
   CALL_GetSynciv(ctx->CurrentServerDispatch, (sync, pname, bufSize, length, values));
}


/* TextureView: marshalled asynchronously */
struct marshal_cmd_TextureView
{
   struct marshal_cmd_base cmd_base;
   GLuint texture;
   GLenum target;
   GLuint origtexture;
   GLenum internalformat;
   GLuint minlevel;
   GLuint numlevels;
   GLuint minlayer;
   GLuint numlayers;
};
static inline void
_mesa_unmarshal_TextureView(struct gl_context *ctx, const struct marshal_cmd_TextureView *cmd)
{
   const GLuint texture = cmd->texture;
   const GLenum target = cmd->target;
   const GLuint origtexture = cmd->origtexture;
   const GLenum internalformat = cmd->internalformat;
   const GLuint minlevel = cmd->minlevel;
   const GLuint numlevels = cmd->numlevels;
   const GLuint minlayer = cmd->minlayer;
   const GLuint numlayers = cmd->numlayers;
   CALL_TextureView(ctx->CurrentServerDispatch, (texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers));
}
static void GLAPIENTRY
_mesa_marshal_TextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TextureView);
   struct marshal_cmd_TextureView *cmd;
   debug_print_marshal("TextureView");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TextureView, cmd_size);
      cmd->texture = texture;
      cmd->target = target;
      cmd->origtexture = origtexture;
      cmd->internalformat = internalformat;
      cmd->minlevel = minlevel;
      cmd->numlevels = numlevels;
      cmd->minlayer = minlayer;
      cmd->numlayers = numlayers;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TextureView");
   CALL_TextureView(ctx->CurrentServerDispatch, (texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers));
}


/* TexEnviv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexEnviv(GLenum target, GLenum pname, const GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexEnviv");
   CALL_TexEnviv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* TexSubImage3D: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexSubImage3D");
   CALL_TexSubImage3D(ctx->CurrentServerDispatch, (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels));
}


/* Bitmap: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_Bitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("Bitmap");
   CALL_Bitmap(ctx->CurrentServerDispatch, (width, height, xorig, yorig, xmove, ymove, bitmap));
}


/* VertexAttribDivisor: marshalled asynchronously */
struct marshal_cmd_VertexAttribDivisor
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLuint divisor;
};
static inline void
_mesa_unmarshal_VertexAttribDivisor(struct gl_context *ctx, const struct marshal_cmd_VertexAttribDivisor *cmd)
{
   const GLuint index = cmd->index;
   const GLuint divisor = cmd->divisor;
   CALL_VertexAttribDivisor(ctx->CurrentServerDispatch, (index, divisor));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribDivisor(GLuint index, GLuint divisor)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribDivisor);
   struct marshal_cmd_VertexAttribDivisor *cmd;
   debug_print_marshal("VertexAttribDivisor");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribDivisor, cmd_size);
      cmd->index = index;
      cmd->divisor = divisor;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribDivisor");
   CALL_VertexAttribDivisor(ctx->CurrentServerDispatch, (index, divisor));
}


/* DrawTransformFeedbackStream: marshalled asynchronously */
struct marshal_cmd_DrawTransformFeedbackStream
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLuint id;
   GLuint stream;
};
static inline void
_mesa_unmarshal_DrawTransformFeedbackStream(struct gl_context *ctx, const struct marshal_cmd_DrawTransformFeedbackStream *cmd)
{
   const GLenum mode = cmd->mode;
   const GLuint id = cmd->id;
   const GLuint stream = cmd->stream;
   CALL_DrawTransformFeedbackStream(ctx->CurrentServerDispatch, (mode, id, stream));
}
static void GLAPIENTRY
_mesa_marshal_DrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawTransformFeedbackStream);
   struct marshal_cmd_DrawTransformFeedbackStream *cmd;
   debug_print_marshal("DrawTransformFeedbackStream");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawTransformFeedbackStream, cmd_size);
      cmd->mode = mode;
      cmd->id = id;
      cmd->stream = stream;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawTransformFeedbackStream");
   CALL_DrawTransformFeedbackStream(ctx->CurrentServerDispatch, (mode, id, stream));
}


/* GetIntegerv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetIntegerv(GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetIntegerv");
   CALL_GetIntegerv(ctx->CurrentServerDispatch, (pname, params));
}


/* EndPerfQueryINTEL: marshalled asynchronously */
struct marshal_cmd_EndPerfQueryINTEL
{
   struct marshal_cmd_base cmd_base;
   GLuint queryHandle;
};
static inline void
_mesa_unmarshal_EndPerfQueryINTEL(struct gl_context *ctx, const struct marshal_cmd_EndPerfQueryINTEL *cmd)
{
   const GLuint queryHandle = cmd->queryHandle;
   CALL_EndPerfQueryINTEL(ctx->CurrentServerDispatch, (queryHandle));
}
static void GLAPIENTRY
_mesa_marshal_EndPerfQueryINTEL(GLuint queryHandle)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EndPerfQueryINTEL);
   struct marshal_cmd_EndPerfQueryINTEL *cmd;
   debug_print_marshal("EndPerfQueryINTEL");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EndPerfQueryINTEL, cmd_size);
      cmd->queryHandle = queryHandle;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EndPerfQueryINTEL");
   CALL_EndPerfQueryINTEL(ctx->CurrentServerDispatch, (queryHandle));
}


/* NamedBufferPageCommitmentARB: marshalled asynchronously */
struct marshal_cmd_NamedBufferPageCommitmentARB
{
   struct marshal_cmd_base cmd_base;
   GLuint buffer;
   GLintptr offset;
   GLsizeiptr size;
   GLboolean commit;
};
static inline void
_mesa_unmarshal_NamedBufferPageCommitmentARB(struct gl_context *ctx, const struct marshal_cmd_NamedBufferPageCommitmentARB *cmd)
{
   const GLuint buffer = cmd->buffer;
   const GLintptr offset = cmd->offset;
   const GLsizeiptr size = cmd->size;
   const GLboolean commit = cmd->commit;
   CALL_NamedBufferPageCommitmentARB(ctx->CurrentServerDispatch, (buffer, offset, size, commit));
}
static void GLAPIENTRY
_mesa_marshal_NamedBufferPageCommitmentARB(GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_NamedBufferPageCommitmentARB);
   struct marshal_cmd_NamedBufferPageCommitmentARB *cmd;
   debug_print_marshal("NamedBufferPageCommitmentARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_NamedBufferPageCommitmentARB, cmd_size);
      cmd->buffer = buffer;
      cmd->offset = offset;
      cmd->size = size;
      cmd->commit = commit;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("NamedBufferPageCommitmentARB");
   CALL_NamedBufferPageCommitmentARB(ctx->CurrentServerDispatch, (buffer, offset, size, commit));
}


/* GetActiveUniform: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetActiveUniform");
   CALL_GetActiveUniform(ctx->CurrentServerDispatch, (program, index, bufSize, length, size, type, name));
}


/* AlphaFuncx: marshalled asynchronously */
struct marshal_cmd_AlphaFuncx
{
   struct marshal_cmd_base cmd_base;
   GLenum func;
   GLclampx ref;
};
static inline void
_mesa_unmarshal_AlphaFuncx(struct gl_context *ctx, const struct marshal_cmd_AlphaFuncx *cmd)
{
   const GLenum func = cmd->func;
   const GLclampx ref = cmd->ref;
   CALL_AlphaFuncx(ctx->CurrentServerDispatch, (func, ref));
}
static void GLAPIENTRY
_mesa_marshal_AlphaFuncx(GLenum func, GLclampx ref)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_AlphaFuncx);
   struct marshal_cmd_AlphaFuncx *cmd;
   debug_print_marshal("AlphaFuncx");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_AlphaFuncx, cmd_size);
      cmd->func = func;
      cmd->ref = ref;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("AlphaFuncx");
   CALL_AlphaFuncx(ctx->CurrentServerDispatch, (func, ref));
}


/* VertexAttribI2ivEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribI2ivEXT(GLuint index, const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribI2ivEXT");
   CALL_VertexAttribI2ivEXT(ctx->CurrentServerDispatch, (index, v));
}


/* Map1d: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_Map1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("Map1d");
   CALL_Map1d(ctx->CurrentServerDispatch, (target, u1, u2, stride, order, points));
}


/* Map1f: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_Map1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("Map1f");
   CALL_Map1f(ctx->CurrentServerDispatch, (target, u1, u2, stride, order, points));
}


/* AreTexturesResident: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_AreTexturesResident(GLsizei n, const GLuint * textures, GLboolean * residences)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("AreTexturesResident");
   return CALL_AreTexturesResident(ctx->CurrentServerDispatch, (n, textures, residences));
}


/* VertexArrayVertexBuffer: marshalled asynchronously */
struct marshal_cmd_VertexArrayVertexBuffer
{
   struct marshal_cmd_base cmd_base;
   GLuint vaobj;
   GLuint bindingindex;
   GLuint buffer;
   GLintptr offset;
   GLsizei stride;
};
static inline void
_mesa_unmarshal_VertexArrayVertexBuffer(struct gl_context *ctx, const struct marshal_cmd_VertexArrayVertexBuffer *cmd)
{
   const GLuint vaobj = cmd->vaobj;
   const GLuint bindingindex = cmd->bindingindex;
   const GLuint buffer = cmd->buffer;
   const GLintptr offset = cmd->offset;
   const GLsizei stride = cmd->stride;
   CALL_VertexArrayVertexBuffer(ctx->CurrentServerDispatch, (vaobj, bindingindex, buffer, offset, stride));
}
static void GLAPIENTRY
_mesa_marshal_VertexArrayVertexBuffer(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexArrayVertexBuffer);
   struct marshal_cmd_VertexArrayVertexBuffer *cmd;
   debug_print_marshal("VertexArrayVertexBuffer");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexArrayVertexBuffer, cmd_size);
      cmd->vaobj = vaobj;
      cmd->bindingindex = bindingindex;
      cmd->buffer = buffer;
      cmd->offset = offset;
      cmd->stride = stride;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexArrayVertexBuffer");
   CALL_VertexArrayVertexBuffer(ctx->CurrentServerDispatch, (vaobj, bindingindex, buffer, offset, stride));
}


/* PixelTransferf: marshalled asynchronously */
struct marshal_cmd_PixelTransferf
{
   struct marshal_cmd_base cmd_base;
   GLenum pname;
   GLfloat param;
};
static inline void
_mesa_unmarshal_PixelTransferf(struct gl_context *ctx, const struct marshal_cmd_PixelTransferf *cmd)
{
   const GLenum pname = cmd->pname;
   const GLfloat param = cmd->param;
   CALL_PixelTransferf(ctx->CurrentServerDispatch, (pname, param));
}
static void GLAPIENTRY
_mesa_marshal_PixelTransferf(GLenum pname, GLfloat param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PixelTransferf);
   struct marshal_cmd_PixelTransferf *cmd;
   debug_print_marshal("PixelTransferf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PixelTransferf, cmd_size);
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PixelTransferf");
   CALL_PixelTransferf(ctx->CurrentServerDispatch, (pname, param));
}


/* PixelTransferi: marshalled asynchronously */
struct marshal_cmd_PixelTransferi
{
   struct marshal_cmd_base cmd_base;
   GLenum pname;
   GLint param;
};
static inline void
_mesa_unmarshal_PixelTransferi(struct gl_context *ctx, const struct marshal_cmd_PixelTransferi *cmd)
{
   const GLenum pname = cmd->pname;
   const GLint param = cmd->param;
   CALL_PixelTransferi(ctx->CurrentServerDispatch, (pname, param));
}
static void GLAPIENTRY
_mesa_marshal_PixelTransferi(GLenum pname, GLint param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PixelTransferi);
   struct marshal_cmd_PixelTransferi *cmd;
   debug_print_marshal("PixelTransferi");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PixelTransferi, cmd_size);
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PixelTransferi");
   CALL_PixelTransferi(ctx->CurrentServerDispatch, (pname, param));
}


/* GetProgramResourceiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei  propCount, const GLenum * props, GLsizei  bufSize, GLsizei * length, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetProgramResourceiv");
   CALL_GetProgramResourceiv(ctx->CurrentServerDispatch, (program, programInterface, index, propCount, props, bufSize, length, params));
}


/* VertexAttrib3fvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib3fvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat v[3];
};
static inline void
_mesa_unmarshal_VertexAttrib3fvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib3fvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat * v = cmd->v;
   CALL_VertexAttrib3fvNV(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib3fvNV(GLuint index, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib3fvNV);
   struct marshal_cmd_VertexAttrib3fvNV *cmd;
   debug_print_marshal("VertexAttrib3fvNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib3fvNV, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib3fvNV");
   CALL_VertexAttrib3fvNV(ctx->CurrentServerDispatch, (index, v));
}


/* SecondaryColorP3ui: marshalled asynchronously */
struct marshal_cmd_SecondaryColorP3ui
{
   struct marshal_cmd_base cmd_base;
   GLenum type;
   GLuint color;
};
static inline void
_mesa_unmarshal_SecondaryColorP3ui(struct gl_context *ctx, const struct marshal_cmd_SecondaryColorP3ui *cmd)
{
   const GLenum type = cmd->type;
   const GLuint color = cmd->color;
   CALL_SecondaryColorP3ui(ctx->CurrentServerDispatch, (type, color));
}
static void GLAPIENTRY
_mesa_marshal_SecondaryColorP3ui(GLenum type, GLuint color)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SecondaryColorP3ui);
   struct marshal_cmd_SecondaryColorP3ui *cmd;
   debug_print_marshal("SecondaryColorP3ui");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SecondaryColorP3ui, cmd_size);
      cmd->type = type;
      cmd->color = color;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SecondaryColorP3ui");
   CALL_SecondaryColorP3ui(ctx->CurrentServerDispatch, (type, color));
}


/* BindTextures: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_BindTextures(GLuint first, GLsizei count, const GLuint * textures)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("BindTextures");
   CALL_BindTextures(ctx->CurrentServerDispatch, (first, count, textures));
}


/* VertexAttrib4fvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib4fvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat v[4];
};
static inline void
_mesa_unmarshal_VertexAttrib4fvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib4fvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat * v = cmd->v;
   CALL_VertexAttrib4fvNV(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib4fvNV(GLuint index, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib4fvNV);
   struct marshal_cmd_VertexAttrib4fvNV *cmd;
   debug_print_marshal("VertexAttrib4fvNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib4fvNV, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 16);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib4fvNV");
   CALL_VertexAttrib4fvNV(ctx->CurrentServerDispatch, (index, v));
}


/* Rectiv: marshalled asynchronously */
struct marshal_cmd_Rectiv
{
   struct marshal_cmd_base cmd_base;
   GLint v1[2];
   GLint v2[2];
};
static inline void
_mesa_unmarshal_Rectiv(struct gl_context *ctx, const struct marshal_cmd_Rectiv *cmd)
{
   const GLint * v1 = cmd->v1;
   const GLint * v2 = cmd->v2;
   CALL_Rectiv(ctx->CurrentServerDispatch, (v1, v2));
}
static void GLAPIENTRY
_mesa_marshal_Rectiv(const GLint * v1, const GLint * v2)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Rectiv);
   struct marshal_cmd_Rectiv *cmd;
   debug_print_marshal("Rectiv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Rectiv, cmd_size);
      memcpy(cmd->v1, v1, 8);
      memcpy(cmd->v2, v2, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Rectiv");
   CALL_Rectiv(ctx->CurrentServerDispatch, (v1, v2));
}


/* MultiTexCoord1iv: marshalled asynchronously */
struct marshal_cmd_MultiTexCoord1iv
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLint v[1];
};
static inline void
_mesa_unmarshal_MultiTexCoord1iv(struct gl_context *ctx, const struct marshal_cmd_MultiTexCoord1iv *cmd)
{
   const GLenum target = cmd->target;
   const GLint * v = cmd->v;
   CALL_MultiTexCoord1iv(ctx->CurrentServerDispatch, (target, v));
}
static void GLAPIENTRY
_mesa_marshal_MultiTexCoord1iv(GLenum target, const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultiTexCoord1iv);
   struct marshal_cmd_MultiTexCoord1iv *cmd;
   debug_print_marshal("MultiTexCoord1iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultiTexCoord1iv, cmd_size);
      cmd->target = target;
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultiTexCoord1iv");
   CALL_MultiTexCoord1iv(ctx->CurrentServerDispatch, (target, v));
}


/* PassTexCoordATI: marshalled asynchronously */
struct marshal_cmd_PassTexCoordATI
{
   struct marshal_cmd_base cmd_base;
   GLuint dst;
   GLuint coord;
   GLenum swizzle;
};
static inline void
_mesa_unmarshal_PassTexCoordATI(struct gl_context *ctx, const struct marshal_cmd_PassTexCoordATI *cmd)
{
   const GLuint dst = cmd->dst;
   const GLuint coord = cmd->coord;
   const GLenum swizzle = cmd->swizzle;
   CALL_PassTexCoordATI(ctx->CurrentServerDispatch, (dst, coord, swizzle));
}
static void GLAPIENTRY
_mesa_marshal_PassTexCoordATI(GLuint dst, GLuint coord, GLenum swizzle)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PassTexCoordATI);
   struct marshal_cmd_PassTexCoordATI *cmd;
   debug_print_marshal("PassTexCoordATI");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PassTexCoordATI, cmd_size);
      cmd->dst = dst;
      cmd->coord = coord;
      cmd->swizzle = swizzle;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PassTexCoordATI");
   CALL_PassTexCoordATI(ctx->CurrentServerDispatch, (dst, coord, swizzle));
}


/* Vertex2fv: marshalled asynchronously */
struct marshal_cmd_Vertex2fv
{
   struct marshal_cmd_base cmd_base;
   GLfloat v[2];
};
static inline void
_mesa_unmarshal_Vertex2fv(struct gl_context *ctx, const struct marshal_cmd_Vertex2fv *cmd)
{
   const GLfloat * v = cmd->v;
   CALL_Vertex2fv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Vertex2fv(const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex2fv);
   struct marshal_cmd_Vertex2fv *cmd;
   debug_print_marshal("Vertex2fv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex2fv, cmd_size);
      memcpy(cmd->v, v, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex2fv");
   CALL_Vertex2fv(ctx->CurrentServerDispatch, (v));
}


/* BindRenderbufferEXT: marshalled asynchronously */
struct marshal_cmd_BindRenderbufferEXT
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLuint renderbuffer;
};
static inline void
_mesa_unmarshal_BindRenderbufferEXT(struct gl_context *ctx, const struct marshal_cmd_BindRenderbufferEXT *cmd)
{
   const GLenum target = cmd->target;
   const GLuint renderbuffer = cmd->renderbuffer;
   CALL_BindRenderbufferEXT(ctx->CurrentServerDispatch, (target, renderbuffer));
}
static void GLAPIENTRY
_mesa_marshal_BindRenderbufferEXT(GLenum target, GLuint renderbuffer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BindRenderbufferEXT);
   struct marshal_cmd_BindRenderbufferEXT *cmd;
   debug_print_marshal("BindRenderbufferEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BindRenderbufferEXT, cmd_size);
      cmd->target = target;
      cmd->renderbuffer = renderbuffer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BindRenderbufferEXT");
   CALL_BindRenderbufferEXT(ctx->CurrentServerDispatch, (target, renderbuffer));
}


/* Vertex3sv: marshalled asynchronously */
struct marshal_cmd_Vertex3sv
{
   struct marshal_cmd_base cmd_base;
   GLshort v[3];
};
static inline void
_mesa_unmarshal_Vertex3sv(struct gl_context *ctx, const struct marshal_cmd_Vertex3sv *cmd)
{
   const GLshort * v = cmd->v;
   CALL_Vertex3sv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Vertex3sv(const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Vertex3sv);
   struct marshal_cmd_Vertex3sv *cmd;
   debug_print_marshal("Vertex3sv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Vertex3sv, cmd_size);
      memcpy(cmd->v, v, 6);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Vertex3sv");
   CALL_Vertex3sv(ctx->CurrentServerDispatch, (v));
}


/* EvalMesh1: marshalled asynchronously */
struct marshal_cmd_EvalMesh1
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLint i1;
   GLint i2;
};
static inline void
_mesa_unmarshal_EvalMesh1(struct gl_context *ctx, const struct marshal_cmd_EvalMesh1 *cmd)
{
   const GLenum mode = cmd->mode;
   const GLint i1 = cmd->i1;
   const GLint i2 = cmd->i2;
   CALL_EvalMesh1(ctx->CurrentServerDispatch, (mode, i1, i2));
}
static void GLAPIENTRY
_mesa_marshal_EvalMesh1(GLenum mode, GLint i1, GLint i2)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EvalMesh1);
   struct marshal_cmd_EvalMesh1 *cmd;
   debug_print_marshal("EvalMesh1");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EvalMesh1, cmd_size);
      cmd->mode = mode;
      cmd->i1 = i1;
      cmd->i2 = i2;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EvalMesh1");
   CALL_EvalMesh1(ctx->CurrentServerDispatch, (mode, i1, i2));
}


/* DiscardFramebufferEXT: marshalled asynchronously */
struct marshal_cmd_DiscardFramebufferEXT
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei numAttachments;
   /* Next safe_mul(numAttachments, 4) bytes are GLenum attachments[numAttachments] */
};
static inline void
_mesa_unmarshal_DiscardFramebufferEXT(struct gl_context *ctx, const struct marshal_cmd_DiscardFramebufferEXT *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei numAttachments = cmd->numAttachments;
   const GLenum * attachments;
   const char *variable_data = (const char *) (cmd + 1);
   attachments = (const GLenum *) variable_data;
   variable_data += numAttachments * 4;
   CALL_DiscardFramebufferEXT(ctx->CurrentServerDispatch, (target, numAttachments, attachments));
}
static void GLAPIENTRY
_mesa_marshal_DiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum * attachments)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DiscardFramebufferEXT) + safe_mul(numAttachments, 4);
   struct marshal_cmd_DiscardFramebufferEXT *cmd;
   debug_print_marshal("DiscardFramebufferEXT");
   if (unlikely(safe_mul(numAttachments, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DiscardFramebufferEXT, cmd_size);
      cmd->target = target;
      cmd->numAttachments = numAttachments;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, attachments, numAttachments * 4);
      variable_data += numAttachments * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DiscardFramebufferEXT");
   CALL_DiscardFramebufferEXT(ctx->CurrentServerDispatch, (target, numAttachments, attachments));
}


/* Uniform2f: marshalled asynchronously */
struct marshal_cmd_Uniform2f
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLfloat v0;
   GLfloat v1;
};
static inline void
_mesa_unmarshal_Uniform2f(struct gl_context *ctx, const struct marshal_cmd_Uniform2f *cmd)
{
   const GLint location = cmd->location;
   const GLfloat v0 = cmd->v0;
   const GLfloat v1 = cmd->v1;
   CALL_Uniform2f(ctx->CurrentServerDispatch, (location, v0, v1));
}
static void GLAPIENTRY
_mesa_marshal_Uniform2f(GLint location, GLfloat v0, GLfloat v1)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform2f);
   struct marshal_cmd_Uniform2f *cmd;
   debug_print_marshal("Uniform2f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform2f, cmd_size);
      cmd->location = location;
      cmd->v0 = v0;
      cmd->v1 = v1;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform2f");
   CALL_Uniform2f(ctx->CurrentServerDispatch, (location, v0, v1));
}


/* Uniform2d: marshalled asynchronously */
struct marshal_cmd_Uniform2d
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLdouble x;
   GLdouble y;
};
static inline void
_mesa_unmarshal_Uniform2d(struct gl_context *ctx, const struct marshal_cmd_Uniform2d *cmd)
{
   const GLint location = cmd->location;
   const GLdouble x = cmd->x;
   const GLdouble y = cmd->y;
   CALL_Uniform2d(ctx->CurrentServerDispatch, (location, x, y));
}
static void GLAPIENTRY
_mesa_marshal_Uniform2d(GLint location, GLdouble x, GLdouble y)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform2d);
   struct marshal_cmd_Uniform2d *cmd;
   debug_print_marshal("Uniform2d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform2d, cmd_size);
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform2d");
   CALL_Uniform2d(ctx->CurrentServerDispatch, (location, x, y));
}


/* ColorPointerEXT: marshalled asynchronously */
struct marshal_cmd_ColorPointerEXT
{
   struct marshal_cmd_base cmd_base;
   GLint size;
   GLenum type;
   GLsizei stride;
   GLsizei count;
   const GLvoid * pointer;
};
static inline void
_mesa_unmarshal_ColorPointerEXT(struct gl_context *ctx, const struct marshal_cmd_ColorPointerEXT *cmd)
{
   const GLint size = cmd->size;
   const GLenum type = cmd->type;
   const GLsizei stride = cmd->stride;
   const GLsizei count = cmd->count;
   const GLvoid * pointer = cmd->pointer;
   CALL_ColorPointerEXT(ctx->CurrentServerDispatch, (size, type, stride, count, pointer));
}
static void GLAPIENTRY
_mesa_marshal_ColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ColorPointerEXT);
   struct marshal_cmd_ColorPointerEXT *cmd;
   debug_print_marshal("ColorPointerEXT");
   if (_mesa_glthread_is_non_vbo_vertex_attrib_pointer(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("ColorPointerEXT");
      CALL_ColorPointerEXT(ctx->CurrentServerDispatch, (size, type, stride, count, pointer));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ColorPointerEXT, cmd_size);
      cmd->size = size;
      cmd->type = type;
      cmd->stride = stride;
      cmd->count = count;
      cmd->pointer = pointer;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ColorPointerEXT");
   CALL_ColorPointerEXT(ctx->CurrentServerDispatch, (size, type, stride, count, pointer));
}


/* LineWidth: marshalled asynchronously */
struct marshal_cmd_LineWidth
{
   struct marshal_cmd_base cmd_base;
   GLfloat width;
};
static inline void
_mesa_unmarshal_LineWidth(struct gl_context *ctx, const struct marshal_cmd_LineWidth *cmd)
{
   const GLfloat width = cmd->width;
   CALL_LineWidth(ctx->CurrentServerDispatch, (width));
}
static void GLAPIENTRY
_mesa_marshal_LineWidth(GLfloat width)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_LineWidth);
   struct marshal_cmd_LineWidth *cmd;
   debug_print_marshal("LineWidth");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_LineWidth, cmd_size);
      cmd->width = width;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("LineWidth");
   CALL_LineWidth(ctx->CurrentServerDispatch, (width));
}


/* Uniform2i: marshalled asynchronously */
struct marshal_cmd_Uniform2i
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLint v0;
   GLint v1;
};
static inline void
_mesa_unmarshal_Uniform2i(struct gl_context *ctx, const struct marshal_cmd_Uniform2i *cmd)
{
   const GLint location = cmd->location;
   const GLint v0 = cmd->v0;
   const GLint v1 = cmd->v1;
   CALL_Uniform2i(ctx->CurrentServerDispatch, (location, v0, v1));
}
static void GLAPIENTRY
_mesa_marshal_Uniform2i(GLint location, GLint v0, GLint v1)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform2i);
   struct marshal_cmd_Uniform2i *cmd;
   debug_print_marshal("Uniform2i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform2i, cmd_size);
      cmd->location = location;
      cmd->v0 = v0;
      cmd->v1 = v1;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform2i");
   CALL_Uniform2i(ctx->CurrentServerDispatch, (location, v0, v1));
}


/* MultiDrawElementsBaseVertex: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_MultiDrawElementsBaseVertex(GLenum mode, const GLsizei * count, GLenum type, const GLvoid * const * indices, GLsizei primcount, const GLint * basevertex)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("MultiDrawElementsBaseVertex");
   CALL_MultiDrawElementsBaseVertex(ctx->CurrentServerDispatch, (mode, count, type, indices, primcount, basevertex));
}


/* Lightxv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_Lightxv(GLenum light, GLenum pname, const GLfixed * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("Lightxv");
   CALL_Lightxv(ctx->CurrentServerDispatch, (light, pname, params));
}


/* DepthRangeIndexed: marshalled asynchronously */
struct marshal_cmd_DepthRangeIndexed
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLclampd n;
   GLclampd f;
};
static inline void
_mesa_unmarshal_DepthRangeIndexed(struct gl_context *ctx, const struct marshal_cmd_DepthRangeIndexed *cmd)
{
   const GLuint index = cmd->index;
   const GLclampd n = cmd->n;
   const GLclampd f = cmd->f;
   CALL_DepthRangeIndexed(ctx->CurrentServerDispatch, (index, n, f));
}
static void GLAPIENTRY
_mesa_marshal_DepthRangeIndexed(GLuint index, GLclampd n, GLclampd f)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DepthRangeIndexed);
   struct marshal_cmd_DepthRangeIndexed *cmd;
   debug_print_marshal("DepthRangeIndexed");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DepthRangeIndexed, cmd_size);
      cmd->index = index;
      cmd->n = n;
      cmd->f = f;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DepthRangeIndexed");
   CALL_DepthRangeIndexed(ctx->CurrentServerDispatch, (index, n, f));
}


/* GetConvolutionParameterfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetConvolutionParameterfv");
   CALL_GetConvolutionParameterfv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* GetMaterialfv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetMaterialfv(GLenum face, GLenum pname, GLfloat * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetMaterialfv");
   CALL_GetMaterialfv(ctx->CurrentServerDispatch, (face, pname, params));
}


/* TexImage3DMultisample: marshalled asynchronously */
struct marshal_cmd_TexImage3DMultisample
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei samples;
   GLenum internalformat;
   GLsizei width;
   GLsizei height;
   GLsizei depth;
   GLboolean fixedsamplelocations;
};
static inline void
_mesa_unmarshal_TexImage3DMultisample(struct gl_context *ctx, const struct marshal_cmd_TexImage3DMultisample *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei samples = cmd->samples;
   const GLenum internalformat = cmd->internalformat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLsizei depth = cmd->depth;
   const GLboolean fixedsamplelocations = cmd->fixedsamplelocations;
   CALL_TexImage3DMultisample(ctx->CurrentServerDispatch, (target, samples, internalformat, width, height, depth, fixedsamplelocations));
}
static void GLAPIENTRY
_mesa_marshal_TexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexImage3DMultisample);
   struct marshal_cmd_TexImage3DMultisample *cmd;
   debug_print_marshal("TexImage3DMultisample");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexImage3DMultisample, cmd_size);
      cmd->target = target;
      cmd->samples = samples;
      cmd->internalformat = internalformat;
      cmd->width = width;
      cmd->height = height;
      cmd->depth = depth;
      cmd->fixedsamplelocations = fixedsamplelocations;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexImage3DMultisample");
   CALL_TexImage3DMultisample(ctx->CurrentServerDispatch, (target, samples, internalformat, width, height, depth, fixedsamplelocations));
}


/* VertexAttrib1fvNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib1fvNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLfloat v[1];
};
static inline void
_mesa_unmarshal_VertexAttrib1fvNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib1fvNV *cmd)
{
   const GLuint index = cmd->index;
   const GLfloat * v = cmd->v;
   CALL_VertexAttrib1fvNV(ctx->CurrentServerDispatch, (index, v));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib1fvNV(GLuint index, const GLfloat * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib1fvNV);
   struct marshal_cmd_VertexAttrib1fvNV *cmd;
   debug_print_marshal("VertexAttrib1fvNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib1fvNV, cmd_size);
      cmd->index = index;
      memcpy(cmd->v, v, 4);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib1fvNV");
   CALL_VertexAttrib1fvNV(ctx->CurrentServerDispatch, (index, v));
}


/* GetUniformBlockIndex: marshalled synchronously */
static GLuint GLAPIENTRY
_mesa_marshal_GetUniformBlockIndex(GLuint program, const GLchar * uniformBlockName)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetUniformBlockIndex");
   return CALL_GetUniformBlockIndex(ctx->CurrentServerDispatch, (program, uniformBlockName));
}


/* DetachShader: marshalled asynchronously */
struct marshal_cmd_DetachShader
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLuint shader;
};
static inline void
_mesa_unmarshal_DetachShader(struct gl_context *ctx, const struct marshal_cmd_DetachShader *cmd)
{
   const GLuint program = cmd->program;
   const GLuint shader = cmd->shader;
   CALL_DetachShader(ctx->CurrentServerDispatch, (program, shader));
}
static void GLAPIENTRY
_mesa_marshal_DetachShader(GLuint program, GLuint shader)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DetachShader);
   struct marshal_cmd_DetachShader *cmd;
   debug_print_marshal("DetachShader");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DetachShader, cmd_size);
      cmd->program = program;
      cmd->shader = shader;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DetachShader");
   CALL_DetachShader(ctx->CurrentServerDispatch, (program, shader));
}


/* CopyTexSubImage2D: marshalled asynchronously */
struct marshal_cmd_CopyTexSubImage2D
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLint level;
   GLint xoffset;
   GLint yoffset;
   GLint x;
   GLint y;
   GLsizei width;
   GLsizei height;
};
static inline void
_mesa_unmarshal_CopyTexSubImage2D(struct gl_context *ctx, const struct marshal_cmd_CopyTexSubImage2D *cmd)
{
   const GLenum target = cmd->target;
   const GLint level = cmd->level;
   const GLint xoffset = cmd->xoffset;
   const GLint yoffset = cmd->yoffset;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   CALL_CopyTexSubImage2D(ctx->CurrentServerDispatch, (target, level, xoffset, yoffset, x, y, width, height));
}
static void GLAPIENTRY
_mesa_marshal_CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CopyTexSubImage2D);
   struct marshal_cmd_CopyTexSubImage2D *cmd;
   debug_print_marshal("CopyTexSubImage2D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CopyTexSubImage2D, cmd_size);
      cmd->target = target;
      cmd->level = level;
      cmd->xoffset = xoffset;
      cmd->yoffset = yoffset;
      cmd->x = x;
      cmd->y = y;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CopyTexSubImage2D");
   CALL_CopyTexSubImage2D(ctx->CurrentServerDispatch, (target, level, xoffset, yoffset, x, y, width, height));
}


/* GetNamedFramebufferParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetNamedFramebufferParameteriv(GLuint framebuffer, GLenum pname, GLint * param)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetNamedFramebufferParameteriv");
   CALL_GetNamedFramebufferParameteriv(ctx->CurrentServerDispatch, (framebuffer, pname, param));
}


/* GetObjectParameterivARB: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetObjectParameterivARB(GLhandleARB obj, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetObjectParameterivARB");
   CALL_GetObjectParameterivARB(ctx->CurrentServerDispatch, (obj, pname, params));
}


/* Color3iv: marshalled asynchronously */
struct marshal_cmd_Color3iv
{
   struct marshal_cmd_base cmd_base;
   GLint v[3];
};
static inline void
_mesa_unmarshal_Color3iv(struct gl_context *ctx, const struct marshal_cmd_Color3iv *cmd)
{
   const GLint * v = cmd->v;
   CALL_Color3iv(ctx->CurrentServerDispatch, (v));
}
static void GLAPIENTRY
_mesa_marshal_Color3iv(const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Color3iv);
   struct marshal_cmd_Color3iv *cmd;
   debug_print_marshal("Color3iv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Color3iv, cmd_size);
      memcpy(cmd->v, v, 12);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Color3iv");
   CALL_Color3iv(ctx->CurrentServerDispatch, (v));
}


/* DrawElements: marshalled asynchronously */
struct marshal_cmd_DrawElements
{
   struct marshal_cmd_base cmd_base;
   GLenum mode;
   GLsizei count;
   GLenum type;
   const GLvoid * indices;
};
static inline void
_mesa_unmarshal_DrawElements(struct gl_context *ctx, const struct marshal_cmd_DrawElements *cmd)
{
   const GLenum mode = cmd->mode;
   const GLsizei count = cmd->count;
   const GLenum type = cmd->type;
   const GLvoid * indices = cmd->indices;
   CALL_DrawElements(ctx->CurrentServerDispatch, (mode, count, type, indices));
}
static void GLAPIENTRY
_mesa_marshal_DrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_DrawElements);
   struct marshal_cmd_DrawElements *cmd;
   debug_print_marshal("DrawElements");
   if (_mesa_glthread_is_non_vbo_draw_elements(ctx)) {
      _mesa_glthread_finish(ctx);
      _mesa_glthread_restore_dispatch(ctx);
      debug_print_sync_fallback("DrawElements");
      CALL_DrawElements(ctx->CurrentServerDispatch, (mode, count, type, indices));
      return;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_DrawElements, cmd_size);
      cmd->mode = mode;
      cmd->count = count;
      cmd->type = type;
      cmd->indices = indices;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("DrawElements");
   CALL_DrawElements(ctx->CurrentServerDispatch, (mode, count, type, indices));
}


/* ScissorArrayv: marshalled asynchronously */
struct marshal_cmd_ScissorArrayv
{
   struct marshal_cmd_base cmd_base;
   GLuint first;
   GLsizei count;
   /* Next safe_mul(count, 16) bytes are int v[count][4] */
};
static inline void
_mesa_unmarshal_ScissorArrayv(struct gl_context *ctx, const struct marshal_cmd_ScissorArrayv *cmd)
{
   const GLuint first = cmd->first;
   const GLsizei count = cmd->count;
   const int * v;
   const char *variable_data = (const char *) (cmd + 1);
   v = (const int *) variable_data;
   variable_data += count * 16;
   CALL_ScissorArrayv(ctx->CurrentServerDispatch, (first, count, v));
}
static void GLAPIENTRY
_mesa_marshal_ScissorArrayv(GLuint first, GLsizei count, const int * v)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ScissorArrayv) + safe_mul(count, 16);
   struct marshal_cmd_ScissorArrayv *cmd;
   debug_print_marshal("ScissorArrayv");
   if (unlikely(safe_mul(count, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ScissorArrayv, cmd_size);
      cmd->first = first;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, v, count * 16);
      variable_data += count * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ScissorArrayv");
   CALL_ScissorArrayv(ctx->CurrentServerDispatch, (first, count, v));
}


/* GetInternalformativ: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetInternalformativ");
   CALL_GetInternalformativ(ctx->CurrentServerDispatch, (target, internalformat, pname, bufSize, params));
}


/* EvalPoint2: marshalled asynchronously */
struct marshal_cmd_EvalPoint2
{
   struct marshal_cmd_base cmd_base;
   GLint i;
   GLint j;
};
static inline void
_mesa_unmarshal_EvalPoint2(struct gl_context *ctx, const struct marshal_cmd_EvalPoint2 *cmd)
{
   const GLint i = cmd->i;
   const GLint j = cmd->j;
   CALL_EvalPoint2(ctx->CurrentServerDispatch, (i, j));
}
static void GLAPIENTRY
_mesa_marshal_EvalPoint2(GLint i, GLint j)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EvalPoint2);
   struct marshal_cmd_EvalPoint2 *cmd;
   debug_print_marshal("EvalPoint2");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EvalPoint2, cmd_size);
      cmd->i = i;
      cmd->j = j;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EvalPoint2");
   CALL_EvalPoint2(ctx->CurrentServerDispatch, (i, j));
}


/* EvalPoint1: marshalled asynchronously */
struct marshal_cmd_EvalPoint1
{
   struct marshal_cmd_base cmd_base;
   GLint i;
};
static inline void
_mesa_unmarshal_EvalPoint1(struct gl_context *ctx, const struct marshal_cmd_EvalPoint1 *cmd)
{
   const GLint i = cmd->i;
   CALL_EvalPoint1(ctx->CurrentServerDispatch, (i));
}
static void GLAPIENTRY
_mesa_marshal_EvalPoint1(GLint i)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EvalPoint1);
   struct marshal_cmd_EvalPoint1 *cmd;
   debug_print_marshal("EvalPoint1");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EvalPoint1, cmd_size);
      cmd->i = i;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EvalPoint1");
   CALL_EvalPoint1(ctx->CurrentServerDispatch, (i));
}


/* VertexAttribLPointer: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * pointer)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribLPointer");
   CALL_VertexAttribLPointer(ctx->CurrentServerDispatch, (index, size, type, stride, pointer));
}


/* PopMatrix: marshalled asynchronously */
struct marshal_cmd_PopMatrix
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_PopMatrix(struct gl_context *ctx, const struct marshal_cmd_PopMatrix *cmd)
{
   CALL_PopMatrix(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_PopMatrix(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_PopMatrix);
   struct marshal_cmd_PopMatrix *cmd;
   debug_print_marshal("PopMatrix");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_PopMatrix, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("PopMatrix");
   CALL_PopMatrix(ctx->CurrentServerDispatch, ());
}


/* GetTexGeniv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetTexGeniv(GLenum coord, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTexGeniv");
   CALL_GetTexGeniv(ctx->CurrentServerDispatch, (coord, pname, params));
}


/* GetFirstPerfQueryIdINTEL: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetFirstPerfQueryIdINTEL(GLuint * queryId)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetFirstPerfQueryIdINTEL");
   CALL_GetFirstPerfQueryIdINTEL(ctx->CurrentServerDispatch, (queryId));
}


/* UnmapBuffer: marshalled synchronously */
static GLboolean GLAPIENTRY
_mesa_marshal_UnmapBuffer(GLenum target)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("UnmapBuffer");
   return CALL_UnmapBuffer(ctx->CurrentServerDispatch, (target));
}


/* EvalCoord1d: marshalled asynchronously */
struct marshal_cmd_EvalCoord1d
{
   struct marshal_cmd_base cmd_base;
   GLdouble u;
};
static inline void
_mesa_unmarshal_EvalCoord1d(struct gl_context *ctx, const struct marshal_cmd_EvalCoord1d *cmd)
{
   const GLdouble u = cmd->u;
   CALL_EvalCoord1d(ctx->CurrentServerDispatch, (u));
}
static void GLAPIENTRY
_mesa_marshal_EvalCoord1d(GLdouble u)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EvalCoord1d);
   struct marshal_cmd_EvalCoord1d *cmd;
   debug_print_marshal("EvalCoord1d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EvalCoord1d, cmd_size);
      cmd->u = u;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EvalCoord1d");
   CALL_EvalCoord1d(ctx->CurrentServerDispatch, (u));
}


/* VertexAttribL1d: marshalled asynchronously */
struct marshal_cmd_VertexAttribL1d
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble x;
};
static inline void
_mesa_unmarshal_VertexAttribL1d(struct gl_context *ctx, const struct marshal_cmd_VertexAttribL1d *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble x = cmd->x;
   CALL_VertexAttribL1d(ctx->CurrentServerDispatch, (index, x));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttribL1d(GLuint index, GLdouble x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttribL1d);
   struct marshal_cmd_VertexAttribL1d *cmd;
   debug_print_marshal("VertexAttribL1d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttribL1d, cmd_size);
      cmd->index = index;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttribL1d");
   CALL_VertexAttribL1d(ctx->CurrentServerDispatch, (index, x));
}


/* EvalCoord1f: marshalled asynchronously */
struct marshal_cmd_EvalCoord1f
{
   struct marshal_cmd_base cmd_base;
   GLfloat u;
};
static inline void
_mesa_unmarshal_EvalCoord1f(struct gl_context *ctx, const struct marshal_cmd_EvalCoord1f *cmd)
{
   const GLfloat u = cmd->u;
   CALL_EvalCoord1f(ctx->CurrentServerDispatch, (u));
}
static void GLAPIENTRY
_mesa_marshal_EvalCoord1f(GLfloat u)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EvalCoord1f);
   struct marshal_cmd_EvalCoord1f *cmd;
   debug_print_marshal("EvalCoord1f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EvalCoord1f, cmd_size);
      cmd->u = u;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EvalCoord1f");
   CALL_EvalCoord1f(ctx->CurrentServerDispatch, (u));
}


/* Materialf: marshalled asynchronously */
struct marshal_cmd_Materialf
{
   struct marshal_cmd_base cmd_base;
   GLenum face;
   GLenum pname;
   GLfloat param;
};
static inline void
_mesa_unmarshal_Materialf(struct gl_context *ctx, const struct marshal_cmd_Materialf *cmd)
{
   const GLenum face = cmd->face;
   const GLenum pname = cmd->pname;
   const GLfloat param = cmd->param;
   CALL_Materialf(ctx->CurrentServerDispatch, (face, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_Materialf(GLenum face, GLenum pname, GLfloat param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Materialf);
   struct marshal_cmd_Materialf *cmd;
   debug_print_marshal("Materialf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Materialf, cmd_size);
      cmd->face = face;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Materialf");
   CALL_Materialf(ctx->CurrentServerDispatch, (face, pname, param));
}


/* Materiali: marshalled asynchronously */
struct marshal_cmd_Materiali
{
   struct marshal_cmd_base cmd_base;
   GLenum face;
   GLenum pname;
   GLint param;
};
static inline void
_mesa_unmarshal_Materiali(struct gl_context *ctx, const struct marshal_cmd_Materiali *cmd)
{
   const GLenum face = cmd->face;
   const GLenum pname = cmd->pname;
   const GLint param = cmd->param;
   CALL_Materiali(ctx->CurrentServerDispatch, (face, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_Materiali(GLenum face, GLenum pname, GLint param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Materiali);
   struct marshal_cmd_Materiali *cmd;
   debug_print_marshal("Materiali");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Materiali, cmd_size);
      cmd->face = face;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Materiali");
   CALL_Materiali(ctx->CurrentServerDispatch, (face, pname, param));
}


/* ProgramUniform1uiv: marshalled asynchronously */
struct marshal_cmd_ProgramUniform1uiv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 4) bytes are GLuint value[count] */
};
static inline void
_mesa_unmarshal_ProgramUniform1uiv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform1uiv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLuint * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLuint *) variable_data;
   variable_data += count * 4;
   CALL_ProgramUniform1uiv(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform1uiv) + safe_mul(count, 4);
   struct marshal_cmd_ProgramUniform1uiv *cmd;
   debug_print_marshal("ProgramUniform1uiv");
   if (unlikely(safe_mul(count, 4) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform1uiv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 4);
      variable_data += count * 4;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform1uiv");
   CALL_ProgramUniform1uiv(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* EvalCoord1dv: marshalled asynchronously */
struct marshal_cmd_EvalCoord1dv
{
   struct marshal_cmd_base cmd_base;
   GLdouble u[1];
};
static inline void
_mesa_unmarshal_EvalCoord1dv(struct gl_context *ctx, const struct marshal_cmd_EvalCoord1dv *cmd)
{
   const GLdouble * u = cmd->u;
   CALL_EvalCoord1dv(ctx->CurrentServerDispatch, (u));
}
static void GLAPIENTRY
_mesa_marshal_EvalCoord1dv(const GLdouble * u)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EvalCoord1dv);
   struct marshal_cmd_EvalCoord1dv *cmd;
   debug_print_marshal("EvalCoord1dv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EvalCoord1dv, cmd_size);
      memcpy(cmd->u, u, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EvalCoord1dv");
   CALL_EvalCoord1dv(ctx->CurrentServerDispatch, (u));
}


/* Materialx: marshalled asynchronously */
struct marshal_cmd_Materialx
{
   struct marshal_cmd_base cmd_base;
   GLenum face;
   GLenum pname;
   GLfixed param;
};
static inline void
_mesa_unmarshal_Materialx(struct gl_context *ctx, const struct marshal_cmd_Materialx *cmd)
{
   const GLenum face = cmd->face;
   const GLenum pname = cmd->pname;
   const GLfixed param = cmd->param;
   CALL_Materialx(ctx->CurrentServerDispatch, (face, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_Materialx(GLenum face, GLenum pname, GLfixed param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Materialx);
   struct marshal_cmd_Materialx *cmd;
   debug_print_marshal("Materialx");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Materialx, cmd_size);
      cmd->face = face;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Materialx");
   CALL_Materialx(ctx->CurrentServerDispatch, (face, pname, param));
}


/* GetQueryBufferObjectiv: marshalled asynchronously */
struct marshal_cmd_GetQueryBufferObjectiv
{
   struct marshal_cmd_base cmd_base;
   GLuint id;
   GLuint buffer;
   GLenum pname;
   GLintptr offset;
};
static inline void
_mesa_unmarshal_GetQueryBufferObjectiv(struct gl_context *ctx, const struct marshal_cmd_GetQueryBufferObjectiv *cmd)
{
   const GLuint id = cmd->id;
   const GLuint buffer = cmd->buffer;
   const GLenum pname = cmd->pname;
   const GLintptr offset = cmd->offset;
   CALL_GetQueryBufferObjectiv(ctx->CurrentServerDispatch, (id, buffer, pname, offset));
}
static void GLAPIENTRY
_mesa_marshal_GetQueryBufferObjectiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_GetQueryBufferObjectiv);
   struct marshal_cmd_GetQueryBufferObjectiv *cmd;
   debug_print_marshal("GetQueryBufferObjectiv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_GetQueryBufferObjectiv, cmd_size);
      cmd->id = id;
      cmd->buffer = buffer;
      cmd->pname = pname;
      cmd->offset = offset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("GetQueryBufferObjectiv");
   CALL_GetQueryBufferObjectiv(ctx->CurrentServerDispatch, (id, buffer, pname, offset));
}


/* GetTextureSamplerHandleARB: marshalled synchronously */
static GLuint64 GLAPIENTRY
_mesa_marshal_GetTextureSamplerHandleARB(GLuint texture, GLuint sampler)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetTextureSamplerHandleARB");
   return CALL_GetTextureSamplerHandleARB(ctx->CurrentServerDispatch, (texture, sampler));
}


/* GetLightiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetLightiv(GLenum light, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetLightiv");
   CALL_GetLightiv(ctx->CurrentServerDispatch, (light, pname, params));
}


/* ProgramUniform3i64ARB: marshalled asynchronously */
struct marshal_cmd_ProgramUniform3i64ARB
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLint64 x;
   GLint64 y;
   GLint64 z;
};
static inline void
_mesa_unmarshal_ProgramUniform3i64ARB(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform3i64ARB *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLint64 x = cmd->x;
   const GLint64 y = cmd->y;
   const GLint64 z = cmd->z;
   CALL_ProgramUniform3i64ARB(ctx->CurrentServerDispatch, (program, location, x, y, z));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform3i64ARB(GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform3i64ARB);
   struct marshal_cmd_ProgramUniform3i64ARB *cmd;
   debug_print_marshal("ProgramUniform3i64ARB");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform3i64ARB, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      cmd->y = y;
      cmd->z = z;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform3i64ARB");
   CALL_ProgramUniform3i64ARB(ctx->CurrentServerDispatch, (program, location, x, y, z));
}


/* ProgramUniform1i: marshalled asynchronously */
struct marshal_cmd_ProgramUniform1i
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLint x;
};
static inline void
_mesa_unmarshal_ProgramUniform1i(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform1i *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLint x = cmd->x;
   CALL_ProgramUniform1i(ctx->CurrentServerDispatch, (program, location, x));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform1i(GLuint program, GLint location, GLint x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform1i);
   struct marshal_cmd_ProgramUniform1i *cmd;
   debug_print_marshal("ProgramUniform1i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform1i, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform1i");
   CALL_ProgramUniform1i(ctx->CurrentServerDispatch, (program, location, x));
}


/* ProgramUniform1f: marshalled asynchronously */
struct marshal_cmd_ProgramUniform1f
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLfloat x;
};
static inline void
_mesa_unmarshal_ProgramUniform1f(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform1f *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLfloat x = cmd->x;
   CALL_ProgramUniform1f(ctx->CurrentServerDispatch, (program, location, x));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform1f(GLuint program, GLint location, GLfloat x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform1f);
   struct marshal_cmd_ProgramUniform1f *cmd;
   debug_print_marshal("ProgramUniform1f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform1f, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform1f");
   CALL_ProgramUniform1f(ctx->CurrentServerDispatch, (program, location, x));
}


/* ProgramUniform1d: marshalled asynchronously */
struct marshal_cmd_ProgramUniform1d
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLdouble x;
};
static inline void
_mesa_unmarshal_ProgramUniform1d(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform1d *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLdouble x = cmd->x;
   CALL_ProgramUniform1d(ctx->CurrentServerDispatch, (program, location, x));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform1d(GLuint program, GLint location, GLdouble x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform1d);
   struct marshal_cmd_ProgramUniform1d *cmd;
   debug_print_marshal("ProgramUniform1d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform1d, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform1d");
   CALL_ProgramUniform1d(ctx->CurrentServerDispatch, (program, location, x));
}


/* WindowPos3iv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_WindowPos3iv(const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("WindowPos3iv");
   CALL_WindowPos3iv(ctx->CurrentServerDispatch, (v));
}


/* CopyConvolutionFilter2D: marshalled asynchronously */
struct marshal_cmd_CopyConvolutionFilter2D
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLenum internalformat;
   GLint x;
   GLint y;
   GLsizei width;
   GLsizei height;
};
static inline void
_mesa_unmarshal_CopyConvolutionFilter2D(struct gl_context *ctx, const struct marshal_cmd_CopyConvolutionFilter2D *cmd)
{
   const GLenum target = cmd->target;
   const GLenum internalformat = cmd->internalformat;
   const GLint x = cmd->x;
   const GLint y = cmd->y;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   CALL_CopyConvolutionFilter2D(ctx->CurrentServerDispatch, (target, internalformat, x, y, width, height));
}
static void GLAPIENTRY
_mesa_marshal_CopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CopyConvolutionFilter2D);
   struct marshal_cmd_CopyConvolutionFilter2D *cmd;
   debug_print_marshal("CopyConvolutionFilter2D");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CopyConvolutionFilter2D, cmd_size);
      cmd->target = target;
      cmd->internalformat = internalformat;
      cmd->x = x;
      cmd->y = y;
      cmd->width = width;
      cmd->height = height;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CopyConvolutionFilter2D");
   CALL_CopyConvolutionFilter2D(ctx->CurrentServerDispatch, (target, internalformat, x, y, width, height));
}


/* CopyBufferSubData: marshalled asynchronously */
struct marshal_cmd_CopyBufferSubData
{
   struct marshal_cmd_base cmd_base;
   GLenum readTarget;
   GLenum writeTarget;
   GLintptr readOffset;
   GLintptr writeOffset;
   GLsizeiptr size;
};
static inline void
_mesa_unmarshal_CopyBufferSubData(struct gl_context *ctx, const struct marshal_cmd_CopyBufferSubData *cmd)
{
   const GLenum readTarget = cmd->readTarget;
   const GLenum writeTarget = cmd->writeTarget;
   const GLintptr readOffset = cmd->readOffset;
   const GLintptr writeOffset = cmd->writeOffset;
   const GLsizeiptr size = cmd->size;
   CALL_CopyBufferSubData(ctx->CurrentServerDispatch, (readTarget, writeTarget, readOffset, writeOffset, size));
}
static void GLAPIENTRY
_mesa_marshal_CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_CopyBufferSubData);
   struct marshal_cmd_CopyBufferSubData *cmd;
   debug_print_marshal("CopyBufferSubData");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_CopyBufferSubData, cmd_size);
      cmd->readTarget = readTarget;
      cmd->writeTarget = writeTarget;
      cmd->readOffset = readOffset;
      cmd->writeOffset = writeOffset;
      cmd->size = size;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("CopyBufferSubData");
   CALL_CopyBufferSubData(ctx->CurrentServerDispatch, (readTarget, writeTarget, readOffset, writeOffset, size));
}


/* UniformMatrix3x4fv: marshalled asynchronously */
struct marshal_cmd_UniformMatrix3x4fv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 48) bytes are GLfloat value[count][12] */
};
static inline void
_mesa_unmarshal_UniformMatrix3x4fv(struct gl_context *ctx, const struct marshal_cmd_UniformMatrix3x4fv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLfloat * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLfloat *) variable_data;
   variable_data += count * 48;
   CALL_UniformMatrix3x4fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_UniformMatrix3x4fv) + safe_mul(count, 48);
   struct marshal_cmd_UniformMatrix3x4fv *cmd;
   debug_print_marshal("UniformMatrix3x4fv");
   if (unlikely(safe_mul(count, 48) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_UniformMatrix3x4fv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 48);
      variable_data += count * 48;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("UniformMatrix3x4fv");
   CALL_UniformMatrix3x4fv(ctx->CurrentServerDispatch, (location, count, transpose, value));
}


/* Recti: marshalled asynchronously */
struct marshal_cmd_Recti
{
   struct marshal_cmd_base cmd_base;
   GLint x1;
   GLint y1;
   GLint x2;
   GLint y2;
};
static inline void
_mesa_unmarshal_Recti(struct gl_context *ctx, const struct marshal_cmd_Recti *cmd)
{
   const GLint x1 = cmd->x1;
   const GLint y1 = cmd->y1;
   const GLint x2 = cmd->x2;
   const GLint y2 = cmd->y2;
   CALL_Recti(ctx->CurrentServerDispatch, (x1, y1, x2, y2));
}
static void GLAPIENTRY
_mesa_marshal_Recti(GLint x1, GLint y1, GLint x2, GLint y2)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Recti);
   struct marshal_cmd_Recti *cmd;
   debug_print_marshal("Recti");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Recti, cmd_size);
      cmd->x1 = x1;
      cmd->y1 = y1;
      cmd->x2 = x2;
      cmd->y2 = y2;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Recti");
   CALL_Recti(ctx->CurrentServerDispatch, (x1, y1, x2, y2));
}


/* VertexAttribI3ivEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexAttribI3ivEXT(GLuint index, const GLint * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexAttribI3ivEXT");
   CALL_VertexAttribI3ivEXT(ctx->CurrentServerDispatch, (index, v));
}


/* DeleteSamplers: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_DeleteSamplers(GLsizei count, const GLuint * samplers)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("DeleteSamplers");
   CALL_DeleteSamplers(ctx->CurrentServerDispatch, (count, samplers));
}


/* SamplerParameteri: marshalled asynchronously */
struct marshal_cmd_SamplerParameteri
{
   struct marshal_cmd_base cmd_base;
   GLuint sampler;
   GLenum pname;
   GLint param;
};
static inline void
_mesa_unmarshal_SamplerParameteri(struct gl_context *ctx, const struct marshal_cmd_SamplerParameteri *cmd)
{
   const GLuint sampler = cmd->sampler;
   const GLenum pname = cmd->pname;
   const GLint param = cmd->param;
   CALL_SamplerParameteri(ctx->CurrentServerDispatch, (sampler, pname, param));
}
static void GLAPIENTRY
_mesa_marshal_SamplerParameteri(GLuint sampler, GLenum pname, GLint param)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_SamplerParameteri);
   struct marshal_cmd_SamplerParameteri *cmd;
   debug_print_marshal("SamplerParameteri");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_SamplerParameteri, cmd_size);
      cmd->sampler = sampler;
      cmd->pname = pname;
      cmd->param = param;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("SamplerParameteri");
   CALL_SamplerParameteri(ctx->CurrentServerDispatch, (sampler, pname, param));
}


/* WindowRectanglesEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_WindowRectanglesEXT(GLenum mode, GLsizei count, const GLint * box)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("WindowRectanglesEXT");
   CALL_WindowRectanglesEXT(ctx->CurrentServerDispatch, (mode, count, box));
}


/* Rectf: marshalled asynchronously */
struct marshal_cmd_Rectf
{
   struct marshal_cmd_base cmd_base;
   GLfloat x1;
   GLfloat y1;
   GLfloat x2;
   GLfloat y2;
};
static inline void
_mesa_unmarshal_Rectf(struct gl_context *ctx, const struct marshal_cmd_Rectf *cmd)
{
   const GLfloat x1 = cmd->x1;
   const GLfloat y1 = cmd->y1;
   const GLfloat x2 = cmd->x2;
   const GLfloat y2 = cmd->y2;
   CALL_Rectf(ctx->CurrentServerDispatch, (x1, y1, x2, y2));
}
static void GLAPIENTRY
_mesa_marshal_Rectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Rectf);
   struct marshal_cmd_Rectf *cmd;
   debug_print_marshal("Rectf");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Rectf, cmd_size);
      cmd->x1 = x1;
      cmd->y1 = y1;
      cmd->x2 = x2;
      cmd->y2 = y2;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Rectf");
   CALL_Rectf(ctx->CurrentServerDispatch, (x1, y1, x2, y2));
}


/* Rectd: marshalled asynchronously */
struct marshal_cmd_Rectd
{
   struct marshal_cmd_base cmd_base;
   GLdouble x1;
   GLdouble y1;
   GLdouble x2;
   GLdouble y2;
};
static inline void
_mesa_unmarshal_Rectd(struct gl_context *ctx, const struct marshal_cmd_Rectd *cmd)
{
   const GLdouble x1 = cmd->x1;
   const GLdouble y1 = cmd->y1;
   const GLdouble x2 = cmd->x2;
   const GLdouble y2 = cmd->y2;
   CALL_Rectd(ctx->CurrentServerDispatch, (x1, y1, x2, y2));
}
static void GLAPIENTRY
_mesa_marshal_Rectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Rectd);
   struct marshal_cmd_Rectd *cmd;
   debug_print_marshal("Rectd");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Rectd, cmd_size);
      cmd->x1 = x1;
      cmd->y1 = y1;
      cmd->x2 = x2;
      cmd->y2 = y2;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Rectd");
   CALL_Rectd(ctx->CurrentServerDispatch, (x1, y1, x2, y2));
}


/* MultMatrixx: marshalled asynchronously */
struct marshal_cmd_MultMatrixx
{
   struct marshal_cmd_base cmd_base;
   GLfixed m[16];
};
static inline void
_mesa_unmarshal_MultMatrixx(struct gl_context *ctx, const struct marshal_cmd_MultMatrixx *cmd)
{
   const GLfixed * m = cmd->m;
   CALL_MultMatrixx(ctx->CurrentServerDispatch, (m));
}
static void GLAPIENTRY
_mesa_marshal_MultMatrixx(const GLfixed * m)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MultMatrixx);
   struct marshal_cmd_MultMatrixx *cmd;
   debug_print_marshal("MultMatrixx");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MultMatrixx, cmd_size);
      memcpy(cmd->m, m, 64);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MultMatrixx");
   CALL_MultMatrixx(ctx->CurrentServerDispatch, (m));
}


/* TexStorageMem3DMultisampleEXT: marshalled asynchronously */
struct marshal_cmd_TexStorageMem3DMultisampleEXT
{
   struct marshal_cmd_base cmd_base;
   GLenum target;
   GLsizei samples;
   GLenum internalFormat;
   GLsizei width;
   GLsizei height;
   GLsizei depth;
   GLboolean fixedSampleLocations;
   GLuint memory;
   GLuint64 offset;
};
static inline void
_mesa_unmarshal_TexStorageMem3DMultisampleEXT(struct gl_context *ctx, const struct marshal_cmd_TexStorageMem3DMultisampleEXT *cmd)
{
   const GLenum target = cmd->target;
   const GLsizei samples = cmd->samples;
   const GLenum internalFormat = cmd->internalFormat;
   const GLsizei width = cmd->width;
   const GLsizei height = cmd->height;
   const GLsizei depth = cmd->depth;
   const GLboolean fixedSampleLocations = cmd->fixedSampleLocations;
   const GLuint memory = cmd->memory;
   const GLuint64 offset = cmd->offset;
   CALL_TexStorageMem3DMultisampleEXT(ctx->CurrentServerDispatch, (target, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset));
}
static void GLAPIENTRY
_mesa_marshal_TexStorageMem3DMultisampleEXT(GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexStorageMem3DMultisampleEXT);
   struct marshal_cmd_TexStorageMem3DMultisampleEXT *cmd;
   debug_print_marshal("TexStorageMem3DMultisampleEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexStorageMem3DMultisampleEXT, cmd_size);
      cmd->target = target;
      cmd->samples = samples;
      cmd->internalFormat = internalFormat;
      cmd->width = width;
      cmd->height = height;
      cmd->depth = depth;
      cmd->fixedSampleLocations = fixedSampleLocations;
      cmd->memory = memory;
      cmd->offset = offset;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexStorageMem3DMultisampleEXT");
   CALL_TexStorageMem3DMultisampleEXT(ctx->CurrentServerDispatch, (target, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset));
}


/* Rects: marshalled asynchronously */
struct marshal_cmd_Rects
{
   struct marshal_cmd_base cmd_base;
   GLshort x1;
   GLshort y1;
   GLshort x2;
   GLshort y2;
};
static inline void
_mesa_unmarshal_Rects(struct gl_context *ctx, const struct marshal_cmd_Rects *cmd)
{
   const GLshort x1 = cmd->x1;
   const GLshort y1 = cmd->y1;
   const GLshort x2 = cmd->x2;
   const GLshort y2 = cmd->y2;
   CALL_Rects(ctx->CurrentServerDispatch, (x1, y1, x2, y2));
}
static void GLAPIENTRY
_mesa_marshal_Rects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Rects);
   struct marshal_cmd_Rects *cmd;
   debug_print_marshal("Rects");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Rects, cmd_size);
      cmd->x1 = x1;
      cmd->y1 = y1;
      cmd->x2 = x2;
      cmd->y2 = y2;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Rects");
   CALL_Rects(ctx->CurrentServerDispatch, (x1, y1, x2, y2));
}


/* GetVertexAttribIiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetVertexAttribIiv(GLuint index, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetVertexAttribIiv");
   CALL_GetVertexAttribIiv(ctx->CurrentServerDispatch, (index, pname, params));
}


/* ClientWaitSync: marshalled synchronously */
static GLenum GLAPIENTRY
_mesa_marshal_ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ClientWaitSync");
   return CALL_ClientWaitSync(ctx->CurrentServerDispatch, (sync, flags, timeout));
}


/* TexCoord4s: marshalled asynchronously */
struct marshal_cmd_TexCoord4s
{
   struct marshal_cmd_base cmd_base;
   GLshort s;
   GLshort t;
   GLshort r;
   GLshort q;
};
static inline void
_mesa_unmarshal_TexCoord4s(struct gl_context *ctx, const struct marshal_cmd_TexCoord4s *cmd)
{
   const GLshort s = cmd->s;
   const GLshort t = cmd->t;
   const GLshort r = cmd->r;
   const GLshort q = cmd->q;
   CALL_TexCoord4s(ctx->CurrentServerDispatch, (s, t, r, q));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord4s);
   struct marshal_cmd_TexCoord4s *cmd;
   debug_print_marshal("TexCoord4s");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord4s, cmd_size);
      cmd->s = s;
      cmd->t = t;
      cmd->r = r;
      cmd->q = q;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord4s");
   CALL_TexCoord4s(ctx->CurrentServerDispatch, (s, t, r, q));
}


/* TexEnvxv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_TexEnvxv(GLenum target, GLenum pname, const GLfixed * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("TexEnvxv");
   CALL_TexEnvxv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* TexCoord4i: marshalled asynchronously */
struct marshal_cmd_TexCoord4i
{
   struct marshal_cmd_base cmd_base;
   GLint s;
   GLint t;
   GLint r;
   GLint q;
};
static inline void
_mesa_unmarshal_TexCoord4i(struct gl_context *ctx, const struct marshal_cmd_TexCoord4i *cmd)
{
   const GLint s = cmd->s;
   const GLint t = cmd->t;
   const GLint r = cmd->r;
   const GLint q = cmd->q;
   CALL_TexCoord4i(ctx->CurrentServerDispatch, (s, t, r, q));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord4i(GLint s, GLint t, GLint r, GLint q)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord4i);
   struct marshal_cmd_TexCoord4i *cmd;
   debug_print_marshal("TexCoord4i");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord4i, cmd_size);
      cmd->s = s;
      cmd->t = t;
      cmd->r = r;
      cmd->q = q;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord4i");
   CALL_TexCoord4i(ctx->CurrentServerDispatch, (s, t, r, q));
}


/* ObjectPurgeableAPPLE: marshalled synchronously */
static GLenum GLAPIENTRY
_mesa_marshal_ObjectPurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ObjectPurgeableAPPLE");
   return CALL_ObjectPurgeableAPPLE(ctx->CurrentServerDispatch, (objectType, name, option));
}


/* ProgramUniform1ui64vARB: marshalled asynchronously */
struct marshal_cmd_ProgramUniform1ui64vARB
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 8) bytes are GLuint64 value[count] */
};
static inline void
_mesa_unmarshal_ProgramUniform1ui64vARB(struct gl_context *ctx, const struct marshal_cmd_ProgramUniform1ui64vARB *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLuint64 * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLuint64 *) variable_data;
   variable_data += count * 8;
   CALL_ProgramUniform1ui64vARB(ctx->CurrentServerDispatch, (program, location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniform1ui64vARB(GLuint program, GLint location, GLsizei count, const GLuint64 * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniform1ui64vARB) + safe_mul(count, 8);
   struct marshal_cmd_ProgramUniform1ui64vARB *cmd;
   debug_print_marshal("ProgramUniform1ui64vARB");
   if (unlikely(safe_mul(count, 8) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniform1ui64vARB, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 8);
      variable_data += count * 8;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniform1ui64vARB");
   CALL_ProgramUniform1ui64vARB(ctx->CurrentServerDispatch, (program, location, count, value));
}


/* TexCoord4d: marshalled asynchronously */
struct marshal_cmd_TexCoord4d
{
   struct marshal_cmd_base cmd_base;
   GLdouble s;
   GLdouble t;
   GLdouble r;
   GLdouble q;
};
static inline void
_mesa_unmarshal_TexCoord4d(struct gl_context *ctx, const struct marshal_cmd_TexCoord4d *cmd)
{
   const GLdouble s = cmd->s;
   const GLdouble t = cmd->t;
   const GLdouble r = cmd->r;
   const GLdouble q = cmd->q;
   CALL_TexCoord4d(ctx->CurrentServerDispatch, (s, t, r, q));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord4d);
   struct marshal_cmd_TexCoord4d *cmd;
   debug_print_marshal("TexCoord4d");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord4d, cmd_size);
      cmd->s = s;
      cmd->t = t;
      cmd->r = r;
      cmd->q = q;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord4d");
   CALL_TexCoord4d(ctx->CurrentServerDispatch, (s, t, r, q));
}


/* TexCoord4f: marshalled asynchronously */
struct marshal_cmd_TexCoord4f
{
   struct marshal_cmd_base cmd_base;
   GLfloat s;
   GLfloat t;
   GLfloat r;
   GLfloat q;
};
static inline void
_mesa_unmarshal_TexCoord4f(struct gl_context *ctx, const struct marshal_cmd_TexCoord4f *cmd)
{
   const GLfloat s = cmd->s;
   const GLfloat t = cmd->t;
   const GLfloat r = cmd->r;
   const GLfloat q = cmd->q;
   CALL_TexCoord4f(ctx->CurrentServerDispatch, (s, t, r, q));
}
static void GLAPIENTRY
_mesa_marshal_TexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_TexCoord4f);
   struct marshal_cmd_TexCoord4f *cmd;
   debug_print_marshal("TexCoord4f");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_TexCoord4f, cmd_size);
      cmd->s = s;
      cmd->t = t;
      cmd->r = r;
      cmd->q = q;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("TexCoord4f");
   CALL_TexCoord4f(ctx->CurrentServerDispatch, (s, t, r, q));
}


/* GetBooleanv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetBooleanv(GLenum pname, GLboolean * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetBooleanv");
   CALL_GetBooleanv(ctx->CurrentServerDispatch, (pname, params));
}


/* ProgramUniformMatrix3dv: marshalled asynchronously */
struct marshal_cmd_ProgramUniformMatrix3dv
{
   struct marshal_cmd_base cmd_base;
   GLuint program;
   GLint location;
   GLsizei count;
   GLboolean transpose;
   /* Next safe_mul(count, 72) bytes are GLdouble value[count][9] */
};
static inline void
_mesa_unmarshal_ProgramUniformMatrix3dv(struct gl_context *ctx, const struct marshal_cmd_ProgramUniformMatrix3dv *cmd)
{
   const GLuint program = cmd->program;
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLboolean transpose = cmd->transpose;
   const GLdouble * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLdouble *) variable_data;
   variable_data += count * 72;
   CALL_ProgramUniformMatrix3dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}
static void GLAPIENTRY
_mesa_marshal_ProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_ProgramUniformMatrix3dv) + safe_mul(count, 72);
   struct marshal_cmd_ProgramUniformMatrix3dv *cmd;
   debug_print_marshal("ProgramUniformMatrix3dv");
   if (unlikely(safe_mul(count, 72) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_ProgramUniformMatrix3dv, cmd_size);
      cmd->program = program;
      cmd->location = location;
      cmd->count = count;
      cmd->transpose = transpose;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 72);
      variable_data += count * 72;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("ProgramUniformMatrix3dv");
   CALL_ProgramUniformMatrix3dv(ctx->CurrentServerDispatch, (program, location, count, transpose, value));
}


/* LockArraysEXT: marshalled asynchronously */
struct marshal_cmd_LockArraysEXT
{
   struct marshal_cmd_base cmd_base;
   GLint first;
   GLsizei count;
};
static inline void
_mesa_unmarshal_LockArraysEXT(struct gl_context *ctx, const struct marshal_cmd_LockArraysEXT *cmd)
{
   const GLint first = cmd->first;
   const GLsizei count = cmd->count;
   CALL_LockArraysEXT(ctx->CurrentServerDispatch, (first, count));
}
static void GLAPIENTRY
_mesa_marshal_LockArraysEXT(GLint first, GLsizei count)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_LockArraysEXT);
   struct marshal_cmd_LockArraysEXT *cmd;
   debug_print_marshal("LockArraysEXT");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_LockArraysEXT, cmd_size);
      cmd->first = first;
      cmd->count = count;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("LockArraysEXT");
   CALL_LockArraysEXT(ctx->CurrentServerDispatch, (first, count));
}


/* GetActiveUniformBlockiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetActiveUniformBlockiv");
   CALL_GetActiveUniformBlockiv(ctx->CurrentServerDispatch, (program, uniformBlockIndex, pname, params));
}


/* GetPerfMonitorCountersAMD: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetPerfMonitorCountersAMD(GLuint group, GLint * numCounters, GLint * maxActiveCounters, GLsizei countersSize, GLuint * counters)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetPerfMonitorCountersAMD");
   CALL_GetPerfMonitorCountersAMD(ctx->CurrentServerDispatch, (group, numCounters, maxActiveCounters, countersSize, counters));
}


/* ObjectPtrLabel: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_ObjectPtrLabel(const GLvoid * ptr, GLsizei length, const GLchar * label)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("ObjectPtrLabel");
   CALL_ObjectPtrLabel(ctx->CurrentServerDispatch, (ptr, length, label));
}


/* Rectfv: marshalled asynchronously */
struct marshal_cmd_Rectfv
{
   struct marshal_cmd_base cmd_base;
   GLfloat v1[2];
   GLfloat v2[2];
};
static inline void
_mesa_unmarshal_Rectfv(struct gl_context *ctx, const struct marshal_cmd_Rectfv *cmd)
{
   const GLfloat * v1 = cmd->v1;
   const GLfloat * v2 = cmd->v2;
   CALL_Rectfv(ctx->CurrentServerDispatch, (v1, v2));
}
static void GLAPIENTRY
_mesa_marshal_Rectfv(const GLfloat * v1, const GLfloat * v2)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Rectfv);
   struct marshal_cmd_Rectfv *cmd;
   debug_print_marshal("Rectfv");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Rectfv, cmd_size);
      memcpy(cmd->v1, v1, 8);
      memcpy(cmd->v2, v2, 8);
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Rectfv");
   CALL_Rectfv(ctx->CurrentServerDispatch, (v1, v2));
}


/* BindImageTexture: marshalled asynchronously */
struct marshal_cmd_BindImageTexture
{
   struct marshal_cmd_base cmd_base;
   GLuint unit;
   GLuint texture;
   GLint level;
   GLboolean layered;
   GLint layer;
   GLenum access;
   GLenum format;
};
static inline void
_mesa_unmarshal_BindImageTexture(struct gl_context *ctx, const struct marshal_cmd_BindImageTexture *cmd)
{
   const GLuint unit = cmd->unit;
   const GLuint texture = cmd->texture;
   const GLint level = cmd->level;
   const GLboolean layered = cmd->layered;
   const GLint layer = cmd->layer;
   const GLenum access = cmd->access;
   const GLenum format = cmd->format;
   CALL_BindImageTexture(ctx->CurrentServerDispatch, (unit, texture, level, layered, layer, access, format));
}
static void GLAPIENTRY
_mesa_marshal_BindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_BindImageTexture);
   struct marshal_cmd_BindImageTexture *cmd;
   debug_print_marshal("BindImageTexture");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_BindImageTexture, cmd_size);
      cmd->unit = unit;
      cmd->texture = texture;
      cmd->level = level;
      cmd->layered = layered;
      cmd->layer = layer;
      cmd->access = access;
      cmd->format = format;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("BindImageTexture");
   CALL_BindImageTexture(ctx->CurrentServerDispatch, (unit, texture, level, layered, layer, access, format));
}


/* VertexP4uiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_VertexP4uiv(GLenum type, const GLuint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("VertexP4uiv");
   CALL_VertexP4uiv(ctx->CurrentServerDispatch, (type, value));
}


/* GetUniformSubroutineuiv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetUniformSubroutineuiv");
   CALL_GetUniformSubroutineuiv(ctx->CurrentServerDispatch, (shadertype, location, params));
}


/* MinSampleShading: marshalled asynchronously */
struct marshal_cmd_MinSampleShading
{
   struct marshal_cmd_base cmd_base;
   GLfloat value;
};
static inline void
_mesa_unmarshal_MinSampleShading(struct gl_context *ctx, const struct marshal_cmd_MinSampleShading *cmd)
{
   const GLfloat value = cmd->value;
   CALL_MinSampleShading(ctx->CurrentServerDispatch, (value));
}
static void GLAPIENTRY
_mesa_marshal_MinSampleShading(GLfloat value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_MinSampleShading);
   struct marshal_cmd_MinSampleShading *cmd;
   debug_print_marshal("MinSampleShading");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_MinSampleShading, cmd_size);
      cmd->value = value;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("MinSampleShading");
   CALL_MinSampleShading(ctx->CurrentServerDispatch, (value));
}


/* GetRenderbufferParameteriv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint * params)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetRenderbufferParameteriv");
   CALL_GetRenderbufferParameteriv(ctx->CurrentServerDispatch, (target, pname, params));
}


/* VertexAttrib1dNV: marshalled asynchronously */
struct marshal_cmd_VertexAttrib1dNV
{
   struct marshal_cmd_base cmd_base;
   GLuint index;
   GLdouble x;
};
static inline void
_mesa_unmarshal_VertexAttrib1dNV(struct gl_context *ctx, const struct marshal_cmd_VertexAttrib1dNV *cmd)
{
   const GLuint index = cmd->index;
   const GLdouble x = cmd->x;
   CALL_VertexAttrib1dNV(ctx->CurrentServerDispatch, (index, x));
}
static void GLAPIENTRY
_mesa_marshal_VertexAttrib1dNV(GLuint index, GLdouble x)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_VertexAttrib1dNV);
   struct marshal_cmd_VertexAttrib1dNV *cmd;
   debug_print_marshal("VertexAttrib1dNV");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_VertexAttrib1dNV, cmd_size);
      cmd->index = index;
      cmd->x = x;
      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("VertexAttrib1dNV");
   CALL_VertexAttrib1dNV(ctx->CurrentServerDispatch, (index, x));
}


/* WindowPos2sv: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_WindowPos2sv(const GLshort * v)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("WindowPos2sv");
   CALL_WindowPos2sv(ctx->CurrentServerDispatch, (v));
}


/* GetPerfMonitorCounterStringAMD: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_GetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei * length, GLchar * counterString)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("GetPerfMonitorCounterStringAMD");
   CALL_GetPerfMonitorCounterStringAMD(ctx->CurrentServerDispatch, (group, counter, bufSize, length, counterString));
}


/* EndFragmentShaderATI: marshalled asynchronously */
struct marshal_cmd_EndFragmentShaderATI
{
   struct marshal_cmd_base cmd_base;
};
static inline void
_mesa_unmarshal_EndFragmentShaderATI(struct gl_context *ctx, const struct marshal_cmd_EndFragmentShaderATI *cmd)
{
   CALL_EndFragmentShaderATI(ctx->CurrentServerDispatch, ());
}
static void GLAPIENTRY
_mesa_marshal_EndFragmentShaderATI(void)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_EndFragmentShaderATI);
   struct marshal_cmd_EndFragmentShaderATI *cmd;
   debug_print_marshal("EndFragmentShaderATI");
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_EndFragmentShaderATI, cmd_size);
      (void) cmd;

      _mesa_post_marshal_hook(ctx);
      return;
   }

   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("EndFragmentShaderATI");
   CALL_EndFragmentShaderATI(ctx->CurrentServerDispatch, ());
}


/* Uniform4iv: marshalled asynchronously */
struct marshal_cmd_Uniform4iv
{
   struct marshal_cmd_base cmd_base;
   GLint location;
   GLsizei count;
   /* Next safe_mul(count, 16) bytes are GLint value[count][4] */
};
static inline void
_mesa_unmarshal_Uniform4iv(struct gl_context *ctx, const struct marshal_cmd_Uniform4iv *cmd)
{
   const GLint location = cmd->location;
   const GLsizei count = cmd->count;
   const GLint * value;
   const char *variable_data = (const char *) (cmd + 1);
   value = (const GLint *) variable_data;
   variable_data += count * 16;
   CALL_Uniform4iv(ctx->CurrentServerDispatch, (location, count, value));
}
static void GLAPIENTRY
_mesa_marshal_Uniform4iv(GLint location, GLsizei count, const GLint * value)
{
   GET_CURRENT_CONTEXT(ctx);
   size_t cmd_size = sizeof(struct marshal_cmd_Uniform4iv) + safe_mul(count, 16);
   struct marshal_cmd_Uniform4iv *cmd;
   debug_print_marshal("Uniform4iv");
   if (unlikely(safe_mul(count, 16) < 0)) {
      goto fallback_to_sync;
   }
   if (cmd_size <= MARSHAL_MAX_CMD_SIZE) {
      cmd = _mesa_glthread_allocate_command(ctx, DISPATCH_CMD_Uniform4iv, cmd_size);
      cmd->location = location;
      cmd->count = count;
      char *variable_data = (char *) (cmd + 1);
      memcpy(variable_data, value, count * 16);
      variable_data += count * 16;
      _mesa_post_marshal_hook(ctx);
      return;
   }

fallback_to_sync:
   _mesa_glthread_finish(ctx);
   debug_print_sync_fallback("Uniform4iv");
   CALL_Uniform4iv(ctx->CurrentServerDispatch, (location, count, value));
}


/* CreateMemoryObjectsEXT: marshalled synchronously */
static void GLAPIENTRY
_mesa_marshal_CreateMemoryObjectsEXT(GLsizei n, GLuint * memoryObjects)
{
   GET_CURRENT_CONTEXT(ctx);
   _mesa_glthread_finish(ctx);
   debug_print_sync("CreateMemoryObjectsEXT");
   CALL_CreateMemoryObjectsEXT(ctx->CurrentServerDispatch, (n, memoryObjects));
}


size_t
_mesa_unmarshal_dispatch_cmd(struct gl_context *ctx, const void *cmd)
{
   const struct marshal_cmd_base *cmd_base = cmd;
   switch (cmd_base->cmd_id) {
   case DISPATCH_CMD_MapGrid1d:
      debug_print_unmarshal("MapGrid1d");
      _mesa_unmarshal_MapGrid1d(ctx, (const struct marshal_cmd_MapGrid1d *) cmd);
      break;
   case DISPATCH_CMD_MapGrid1f:
      debug_print_unmarshal("MapGrid1f");
      _mesa_unmarshal_MapGrid1f(ctx, (const struct marshal_cmd_MapGrid1f *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform3i64vARB:
      debug_print_unmarshal("ProgramUniform3i64vARB");
      _mesa_unmarshal_ProgramUniform3i64vARB(ctx, (const struct marshal_cmd_ProgramUniform3i64vARB *) cmd);
      break;
   case DISPATCH_CMD_TexCoordP1ui:
      debug_print_unmarshal("TexCoordP1ui");
      _mesa_unmarshal_TexCoordP1ui(ctx, (const struct marshal_cmd_TexCoordP1ui *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord1dv:
      debug_print_unmarshal("MultiTexCoord1dv");
      _mesa_unmarshal_MultiTexCoord1dv(ctx, (const struct marshal_cmd_MultiTexCoord1dv *) cmd);
      break;
   case DISPATCH_CMD_AttachShader:
      debug_print_unmarshal("AttachShader");
      _mesa_unmarshal_AttachShader(ctx, (const struct marshal_cmd_AttachShader *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib3fARB:
      debug_print_unmarshal("VertexAttrib3fARB");
      _mesa_unmarshal_VertexAttrib3fARB(ctx, (const struct marshal_cmd_VertexAttrib3fARB *) cmd);
      break;
   case DISPATCH_CMD_Indexubv:
      debug_print_unmarshal("Indexubv");
      _mesa_unmarshal_Indexubv(ctx, (const struct marshal_cmd_Indexubv *) cmd);
      break;
   case DISPATCH_CMD_Color3ubv:
      debug_print_unmarshal("Color3ubv");
      _mesa_unmarshal_Color3ubv(ctx, (const struct marshal_cmd_Color3ubv *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform2ui:
      debug_print_unmarshal("ProgramUniform2ui");
      _mesa_unmarshal_ProgramUniform2ui(ctx, (const struct marshal_cmd_ProgramUniform2ui *) cmd);
      break;
   case DISPATCH_CMD_RenderbufferStorage:
      debug_print_unmarshal("RenderbufferStorage");
      _mesa_unmarshal_RenderbufferStorage(ctx, (const struct marshal_cmd_RenderbufferStorage *) cmd);
      break;
   case DISPATCH_CMD_Uniform3i:
      debug_print_unmarshal("Uniform3i");
      _mesa_unmarshal_Uniform3i(ctx, (const struct marshal_cmd_Uniform3i *) cmd);
      break;
   case DISPATCH_CMD_Uniform3d:
      debug_print_unmarshal("Uniform3d");
      _mesa_unmarshal_Uniform3d(ctx, (const struct marshal_cmd_Uniform3d *) cmd);
      break;
   case DISPATCH_CMD_Uniform3f:
      debug_print_unmarshal("Uniform3f");
      _mesa_unmarshal_Uniform3f(ctx, (const struct marshal_cmd_Uniform3f *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix2x4fv:
      debug_print_unmarshal("UniformMatrix2x4fv");
      _mesa_unmarshal_UniformMatrix2x4fv(ctx, (const struct marshal_cmd_UniformMatrix2x4fv *) cmd);
      break;
   case DISPATCH_CMD_Normal3iv:
      debug_print_unmarshal("Normal3iv");
      _mesa_unmarshal_Normal3iv(ctx, (const struct marshal_cmd_Normal3iv *) cmd);
      break;
   case DISPATCH_CMD_DrawTexiOES:
      debug_print_unmarshal("DrawTexiOES");
      _mesa_unmarshal_DrawTexiOES(ctx, (const struct marshal_cmd_DrawTexiOES *) cmd);
      break;
   case DISPATCH_CMD_Viewport:
      debug_print_unmarshal("Viewport");
      _mesa_unmarshal_Viewport(ctx, (const struct marshal_cmd_Viewport *) cmd);
      break;
   case DISPATCH_CMD_DeleteVertexArrays:
      debug_print_unmarshal("DeleteVertexArrays");
      _mesa_unmarshal_DeleteVertexArrays(ctx, (const struct marshal_cmd_DeleteVertexArrays *) cmd);
      break;
   case DISPATCH_CMD_ClearColorIuiEXT:
      debug_print_unmarshal("ClearColorIuiEXT");
      _mesa_unmarshal_ClearColorIuiEXT(ctx, (const struct marshal_cmd_ClearColorIuiEXT *) cmd);
      break;
   case DISPATCH_CMD_PolygonOffsetx:
      debug_print_unmarshal("PolygonOffsetx");
      _mesa_unmarshal_PolygonOffsetx(ctx, (const struct marshal_cmd_PolygonOffsetx *) cmd);
      break;
   case DISPATCH_CMD_DepthRangeIndexedfOES:
      debug_print_unmarshal("DepthRangeIndexedfOES");
      _mesa_unmarshal_DepthRangeIndexedfOES(ctx, (const struct marshal_cmd_DepthRangeIndexedfOES *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4usv:
      debug_print_unmarshal("VertexAttrib4usv");
      _mesa_unmarshal_VertexAttrib4usv(ctx, (const struct marshal_cmd_VertexAttrib4usv *) cmd);
      break;
   case DISPATCH_CMD_TextureStorage1DEXT:
      debug_print_unmarshal("TextureStorage1DEXT");
      _mesa_unmarshal_TextureStorage1DEXT(ctx, (const struct marshal_cmd_TextureStorage1DEXT *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4Nub:
      debug_print_unmarshal("VertexAttrib4Nub");
      _mesa_unmarshal_VertexAttrib4Nub(ctx, (const struct marshal_cmd_VertexAttrib4Nub *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribP3ui:
      debug_print_unmarshal("VertexAttribP3ui");
      _mesa_unmarshal_VertexAttribP3ui(ctx, (const struct marshal_cmd_VertexAttribP3ui *) cmd);
      break;
   case DISPATCH_CMD_PointSize:
      debug_print_unmarshal("PointSize");
      _mesa_unmarshal_PointSize(ctx, (const struct marshal_cmd_PointSize *) cmd);
      break;
   case DISPATCH_CMD_PopName:
      debug_print_unmarshal("PopName");
      _mesa_unmarshal_PopName(ctx, (const struct marshal_cmd_PopName *) cmd);
      break;
   case DISPATCH_CMD_FramebufferTexture:
      debug_print_unmarshal("FramebufferTexture");
      _mesa_unmarshal_FramebufferTexture(ctx, (const struct marshal_cmd_FramebufferTexture *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4ubNV:
      debug_print_unmarshal("VertexAttrib4ubNV");
      _mesa_unmarshal_VertexAttrib4ubNV(ctx, (const struct marshal_cmd_VertexAttrib4ubNV *) cmd);
      break;
   case DISPATCH_CMD_ValidateProgramPipeline:
      debug_print_unmarshal("ValidateProgramPipeline");
      _mesa_unmarshal_ValidateProgramPipeline(ctx, (const struct marshal_cmd_ValidateProgramPipeline *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribs3dvNV:
      debug_print_unmarshal("VertexAttribs3dvNV");
      _mesa_unmarshal_VertexAttribs3dvNV(ctx, (const struct marshal_cmd_VertexAttribs3dvNV *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix2x4dv:
      debug_print_unmarshal("ProgramUniformMatrix2x4dv");
      _mesa_unmarshal_ProgramUniformMatrix2x4dv(ctx, (const struct marshal_cmd_ProgramUniformMatrix2x4dv *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform4iv:
      debug_print_unmarshal("ProgramUniform4iv");
      _mesa_unmarshal_ProgramUniform4iv(ctx, (const struct marshal_cmd_ProgramUniform4iv *) cmd);
      break;
   case DISPATCH_CMD_TexCoord2iv:
      debug_print_unmarshal("TexCoord2iv");
      _mesa_unmarshal_TexCoord2iv(ctx, (const struct marshal_cmd_TexCoord2iv *) cmd);
      break;
   case DISPATCH_CMD_TexImage2DMultisample:
      debug_print_unmarshal("TexImage2DMultisample");
      _mesa_unmarshal_TexImage2DMultisample(ctx, (const struct marshal_cmd_TexImage2DMultisample *) cmd);
      break;
   case DISPATCH_CMD_TexParameterx:
      debug_print_unmarshal("TexParameterx");
      _mesa_unmarshal_TexParameterx(ctx, (const struct marshal_cmd_TexParameterx *) cmd);
      break;
   case DISPATCH_CMD_Rotatef:
      debug_print_unmarshal("Rotatef");
      _mesa_unmarshal_Rotatef(ctx, (const struct marshal_cmd_Rotatef *) cmd);
      break;
   case DISPATCH_CMD_TexParameterf:
      debug_print_unmarshal("TexParameterf");
      _mesa_unmarshal_TexParameterf(ctx, (const struct marshal_cmd_TexParameterf *) cmd);
      break;
   case DISPATCH_CMD_TexParameteri:
      debug_print_unmarshal("TexParameteri");
      _mesa_unmarshal_TexParameteri(ctx, (const struct marshal_cmd_TexParameteri *) cmd);
      break;
   case DISPATCH_CMD_VDPAUFiniNV:
      debug_print_unmarshal("VDPAUFiniNV");
      _mesa_unmarshal_VDPAUFiniNV(ctx, (const struct marshal_cmd_VDPAUFiniNV *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix4x2fv:
      debug_print_unmarshal("ProgramUniformMatrix4x2fv");
      _mesa_unmarshal_ProgramUniformMatrix4x2fv(ctx, (const struct marshal_cmd_ProgramUniformMatrix4x2fv *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform2f:
      debug_print_unmarshal("ProgramUniform2f");
      _mesa_unmarshal_ProgramUniform2f(ctx, (const struct marshal_cmd_ProgramUniform2f *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform2d:
      debug_print_unmarshal("ProgramUniform2d");
      _mesa_unmarshal_ProgramUniform2d(ctx, (const struct marshal_cmd_ProgramUniform2d *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform2i:
      debug_print_unmarshal("ProgramUniform2i");
      _mesa_unmarshal_ProgramUniform2i(ctx, (const struct marshal_cmd_ProgramUniform2i *) cmd);
      break;
   case DISPATCH_CMD_Fogx:
      debug_print_unmarshal("Fogx");
      _mesa_unmarshal_Fogx(ctx, (const struct marshal_cmd_Fogx *) cmd);
      break;
   case DISPATCH_CMD_Uniform3ui64ARB:
      debug_print_unmarshal("Uniform3ui64ARB");
      _mesa_unmarshal_Uniform3ui64ARB(ctx, (const struct marshal_cmd_Uniform3ui64ARB *) cmd);
      break;
   case DISPATCH_CMD_Fogf:
      debug_print_unmarshal("Fogf");
      _mesa_unmarshal_Fogf(ctx, (const struct marshal_cmd_Fogf *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform3ui64vARB:
      debug_print_unmarshal("ProgramUniform3ui64vARB");
      _mesa_unmarshal_ProgramUniform3ui64vARB(ctx, (const struct marshal_cmd_ProgramUniform3ui64vARB *) cmd);
      break;
   case DISPATCH_CMD_Color4usv:
      debug_print_unmarshal("Color4usv");
      _mesa_unmarshal_Color4usv(ctx, (const struct marshal_cmd_Color4usv *) cmd);
      break;
   case DISPATCH_CMD_Fogi:
      debug_print_unmarshal("Fogi");
      _mesa_unmarshal_Fogi(ctx, (const struct marshal_cmd_Fogi *) cmd);
      break;
   case DISPATCH_CMD_DepthFunc:
      debug_print_unmarshal("DepthFunc");
      _mesa_unmarshal_DepthFunc(ctx, (const struct marshal_cmd_DepthFunc *) cmd);
      break;
   case DISPATCH_CMD_VertexArrayAttribLFormat:
      debug_print_unmarshal("VertexArrayAttribLFormat");
      _mesa_unmarshal_VertexArrayAttribLFormat(ctx, (const struct marshal_cmd_VertexArrayAttribLFormat *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribI4uiEXT:
      debug_print_unmarshal("VertexAttribI4uiEXT");
      _mesa_unmarshal_VertexAttribI4uiEXT(ctx, (const struct marshal_cmd_VertexAttribI4uiEXT *) cmd);
      break;
   case DISPATCH_CMD_DrawElementsInstancedBaseVertexBaseInstance:
      debug_print_unmarshal("DrawElementsInstancedBaseVertexBaseInstance");
      _mesa_unmarshal_DrawElementsInstancedBaseVertexBaseInstance(ctx, (const struct marshal_cmd_DrawElementsInstancedBaseVertexBaseInstance *) cmd);
      break;
   case DISPATCH_CMD_ProgramEnvParameter4dvARB:
      debug_print_unmarshal("ProgramEnvParameter4dvARB");
      _mesa_unmarshal_ProgramEnvParameter4dvARB(ctx, (const struct marshal_cmd_ProgramEnvParameter4dvARB *) cmd);
      break;
   case DISPATCH_CMD_CopyNamedBufferSubData:
      debug_print_unmarshal("CopyNamedBufferSubData");
      _mesa_unmarshal_CopyNamedBufferSubData(ctx, (const struct marshal_cmd_CopyNamedBufferSubData *) cmd);
      break;
   case DISPATCH_CMD_BindSampler:
      debug_print_unmarshal("BindSampler");
      _mesa_unmarshal_BindSampler(ctx, (const struct marshal_cmd_BindSampler *) cmd);
      break;
   case DISPATCH_CMD_GetQueryBufferObjectuiv:
      debug_print_unmarshal("GetQueryBufferObjectuiv");
      _mesa_unmarshal_GetQueryBufferObjectuiv(ctx, (const struct marshal_cmd_GetQueryBufferObjectuiv *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord2fARB:
      debug_print_unmarshal("MultiTexCoord2fARB");
      _mesa_unmarshal_MultiTexCoord2fARB(ctx, (const struct marshal_cmd_MultiTexCoord2fARB *) cmd);
      break;
   case DISPATCH_CMD_Uniform1ui64ARB:
      debug_print_unmarshal("Uniform1ui64ARB");
      _mesa_unmarshal_Uniform1ui64ARB(ctx, (const struct marshal_cmd_Uniform1ui64ARB *) cmd);
      break;
   case DISPATCH_CMD_IndexPointer:
      debug_print_unmarshal("IndexPointer");
      _mesa_unmarshal_IndexPointer(ctx, (const struct marshal_cmd_IndexPointer *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord3iv:
      debug_print_unmarshal("MultiTexCoord3iv");
      _mesa_unmarshal_MultiTexCoord3iv(ctx, (const struct marshal_cmd_MultiTexCoord3iv *) cmd);
      break;
   case DISPATCH_CMD_ClearStencil:
      debug_print_unmarshal("ClearStencil");
      _mesa_unmarshal_ClearStencil(ctx, (const struct marshal_cmd_ClearStencil *) cmd);
      break;
   case DISPATCH_CMD_ClearColorIiEXT:
      debug_print_unmarshal("ClearColorIiEXT");
      _mesa_unmarshal_ClearColorIiEXT(ctx, (const struct marshal_cmd_ClearColorIiEXT *) cmd);
      break;
   case DISPATCH_CMD_LoadMatrixd:
      debug_print_unmarshal("LoadMatrixd");
      _mesa_unmarshal_LoadMatrixd(ctx, (const struct marshal_cmd_LoadMatrixd *) cmd);
      break;
   case DISPATCH_CMD_VertexP4ui:
      debug_print_unmarshal("VertexP4ui");
      _mesa_unmarshal_VertexP4ui(ctx, (const struct marshal_cmd_VertexP4ui *) cmd);
      break;
   case DISPATCH_CMD_TextureStorage3DMultisample:
      debug_print_unmarshal("TextureStorage3DMultisample");
      _mesa_unmarshal_TextureStorage3DMultisample(ctx, (const struct marshal_cmd_TextureStorage3DMultisample *) cmd);
      break;
   case DISPATCH_CMD_ReleaseShaderCompiler:
      debug_print_unmarshal("ReleaseShaderCompiler");
      _mesa_unmarshal_ReleaseShaderCompiler(ctx, (const struct marshal_cmd_ReleaseShaderCompiler *) cmd);
      break;
   case DISPATCH_CMD_BlendFuncSeparate:
      debug_print_unmarshal("BlendFuncSeparate");
      _mesa_unmarshal_BlendFuncSeparate(ctx, (const struct marshal_cmd_BlendFuncSeparate *) cmd);
      break;
   case DISPATCH_CMD_Color3us:
      debug_print_unmarshal("Color3us");
      _mesa_unmarshal_Color3us(ctx, (const struct marshal_cmd_Color3us *) cmd);
      break;
   case DISPATCH_CMD_LoadMatrixx:
      debug_print_unmarshal("LoadMatrixx");
      _mesa_unmarshal_LoadMatrixx(ctx, (const struct marshal_cmd_LoadMatrixx *) cmd);
      break;
   case DISPATCH_CMD_Color3ub:
      debug_print_unmarshal("Color3ub");
      _mesa_unmarshal_Color3ub(ctx, (const struct marshal_cmd_Color3ub *) cmd);
      break;
   case DISPATCH_CMD_Color3ui:
      debug_print_unmarshal("Color3ui");
      _mesa_unmarshal_Color3ui(ctx, (const struct marshal_cmd_Color3ui *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4dvNV:
      debug_print_unmarshal("VertexAttrib4dvNV");
      _mesa_unmarshal_VertexAttrib4dvNV(ctx, (const struct marshal_cmd_VertexAttrib4dvNV *) cmd);
      break;
   case DISPATCH_CMD_AlphaFragmentOp2ATI:
      debug_print_unmarshal("AlphaFragmentOp2ATI");
      _mesa_unmarshal_AlphaFragmentOp2ATI(ctx, (const struct marshal_cmd_AlphaFragmentOp2ATI *) cmd);
      break;
   case DISPATCH_CMD_RasterPos4dv:
      debug_print_unmarshal("RasterPos4dv");
      _mesa_unmarshal_RasterPos4dv(ctx, (const struct marshal_cmd_RasterPos4dv *) cmd);
      break;
   case DISPATCH_CMD_LineWidthx:
      debug_print_unmarshal("LineWidthx");
      _mesa_unmarshal_LineWidthx(ctx, (const struct marshal_cmd_LineWidthx *) cmd);
      break;
   case DISPATCH_CMD_Indexdv:
      debug_print_unmarshal("Indexdv");
      _mesa_unmarshal_Indexdv(ctx, (const struct marshal_cmd_Indexdv *) cmd);
      break;
   case DISPATCH_CMD_DepthMask:
      debug_print_unmarshal("DepthMask");
      _mesa_unmarshal_DepthMask(ctx, (const struct marshal_cmd_DepthMask *) cmd);
      break;
   case DISPATCH_CMD_BindFragmentShaderATI:
      debug_print_unmarshal("BindFragmentShaderATI");
      _mesa_unmarshal_BindFragmentShaderATI(ctx, (const struct marshal_cmd_BindFragmentShaderATI *) cmd);
      break;
   case DISPATCH_CMD_BlendFuncSeparateiARB:
      debug_print_unmarshal("BlendFuncSeparateiARB");
      _mesa_unmarshal_BlendFuncSeparateiARB(ctx, (const struct marshal_cmd_BlendFuncSeparateiARB *) cmd);
      break;
   case DISPATCH_CMD_VertexPointer:
      debug_print_unmarshal("VertexPointer");
      _mesa_unmarshal_VertexPointer(ctx, (const struct marshal_cmd_VertexPointer *) cmd);
      break;
   case DISPATCH_CMD_ProgramLocalParameter4dvARB:
      debug_print_unmarshal("ProgramLocalParameter4dvARB");
      _mesa_unmarshal_ProgramLocalParameter4dvARB(ctx, (const struct marshal_cmd_ProgramLocalParameter4dvARB *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix2dv:
      debug_print_unmarshal("UniformMatrix2dv");
      _mesa_unmarshal_UniformMatrix2dv(ctx, (const struct marshal_cmd_UniformMatrix2dv *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix3x2dv:
      debug_print_unmarshal("UniformMatrix3x2dv");
      _mesa_unmarshal_UniformMatrix3x2dv(ctx, (const struct marshal_cmd_UniformMatrix3x2dv *) cmd);
      break;
   case DISPATCH_CMD_WindowPos4fMESA:
      debug_print_unmarshal("WindowPos4fMESA");
      _mesa_unmarshal_WindowPos4fMESA(ctx, (const struct marshal_cmd_WindowPos4fMESA *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribs2fvNV:
      debug_print_unmarshal("VertexAttribs2fvNV");
      _mesa_unmarshal_VertexAttribs2fvNV(ctx, (const struct marshal_cmd_VertexAttribs2fvNV *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribP4ui:
      debug_print_unmarshal("VertexAttribP4ui");
      _mesa_unmarshal_VertexAttribP4ui(ctx, (const struct marshal_cmd_VertexAttribP4ui *) cmd);
      break;
   case DISPATCH_CMD_Uniform4i:
      debug_print_unmarshal("Uniform4i");
      _mesa_unmarshal_Uniform4i(ctx, (const struct marshal_cmd_Uniform4i *) cmd);
      break;
   case DISPATCH_CMD_Uniform4d:
      debug_print_unmarshal("Uniform4d");
      _mesa_unmarshal_Uniform4d(ctx, (const struct marshal_cmd_Uniform4d *) cmd);
      break;
   case DISPATCH_CMD_Uniform4f:
      debug_print_unmarshal("Uniform4f");
      _mesa_unmarshal_Uniform4f(ctx, (const struct marshal_cmd_Uniform4f *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform3dv:
      debug_print_unmarshal("ProgramUniform3dv");
      _mesa_unmarshal_ProgramUniform3dv(ctx, (const struct marshal_cmd_ProgramUniform3dv *) cmd);
      break;
   case DISPATCH_CMD_NamedFramebufferTexture:
      debug_print_unmarshal("NamedFramebufferTexture");
      _mesa_unmarshal_NamedFramebufferTexture(ctx, (const struct marshal_cmd_NamedFramebufferTexture *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform3d:
      debug_print_unmarshal("ProgramUniform3d");
      _mesa_unmarshal_ProgramUniform3d(ctx, (const struct marshal_cmd_ProgramUniform3d *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform3f:
      debug_print_unmarshal("ProgramUniform3f");
      _mesa_unmarshal_ProgramUniform3f(ctx, (const struct marshal_cmd_ProgramUniform3f *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform3i:
      debug_print_unmarshal("ProgramUniform3i");
      _mesa_unmarshal_ProgramUniform3i(ctx, (const struct marshal_cmd_ProgramUniform3i *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColor3s:
      debug_print_unmarshal("SecondaryColor3s");
      _mesa_unmarshal_SecondaryColor3s(ctx, (const struct marshal_cmd_SecondaryColor3s *) cmd);
      break;
   case DISPATCH_CMD_TexStorageMem2DEXT:
      debug_print_unmarshal("TexStorageMem2DEXT");
      _mesa_unmarshal_TexStorageMem2DEXT(ctx, (const struct marshal_cmd_TexStorageMem2DEXT *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix3x4dv:
      debug_print_unmarshal("UniformMatrix3x4dv");
      _mesa_unmarshal_UniformMatrix3x4dv(ctx, (const struct marshal_cmd_UniformMatrix3x4dv *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib3fNV:
      debug_print_unmarshal("VertexAttrib3fNV");
      _mesa_unmarshal_VertexAttrib3fNV(ctx, (const struct marshal_cmd_VertexAttrib3fNV *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColor3b:
      debug_print_unmarshal("SecondaryColor3b");
      _mesa_unmarshal_SecondaryColor3b(ctx, (const struct marshal_cmd_SecondaryColor3b *) cmd);
      break;
   case DISPATCH_CMD_EnableClientState:
      debug_print_unmarshal("EnableClientState");
      _mesa_unmarshal_EnableClientState(ctx, (const struct marshal_cmd_EnableClientState *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColor3i:
      debug_print_unmarshal("SecondaryColor3i");
      _mesa_unmarshal_SecondaryColor3i(ctx, (const struct marshal_cmd_SecondaryColor3i *) cmd);
      break;
   case DISPATCH_CMD_FlushMappedBufferRange:
      debug_print_unmarshal("FlushMappedBufferRange");
      _mesa_unmarshal_FlushMappedBufferRange(ctx, (const struct marshal_cmd_FlushMappedBufferRange *) cmd);
      break;
   case DISPATCH_CMD_TexStorageMem3DEXT:
      debug_print_unmarshal("TexStorageMem3DEXT");
      _mesa_unmarshal_TexStorageMem3DEXT(ctx, (const struct marshal_cmd_TexStorageMem3DEXT *) cmd);
      break;
   case DISPATCH_CMD_EndPerfMonitorAMD:
      debug_print_unmarshal("EndPerfMonitorAMD");
      _mesa_unmarshal_EndPerfMonitorAMD(ctx, (const struct marshal_cmd_EndPerfMonitorAMD *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribs4dvNV:
      debug_print_unmarshal("VertexAttribs4dvNV");
      _mesa_unmarshal_VertexAttribs4dvNV(ctx, (const struct marshal_cmd_VertexAttribs4dvNV *) cmd);
      break;
   case DISPATCH_CMD_Uniform2i64vARB:
      debug_print_unmarshal("Uniform2i64vARB");
      _mesa_unmarshal_Uniform2i64vARB(ctx, (const struct marshal_cmd_Uniform2i64vARB *) cmd);
      break;
   case DISPATCH_CMD_Rectdv:
      debug_print_unmarshal("Rectdv");
      _mesa_unmarshal_Rectdv(ctx, (const struct marshal_cmd_Rectdv *) cmd);
      break;
   case DISPATCH_CMD_DrawArraysInstancedARB:
      debug_print_unmarshal("DrawArraysInstancedARB");
      _mesa_unmarshal_DrawArraysInstancedARB(ctx, (const struct marshal_cmd_DrawArraysInstancedARB *) cmd);
      break;
   case DISPATCH_CMD_MakeImageHandleNonResidentARB:
      debug_print_unmarshal("MakeImageHandleNonResidentARB");
      _mesa_unmarshal_MakeImageHandleNonResidentARB(ctx, (const struct marshal_cmd_MakeImageHandleNonResidentARB *) cmd);
      break;
   case DISPATCH_CMD_ImportMemoryFdEXT:
      debug_print_unmarshal("ImportMemoryFdEXT");
      _mesa_unmarshal_ImportMemoryFdEXT(ctx, (const struct marshal_cmd_ImportMemoryFdEXT *) cmd);
      break;
   case DISPATCH_CMD_TexStorageMem1DEXT:
      debug_print_unmarshal("TexStorageMem1DEXT");
      _mesa_unmarshal_TexStorageMem1DEXT(ctx, (const struct marshal_cmd_TexStorageMem1DEXT *) cmd);
      break;
   case DISPATCH_CMD_BlendBarrier:
      debug_print_unmarshal("BlendBarrier");
      _mesa_unmarshal_BlendBarrier(ctx, (const struct marshal_cmd_BlendBarrier *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib2svNV:
      debug_print_unmarshal("VertexAttrib2svNV");
      _mesa_unmarshal_VertexAttrib2svNV(ctx, (const struct marshal_cmd_VertexAttrib2svNV *) cmd);
      break;
   case DISPATCH_CMD_Disablei:
      debug_print_unmarshal("Disablei");
      _mesa_unmarshal_Disablei(ctx, (const struct marshal_cmd_Disablei *) cmd);
      break;
   case DISPATCH_CMD_Color3dv:
      debug_print_unmarshal("Color3dv");
      _mesa_unmarshal_Color3dv(ctx, (const struct marshal_cmd_Color3dv *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform1ui64ARB:
      debug_print_unmarshal("ProgramUniform1ui64ARB");
      _mesa_unmarshal_ProgramUniform1ui64ARB(ctx, (const struct marshal_cmd_ProgramUniform1ui64ARB *) cmd);
      break;
   case DISPATCH_CMD_BeginQuery:
      debug_print_unmarshal("BeginQuery");
      _mesa_unmarshal_BeginQuery(ctx, (const struct marshal_cmd_BeginQuery *) cmd);
      break;
   case DISPATCH_CMD_PixelStoref:
      debug_print_unmarshal("PixelStoref");
      _mesa_unmarshal_PixelStoref(ctx, (const struct marshal_cmd_PixelStoref *) cmd);
      break;
   case DISPATCH_CMD_PixelStorei:
      debug_print_unmarshal("PixelStorei");
      _mesa_unmarshal_PixelStorei(ctx, (const struct marshal_cmd_PixelStorei *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribs1svNV:
      debug_print_unmarshal("VertexAttribs1svNV");
      _mesa_unmarshal_VertexAttribs1svNV(ctx, (const struct marshal_cmd_VertexAttribs1svNV *) cmd);
      break;
   case DISPATCH_CMD_DispatchComputeIndirect:
      debug_print_unmarshal("DispatchComputeIndirect");
      _mesa_unmarshal_DispatchComputeIndirect(ctx, (const struct marshal_cmd_DispatchComputeIndirect *) cmd);
      break;
   case DISPATCH_CMD_InvalidateBufferData:
      debug_print_unmarshal("InvalidateBufferData");
      _mesa_unmarshal_InvalidateBufferData(ctx, (const struct marshal_cmd_InvalidateBufferData *) cmd);
      break;
   case DISPATCH_CMD_Uniform1ui64vARB:
      debug_print_unmarshal("Uniform1ui64vARB");
      _mesa_unmarshal_Uniform1ui64vARB(ctx, (const struct marshal_cmd_Uniform1ui64vARB *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib1svNV:
      debug_print_unmarshal("VertexAttrib1svNV");
      _mesa_unmarshal_VertexAttrib1svNV(ctx, (const struct marshal_cmd_VertexAttrib1svNV *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColor3ubv:
      debug_print_unmarshal("SecondaryColor3ubv");
      _mesa_unmarshal_SecondaryColor3ubv(ctx, (const struct marshal_cmd_SecondaryColor3ubv *) cmd);
      break;
   case DISPATCH_CMD_Uniform4ui64ARB:
      debug_print_unmarshal("Uniform4ui64ARB");
      _mesa_unmarshal_Uniform4ui64ARB(ctx, (const struct marshal_cmd_Uniform4ui64ARB *) cmd);
      break;
   case DISPATCH_CMD_RasterPos3fv:
      debug_print_unmarshal("RasterPos3fv");
      _mesa_unmarshal_RasterPos3fv(ctx, (const struct marshal_cmd_RasterPos3fv *) cmd);
      break;
   case DISPATCH_CMD_BindProgramARB:
      debug_print_unmarshal("BindProgramARB");
      _mesa_unmarshal_BindProgramARB(ctx, (const struct marshal_cmd_BindProgramARB *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib3sNV:
      debug_print_unmarshal("VertexAttrib3sNV");
      _mesa_unmarshal_VertexAttrib3sNV(ctx, (const struct marshal_cmd_VertexAttrib3sNV *) cmd);
      break;
   case DISPATCH_CMD_ColorFragmentOp1ATI:
      debug_print_unmarshal("ColorFragmentOp1ATI");
      _mesa_unmarshal_ColorFragmentOp1ATI(ctx, (const struct marshal_cmd_ColorFragmentOp1ATI *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix4x3fv:
      debug_print_unmarshal("ProgramUniformMatrix4x3fv");
      _mesa_unmarshal_ProgramUniformMatrix4x3fv(ctx, (const struct marshal_cmd_ProgramUniformMatrix4x3fv *) cmd);
      break;
   case DISPATCH_CMD_PopClientAttrib:
      debug_print_unmarshal("PopClientAttrib");
      _mesa_unmarshal_PopClientAttrib(ctx, (const struct marshal_cmd_PopClientAttrib *) cmd);
      break;
   case DISPATCH_CMD_DrawElementsInstancedARB:
      debug_print_unmarshal("DrawElementsInstancedARB");
      _mesa_unmarshal_DrawElementsInstancedARB(ctx, (const struct marshal_cmd_DrawElementsInstancedARB *) cmd);
      break;
   case DISPATCH_CMD_DisableVertexArrayAttrib:
      debug_print_unmarshal("DisableVertexArrayAttrib");
      _mesa_unmarshal_DisableVertexArrayAttrib(ctx, (const struct marshal_cmd_DisableVertexArrayAttrib *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribL4d:
      debug_print_unmarshal("VertexAttribL4d");
      _mesa_unmarshal_VertexAttribL4d(ctx, (const struct marshal_cmd_VertexAttribL4d *) cmd);
      break;
   case DISPATCH_CMD_ListBase:
      debug_print_unmarshal("ListBase");
      _mesa_unmarshal_ListBase(ctx, (const struct marshal_cmd_ListBase *) cmd);
      break;
   case DISPATCH_CMD_GenerateMipmap:
      debug_print_unmarshal("GenerateMipmap");
      _mesa_unmarshal_GenerateMipmap(ctx, (const struct marshal_cmd_GenerateMipmap *) cmd);
      break;
   case DISPATCH_CMD_BindBufferRange:
      debug_print_unmarshal("BindBufferRange");
      _mesa_unmarshal_BindBufferRange(ctx, (const struct marshal_cmd_BindBufferRange *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix2x4fv:
      debug_print_unmarshal("ProgramUniformMatrix2x4fv");
      _mesa_unmarshal_ProgramUniformMatrix2x4fv(ctx, (const struct marshal_cmd_ProgramUniformMatrix2x4fv *) cmd);
      break;
   case DISPATCH_CMD_BindBufferBase:
      debug_print_unmarshal("BindBufferBase");
      _mesa_unmarshal_BindBufferBase(ctx, (const struct marshal_cmd_BindBufferBase *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib2s:
      debug_print_unmarshal("VertexAttrib2s");
      _mesa_unmarshal_VertexAttrib2s(ctx, (const struct marshal_cmd_VertexAttrib2s *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColor3fvEXT:
      debug_print_unmarshal("SecondaryColor3fvEXT");
      _mesa_unmarshal_SecondaryColor3fvEXT(ctx, (const struct marshal_cmd_SecondaryColor3fvEXT *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib2d:
      debug_print_unmarshal("VertexAttrib2d");
      _mesa_unmarshal_VertexAttrib2d(ctx, (const struct marshal_cmd_VertexAttrib2d *) cmd);
      break;
   case DISPATCH_CMD_Uniform1fv:
      debug_print_unmarshal("Uniform1fv");
      _mesa_unmarshal_Uniform1fv(ctx, (const struct marshal_cmd_Uniform1fv *) cmd);
      break;
   case DISPATCH_CMD_DepthBoundsEXT:
      debug_print_unmarshal("DepthBoundsEXT");
      _mesa_unmarshal_DepthBoundsEXT(ctx, (const struct marshal_cmd_DepthBoundsEXT *) cmd);
      break;
   case DISPATCH_CMD_BufferStorageMemEXT:
      debug_print_unmarshal("BufferStorageMemEXT");
      _mesa_unmarshal_BufferStorageMemEXT(ctx, (const struct marshal_cmd_BufferStorageMemEXT *) cmd);
      break;
   case DISPATCH_CMD_WindowPos3fv:
      debug_print_unmarshal("WindowPos3fv");
      _mesa_unmarshal_WindowPos3fv(ctx, (const struct marshal_cmd_WindowPos3fv *) cmd);
      break;
   case DISPATCH_CMD_NamedRenderbufferStorage:
      debug_print_unmarshal("NamedRenderbufferStorage");
      _mesa_unmarshal_NamedRenderbufferStorage(ctx, (const struct marshal_cmd_NamedRenderbufferStorage *) cmd);
      break;
   case DISPATCH_CMD_BindRenderbuffer:
      debug_print_unmarshal("BindRenderbuffer");
      _mesa_unmarshal_BindRenderbuffer(ctx, (const struct marshal_cmd_BindRenderbuffer *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColor3fEXT:
      debug_print_unmarshal("SecondaryColor3fEXT");
      _mesa_unmarshal_SecondaryColor3fEXT(ctx, (const struct marshal_cmd_SecondaryColor3fEXT *) cmd);
      break;
   case DISPATCH_CMD_PrimitiveRestartIndex:
      debug_print_unmarshal("PrimitiveRestartIndex");
      _mesa_unmarshal_PrimitiveRestartIndex(ctx, (const struct marshal_cmd_PrimitiveRestartIndex *) cmd);
      break;
   case DISPATCH_CMD_TextureStorageMem3DEXT:
      debug_print_unmarshal("TextureStorageMem3DEXT");
      _mesa_unmarshal_TextureStorageMem3DEXT(ctx, (const struct marshal_cmd_TextureStorageMem3DEXT *) cmd);
      break;
   case DISPATCH_CMD_ActiveStencilFaceEXT:
      debug_print_unmarshal("ActiveStencilFaceEXT");
      _mesa_unmarshal_ActiveStencilFaceEXT(ctx, (const struct marshal_cmd_ActiveStencilFaceEXT *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4dNV:
      debug_print_unmarshal("VertexAttrib4dNV");
      _mesa_unmarshal_VertexAttrib4dNV(ctx, (const struct marshal_cmd_VertexAttrib4dNV *) cmd);
      break;
   case DISPATCH_CMD_DepthRange:
      debug_print_unmarshal("DepthRange");
      _mesa_unmarshal_DepthRange(ctx, (const struct marshal_cmd_DepthRange *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4fNV:
      debug_print_unmarshal("VertexAttrib4fNV");
      _mesa_unmarshal_VertexAttrib4fNV(ctx, (const struct marshal_cmd_VertexAttrib4fNV *) cmd);
      break;
   case DISPATCH_CMD_Uniform4fv:
      debug_print_unmarshal("Uniform4fv");
      _mesa_unmarshal_Uniform4fv(ctx, (const struct marshal_cmd_Uniform4fv *) cmd);
      break;
   case DISPATCH_CMD_Frustumf:
      debug_print_unmarshal("Frustumf");
      _mesa_unmarshal_Frustumf(ctx, (const struct marshal_cmd_Frustumf *) cmd);
      break;
   case DISPATCH_CMD_GetQueryBufferObjectui64v:
      debug_print_unmarshal("GetQueryBufferObjectui64v");
      _mesa_unmarshal_GetQueryBufferObjectui64v(ctx, (const struct marshal_cmd_GetQueryBufferObjectui64v *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform2uiv:
      debug_print_unmarshal("ProgramUniform2uiv");
      _mesa_unmarshal_ProgramUniform2uiv(ctx, (const struct marshal_cmd_ProgramUniform2uiv *) cmd);
      break;
   case DISPATCH_CMD_Rectsv:
      debug_print_unmarshal("Rectsv");
      _mesa_unmarshal_Rectsv(ctx, (const struct marshal_cmd_Rectsv *) cmd);
      break;
   case DISPATCH_CMD_Frustumx:
      debug_print_unmarshal("Frustumx");
      _mesa_unmarshal_Frustumx(ctx, (const struct marshal_cmd_Frustumx *) cmd);
      break;
   case DISPATCH_CMD_CullFace:
      debug_print_unmarshal("CullFace");
      _mesa_unmarshal_CullFace(ctx, (const struct marshal_cmd_CullFace *) cmd);
      break;
   case DISPATCH_CMD_BindTexture:
      debug_print_unmarshal("BindTexture");
      _mesa_unmarshal_BindTexture(ctx, (const struct marshal_cmd_BindTexture *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord4fARB:
      debug_print_unmarshal("MultiTexCoord4fARB");
      _mesa_unmarshal_MultiTexCoord4fARB(ctx, (const struct marshal_cmd_MultiTexCoord4fARB *) cmd);
      break;
   case DISPATCH_CMD_Uniform2ui64ARB:
      debug_print_unmarshal("Uniform2ui64ARB");
      _mesa_unmarshal_Uniform2ui64ARB(ctx, (const struct marshal_cmd_Uniform2ui64ARB *) cmd);
      break;
   case DISPATCH_CMD_BeginPerfQueryINTEL:
      debug_print_unmarshal("BeginPerfQueryINTEL");
      _mesa_unmarshal_BeginPerfQueryINTEL(ctx, (const struct marshal_cmd_BeginPerfQueryINTEL *) cmd);
      break;
   case DISPATCH_CMD_NormalPointer:
      debug_print_unmarshal("NormalPointer");
      _mesa_unmarshal_NormalPointer(ctx, (const struct marshal_cmd_NormalPointer *) cmd);
      break;
   case DISPATCH_CMD_WindowPos4iMESA:
      debug_print_unmarshal("WindowPos4iMESA");
      _mesa_unmarshal_WindowPos4iMESA(ctx, (const struct marshal_cmd_WindowPos4iMESA *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4bv:
      debug_print_unmarshal("VertexAttrib4bv");
      _mesa_unmarshal_VertexAttrib4bv(ctx, (const struct marshal_cmd_VertexAttrib4bv *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColor3usv:
      debug_print_unmarshal("SecondaryColor3usv");
      _mesa_unmarshal_SecondaryColor3usv(ctx, (const struct marshal_cmd_SecondaryColor3usv *) cmd);
      break;
   case DISPATCH_CMD_Indexfv:
      debug_print_unmarshal("Indexfv");
      _mesa_unmarshal_Indexfv(ctx, (const struct marshal_cmd_Indexfv *) cmd);
      break;
   case DISPATCH_CMD_AlphaFragmentOp1ATI:
      debug_print_unmarshal("AlphaFragmentOp1ATI");
      _mesa_unmarshal_AlphaFragmentOp1ATI(ctx, (const struct marshal_cmd_AlphaFragmentOp1ATI *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform2dv:
      debug_print_unmarshal("ProgramUniform2dv");
      _mesa_unmarshal_ProgramUniform2dv(ctx, (const struct marshal_cmd_ProgramUniform2dv *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord3i:
      debug_print_unmarshal("MultiTexCoord3i");
      _mesa_unmarshal_MultiTexCoord3i(ctx, (const struct marshal_cmd_MultiTexCoord3i *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform1fv:
      debug_print_unmarshal("ProgramUniform1fv");
      _mesa_unmarshal_ProgramUniform1fv(ctx, (const struct marshal_cmd_ProgramUniform1fv *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord3d:
      debug_print_unmarshal("MultiTexCoord3d");
      _mesa_unmarshal_MultiTexCoord3d(ctx, (const struct marshal_cmd_MultiTexCoord3d *) cmd);
      break;
   case DISPATCH_CMD_TexCoord3sv:
      debug_print_unmarshal("TexCoord3sv");
      _mesa_unmarshal_TexCoord3sv(ctx, (const struct marshal_cmd_TexCoord3sv *) cmd);
      break;
   case DISPATCH_CMD_Minmax:
      debug_print_unmarshal("Minmax");
      _mesa_unmarshal_Minmax(ctx, (const struct marshal_cmd_Minmax *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord3s:
      debug_print_unmarshal("MultiTexCoord3s");
      _mesa_unmarshal_MultiTexCoord3s(ctx, (const struct marshal_cmd_MultiTexCoord3s *) cmd);
      break;
   case DISPATCH_CMD_Vertex4iv:
      debug_print_unmarshal("Vertex4iv");
      _mesa_unmarshal_Vertex4iv(ctx, (const struct marshal_cmd_Vertex4iv *) cmd);
      break;
   case DISPATCH_CMD_BufferSubData:
      debug_print_unmarshal("BufferSubData");
      _mesa_unmarshal_BufferSubData(ctx, (const struct marshal_cmd_BufferSubData *) cmd);
      break;
   case DISPATCH_CMD_TexCoord4dv:
      debug_print_unmarshal("TexCoord4dv");
      _mesa_unmarshal_TexCoord4dv(ctx, (const struct marshal_cmd_TexCoord4dv *) cmd);
      break;
   case DISPATCH_CMD_Begin:
      debug_print_unmarshal("Begin");
      _mesa_unmarshal_Begin(ctx, (const struct marshal_cmd_Begin *) cmd);
      break;
   case DISPATCH_CMD_LightModeli:
      debug_print_unmarshal("LightModeli");
      _mesa_unmarshal_LightModeli(ctx, (const struct marshal_cmd_LightModeli *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix2fv:
      debug_print_unmarshal("UniformMatrix2fv");
      _mesa_unmarshal_UniformMatrix2fv(ctx, (const struct marshal_cmd_UniformMatrix2fv *) cmd);
      break;
   case DISPATCH_CMD_LightModelf:
      debug_print_unmarshal("LightModelf");
      _mesa_unmarshal_LightModelf(ctx, (const struct marshal_cmd_LightModelf *) cmd);
      break;
   case DISPATCH_CMD_TextureStorage1D:
      debug_print_unmarshal("TextureStorage1D");
      _mesa_unmarshal_TextureStorage1D(ctx, (const struct marshal_cmd_TextureStorage1D *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord2fvARB:
      debug_print_unmarshal("MultiTexCoord2fvARB");
      _mesa_unmarshal_MultiTexCoord2fvARB(ctx, (const struct marshal_cmd_MultiTexCoord2fvARB *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4ubv:
      debug_print_unmarshal("VertexAttrib4ubv");
      _mesa_unmarshal_VertexAttrib4ubv(ctx, (const struct marshal_cmd_VertexAttrib4ubv *) cmd);
      break;
   case DISPATCH_CMD_ColorMask:
      debug_print_unmarshal("ColorMask");
      _mesa_unmarshal_ColorMask(ctx, (const struct marshal_cmd_ColorMask *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord4x:
      debug_print_unmarshal("MultiTexCoord4x");
      _mesa_unmarshal_MultiTexCoord4x(ctx, (const struct marshal_cmd_MultiTexCoord4x *) cmd);
      break;
   case DISPATCH_CMD_UniformHandleui64ARB:
      debug_print_unmarshal("UniformHandleui64ARB");
      _mesa_unmarshal_UniformHandleui64ARB(ctx, (const struct marshal_cmd_UniformHandleui64ARB *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribs4svNV:
      debug_print_unmarshal("VertexAttribs4svNV");
      _mesa_unmarshal_VertexAttribs4svNV(ctx, (const struct marshal_cmd_VertexAttribs4svNV *) cmd);
      break;
   case DISPATCH_CMD_DrawElementsInstancedBaseInstance:
      debug_print_unmarshal("DrawElementsInstancedBaseInstance");
      _mesa_unmarshal_DrawElementsInstancedBaseInstance(ctx, (const struct marshal_cmd_DrawElementsInstancedBaseInstance *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix4fv:
      debug_print_unmarshal("UniformMatrix4fv");
      _mesa_unmarshal_UniformMatrix4fv(ctx, (const struct marshal_cmd_UniformMatrix4fv *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix3x2fv:
      debug_print_unmarshal("UniformMatrix3x2fv");
      _mesa_unmarshal_UniformMatrix3x2fv(ctx, (const struct marshal_cmd_UniformMatrix3x2fv *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4Nuiv:
      debug_print_unmarshal("VertexAttrib4Nuiv");
      _mesa_unmarshal_VertexAttrib4Nuiv(ctx, (const struct marshal_cmd_VertexAttrib4Nuiv *) cmd);
      break;
   case DISPATCH_CMD_ClientActiveTexture:
      debug_print_unmarshal("ClientActiveTexture");
      _mesa_unmarshal_ClientActiveTexture(ctx, (const struct marshal_cmd_ClientActiveTexture *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord2sv:
      debug_print_unmarshal("MultiTexCoord2sv");
      _mesa_unmarshal_MultiTexCoord2sv(ctx, (const struct marshal_cmd_MultiTexCoord2sv *) cmd);
      break;
   case DISPATCH_CMD_NamedFramebufferDrawBuffer:
      debug_print_unmarshal("NamedFramebufferDrawBuffer");
      _mesa_unmarshal_NamedFramebufferDrawBuffer(ctx, (const struct marshal_cmd_NamedFramebufferDrawBuffer *) cmd);
      break;
   case DISPATCH_CMD_NamedFramebufferTextureLayer:
      debug_print_unmarshal("NamedFramebufferTextureLayer");
      _mesa_unmarshal_NamedFramebufferTextureLayer(ctx, (const struct marshal_cmd_NamedFramebufferTextureLayer *) cmd);
      break;
   case DISPATCH_CMD_LoadIdentity:
      debug_print_unmarshal("LoadIdentity");
      _mesa_unmarshal_LoadIdentity(ctx, (const struct marshal_cmd_LoadIdentity *) cmd);
      break;
   case DISPATCH_CMD_ActiveShaderProgram:
      debug_print_unmarshal("ActiveShaderProgram");
      _mesa_unmarshal_ActiveShaderProgram(ctx, (const struct marshal_cmd_ActiveShaderProgram *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4ubvNV:
      debug_print_unmarshal("VertexAttrib4ubvNV");
      _mesa_unmarshal_VertexAttrib4ubvNV(ctx, (const struct marshal_cmd_VertexAttrib4ubvNV *) cmd);
      break;
   case DISPATCH_CMD_FogCoordfEXT:
      debug_print_unmarshal("FogCoordfEXT");
      _mesa_unmarshal_FogCoordfEXT(ctx, (const struct marshal_cmd_FogCoordfEXT *) cmd);
      break;
   case DISPATCH_CMD_BindTransformFeedback:
      debug_print_unmarshal("BindTransformFeedback");
      _mesa_unmarshal_BindTransformFeedback(ctx, (const struct marshal_cmd_BindTransformFeedback *) cmd);
      break;
   case DISPATCH_CMD_TextureBufferRange:
      debug_print_unmarshal("TextureBufferRange");
      _mesa_unmarshal_TextureBufferRange(ctx, (const struct marshal_cmd_TextureBufferRange *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4svNV:
      debug_print_unmarshal("VertexAttrib4svNV");
      _mesa_unmarshal_VertexAttrib4svNV(ctx, (const struct marshal_cmd_VertexAttrib4svNV *) cmd);
      break;
   case DISPATCH_CMD_PatchParameteri:
      debug_print_unmarshal("PatchParameteri");
      _mesa_unmarshal_PatchParameteri(ctx, (const struct marshal_cmd_PatchParameteri *) cmd);
      break;
   case DISPATCH_CMD_NamedFramebufferParameteri:
      debug_print_unmarshal("NamedFramebufferParameteri");
      _mesa_unmarshal_NamedFramebufferParameteri(ctx, (const struct marshal_cmd_NamedFramebufferParameteri *) cmd);
      break;
   case DISPATCH_CMD_VDPAUSurfaceAccessNV:
      debug_print_unmarshal("VDPAUSurfaceAccessNV");
      _mesa_unmarshal_VDPAUSurfaceAccessNV(ctx, (const struct marshal_cmd_VDPAUSurfaceAccessNV *) cmd);
      break;
   case DISPATCH_CMD_EdgeFlagPointer:
      debug_print_unmarshal("EdgeFlagPointer");
      _mesa_unmarshal_EdgeFlagPointer(ctx, (const struct marshal_cmd_EdgeFlagPointer *) cmd);
      break;
   case DISPATCH_CMD_WindowPos2f:
      debug_print_unmarshal("WindowPos2f");
      _mesa_unmarshal_WindowPos2f(ctx, (const struct marshal_cmd_WindowPos2f *) cmd);
      break;
   case DISPATCH_CMD_WindowPos2d:
      debug_print_unmarshal("WindowPos2d");
      _mesa_unmarshal_WindowPos2d(ctx, (const struct marshal_cmd_WindowPos2d *) cmd);
      break;
   case DISPATCH_CMD_WindowPos2i:
      debug_print_unmarshal("WindowPos2i");
      _mesa_unmarshal_WindowPos2i(ctx, (const struct marshal_cmd_WindowPos2i *) cmd);
      break;
   case DISPATCH_CMD_WindowPos2s:
      debug_print_unmarshal("WindowPos2s");
      _mesa_unmarshal_WindowPos2s(ctx, (const struct marshal_cmd_WindowPos2s *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribI1uiEXT:
      debug_print_unmarshal("VertexAttribI1uiEXT");
      _mesa_unmarshal_VertexAttribI1uiEXT(ctx, (const struct marshal_cmd_VertexAttribI1uiEXT *) cmd);
      break;
   case DISPATCH_CMD_DeleteSync:
      debug_print_unmarshal("DeleteSync");
      _mesa_unmarshal_DeleteSync(ctx, (const struct marshal_cmd_DeleteSync *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColor3dv:
      debug_print_unmarshal("SecondaryColor3dv");
      _mesa_unmarshal_SecondaryColor3dv(ctx, (const struct marshal_cmd_SecondaryColor3dv *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib3s:
      debug_print_unmarshal("VertexAttrib3s");
      _mesa_unmarshal_VertexAttrib3s(ctx, (const struct marshal_cmd_VertexAttrib3s *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix4x3fv:
      debug_print_unmarshal("UniformMatrix4x3fv");
      _mesa_unmarshal_UniformMatrix4x3fv(ctx, (const struct marshal_cmd_UniformMatrix4x3fv *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib3d:
      debug_print_unmarshal("VertexAttrib3d");
      _mesa_unmarshal_VertexAttrib3d(ctx, (const struct marshal_cmd_VertexAttrib3d *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4Nbv:
      debug_print_unmarshal("VertexAttrib4Nbv");
      _mesa_unmarshal_VertexAttrib4Nbv(ctx, (const struct marshal_cmd_VertexAttrib4Nbv *) cmd);
      break;
   case DISPATCH_CMD_InvalidateTexImage:
      debug_print_unmarshal("InvalidateTexImage");
      _mesa_unmarshal_InvalidateTexImage(ctx, (const struct marshal_cmd_InvalidateTexImage *) cmd);
      break;
   case DISPATCH_CMD_Uniform4ui:
      debug_print_unmarshal("Uniform4ui");
      _mesa_unmarshal_Uniform4ui(ctx, (const struct marshal_cmd_Uniform4ui *) cmd);
      break;
   case DISPATCH_CMD_VertexArrayAttribFormat:
      debug_print_unmarshal("VertexArrayAttribFormat");
      _mesa_unmarshal_VertexArrayAttribFormat(ctx, (const struct marshal_cmd_VertexArrayAttribFormat *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib1fARB:
      debug_print_unmarshal("VertexAttrib1fARB");
      _mesa_unmarshal_VertexAttrib1fARB(ctx, (const struct marshal_cmd_VertexAttrib1fARB *) cmd);
      break;
   case DISPATCH_CMD_DrawTexsOES:
      debug_print_unmarshal("DrawTexsOES");
      _mesa_unmarshal_DrawTexsOES(ctx, (const struct marshal_cmd_DrawTexsOES *) cmd);
      break;
   case DISPATCH_CMD_ProgramParameteri:
      debug_print_unmarshal("ProgramParameteri");
      _mesa_unmarshal_ProgramParameteri(ctx, (const struct marshal_cmd_ProgramParameteri *) cmd);
      break;
   case DISPATCH_CMD_Color3fv:
      debug_print_unmarshal("Color3fv");
      _mesa_unmarshal_Color3fv(ctx, (const struct marshal_cmd_Color3fv *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord2i:
      debug_print_unmarshal("MultiTexCoord2i");
      _mesa_unmarshal_MultiTexCoord2i(ctx, (const struct marshal_cmd_MultiTexCoord2i *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord2d:
      debug_print_unmarshal("MultiTexCoord2d");
      _mesa_unmarshal_MultiTexCoord2d(ctx, (const struct marshal_cmd_MultiTexCoord2d *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord2s:
      debug_print_unmarshal("MultiTexCoord2s");
      _mesa_unmarshal_MultiTexCoord2s(ctx, (const struct marshal_cmd_MultiTexCoord2s *) cmd);
      break;
   case DISPATCH_CMD_Indexub:
      debug_print_unmarshal("Indexub");
      _mesa_unmarshal_Indexub(ctx, (const struct marshal_cmd_Indexub *) cmd);
      break;
   case DISPATCH_CMD_PolygonOffsetEXT:
      debug_print_unmarshal("PolygonOffsetEXT");
      _mesa_unmarshal_PolygonOffsetEXT(ctx, (const struct marshal_cmd_PolygonOffsetEXT *) cmd);
      break;
   case DISPATCH_CMD_Scalex:
      debug_print_unmarshal("Scalex");
      _mesa_unmarshal_Scalex(ctx, (const struct marshal_cmd_Scalex *) cmd);
      break;
   case DISPATCH_CMD_Scaled:
      debug_print_unmarshal("Scaled");
      _mesa_unmarshal_Scaled(ctx, (const struct marshal_cmd_Scaled *) cmd);
      break;
   case DISPATCH_CMD_Scalef:
      debug_print_unmarshal("Scalef");
      _mesa_unmarshal_Scalef(ctx, (const struct marshal_cmd_Scalef *) cmd);
      break;
   case DISPATCH_CMD_IndexPointerEXT:
      debug_print_unmarshal("IndexPointerEXT");
      _mesa_unmarshal_IndexPointerEXT(ctx, (const struct marshal_cmd_IndexPointerEXT *) cmd);
      break;
   case DISPATCH_CMD_ColorFragmentOp2ATI:
      debug_print_unmarshal("ColorFragmentOp2ATI");
      _mesa_unmarshal_ColorFragmentOp2ATI(ctx, (const struct marshal_cmd_ColorFragmentOp2ATI *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib2sNV:
      debug_print_unmarshal("VertexAttrib2sNV");
      _mesa_unmarshal_VertexAttrib2sNV(ctx, (const struct marshal_cmd_VertexAttrib2sNV *) cmd);
      break;
   case DISPATCH_CMD_QueryCounter:
      debug_print_unmarshal("QueryCounter");
      _mesa_unmarshal_QueryCounter(ctx, (const struct marshal_cmd_QueryCounter *) cmd);
      break;
   case DISPATCH_CMD_NormalPointerEXT:
      debug_print_unmarshal("NormalPointerEXT");
      _mesa_unmarshal_NormalPointerEXT(ctx, (const struct marshal_cmd_NormalPointerEXT *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform3iv:
      debug_print_unmarshal("ProgramUniform3iv");
      _mesa_unmarshal_ProgramUniform3iv(ctx, (const struct marshal_cmd_ProgramUniform3iv *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix2dv:
      debug_print_unmarshal("ProgramUniformMatrix2dv");
      _mesa_unmarshal_ProgramUniformMatrix2dv(ctx, (const struct marshal_cmd_ProgramUniformMatrix2dv *) cmd);
      break;
   case DISPATCH_CMD_DrawElementsBaseVertex:
      debug_print_unmarshal("DrawElementsBaseVertex");
      _mesa_unmarshal_DrawElementsBaseVertex(ctx, (const struct marshal_cmd_DrawElementsBaseVertex *) cmd);
      break;
   case DISPATCH_CMD_RasterPos3iv:
      debug_print_unmarshal("RasterPos3iv");
      _mesa_unmarshal_RasterPos3iv(ctx, (const struct marshal_cmd_RasterPos3iv *) cmd);
      break;
   case DISPATCH_CMD_ColorMaski:
      debug_print_unmarshal("ColorMaski");
      _mesa_unmarshal_ColorMaski(ctx, (const struct marshal_cmd_ColorMaski *) cmd);
      break;
   case DISPATCH_CMD_Uniform2uiv:
      debug_print_unmarshal("Uniform2uiv");
      _mesa_unmarshal_Uniform2uiv(ctx, (const struct marshal_cmd_Uniform2uiv *) cmd);
      break;
   case DISPATCH_CMD_RasterPos3s:
      debug_print_unmarshal("RasterPos3s");
      _mesa_unmarshal_RasterPos3s(ctx, (const struct marshal_cmd_RasterPos3s *) cmd);
      break;
   case DISPATCH_CMD_RasterPos3d:
      debug_print_unmarshal("RasterPos3d");
      _mesa_unmarshal_RasterPos3d(ctx, (const struct marshal_cmd_RasterPos3d *) cmd);
      break;
   case DISPATCH_CMD_RasterPos3f:
      debug_print_unmarshal("RasterPos3f");
      _mesa_unmarshal_RasterPos3f(ctx, (const struct marshal_cmd_RasterPos3f *) cmd);
      break;
   case DISPATCH_CMD_BindVertexArray:
      debug_print_unmarshal("BindVertexArray");
      _mesa_unmarshal_BindVertexArray(ctx, (const struct marshal_cmd_BindVertexArray *) cmd);
      break;
   case DISPATCH_CMD_RasterPos3i:
      debug_print_unmarshal("RasterPos3i");
      _mesa_unmarshal_RasterPos3i(ctx, (const struct marshal_cmd_RasterPos3i *) cmd);
      break;
   case DISPATCH_CMD_DrawTransformFeedbackStreamInstanced:
      debug_print_unmarshal("DrawTransformFeedbackStreamInstanced");
      _mesa_unmarshal_DrawTransformFeedbackStreamInstanced(ctx, (const struct marshal_cmd_DrawTransformFeedbackStreamInstanced *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib2fvARB:
      debug_print_unmarshal("VertexAttrib2fvARB");
      _mesa_unmarshal_VertexAttrib2fvARB(ctx, (const struct marshal_cmd_VertexAttrib2fvARB *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix4x3dv:
      debug_print_unmarshal("ProgramUniformMatrix4x3dv");
      _mesa_unmarshal_ProgramUniformMatrix4x3dv(ctx, (const struct marshal_cmd_ProgramUniformMatrix4x3dv *) cmd);
      break;
   case DISPATCH_CMD_LoadName:
      debug_print_unmarshal("LoadName");
      _mesa_unmarshal_LoadName(ctx, (const struct marshal_cmd_LoadName *) cmd);
      break;
   case DISPATCH_CMD_ClearIndex:
      debug_print_unmarshal("ClearIndex");
      _mesa_unmarshal_ClearIndex(ctx, (const struct marshal_cmd_ClearIndex *) cmd);
      break;
   case DISPATCH_CMD_FlushMappedNamedBufferRange:
      debug_print_unmarshal("FlushMappedNamedBufferRange");
      _mesa_unmarshal_FlushMappedNamedBufferRange(ctx, (const struct marshal_cmd_FlushMappedNamedBufferRange *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoordP1ui:
      debug_print_unmarshal("MultiTexCoordP1ui");
      _mesa_unmarshal_MultiTexCoordP1ui(ctx, (const struct marshal_cmd_MultiTexCoordP1ui *) cmd);
      break;
   case DISPATCH_CMD_EvalMesh2:
      debug_print_unmarshal("EvalMesh2");
      _mesa_unmarshal_EvalMesh2(ctx, (const struct marshal_cmd_EvalMesh2 *) cmd);
      break;
   case DISPATCH_CMD_Vertex4fv:
      debug_print_unmarshal("Vertex4fv");
      _mesa_unmarshal_Vertex4fv(ctx, (const struct marshal_cmd_Vertex4fv *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform4i64ARB:
      debug_print_unmarshal("ProgramUniform4i64ARB");
      _mesa_unmarshal_ProgramUniform4i64ARB(ctx, (const struct marshal_cmd_ProgramUniform4i64ARB *) cmd);
      break;
   case DISPATCH_CMD_TextureStorage2D:
      debug_print_unmarshal("TextureStorage2D");
      _mesa_unmarshal_TextureStorage2D(ctx, (const struct marshal_cmd_TextureStorage2D *) cmd);
      break;
   case DISPATCH_CMD_BindFramebuffer:
      debug_print_unmarshal("BindFramebuffer");
      _mesa_unmarshal_BindFramebuffer(ctx, (const struct marshal_cmd_BindFramebuffer *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribs3svNV:
      debug_print_unmarshal("VertexAttribs3svNV");
      _mesa_unmarshal_VertexAttribs3svNV(ctx, (const struct marshal_cmd_VertexAttribs3svNV *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib2sv:
      debug_print_unmarshal("VertexAttrib2sv");
      _mesa_unmarshal_VertexAttrib2sv(ctx, (const struct marshal_cmd_VertexAttrib2sv *) cmd);
      break;
   case DISPATCH_CMD_Uniform1dv:
      debug_print_unmarshal("Uniform1dv");
      _mesa_unmarshal_Uniform1dv(ctx, (const struct marshal_cmd_Uniform1dv *) cmd);
      break;
   case DISPATCH_CMD_TransformFeedbackBufferRange:
      debug_print_unmarshal("TransformFeedbackBufferRange");
      _mesa_unmarshal_TransformFeedbackBufferRange(ctx, (const struct marshal_cmd_TransformFeedbackBufferRange *) cmd);
      break;
   case DISPATCH_CMD_PassThrough:
      debug_print_unmarshal("PassThrough");
      _mesa_unmarshal_PassThrough(ctx, (const struct marshal_cmd_PassThrough *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4fvARB:
      debug_print_unmarshal("VertexAttrib4fvARB");
      _mesa_unmarshal_VertexAttrib4fvARB(ctx, (const struct marshal_cmd_VertexAttrib4fvARB *) cmd);
      break;
   case DISPATCH_CMD_Uniform3i64vARB:
      debug_print_unmarshal("Uniform3i64vARB");
      _mesa_unmarshal_Uniform3i64vARB(ctx, (const struct marshal_cmd_Uniform3i64vARB *) cmd);
      break;
   case DISPATCH_CMD_TexGenxOES:
      debug_print_unmarshal("TexGenxOES");
      _mesa_unmarshal_TexGenxOES(ctx, (const struct marshal_cmd_TexGenxOES *) cmd);
      break;
   case DISPATCH_CMD_VertexArrayAttribIFormat:
      debug_print_unmarshal("VertexArrayAttribIFormat");
      _mesa_unmarshal_VertexArrayAttribIFormat(ctx, (const struct marshal_cmd_VertexArrayAttribIFormat *) cmd);
      break;
   case DISPATCH_CMD_StencilOp:
      debug_print_unmarshal("StencilOp");
      _mesa_unmarshal_StencilOp(ctx, (const struct marshal_cmd_StencilOp *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform1iv:
      debug_print_unmarshal("ProgramUniform1iv");
      _mesa_unmarshal_ProgramUniform1iv(ctx, (const struct marshal_cmd_ProgramUniform1iv *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform3ui:
      debug_print_unmarshal("ProgramUniform3ui");
      _mesa_unmarshal_ProgramUniform3ui(ctx, (const struct marshal_cmd_ProgramUniform3ui *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColor3sv:
      debug_print_unmarshal("SecondaryColor3sv");
      _mesa_unmarshal_SecondaryColor3sv(ctx, (const struct marshal_cmd_SecondaryColor3sv *) cmd);
      break;
   case DISPATCH_CMD_TexCoordP3ui:
      debug_print_unmarshal("TexCoordP3ui");
      _mesa_unmarshal_TexCoordP3ui(ctx, (const struct marshal_cmd_TexCoordP3ui *) cmd);
      break;
   case DISPATCH_CMD_VertexArrayElementBuffer:
      debug_print_unmarshal("VertexArrayElementBuffer");
      _mesa_unmarshal_VertexArrayElementBuffer(ctx, (const struct marshal_cmd_VertexArrayElementBuffer *) cmd);
      break;
   case DISPATCH_CMD_Uniform3i64ARB:
      debug_print_unmarshal("Uniform3i64ARB");
      _mesa_unmarshal_Uniform3i64ARB(ctx, (const struct marshal_cmd_Uniform3i64ARB *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribP1ui:
      debug_print_unmarshal("VertexAttribP1ui");
      _mesa_unmarshal_VertexAttribP1ui(ctx, (const struct marshal_cmd_VertexAttribP1ui *) cmd);
      break;
   case DISPATCH_CMD_DeleteLists:
      debug_print_unmarshal("DeleteLists");
      _mesa_unmarshal_DeleteLists(ctx, (const struct marshal_cmd_DeleteLists *) cmd);
      break;
   case DISPATCH_CMD_LogicOp:
      debug_print_unmarshal("LogicOp");
      _mesa_unmarshal_LogicOp(ctx, (const struct marshal_cmd_LogicOp *) cmd);
      break;
   case DISPATCH_CMD_RenderbufferStorageMultisample:
      debug_print_unmarshal("RenderbufferStorageMultisample");
      _mesa_unmarshal_RenderbufferStorageMultisample(ctx, (const struct marshal_cmd_RenderbufferStorageMultisample *) cmd);
      break;
   case DISPATCH_CMD_WindowPos3d:
      debug_print_unmarshal("WindowPos3d");
      _mesa_unmarshal_WindowPos3d(ctx, (const struct marshal_cmd_WindowPos3d *) cmd);
      break;
   case DISPATCH_CMD_Enablei:
      debug_print_unmarshal("Enablei");
      _mesa_unmarshal_Enablei(ctx, (const struct marshal_cmd_Enablei *) cmd);
      break;
   case DISPATCH_CMD_WindowPos3f:
      debug_print_unmarshal("WindowPos3f");
      _mesa_unmarshal_WindowPos3f(ctx, (const struct marshal_cmd_WindowPos3f *) cmd);
      break;
   case DISPATCH_CMD_RasterPos2sv:
      debug_print_unmarshal("RasterPos2sv");
      _mesa_unmarshal_RasterPos2sv(ctx, (const struct marshal_cmd_RasterPos2sv *) cmd);
      break;
   case DISPATCH_CMD_WindowPos3i:
      debug_print_unmarshal("WindowPos3i");
      _mesa_unmarshal_WindowPos3i(ctx, (const struct marshal_cmd_WindowPos3i *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord4iv:
      debug_print_unmarshal("MultiTexCoord4iv");
      _mesa_unmarshal_MultiTexCoord4iv(ctx, (const struct marshal_cmd_MultiTexCoord4iv *) cmd);
      break;
   case DISPATCH_CMD_TexCoord1sv:
      debug_print_unmarshal("TexCoord1sv");
      _mesa_unmarshal_TexCoord1sv(ctx, (const struct marshal_cmd_TexCoord1sv *) cmd);
      break;
   case DISPATCH_CMD_WindowPos3s:
      debug_print_unmarshal("WindowPos3s");
      _mesa_unmarshal_WindowPos3s(ctx, (const struct marshal_cmd_WindowPos3s *) cmd);
      break;
   case DISPATCH_CMD_Orthof:
      debug_print_unmarshal("Orthof");
      _mesa_unmarshal_Orthof(ctx, (const struct marshal_cmd_Orthof *) cmd);
      break;
   case DISPATCH_CMD_DeleteObjectARB:
      debug_print_unmarshal("DeleteObjectARB");
      _mesa_unmarshal_DeleteObjectARB(ctx, (const struct marshal_cmd_DeleteObjectARB *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix2x3dv:
      debug_print_unmarshal("ProgramUniformMatrix2x3dv");
      _mesa_unmarshal_ProgramUniformMatrix2x3dv(ctx, (const struct marshal_cmd_ProgramUniformMatrix2x3dv *) cmd);
      break;
   case DISPATCH_CMD_Color4uiv:
      debug_print_unmarshal("Color4uiv");
      _mesa_unmarshal_Color4uiv(ctx, (const struct marshal_cmd_Color4uiv *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord1sv:
      debug_print_unmarshal("MultiTexCoord1sv");
      _mesa_unmarshal_MultiTexCoord1sv(ctx, (const struct marshal_cmd_MultiTexCoord1sv *) cmd);
      break;
   case DISPATCH_CMD_Orthox:
      debug_print_unmarshal("Orthox");
      _mesa_unmarshal_Orthox(ctx, (const struct marshal_cmd_Orthox *) cmd);
      break;
   case DISPATCH_CMD_PushAttrib:
      debug_print_unmarshal("PushAttrib");
      _mesa_unmarshal_PushAttrib(ctx, (const struct marshal_cmd_PushAttrib *) cmd);
      break;
   case DISPATCH_CMD_RasterPos2i:
      debug_print_unmarshal("RasterPos2i");
      _mesa_unmarshal_RasterPos2i(ctx, (const struct marshal_cmd_RasterPos2i *) cmd);
      break;
   case DISPATCH_CMD_ClipPlane:
      debug_print_unmarshal("ClipPlane");
      _mesa_unmarshal_ClipPlane(ctx, (const struct marshal_cmd_ClipPlane *) cmd);
      break;
   case DISPATCH_CMD_RasterPos2f:
      debug_print_unmarshal("RasterPos2f");
      _mesa_unmarshal_RasterPos2f(ctx, (const struct marshal_cmd_RasterPos2f *) cmd);
      break;
   case DISPATCH_CMD_RasterPos2d:
      debug_print_unmarshal("RasterPos2d");
      _mesa_unmarshal_RasterPos2d(ctx, (const struct marshal_cmd_RasterPos2d *) cmd);
      break;
   case DISPATCH_CMD_MakeImageHandleResidentARB:
      debug_print_unmarshal("MakeImageHandleResidentARB");
      _mesa_unmarshal_MakeImageHandleResidentARB(ctx, (const struct marshal_cmd_MakeImageHandleResidentARB *) cmd);
      break;
   case DISPATCH_CMD_InvalidateSubFramebuffer:
      debug_print_unmarshal("InvalidateSubFramebuffer");
      _mesa_unmarshal_InvalidateSubFramebuffer(ctx, (const struct marshal_cmd_InvalidateSubFramebuffer *) cmd);
      break;
   case DISPATCH_CMD_Color4ub:
      debug_print_unmarshal("Color4ub");
      _mesa_unmarshal_Color4ub(ctx, (const struct marshal_cmd_Color4ub *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix2x4dv:
      debug_print_unmarshal("UniformMatrix2x4dv");
      _mesa_unmarshal_UniformMatrix2x4dv(ctx, (const struct marshal_cmd_UniformMatrix2x4dv *) cmd);
      break;
   case DISPATCH_CMD_RasterPos2s:
      debug_print_unmarshal("RasterPos2s");
      _mesa_unmarshal_RasterPos2s(ctx, (const struct marshal_cmd_RasterPos2s *) cmd);
      break;
   case DISPATCH_CMD_DispatchComputeGroupSizeARB:
      debug_print_unmarshal("DispatchComputeGroupSizeARB");
      _mesa_unmarshal_DispatchComputeGroupSizeARB(ctx, (const struct marshal_cmd_DispatchComputeGroupSizeARB *) cmd);
      break;
   case DISPATCH_CMD_VertexArrayBindingDivisor:
      debug_print_unmarshal("VertexArrayBindingDivisor");
      _mesa_unmarshal_VertexArrayBindingDivisor(ctx, (const struct marshal_cmd_VertexArrayBindingDivisor *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord3dv:
      debug_print_unmarshal("MultiTexCoord3dv");
      _mesa_unmarshal_MultiTexCoord3dv(ctx, (const struct marshal_cmd_MultiTexCoord3dv *) cmd);
      break;
   case DISPATCH_CMD_BindProgramPipeline:
      debug_print_unmarshal("BindProgramPipeline");
      _mesa_unmarshal_BindProgramPipeline(ctx, (const struct marshal_cmd_BindProgramPipeline *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord1i:
      debug_print_unmarshal("MultiTexCoord1i");
      _mesa_unmarshal_MultiTexCoord1i(ctx, (const struct marshal_cmd_MultiTexCoord1i *) cmd);
      break;
   case DISPATCH_CMD_DeletePerfQueryINTEL:
      debug_print_unmarshal("DeletePerfQueryINTEL");
      _mesa_unmarshal_DeletePerfQueryINTEL(ctx, (const struct marshal_cmd_DeletePerfQueryINTEL *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord1d:
      debug_print_unmarshal("MultiTexCoord1d");
      _mesa_unmarshal_MultiTexCoord1d(ctx, (const struct marshal_cmd_MultiTexCoord1d *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord1s:
      debug_print_unmarshal("MultiTexCoord1s");
      _mesa_unmarshal_MultiTexCoord1s(ctx, (const struct marshal_cmd_MultiTexCoord1s *) cmd);
      break;
   case DISPATCH_CMD_BeginConditionalRender:
      debug_print_unmarshal("BeginConditionalRender");
      _mesa_unmarshal_BeginConditionalRender(ctx, (const struct marshal_cmd_BeginConditionalRender *) cmd);
      break;
   case DISPATCH_CMD_CopyConvolutionFilter1D:
      debug_print_unmarshal("CopyConvolutionFilter1D");
      _mesa_unmarshal_CopyConvolutionFilter1D(ctx, (const struct marshal_cmd_CopyConvolutionFilter1D *) cmd);
      break;
   case DISPATCH_CMD_ClearBufferfv:
      debug_print_unmarshal("ClearBufferfv");
      _mesa_unmarshal_ClearBufferfv(ctx, (const struct marshal_cmd_ClearBufferfv *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix4dv:
      debug_print_unmarshal("UniformMatrix4dv");
      _mesa_unmarshal_UniformMatrix4dv(ctx, (const struct marshal_cmd_UniformMatrix4dv *) cmd);
      break;
   case DISPATCH_CMD_ClearBufferfi:
      debug_print_unmarshal("ClearBufferfi");
      _mesa_unmarshal_ClearBufferfi(ctx, (const struct marshal_cmd_ClearBufferfi *) cmd);
      break;
   case DISPATCH_CMD_DeleteFragmentShaderATI:
      debug_print_unmarshal("DeleteFragmentShaderATI");
      _mesa_unmarshal_DeleteFragmentShaderATI(ctx, (const struct marshal_cmd_DeleteFragmentShaderATI *) cmd);
      break;
   case DISPATCH_CMD_DrawElementsInstancedBaseVertex:
      debug_print_unmarshal("DrawElementsInstancedBaseVertex");
      _mesa_unmarshal_DrawElementsInstancedBaseVertex(ctx, (const struct marshal_cmd_DrawElementsInstancedBaseVertex *) cmd);
      break;
   case DISPATCH_CMD_DisableClientState:
      debug_print_unmarshal("DisableClientState");
      _mesa_unmarshal_DisableClientState(ctx, (const struct marshal_cmd_DisableClientState *) cmd);
      break;
   case DISPATCH_CMD_TexGeni:
      debug_print_unmarshal("TexGeni");
      _mesa_unmarshal_TexGeni(ctx, (const struct marshal_cmd_TexGeni *) cmd);
      break;
   case DISPATCH_CMD_TexGenf:
      debug_print_unmarshal("TexGenf");
      _mesa_unmarshal_TexGenf(ctx, (const struct marshal_cmd_TexGenf *) cmd);
      break;
   case DISPATCH_CMD_TexGend:
      debug_print_unmarshal("TexGend");
      _mesa_unmarshal_TexGend(ctx, (const struct marshal_cmd_TexGend *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform4i64vARB:
      debug_print_unmarshal("ProgramUniform4i64vARB");
      _mesa_unmarshal_ProgramUniform4i64vARB(ctx, (const struct marshal_cmd_ProgramUniform4i64vARB *) cmd);
      break;
   case DISPATCH_CMD_Color4sv:
      debug_print_unmarshal("Color4sv");
      _mesa_unmarshal_Color4sv(ctx, (const struct marshal_cmd_Color4sv *) cmd);
      break;
   case DISPATCH_CMD_PixelZoom:
      debug_print_unmarshal("PixelZoom");
      _mesa_unmarshal_PixelZoom(ctx, (const struct marshal_cmd_PixelZoom *) cmd);
      break;
   case DISPATCH_CMD_ProgramEnvParameter4dARB:
      debug_print_unmarshal("ProgramEnvParameter4dARB");
      _mesa_unmarshal_ProgramEnvParameter4dARB(ctx, (const struct marshal_cmd_ProgramEnvParameter4dARB *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform3uiv:
      debug_print_unmarshal("ProgramUniform3uiv");
      _mesa_unmarshal_ProgramUniform3uiv(ctx, (const struct marshal_cmd_ProgramUniform3uiv *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4sNV:
      debug_print_unmarshal("VertexAttrib4sNV");
      _mesa_unmarshal_VertexAttrib4sNV(ctx, (const struct marshal_cmd_VertexAttrib4sNV *) cmd);
      break;
   case DISPATCH_CMD_Uniform3ui64vARB:
      debug_print_unmarshal("Uniform3ui64vARB");
      _mesa_unmarshal_Uniform3ui64vARB(ctx, (const struct marshal_cmd_Uniform3ui64vARB *) cmd);
      break;
   case DISPATCH_CMD_BufferPageCommitmentARB:
      debug_print_unmarshal("BufferPageCommitmentARB");
      _mesa_unmarshal_BufferPageCommitmentARB(ctx, (const struct marshal_cmd_BufferPageCommitmentARB *) cmd);
      break;
   case DISPATCH_CMD_ColorP4ui:
      debug_print_unmarshal("ColorP4ui");
      _mesa_unmarshal_ColorP4ui(ctx, (const struct marshal_cmd_ColorP4ui *) cmd);
      break;
   case DISPATCH_CMD_TextureStorage3D:
      debug_print_unmarshal("TextureStorage3D");
      _mesa_unmarshal_TextureStorage3D(ctx, (const struct marshal_cmd_TextureStorage3D *) cmd);
      break;
   case DISPATCH_CMD_TextureStorageMem2DMultisampleEXT:
      debug_print_unmarshal("TextureStorageMem2DMultisampleEXT");
      _mesa_unmarshal_TextureStorageMem2DMultisampleEXT(ctx, (const struct marshal_cmd_TextureStorageMem2DMultisampleEXT *) cmd);
      break;
   case DISPATCH_CMD_Uniform1iv:
      debug_print_unmarshal("Uniform1iv");
      _mesa_unmarshal_Uniform1iv(ctx, (const struct marshal_cmd_Uniform1iv *) cmd);
      break;
   case DISPATCH_CMD_Uniform4uiv:
      debug_print_unmarshal("Uniform4uiv");
      _mesa_unmarshal_Uniform4uiv(ctx, (const struct marshal_cmd_Uniform4uiv *) cmd);
      break;
   case DISPATCH_CMD_PopDebugGroup:
      debug_print_unmarshal("PopDebugGroup");
      _mesa_unmarshal_PopDebugGroup(ctx, (const struct marshal_cmd_PopDebugGroup *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib1d:
      debug_print_unmarshal("VertexAttrib1d");
      _mesa_unmarshal_VertexAttrib1d(ctx, (const struct marshal_cmd_VertexAttrib1d *) cmd);
      break;
   case DISPATCH_CMD_NamedBufferSubData:
      debug_print_unmarshal("NamedBufferSubData");
      _mesa_unmarshal_NamedBufferSubData(ctx, (const struct marshal_cmd_NamedBufferSubData *) cmd);
      break;
   case DISPATCH_CMD_TexBufferRange:
      debug_print_unmarshal("TexBufferRange");
      _mesa_unmarshal_TexBufferRange(ctx, (const struct marshal_cmd_TexBufferRange *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib1s:
      debug_print_unmarshal("VertexAttrib1s");
      _mesa_unmarshal_VertexAttrib1s(ctx, (const struct marshal_cmd_VertexAttrib1s *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix4x3dv:
      debug_print_unmarshal("UniformMatrix4x3dv");
      _mesa_unmarshal_UniformMatrix4x3dv(ctx, (const struct marshal_cmd_UniformMatrix4x3dv *) cmd);
      break;
   case DISPATCH_CMD_TransformFeedbackBufferBase:
      debug_print_unmarshal("TransformFeedbackBufferBase");
      _mesa_unmarshal_TransformFeedbackBufferBase(ctx, (const struct marshal_cmd_TransformFeedbackBufferBase *) cmd);
      break;
   case DISPATCH_CMD_FogCoordfvEXT:
      debug_print_unmarshal("FogCoordfvEXT");
      _mesa_unmarshal_FogCoordfvEXT(ctx, (const struct marshal_cmd_FogCoordfvEXT *) cmd);
      break;
   case DISPATCH_CMD_Uniform2ui64vARB:
      debug_print_unmarshal("Uniform2ui64vARB");
      _mesa_unmarshal_Uniform2ui64vARB(ctx, (const struct marshal_cmd_Uniform2ui64vARB *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord3fARB:
      debug_print_unmarshal("MultiTexCoord3fARB");
      _mesa_unmarshal_MultiTexCoord3fARB(ctx, (const struct marshal_cmd_MultiTexCoord3fARB *) cmd);
      break;
   case DISPATCH_CMD_Vertex2sv:
      debug_print_unmarshal("Vertex2sv");
      _mesa_unmarshal_Vertex2sv(ctx, (const struct marshal_cmd_Vertex2sv *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib2dNV:
      debug_print_unmarshal("VertexAttrib2dNV");
      _mesa_unmarshal_VertexAttrib2dNV(ctx, (const struct marshal_cmd_VertexAttrib2dNV *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib3svNV:
      debug_print_unmarshal("VertexAttrib3svNV");
      _mesa_unmarshal_VertexAttrib3svNV(ctx, (const struct marshal_cmd_VertexAttrib3svNV *) cmd);
      break;
   case DISPATCH_CMD_ViewportArrayv:
      debug_print_unmarshal("ViewportArrayv");
      _mesa_unmarshal_ViewportArrayv(ctx, (const struct marshal_cmd_ViewportArrayv *) cmd);
      break;
   case DISPATCH_CMD_ArrayElement:
      debug_print_unmarshal("ArrayElement");
      _mesa_unmarshal_ArrayElement(ctx, (const struct marshal_cmd_ArrayElement *) cmd);
      break;
   case DISPATCH_CMD_RasterPos2dv:
      debug_print_unmarshal("RasterPos2dv");
      _mesa_unmarshal_RasterPos2dv(ctx, (const struct marshal_cmd_RasterPos2dv *) cmd);
      break;
   case DISPATCH_CMD_EndQuery:
      debug_print_unmarshal("EndQuery");
      _mesa_unmarshal_EndQuery(ctx, (const struct marshal_cmd_EndQuery *) cmd);
      break;
   case DISPATCH_CMD_TexCoord1dv:
      debug_print_unmarshal("TexCoord1dv");
      _mesa_unmarshal_TexCoord1dv(ctx, (const struct marshal_cmd_TexCoord1dv *) cmd);
      break;
   case DISPATCH_CMD_AlphaFragmentOp3ATI:
      debug_print_unmarshal("AlphaFragmentOp3ATI");
      _mesa_unmarshal_AlphaFragmentOp3ATI(ctx, (const struct marshal_cmd_AlphaFragmentOp3ATI *) cmd);
      break;
   case DISPATCH_CMD_Clear:
      debug_print_unmarshal("Clear");
      _mesa_unmarshal_Clear(ctx, (const struct marshal_cmd_Clear *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4sv:
      debug_print_unmarshal("VertexAttrib4sv");
      _mesa_unmarshal_VertexAttrib4sv(ctx, (const struct marshal_cmd_VertexAttrib4sv *) cmd);
      break;
   case DISPATCH_CMD_Ortho:
      debug_print_unmarshal("Ortho");
      _mesa_unmarshal_Ortho(ctx, (const struct marshal_cmd_Ortho *) cmd);
      break;
   case DISPATCH_CMD_Uniform3uiv:
      debug_print_unmarshal("Uniform3uiv");
      _mesa_unmarshal_Uniform3uiv(ctx, (const struct marshal_cmd_Uniform3uiv *) cmd);
      break;
   case DISPATCH_CMD_EndQueryIndexed:
      debug_print_unmarshal("EndQueryIndexed");
      _mesa_unmarshal_EndQueryIndexed(ctx, (const struct marshal_cmd_EndQueryIndexed *) cmd);
      break;
   case DISPATCH_CMD_MultiDrawArraysIndirectCountARB:
      debug_print_unmarshal("MultiDrawArraysIndirectCountARB");
      _mesa_unmarshal_MultiDrawArraysIndirectCountARB(ctx, (const struct marshal_cmd_MultiDrawArraysIndirectCountARB *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix2fv:
      debug_print_unmarshal("ProgramUniformMatrix2fv");
      _mesa_unmarshal_ProgramUniformMatrix2fv(ctx, (const struct marshal_cmd_ProgramUniformMatrix2fv *) cmd);
      break;
   case DISPATCH_CMD_ProgramLocalParameter4fvARB:
      debug_print_unmarshal("ProgramLocalParameter4fvARB");
      _mesa_unmarshal_ProgramLocalParameter4fvARB(ctx, (const struct marshal_cmd_ProgramLocalParameter4fvARB *) cmd);
      break;
   case DISPATCH_CMD_Uniform4dv:
      debug_print_unmarshal("Uniform4dv");
      _mesa_unmarshal_Uniform4dv(ctx, (const struct marshal_cmd_Uniform4dv *) cmd);
      break;
   case DISPATCH_CMD_LightModelx:
      debug_print_unmarshal("LightModelx");
      _mesa_unmarshal_LightModelx(ctx, (const struct marshal_cmd_LightModelx *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribI3iEXT:
      debug_print_unmarshal("VertexAttribI3iEXT");
      _mesa_unmarshal_VertexAttribI3iEXT(ctx, (const struct marshal_cmd_VertexAttribI3iEXT *) cmd);
      break;
   case DISPATCH_CMD_ClearColorx:
      debug_print_unmarshal("ClearColorx");
      _mesa_unmarshal_ClearColorx(ctx, (const struct marshal_cmd_ClearColorx *) cmd);
      break;
   case DISPATCH_CMD_EndTransformFeedback:
      debug_print_unmarshal("EndTransformFeedback");
      _mesa_unmarshal_EndTransformFeedback(ctx, (const struct marshal_cmd_EndTransformFeedback *) cmd);
      break;
   case DISPATCH_CMD_ViewportIndexedfv:
      debug_print_unmarshal("ViewportIndexedfv");
      _mesa_unmarshal_ViewportIndexedfv(ctx, (const struct marshal_cmd_ViewportIndexedfv *) cmd);
      break;
   case DISPATCH_CMD_BindTextureUnit:
      debug_print_unmarshal("BindTextureUnit");
      _mesa_unmarshal_BindTextureUnit(ctx, (const struct marshal_cmd_BindTextureUnit *) cmd);
      break;
   case DISPATCH_CMD_CallList:
      debug_print_unmarshal("CallList");
      _mesa_unmarshal_CallList(ctx, (const struct marshal_cmd_CallList *) cmd);
      break;
   case DISPATCH_CMD_DeleteProgram:
      debug_print_unmarshal("DeleteProgram");
      _mesa_unmarshal_DeleteProgram(ctx, (const struct marshal_cmd_DeleteProgram *) cmd);
      break;
   case DISPATCH_CMD_ClearDepthf:
      debug_print_unmarshal("ClearDepthf");
      _mesa_unmarshal_ClearDepthf(ctx, (const struct marshal_cmd_ClearDepthf *) cmd);
      break;
   case DISPATCH_CMD_Uniform2iv:
      debug_print_unmarshal("Uniform2iv");
      _mesa_unmarshal_Uniform2iv(ctx, (const struct marshal_cmd_Uniform2iv *) cmd);
      break;
   case DISPATCH_CMD_SampleCoveragex:
      debug_print_unmarshal("SampleCoveragex");
      _mesa_unmarshal_SampleCoveragex(ctx, (const struct marshal_cmd_SampleCoveragex *) cmd);
      break;
   case DISPATCH_CMD_DeleteFramebuffers:
      debug_print_unmarshal("DeleteFramebuffers");
      _mesa_unmarshal_DeleteFramebuffers(ctx, (const struct marshal_cmd_DeleteFramebuffers *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4uiv:
      debug_print_unmarshal("VertexAttrib4uiv");
      _mesa_unmarshal_VertexAttrib4uiv(ctx, (const struct marshal_cmd_VertexAttrib4uiv *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4Nsv:
      debug_print_unmarshal("VertexAttrib4Nsv");
      _mesa_unmarshal_VertexAttrib4Nsv(ctx, (const struct marshal_cmd_VertexAttrib4Nsv *) cmd);
      break;
   case DISPATCH_CMD_Vertex4s:
      debug_print_unmarshal("Vertex4s");
      _mesa_unmarshal_Vertex4s(ctx, (const struct marshal_cmd_Vertex4s *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribI2iEXT:
      debug_print_unmarshal("VertexAttribI2iEXT");
      _mesa_unmarshal_VertexAttribI2iEXT(ctx, (const struct marshal_cmd_VertexAttribI2iEXT *) cmd);
      break;
   case DISPATCH_CMD_Vertex4f:
      debug_print_unmarshal("Vertex4f");
      _mesa_unmarshal_Vertex4f(ctx, (const struct marshal_cmd_Vertex4f *) cmd);
      break;
   case DISPATCH_CMD_Vertex4d:
      debug_print_unmarshal("Vertex4d");
      _mesa_unmarshal_Vertex4d(ctx, (const struct marshal_cmd_Vertex4d *) cmd);
      break;
   case DISPATCH_CMD_Vertex4i:
      debug_print_unmarshal("Vertex4i");
      _mesa_unmarshal_Vertex4i(ctx, (const struct marshal_cmd_Vertex4i *) cmd);
      break;
   case DISPATCH_CMD_MemoryBarrierByRegion:
      debug_print_unmarshal("MemoryBarrierByRegion");
      _mesa_unmarshal_MemoryBarrierByRegion(ctx, (const struct marshal_cmd_MemoryBarrierByRegion *) cmd);
      break;
   case DISPATCH_CMD_StencilFuncSeparateATI:
      debug_print_unmarshal("StencilFuncSeparateATI");
      _mesa_unmarshal_StencilFuncSeparateATI(ctx, (const struct marshal_cmd_StencilFuncSeparateATI *) cmd);
      break;
   case DISPATCH_CMD_Vertex4dv:
      debug_print_unmarshal("Vertex4dv");
      _mesa_unmarshal_Vertex4dv(ctx, (const struct marshal_cmd_Vertex4dv *) cmd);
      break;
   case DISPATCH_CMD_StencilMask:
      debug_print_unmarshal("StencilMask");
      _mesa_unmarshal_StencilMask(ctx, (const struct marshal_cmd_StencilMask *) cmd);
      break;
   case DISPATCH_CMD_NamedFramebufferReadBuffer:
      debug_print_unmarshal("NamedFramebufferReadBuffer");
      _mesa_unmarshal_NamedFramebufferReadBuffer(ctx, (const struct marshal_cmd_NamedFramebufferReadBuffer *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformHandleui64ARB:
      debug_print_unmarshal("ProgramUniformHandleui64ARB");
      _mesa_unmarshal_ProgramUniformHandleui64ARB(ctx, (const struct marshal_cmd_ProgramUniformHandleui64ARB *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform2i64ARB:
      debug_print_unmarshal("ProgramUniform2i64ARB");
      _mesa_unmarshal_ProgramUniform2i64ARB(ctx, (const struct marshal_cmd_ProgramUniform2i64ARB *) cmd);
      break;
   case DISPATCH_CMD_ClearBufferiv:
      debug_print_unmarshal("ClearBufferiv");
      _mesa_unmarshal_ClearBufferiv(ctx, (const struct marshal_cmd_ClearBufferiv *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform2iv:
      debug_print_unmarshal("ProgramUniform2iv");
      _mesa_unmarshal_ProgramUniform2iv(ctx, (const struct marshal_cmd_ProgramUniform2iv *) cmd);
      break;
   case DISPATCH_CMD_FogCoordPointer:
      debug_print_unmarshal("FogCoordPointer");
      _mesa_unmarshal_FogCoordPointer(ctx, (const struct marshal_cmd_FogCoordPointer *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColor3us:
      debug_print_unmarshal("SecondaryColor3us");
      _mesa_unmarshal_SecondaryColor3us(ctx, (const struct marshal_cmd_SecondaryColor3us *) cmd);
      break;
   case DISPATCH_CMD_TextureStorageMem1DEXT:
      debug_print_unmarshal("TextureStorageMem1DEXT");
      _mesa_unmarshal_TextureStorageMem1DEXT(ctx, (const struct marshal_cmd_TextureStorageMem1DEXT *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColor3ub:
      debug_print_unmarshal("SecondaryColor3ub");
      _mesa_unmarshal_SecondaryColor3ub(ctx, (const struct marshal_cmd_SecondaryColor3ub *) cmd);
      break;
   case DISPATCH_CMD_NamedBufferStorageMemEXT:
      debug_print_unmarshal("NamedBufferStorageMemEXT");
      _mesa_unmarshal_NamedBufferStorageMemEXT(ctx, (const struct marshal_cmd_NamedBufferStorageMemEXT *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColor3ui:
      debug_print_unmarshal("SecondaryColor3ui");
      _mesa_unmarshal_SecondaryColor3ui(ctx, (const struct marshal_cmd_SecondaryColor3ui *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform4ui64ARB:
      debug_print_unmarshal("ProgramUniform4ui64ARB");
      _mesa_unmarshal_ProgramUniform4ui64ARB(ctx, (const struct marshal_cmd_ProgramUniform4ui64ARB *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib1sNV:
      debug_print_unmarshal("VertexAttrib1sNV");
      _mesa_unmarshal_VertexAttrib1sNV(ctx, (const struct marshal_cmd_VertexAttrib1sNV *) cmd);
      break;
   case DISPATCH_CMD_TextureBuffer:
      debug_print_unmarshal("TextureBuffer");
      _mesa_unmarshal_TextureBuffer(ctx, (const struct marshal_cmd_TextureBuffer *) cmd);
      break;
   case DISPATCH_CMD_InitNames:
      debug_print_unmarshal("InitNames");
      _mesa_unmarshal_InitNames(ctx, (const struct marshal_cmd_InitNames *) cmd);
      break;
   case DISPATCH_CMD_Normal3sv:
      debug_print_unmarshal("Normal3sv");
      _mesa_unmarshal_Normal3sv(ctx, (const struct marshal_cmd_Normal3sv *) cmd);
      break;
   case DISPATCH_CMD_DeleteQueries:
      debug_print_unmarshal("DeleteQueries");
      _mesa_unmarshal_DeleteQueries(ctx, (const struct marshal_cmd_DeleteQueries *) cmd);
      break;
   case DISPATCH_CMD_InvalidateFramebuffer:
      debug_print_unmarshal("InvalidateFramebuffer");
      _mesa_unmarshal_InvalidateFramebuffer(ctx, (const struct marshal_cmd_InvalidateFramebuffer *) cmd);
      break;
   case DISPATCH_CMD_Hint:
      debug_print_unmarshal("Hint");
      _mesa_unmarshal_Hint(ctx, (const struct marshal_cmd_Hint *) cmd);
      break;
   case DISPATCH_CMD_MemoryBarrier:
      debug_print_unmarshal("MemoryBarrier");
      _mesa_unmarshal_MemoryBarrier(ctx, (const struct marshal_cmd_MemoryBarrier *) cmd);
      break;
   case DISPATCH_CMD_CopyColorSubTable:
      debug_print_unmarshal("CopyColorSubTable");
      _mesa_unmarshal_CopyColorSubTable(ctx, (const struct marshal_cmd_CopyColorSubTable *) cmd);
      break;
   case DISPATCH_CMD_DrawTexsvOES:
      debug_print_unmarshal("DrawTexsvOES");
      _mesa_unmarshal_DrawTexsvOES(ctx, (const struct marshal_cmd_DrawTexsvOES *) cmd);
      break;
   case DISPATCH_CMD_Disable:
      debug_print_unmarshal("Disable");
      _mesa_unmarshal_Disable(ctx, (const struct marshal_cmd_Disable *) cmd);
      break;
   case DISPATCH_CMD_ClearColor:
      debug_print_unmarshal("ClearColor");
      _mesa_unmarshal_ClearColor(ctx, (const struct marshal_cmd_ClearColor *) cmd);
      break;
   case DISPATCH_CMD_RasterPos4iv:
      debug_print_unmarshal("RasterPos4iv");
      _mesa_unmarshal_RasterPos4iv(ctx, (const struct marshal_cmd_RasterPos4iv *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix2x3fv:
      debug_print_unmarshal("ProgramUniformMatrix2x3fv");
      _mesa_unmarshal_ProgramUniformMatrix2x3fv(ctx, (const struct marshal_cmd_ProgramUniformMatrix2x3fv *) cmd);
      break;
   case DISPATCH_CMD_BindVertexBuffer:
      debug_print_unmarshal("BindVertexBuffer");
      _mesa_unmarshal_BindVertexBuffer(ctx, (const struct marshal_cmd_BindVertexBuffer *) cmd);
      break;
   case DISPATCH_CMD_RasterPos4i:
      debug_print_unmarshal("RasterPos4i");
      _mesa_unmarshal_RasterPos4i(ctx, (const struct marshal_cmd_RasterPos4i *) cmd);
      break;
   case DISPATCH_CMD_RasterPos4d:
      debug_print_unmarshal("RasterPos4d");
      _mesa_unmarshal_RasterPos4d(ctx, (const struct marshal_cmd_RasterPos4d *) cmd);
      break;
   case DISPATCH_CMD_RasterPos4f:
      debug_print_unmarshal("RasterPos4f");
      _mesa_unmarshal_RasterPos4f(ctx, (const struct marshal_cmd_RasterPos4f *) cmd);
      break;
   case DISPATCH_CMD_RasterPos3dv:
      debug_print_unmarshal("RasterPos3dv");
      _mesa_unmarshal_RasterPos3dv(ctx, (const struct marshal_cmd_RasterPos3dv *) cmd);
      break;
   case DISPATCH_CMD_TexCoord1iv:
      debug_print_unmarshal("TexCoord1iv");
      _mesa_unmarshal_TexCoord1iv(ctx, (const struct marshal_cmd_TexCoord1iv *) cmd);
      break;
   case DISPATCH_CMD_RasterPos4s:
      debug_print_unmarshal("RasterPos4s");
      _mesa_unmarshal_RasterPos4s(ctx, (const struct marshal_cmd_RasterPos4s *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib3dv:
      debug_print_unmarshal("VertexAttrib3dv");
      _mesa_unmarshal_VertexAttrib3dv(ctx, (const struct marshal_cmd_VertexAttrib3dv *) cmd);
      break;
   case DISPATCH_CMD_Histogram:
      debug_print_unmarshal("Histogram");
      _mesa_unmarshal_Histogram(ctx, (const struct marshal_cmd_Histogram *) cmd);
      break;
   case DISPATCH_CMD_Uniform2fv:
      debug_print_unmarshal("Uniform2fv");
      _mesa_unmarshal_Uniform2fv(ctx, (const struct marshal_cmd_Uniform2fv *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix3x4dv:
      debug_print_unmarshal("ProgramUniformMatrix3x4dv");
      _mesa_unmarshal_ProgramUniformMatrix3x4dv(ctx, (const struct marshal_cmd_ProgramUniformMatrix3x4dv *) cmd);
      break;
   case DISPATCH_CMD_DrawBuffers:
      debug_print_unmarshal("DrawBuffers");
      _mesa_unmarshal_DrawBuffers(ctx, (const struct marshal_cmd_DrawBuffers *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribL1ui64ARB:
      debug_print_unmarshal("VertexAttribL1ui64ARB");
      _mesa_unmarshal_VertexAttribL1ui64ARB(ctx, (const struct marshal_cmd_VertexAttribL1ui64ARB *) cmd);
      break;
   case DISPATCH_CMD_Color3uiv:
      debug_print_unmarshal("Color3uiv");
      _mesa_unmarshal_Color3uiv(ctx, (const struct marshal_cmd_Color3uiv *) cmd);
      break;
   case DISPATCH_CMD_EvalCoord2fv:
      debug_print_unmarshal("EvalCoord2fv");
      _mesa_unmarshal_EvalCoord2fv(ctx, (const struct marshal_cmd_EvalCoord2fv *) cmd);
      break;
   case DISPATCH_CMD_TextureStorage3DEXT:
      debug_print_unmarshal("TextureStorage3DEXT");
      _mesa_unmarshal_TextureStorage3DEXT(ctx, (const struct marshal_cmd_TextureStorage3DEXT *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib2fARB:
      debug_print_unmarshal("VertexAttrib2fARB");
      _mesa_unmarshal_VertexAttrib2fARB(ctx, (const struct marshal_cmd_VertexAttrib2fARB *) cmd);
      break;
   case DISPATCH_CMD_BeginPerfMonitorAMD:
      debug_print_unmarshal("BeginPerfMonitorAMD");
      _mesa_unmarshal_BeginPerfMonitorAMD(ctx, (const struct marshal_cmd_BeginPerfMonitorAMD *) cmd);
      break;
   case DISPATCH_CMD_Normal3bv:
      debug_print_unmarshal("Normal3bv");
      _mesa_unmarshal_Normal3bv(ctx, (const struct marshal_cmd_Normal3bv *) cmd);
      break;
   case DISPATCH_CMD_BeginQueryIndexed:
      debug_print_unmarshal("BeginQueryIndexed");
      _mesa_unmarshal_BeginQueryIndexed(ctx, (const struct marshal_cmd_BeginQueryIndexed *) cmd);
      break;
   case DISPATCH_CMD_Vertex3iv:
      debug_print_unmarshal("Vertex3iv");
      _mesa_unmarshal_Vertex3iv(ctx, (const struct marshal_cmd_Vertex3iv *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix2x3dv:
      debug_print_unmarshal("UniformMatrix2x3dv");
      _mesa_unmarshal_UniformMatrix2x3dv(ctx, (const struct marshal_cmd_UniformMatrix2x3dv *) cmd);
      break;
   case DISPATCH_CMD_TexCoord3dv:
      debug_print_unmarshal("TexCoord3dv");
      _mesa_unmarshal_TexCoord3dv(ctx, (const struct marshal_cmd_TexCoord3dv *) cmd);
      break;
   case DISPATCH_CMD_VertexP3ui:
      debug_print_unmarshal("VertexP3ui");
      _mesa_unmarshal_VertexP3ui(ctx, (const struct marshal_cmd_VertexP3ui *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix3fv:
      debug_print_unmarshal("UniformMatrix3fv");
      _mesa_unmarshal_UniformMatrix3fv(ctx, (const struct marshal_cmd_UniformMatrix3fv *) cmd);
      break;
   case DISPATCH_CMD_PrioritizeTextures:
      debug_print_unmarshal("PrioritizeTextures");
      _mesa_unmarshal_PrioritizeTextures(ctx, (const struct marshal_cmd_PrioritizeTextures *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribI3uiEXT:
      debug_print_unmarshal("VertexAttribI3uiEXT");
      _mesa_unmarshal_VertexAttribI3uiEXT(ctx, (const struct marshal_cmd_VertexAttribI3uiEXT *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform1i64ARB:
      debug_print_unmarshal("ProgramUniform1i64ARB");
      _mesa_unmarshal_ProgramUniform1i64ARB(ctx, (const struct marshal_cmd_ProgramUniform1i64ARB *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColor3uiv:
      debug_print_unmarshal("SecondaryColor3uiv");
      _mesa_unmarshal_SecondaryColor3uiv(ctx, (const struct marshal_cmd_SecondaryColor3uiv *) cmd);
      break;
   case DISPATCH_CMD_EndConditionalRender:
      debug_print_unmarshal("EndConditionalRender");
      _mesa_unmarshal_EndConditionalRender(ctx, (const struct marshal_cmd_EndConditionalRender *) cmd);
      break;
   case DISPATCH_CMD_ProgramLocalParameter4dARB:
      debug_print_unmarshal("ProgramLocalParameter4dARB");
      _mesa_unmarshal_ProgramLocalParameter4dARB(ctx, (const struct marshal_cmd_ProgramLocalParameter4dARB *) cmd);
      break;
   case DISPATCH_CMD_Color3sv:
      debug_print_unmarshal("Color3sv");
      _mesa_unmarshal_Color3sv(ctx, (const struct marshal_cmd_Color3sv *) cmd);
      break;
   case DISPATCH_CMD_BlendEquationSeparateiARB:
      debug_print_unmarshal("BlendEquationSeparateiARB");
      _mesa_unmarshal_BlendEquationSeparateiARB(ctx, (const struct marshal_cmd_BlendEquationSeparateiARB *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord1fvARB:
      debug_print_unmarshal("MultiTexCoord1fvARB");
      _mesa_unmarshal_MultiTexCoord1fvARB(ctx, (const struct marshal_cmd_MultiTexCoord1fvARB *) cmd);
      break;
   case DISPATCH_CMD_TexStorage2D:
      debug_print_unmarshal("TexStorage2D");
      _mesa_unmarshal_TexStorage2D(ctx, (const struct marshal_cmd_TexStorage2D *) cmd);
      break;
   case DISPATCH_CMD_FramebufferTexture2D:
      debug_print_unmarshal("FramebufferTexture2D");
      _mesa_unmarshal_FramebufferTexture2D(ctx, (const struct marshal_cmd_FramebufferTexture2D *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib2dv:
      debug_print_unmarshal("VertexAttrib2dv");
      _mesa_unmarshal_VertexAttrib2dv(ctx, (const struct marshal_cmd_VertexAttrib2dv *) cmd);
      break;
   case DISPATCH_CMD_Vertex4sv:
      debug_print_unmarshal("Vertex4sv");
      _mesa_unmarshal_Vertex4sv(ctx, (const struct marshal_cmd_Vertex4sv *) cmd);
      break;
   case DISPATCH_CMD_ClampColor:
      debug_print_unmarshal("ClampColor");
      _mesa_unmarshal_ClampColor(ctx, (const struct marshal_cmd_ClampColor *) cmd);
      break;
   case DISPATCH_CMD_Uniform1i64ARB:
      debug_print_unmarshal("Uniform1i64ARB");
      _mesa_unmarshal_Uniform1i64ARB(ctx, (const struct marshal_cmd_Uniform1i64ARB *) cmd);
      break;
   case DISPATCH_CMD_AlphaFunc:
      debug_print_unmarshal("AlphaFunc");
      _mesa_unmarshal_AlphaFunc(ctx, (const struct marshal_cmd_AlphaFunc *) cmd);
      break;
   case DISPATCH_CMD_EdgeFlag:
      debug_print_unmarshal("EdgeFlag");
      _mesa_unmarshal_EdgeFlag(ctx, (const struct marshal_cmd_EdgeFlag *) cmd);
      break;
   case DISPATCH_CMD_EdgeFlagv:
      debug_print_unmarshal("EdgeFlagv");
      _mesa_unmarshal_EdgeFlagv(ctx, (const struct marshal_cmd_EdgeFlagv *) cmd);
      break;
   case DISPATCH_CMD_DepthRangex:
      debug_print_unmarshal("DepthRangex");
      _mesa_unmarshal_DepthRangex(ctx, (const struct marshal_cmd_DepthRangex *) cmd);
      break;
   case DISPATCH_CMD_DepthRangef:
      debug_print_unmarshal("DepthRangef");
      _mesa_unmarshal_DepthRangef(ctx, (const struct marshal_cmd_DepthRangef *) cmd);
      break;
   case DISPATCH_CMD_ColorFragmentOp3ATI:
      debug_print_unmarshal("ColorFragmentOp3ATI");
      _mesa_unmarshal_ColorFragmentOp3ATI(ctx, (const struct marshal_cmd_ColorFragmentOp3ATI *) cmd);
      break;
   case DISPATCH_CMD_ValidateProgram:
      debug_print_unmarshal("ValidateProgram");
      _mesa_unmarshal_ValidateProgram(ctx, (const struct marshal_cmd_ValidateProgram *) cmd);
      break;
   case DISPATCH_CMD_VertexPointerEXT:
      debug_print_unmarshal("VertexPointerEXT");
      _mesa_unmarshal_VertexPointerEXT(ctx, (const struct marshal_cmd_VertexPointerEXT *) cmd);
      break;
   case DISPATCH_CMD_Scissor:
      debug_print_unmarshal("Scissor");
      _mesa_unmarshal_Scissor(ctx, (const struct marshal_cmd_Scissor *) cmd);
      break;
   case DISPATCH_CMD_BeginTransformFeedback:
      debug_print_unmarshal("BeginTransformFeedback");
      _mesa_unmarshal_BeginTransformFeedback(ctx, (const struct marshal_cmd_BeginTransformFeedback *) cmd);
      break;
   case DISPATCH_CMD_TexCoord2i:
      debug_print_unmarshal("TexCoord2i");
      _mesa_unmarshal_TexCoord2i(ctx, (const struct marshal_cmd_TexCoord2i *) cmd);
      break;
   case DISPATCH_CMD_VertexArrayAttribBinding:
      debug_print_unmarshal("VertexArrayAttribBinding");
      _mesa_unmarshal_VertexArrayAttribBinding(ctx, (const struct marshal_cmd_VertexArrayAttribBinding *) cmd);
      break;
   case DISPATCH_CMD_Color4ui:
      debug_print_unmarshal("Color4ui");
      _mesa_unmarshal_Color4ui(ctx, (const struct marshal_cmd_Color4ui *) cmd);
      break;
   case DISPATCH_CMD_TexCoord2f:
      debug_print_unmarshal("TexCoord2f");
      _mesa_unmarshal_TexCoord2f(ctx, (const struct marshal_cmd_TexCoord2f *) cmd);
      break;
   case DISPATCH_CMD_TexCoord2d:
      debug_print_unmarshal("TexCoord2d");
      _mesa_unmarshal_TexCoord2d(ctx, (const struct marshal_cmd_TexCoord2d *) cmd);
      break;
   case DISPATCH_CMD_TexCoord2s:
      debug_print_unmarshal("TexCoord2s");
      _mesa_unmarshal_TexCoord2s(ctx, (const struct marshal_cmd_TexCoord2s *) cmd);
      break;
   case DISPATCH_CMD_Color4us:
      debug_print_unmarshal("Color4us");
      _mesa_unmarshal_Color4us(ctx, (const struct marshal_cmd_Color4us *) cmd);
      break;
   case DISPATCH_CMD_Color3bv:
      debug_print_unmarshal("Color3bv");
      _mesa_unmarshal_Color3bv(ctx, (const struct marshal_cmd_Color3bv *) cmd);
      break;
   case DISPATCH_CMD_PrimitiveRestartNV:
      debug_print_unmarshal("PrimitiveRestartNV");
      _mesa_unmarshal_PrimitiveRestartNV(ctx, (const struct marshal_cmd_PrimitiveRestartNV *) cmd);
      break;
   case DISPATCH_CMD_BindBufferOffsetEXT:
      debug_print_unmarshal("BindBufferOffsetEXT");
      _mesa_unmarshal_BindBufferOffsetEXT(ctx, (const struct marshal_cmd_BindBufferOffsetEXT *) cmd);
      break;
   case DISPATCH_CMD_ProvokingVertex:
      debug_print_unmarshal("ProvokingVertex");
      _mesa_unmarshal_ProvokingVertex(ctx, (const struct marshal_cmd_ProvokingVertex *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribs4fvNV:
      debug_print_unmarshal("VertexAttribs4fvNV");
      _mesa_unmarshal_VertexAttribs4fvNV(ctx, (const struct marshal_cmd_VertexAttribs4fvNV *) cmd);
      break;
   case DISPATCH_CMD_Vertex2i:
      debug_print_unmarshal("Vertex2i");
      _mesa_unmarshal_Vertex2i(ctx, (const struct marshal_cmd_Vertex2i *) cmd);
      break;
   case DISPATCH_CMD_GetQueryBufferObjecti64v:
      debug_print_unmarshal("GetQueryBufferObjecti64v");
      _mesa_unmarshal_GetQueryBufferObjecti64v(ctx, (const struct marshal_cmd_GetQueryBufferObjecti64v *) cmd);
      break;
   case DISPATCH_CMD_RasterPos2fv:
      debug_print_unmarshal("RasterPos2fv");
      _mesa_unmarshal_RasterPos2fv(ctx, (const struct marshal_cmd_RasterPos2fv *) cmd);
      break;
   case DISPATCH_CMD_TexCoord1fv:
      debug_print_unmarshal("TexCoord1fv");
      _mesa_unmarshal_TexCoord1fv(ctx, (const struct marshal_cmd_TexCoord1fv *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord4dv:
      debug_print_unmarshal("MultiTexCoord4dv");
      _mesa_unmarshal_MultiTexCoord4dv(ctx, (const struct marshal_cmd_MultiTexCoord4dv *) cmd);
      break;
   case DISPATCH_CMD_ProgramEnvParameter4fvARB:
      debug_print_unmarshal("ProgramEnvParameter4fvARB");
      _mesa_unmarshal_ProgramEnvParameter4fvARB(ctx, (const struct marshal_cmd_ProgramEnvParameter4fvARB *) cmd);
      break;
   case DISPATCH_CMD_RasterPos4fv:
      debug_print_unmarshal("RasterPos4fv");
      _mesa_unmarshal_RasterPos4fv(ctx, (const struct marshal_cmd_RasterPos4fv *) cmd);
      break;
   case DISPATCH_CMD_PushMatrix:
      debug_print_unmarshal("PushMatrix");
      _mesa_unmarshal_PushMatrix(ctx, (const struct marshal_cmd_PushMatrix *) cmd);
      break;
   case DISPATCH_CMD_EndList:
      debug_print_unmarshal("EndList");
      _mesa_unmarshal_EndList(ctx, (const struct marshal_cmd_EndList *) cmd);
      break;
   case DISPATCH_CMD_DrawRangeElements:
      debug_print_unmarshal("DrawRangeElements");
      _mesa_unmarshal_DrawRangeElements(ctx, (const struct marshal_cmd_DrawRangeElements *) cmd);
      break;
   case DISPATCH_CMD_DrawTexfvOES:
      debug_print_unmarshal("DrawTexfvOES");
      _mesa_unmarshal_DrawTexfvOES(ctx, (const struct marshal_cmd_DrawTexfvOES *) cmd);
      break;
   case DISPATCH_CMD_BlendFunciARB:
      debug_print_unmarshal("BlendFunciARB");
      _mesa_unmarshal_BlendFunciARB(ctx, (const struct marshal_cmd_BlendFunciARB *) cmd);
      break;
   case DISPATCH_CMD_ClearNamedFramebufferfi:
      debug_print_unmarshal("ClearNamedFramebufferfi");
      _mesa_unmarshal_ClearNamedFramebufferfi(ctx, (const struct marshal_cmd_ClearNamedFramebufferfi *) cmd);
      break;
   case DISPATCH_CMD_Uniform2ui:
      debug_print_unmarshal("Uniform2ui");
      _mesa_unmarshal_Uniform2ui(ctx, (const struct marshal_cmd_Uniform2ui *) cmd);
      break;
   case DISPATCH_CMD_ScissorIndexed:
      debug_print_unmarshal("ScissorIndexed");
      _mesa_unmarshal_ScissorIndexed(ctx, (const struct marshal_cmd_ScissorIndexed *) cmd);
      break;
   case DISPATCH_CMD_End:
      debug_print_unmarshal("End");
      _mesa_unmarshal_End(ctx, (const struct marshal_cmd_End *) cmd);
      break;
   case DISPATCH_CMD_Enable:
      debug_print_unmarshal("Enable");
      _mesa_unmarshal_Enable(ctx, (const struct marshal_cmd_Enable *) cmd);
      break;
   case DISPATCH_CMD_Normal3x:
      debug_print_unmarshal("Normal3x");
      _mesa_unmarshal_Normal3x(ctx, (const struct marshal_cmd_Normal3x *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4fARB:
      debug_print_unmarshal("VertexAttrib4fARB");
      _mesa_unmarshal_VertexAttrib4fARB(ctx, (const struct marshal_cmd_VertexAttrib4fARB *) cmd);
      break;
   case DISPATCH_CMD_TexCoord4fv:
      debug_print_unmarshal("TexCoord4fv");
      _mesa_unmarshal_TexCoord4fv(ctx, (const struct marshal_cmd_TexCoord4fv *) cmd);
      break;
   case DISPATCH_CMD_InvalidateTexSubImage:
      debug_print_unmarshal("InvalidateTexSubImage");
      _mesa_unmarshal_InvalidateTexSubImage(ctx, (const struct marshal_cmd_InvalidateTexSubImage *) cmd);
      break;
   case DISPATCH_CMD_Normal3s:
      debug_print_unmarshal("Normal3s");
      _mesa_unmarshal_Normal3s(ctx, (const struct marshal_cmd_Normal3s *) cmd);
      break;
   case DISPATCH_CMD_Normal3i:
      debug_print_unmarshal("Normal3i");
      _mesa_unmarshal_Normal3i(ctx, (const struct marshal_cmd_Normal3i *) cmd);
      break;
   case DISPATCH_CMD_Normal3b:
      debug_print_unmarshal("Normal3b");
      _mesa_unmarshal_Normal3b(ctx, (const struct marshal_cmd_Normal3b *) cmd);
      break;
   case DISPATCH_CMD_Normal3d:
      debug_print_unmarshal("Normal3d");
      _mesa_unmarshal_Normal3d(ctx, (const struct marshal_cmd_Normal3d *) cmd);
      break;
   case DISPATCH_CMD_Normal3f:
      debug_print_unmarshal("Normal3f");
      _mesa_unmarshal_Normal3f(ctx, (const struct marshal_cmd_Normal3f *) cmd);
      break;
   case DISPATCH_CMD_Indexi:
      debug_print_unmarshal("Indexi");
      _mesa_unmarshal_Indexi(ctx, (const struct marshal_cmd_Indexi *) cmd);
      break;
   case DISPATCH_CMD_Uniform1uiv:
      debug_print_unmarshal("Uniform1uiv");
      _mesa_unmarshal_Uniform1uiv(ctx, (const struct marshal_cmd_Uniform1uiv *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribI2uiEXT:
      debug_print_unmarshal("VertexAttribI2uiEXT");
      _mesa_unmarshal_VertexAttribI2uiEXT(ctx, (const struct marshal_cmd_VertexAttribI2uiEXT *) cmd);
      break;
   case DISPATCH_CMD_Indexf:
      debug_print_unmarshal("Indexf");
      _mesa_unmarshal_Indexf(ctx, (const struct marshal_cmd_Indexf *) cmd);
      break;
   case DISPATCH_CMD_Indexd:
      debug_print_unmarshal("Indexd");
      _mesa_unmarshal_Indexd(ctx, (const struct marshal_cmd_Indexd *) cmd);
      break;
   case DISPATCH_CMD_Indexs:
      debug_print_unmarshal("Indexs");
      _mesa_unmarshal_Indexs(ctx, (const struct marshal_cmd_Indexs *) cmd);
      break;
   case DISPATCH_CMD_Vertex2d:
      debug_print_unmarshal("Vertex2d");
      _mesa_unmarshal_Vertex2d(ctx, (const struct marshal_cmd_Vertex2d *) cmd);
      break;
   case DISPATCH_CMD_Vertex2f:
      debug_print_unmarshal("Vertex2f");
      _mesa_unmarshal_Vertex2f(ctx, (const struct marshal_cmd_Vertex2f *) cmd);
      break;
   case DISPATCH_CMD_Color4bv:
      debug_print_unmarshal("Color4bv");
      _mesa_unmarshal_Color4bv(ctx, (const struct marshal_cmd_Color4bv *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix3x2dv:
      debug_print_unmarshal("ProgramUniformMatrix3x2dv");
      _mesa_unmarshal_ProgramUniformMatrix3x2dv(ctx, (const struct marshal_cmd_ProgramUniformMatrix3x2dv *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib2fvNV:
      debug_print_unmarshal("VertexAttrib2fvNV");
      _mesa_unmarshal_VertexAttrib2fvNV(ctx, (const struct marshal_cmd_VertexAttrib2fvNV *) cmd);
      break;
   case DISPATCH_CMD_Vertex2s:
      debug_print_unmarshal("Vertex2s");
      _mesa_unmarshal_Vertex2s(ctx, (const struct marshal_cmd_Vertex2s *) cmd);
      break;
   case DISPATCH_CMD_ActiveTexture:
      debug_print_unmarshal("ActiveTexture");
      _mesa_unmarshal_ActiveTexture(ctx, (const struct marshal_cmd_ActiveTexture *) cmd);
      break;
   case DISPATCH_CMD_DrawTexxOES:
      debug_print_unmarshal("DrawTexxOES");
      _mesa_unmarshal_DrawTexxOES(ctx, (const struct marshal_cmd_DrawTexxOES *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoordP3ui:
      debug_print_unmarshal("MultiTexCoordP3ui");
      _mesa_unmarshal_MultiTexCoordP3ui(ctx, (const struct marshal_cmd_MultiTexCoordP3ui *) cmd);
      break;
   case DISPATCH_CMD_DrawBuffer:
      debug_print_unmarshal("DrawBuffer");
      _mesa_unmarshal_DrawBuffer(ctx, (const struct marshal_cmd_DrawBuffer *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord2dv:
      debug_print_unmarshal("MultiTexCoord2dv");
      _mesa_unmarshal_MultiTexCoord2dv(ctx, (const struct marshal_cmd_MultiTexCoord2dv *) cmd);
      break;
   case DISPATCH_CMD_BlendFunc:
      debug_print_unmarshal("BlendFunc");
      _mesa_unmarshal_BlendFunc(ctx, (const struct marshal_cmd_BlendFunc *) cmd);
      break;
   case DISPATCH_CMD_NamedRenderbufferStorageMultisample:
      debug_print_unmarshal("NamedRenderbufferStorageMultisample");
      _mesa_unmarshal_NamedRenderbufferStorageMultisample(ctx, (const struct marshal_cmd_NamedRenderbufferStorageMultisample *) cmd);
      break;
   case DISPATCH_CMD_ColorMaterial:
      debug_print_unmarshal("ColorMaterial");
      _mesa_unmarshal_ColorMaterial(ctx, (const struct marshal_cmd_ColorMaterial *) cmd);
      break;
   case DISPATCH_CMD_RasterPos3sv:
      debug_print_unmarshal("RasterPos3sv");
      _mesa_unmarshal_RasterPos3sv(ctx, (const struct marshal_cmd_RasterPos3sv *) cmd);
      break;
   case DISPATCH_CMD_TexCoordP2ui:
      debug_print_unmarshal("TexCoordP2ui");
      _mesa_unmarshal_TexCoordP2ui(ctx, (const struct marshal_cmd_TexCoordP2ui *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib3fvARB:
      debug_print_unmarshal("VertexAttrib3fvARB");
      _mesa_unmarshal_VertexAttrib3fvARB(ctx, (const struct marshal_cmd_VertexAttrib3fvARB *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix3x4fv:
      debug_print_unmarshal("ProgramUniformMatrix3x4fv");
      _mesa_unmarshal_ProgramUniformMatrix3x4fv(ctx, (const struct marshal_cmd_ProgramUniformMatrix3x4fv *) cmd);
      break;
   case DISPATCH_CMD_TexCoord3i:
      debug_print_unmarshal("TexCoord3i");
      _mesa_unmarshal_TexCoord3i(ctx, (const struct marshal_cmd_TexCoord3i *) cmd);
      break;
   case DISPATCH_CMD_CopyColorTable:
      debug_print_unmarshal("CopyColorTable");
      _mesa_unmarshal_CopyColorTable(ctx, (const struct marshal_cmd_CopyColorTable *) cmd);
      break;
   case DISPATCH_CMD_Frustum:
      debug_print_unmarshal("Frustum");
      _mesa_unmarshal_Frustum(ctx, (const struct marshal_cmd_Frustum *) cmd);
      break;
   case DISPATCH_CMD_TexCoord3d:
      debug_print_unmarshal("TexCoord3d");
      _mesa_unmarshal_TexCoord3d(ctx, (const struct marshal_cmd_TexCoord3d *) cmd);
      break;
   case DISPATCH_CMD_TexCoord3f:
      debug_print_unmarshal("TexCoord3f");
      _mesa_unmarshal_TexCoord3f(ctx, (const struct marshal_cmd_TexCoord3f *) cmd);
      break;
   case DISPATCH_CMD_DepthRangeArrayv:
      debug_print_unmarshal("DepthRangeArrayv");
      _mesa_unmarshal_DepthRangeArrayv(ctx, (const struct marshal_cmd_DepthRangeArrayv *) cmd);
      break;
   case DISPATCH_CMD_DeleteTextures:
      debug_print_unmarshal("DeleteTextures");
      _mesa_unmarshal_DeleteTextures(ctx, (const struct marshal_cmd_DeleteTextures *) cmd);
      break;
   case DISPATCH_CMD_TexCoordPointerEXT:
      debug_print_unmarshal("TexCoordPointerEXT");
      _mesa_unmarshal_TexCoordPointerEXT(ctx, (const struct marshal_cmd_TexCoordPointerEXT *) cmd);
      break;
   case DISPATCH_CMD_TexCoord3s:
      debug_print_unmarshal("TexCoord3s");
      _mesa_unmarshal_TexCoord3s(ctx, (const struct marshal_cmd_TexCoord3s *) cmd);
      break;
   case DISPATCH_CMD_ClearAccum:
      debug_print_unmarshal("ClearAccum");
      _mesa_unmarshal_ClearAccum(ctx, (const struct marshal_cmd_ClearAccum *) cmd);
      break;
   case DISPATCH_CMD_TexCoord4iv:
      debug_print_unmarshal("TexCoord4iv");
      _mesa_unmarshal_TexCoord4iv(ctx, (const struct marshal_cmd_TexCoord4iv *) cmd);
      break;
   case DISPATCH_CMD_TexStorage3D:
      debug_print_unmarshal("TexStorage3D");
      _mesa_unmarshal_TexStorage3D(ctx, (const struct marshal_cmd_TexStorage3D *) cmd);
      break;
   case DISPATCH_CMD_Uniform2i64ARB:
      debug_print_unmarshal("Uniform2i64ARB");
      _mesa_unmarshal_Uniform2i64ARB(ctx, (const struct marshal_cmd_Uniform2i64ARB *) cmd);
      break;
   case DISPATCH_CMD_FramebufferTexture3D:
      debug_print_unmarshal("FramebufferTexture3D");
      _mesa_unmarshal_FramebufferTexture3D(ctx, (const struct marshal_cmd_FramebufferTexture3D *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib2fNV:
      debug_print_unmarshal("VertexAttrib2fNV");
      _mesa_unmarshal_VertexAttrib2fNV(ctx, (const struct marshal_cmd_VertexAttrib2fNV *) cmd);
      break;
   case DISPATCH_CMD_CopyTexImage2D:
      debug_print_unmarshal("CopyTexImage2D");
      _mesa_unmarshal_CopyTexImage2D(ctx, (const struct marshal_cmd_CopyTexImage2D *) cmd);
      break;
   case DISPATCH_CMD_Vertex3fv:
      debug_print_unmarshal("Vertex3fv");
      _mesa_unmarshal_Vertex3fv(ctx, (const struct marshal_cmd_Vertex3fv *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform2i64vARB:
      debug_print_unmarshal("ProgramUniform2i64vARB");
      _mesa_unmarshal_ProgramUniform2i64vARB(ctx, (const struct marshal_cmd_ProgramUniform2i64vARB *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoordP2ui:
      debug_print_unmarshal("MultiTexCoordP2ui");
      _mesa_unmarshal_MultiTexCoordP2ui(ctx, (const struct marshal_cmd_MultiTexCoordP2ui *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribs1dvNV:
      debug_print_unmarshal("VertexAttribs1dvNV");
      _mesa_unmarshal_VertexAttribs1dvNV(ctx, (const struct marshal_cmd_VertexAttribs1dvNV *) cmd);
      break;
   case DISPATCH_CMD_ImportSemaphoreFdEXT:
      debug_print_unmarshal("ImportSemaphoreFdEXT");
      _mesa_unmarshal_ImportSemaphoreFdEXT(ctx, (const struct marshal_cmd_ImportSemaphoreFdEXT *) cmd);
      break;
   case DISPATCH_CMD_EdgeFlagPointerEXT:
      debug_print_unmarshal("EdgeFlagPointerEXT");
      _mesa_unmarshal_EdgeFlagPointerEXT(ctx, (const struct marshal_cmd_EdgeFlagPointerEXT *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribs2svNV:
      debug_print_unmarshal("VertexAttribs2svNV");
      _mesa_unmarshal_VertexAttribs2svNV(ctx, (const struct marshal_cmd_VertexAttribs2svNV *) cmd);
      break;
   case DISPATCH_CMD_BlendEquationiARB:
      debug_print_unmarshal("BlendEquationiARB");
      _mesa_unmarshal_BlendEquationiARB(ctx, (const struct marshal_cmd_BlendEquationiARB *) cmd);
      break;
   case DISPATCH_CMD_PointSizex:
      debug_print_unmarshal("PointSizex");
      _mesa_unmarshal_PointSizex(ctx, (const struct marshal_cmd_PointSizex *) cmd);
      break;
   case DISPATCH_CMD_PolygonMode:
      debug_print_unmarshal("PolygonMode");
      _mesa_unmarshal_PolygonMode(ctx, (const struct marshal_cmd_PolygonMode *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColor3iv:
      debug_print_unmarshal("SecondaryColor3iv");
      _mesa_unmarshal_SecondaryColor3iv(ctx, (const struct marshal_cmd_SecondaryColor3iv *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribI1iEXT:
      debug_print_unmarshal("VertexAttribI1iEXT");
      _mesa_unmarshal_VertexAttribI1iEXT(ctx, (const struct marshal_cmd_VertexAttribI1iEXT *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4Niv:
      debug_print_unmarshal("VertexAttrib4Niv");
      _mesa_unmarshal_VertexAttrib4Niv(ctx, (const struct marshal_cmd_VertexAttrib4Niv *) cmd);
      break;
   case DISPATCH_CMD_LinkProgram:
      debug_print_unmarshal("LinkProgram");
      _mesa_unmarshal_LinkProgram(ctx, (const struct marshal_cmd_LinkProgram *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform4d:
      debug_print_unmarshal("ProgramUniform4d");
      _mesa_unmarshal_ProgramUniform4d(ctx, (const struct marshal_cmd_ProgramUniform4d *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform4f:
      debug_print_unmarshal("ProgramUniform4f");
      _mesa_unmarshal_ProgramUniform4f(ctx, (const struct marshal_cmd_ProgramUniform4f *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform4i:
      debug_print_unmarshal("ProgramUniform4i");
      _mesa_unmarshal_ProgramUniform4i(ctx, (const struct marshal_cmd_ProgramUniform4i *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4d:
      debug_print_unmarshal("VertexAttrib4d");
      _mesa_unmarshal_VertexAttrib4d(ctx, (const struct marshal_cmd_VertexAttrib4d *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform4ui64vARB:
      debug_print_unmarshal("ProgramUniform4ui64vARB");
      _mesa_unmarshal_ProgramUniform4ui64vARB(ctx, (const struct marshal_cmd_ProgramUniform4ui64vARB *) cmd);
      break;
   case DISPATCH_CMD_WindowPos4sMESA:
      debug_print_unmarshal("WindowPos4sMESA");
      _mesa_unmarshal_WindowPos4sMESA(ctx, (const struct marshal_cmd_WindowPos4sMESA *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4s:
      debug_print_unmarshal("VertexAttrib4s");
      _mesa_unmarshal_VertexAttrib4s(ctx, (const struct marshal_cmd_VertexAttrib4s *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform1i64vARB:
      debug_print_unmarshal("ProgramUniform1i64vARB");
      _mesa_unmarshal_ProgramUniform1i64vARB(ctx, (const struct marshal_cmd_ProgramUniform1i64vARB *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib1dvNV:
      debug_print_unmarshal("VertexAttrib1dvNV");
      _mesa_unmarshal_VertexAttrib1dvNV(ctx, (const struct marshal_cmd_VertexAttrib1dvNV *) cmd);
      break;
   case DISPATCH_CMD_TexStorage3DMultisample:
      debug_print_unmarshal("TexStorage3DMultisample");
      _mesa_unmarshal_TexStorage3DMultisample(ctx, (const struct marshal_cmd_TexStorage3DMultisample *) cmd);
      break;
   case DISPATCH_CMD_ScissorIndexedv:
      debug_print_unmarshal("ScissorIndexedv");
      _mesa_unmarshal_ScissorIndexedv(ctx, (const struct marshal_cmd_ScissorIndexedv *) cmd);
      break;
   case DISPATCH_CMD_Uniform2dv:
      debug_print_unmarshal("Uniform2dv");
      _mesa_unmarshal_Uniform2dv(ctx, (const struct marshal_cmd_Uniform2dv *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4dv:
      debug_print_unmarshal("VertexAttrib4dv");
      _mesa_unmarshal_VertexAttrib4dv(ctx, (const struct marshal_cmd_VertexAttrib4dv *) cmd);
      break;
   case DISPATCH_CMD_EvalCoord2dv:
      debug_print_unmarshal("EvalCoord2dv");
      _mesa_unmarshal_EvalCoord2dv(ctx, (const struct marshal_cmd_EvalCoord2dv *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib1fNV:
      debug_print_unmarshal("VertexAttrib1fNV");
      _mesa_unmarshal_VertexAttrib1fNV(ctx, (const struct marshal_cmd_VertexAttrib1fNV *) cmd);
      break;
   case DISPATCH_CMD_RasterPos2iv:
      debug_print_unmarshal("RasterPos2iv");
      _mesa_unmarshal_RasterPos2iv(ctx, (const struct marshal_cmd_RasterPos2iv *) cmd);
      break;
   case DISPATCH_CMD_FrontFace:
      debug_print_unmarshal("FrontFace");
      _mesa_unmarshal_FrontFace(ctx, (const struct marshal_cmd_FrontFace *) cmd);
      break;
   case DISPATCH_CMD_Normal3dv:
      debug_print_unmarshal("Normal3dv");
      _mesa_unmarshal_Normal3dv(ctx, (const struct marshal_cmd_Normal3dv *) cmd);
      break;
   case DISPATCH_CMD_Lightf:
      debug_print_unmarshal("Lightf");
      _mesa_unmarshal_Lightf(ctx, (const struct marshal_cmd_Lightf *) cmd);
      break;
   case DISPATCH_CMD_MatrixMode:
      debug_print_unmarshal("MatrixMode");
      _mesa_unmarshal_MatrixMode(ctx, (const struct marshal_cmd_MatrixMode *) cmd);
      break;
   case DISPATCH_CMD_Lighti:
      debug_print_unmarshal("Lighti");
      _mesa_unmarshal_Lighti(ctx, (const struct marshal_cmd_Lighti *) cmd);
      break;
   case DISPATCH_CMD_Lightx:
      debug_print_unmarshal("Lightx");
      _mesa_unmarshal_Lightx(ctx, (const struct marshal_cmd_Lightx *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform3fv:
      debug_print_unmarshal("ProgramUniform3fv");
      _mesa_unmarshal_ProgramUniform3fv(ctx, (const struct marshal_cmd_ProgramUniform3fv *) cmd);
      break;
   case DISPATCH_CMD_MultMatrixd:
      debug_print_unmarshal("MultMatrixd");
      _mesa_unmarshal_MultMatrixd(ctx, (const struct marshal_cmd_MultMatrixd *) cmd);
      break;
   case DISPATCH_CMD_MultMatrixf:
      debug_print_unmarshal("MultMatrixf");
      _mesa_unmarshal_MultMatrixf(ctx, (const struct marshal_cmd_MultMatrixf *) cmd);
      break;
   case DISPATCH_CMD_Uniform4ui64vARB:
      debug_print_unmarshal("Uniform4ui64vARB");
      _mesa_unmarshal_Uniform4ui64vARB(ctx, (const struct marshal_cmd_Uniform4ui64vARB *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord4fvARB:
      debug_print_unmarshal("MultiTexCoord4fvARB");
      _mesa_unmarshal_MultiTexCoord4fvARB(ctx, (const struct marshal_cmd_MultiTexCoord4fvARB *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix2x3fv:
      debug_print_unmarshal("UniformMatrix2x3fv");
      _mesa_unmarshal_UniformMatrix2x3fv(ctx, (const struct marshal_cmd_UniformMatrix2x3fv *) cmd);
      break;
   case DISPATCH_CMD_SamplerParameterf:
      debug_print_unmarshal("SamplerParameterf");
      _mesa_unmarshal_SamplerParameterf(ctx, (const struct marshal_cmd_SamplerParameterf *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix3dv:
      debug_print_unmarshal("UniformMatrix3dv");
      _mesa_unmarshal_UniformMatrix3dv(ctx, (const struct marshal_cmd_UniformMatrix3dv *) cmd);
      break;
   case DISPATCH_CMD_PointParameterx:
      debug_print_unmarshal("PointParameterx");
      _mesa_unmarshal_PointParameterx(ctx, (const struct marshal_cmd_PointParameterx *) cmd);
      break;
   case DISPATCH_CMD_DrawArrays:
      debug_print_unmarshal("DrawArrays");
      _mesa_unmarshal_DrawArrays(ctx, (const struct marshal_cmd_DrawArrays *) cmd);
      break;
   case DISPATCH_CMD_Uniform3dv:
      debug_print_unmarshal("Uniform3dv");
      _mesa_unmarshal_Uniform3dv(ctx, (const struct marshal_cmd_Uniform3dv *) cmd);
      break;
   case DISPATCH_CMD_PointParameteri:
      debug_print_unmarshal("PointParameteri");
      _mesa_unmarshal_PointParameteri(ctx, (const struct marshal_cmd_PointParameteri *) cmd);
      break;
   case DISPATCH_CMD_PointParameterf:
      debug_print_unmarshal("PointParameterf");
      _mesa_unmarshal_PointParameterf(ctx, (const struct marshal_cmd_PointParameterf *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribBinding:
      debug_print_unmarshal("VertexAttribBinding");
      _mesa_unmarshal_VertexAttribBinding(ctx, (const struct marshal_cmd_VertexAttribBinding *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform1dv:
      debug_print_unmarshal("ProgramUniform1dv");
      _mesa_unmarshal_ProgramUniform1dv(ctx, (const struct marshal_cmd_ProgramUniform1dv *) cmd);
      break;
   case DISPATCH_CMD_DeleteBuffers:
      debug_print_unmarshal("DeleteBuffers");
      _mesa_unmarshal_DeleteBuffers(ctx, (const struct marshal_cmd_DeleteBuffers *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribP2ui:
      debug_print_unmarshal("VertexAttribP2ui");
      _mesa_unmarshal_VertexAttribP2ui(ctx, (const struct marshal_cmd_VertexAttribP2ui *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform4dv:
      debug_print_unmarshal("ProgramUniform4dv");
      _mesa_unmarshal_ProgramUniform4dv(ctx, (const struct marshal_cmd_ProgramUniform4dv *) cmd);
      break;
   case DISPATCH_CMD_DrawTexivOES:
      debug_print_unmarshal("DrawTexivOES");
      _mesa_unmarshal_DrawTexivOES(ctx, (const struct marshal_cmd_DrawTexivOES *) cmd);
      break;
   case DISPATCH_CMD_CopyTexImage1D:
      debug_print_unmarshal("CopyTexImage1D");
      _mesa_unmarshal_CopyTexImage1D(ctx, (const struct marshal_cmd_CopyTexImage1D *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribFormat:
      debug_print_unmarshal("VertexAttribFormat");
      _mesa_unmarshal_VertexAttribFormat(ctx, (const struct marshal_cmd_VertexAttribFormat *) cmd);
      break;
   case DISPATCH_CMD_Vertex3i:
      debug_print_unmarshal("Vertex3i");
      _mesa_unmarshal_Vertex3i(ctx, (const struct marshal_cmd_Vertex3i *) cmd);
      break;
   case DISPATCH_CMD_Vertex3f:
      debug_print_unmarshal("Vertex3f");
      _mesa_unmarshal_Vertex3f(ctx, (const struct marshal_cmd_Vertex3f *) cmd);
      break;
   case DISPATCH_CMD_Vertex3d:
      debug_print_unmarshal("Vertex3d");
      _mesa_unmarshal_Vertex3d(ctx, (const struct marshal_cmd_Vertex3d *) cmd);
      break;
   case DISPATCH_CMD_ReadBuffer:
      debug_print_unmarshal("ReadBuffer");
      _mesa_unmarshal_ReadBuffer(ctx, (const struct marshal_cmd_ReadBuffer *) cmd);
      break;
   case DISPATCH_CMD_ConvolutionParameteri:
      debug_print_unmarshal("ConvolutionParameteri");
      _mesa_unmarshal_ConvolutionParameteri(ctx, (const struct marshal_cmd_ConvolutionParameteri *) cmd);
      break;
   case DISPATCH_CMD_Vertex3s:
      debug_print_unmarshal("Vertex3s");
      _mesa_unmarshal_Vertex3s(ctx, (const struct marshal_cmd_Vertex3s *) cmd);
      break;
   case DISPATCH_CMD_ConvolutionParameterf:
      debug_print_unmarshal("ConvolutionParameterf");
      _mesa_unmarshal_ConvolutionParameterf(ctx, (const struct marshal_cmd_ConvolutionParameterf *) cmd);
      break;
   case DISPATCH_CMD_TexCoord3fv:
      debug_print_unmarshal("TexCoord3fv");
      _mesa_unmarshal_TexCoord3fv(ctx, (const struct marshal_cmd_TexCoord3fv *) cmd);
      break;
   case DISPATCH_CMD_TextureBarrierNV:
      debug_print_unmarshal("TextureBarrierNV");
      _mesa_unmarshal_TextureBarrierNV(ctx, (const struct marshal_cmd_TextureBarrierNV *) cmd);
      break;
   case DISPATCH_CMD_ProgramLocalParameter4fARB:
      debug_print_unmarshal("ProgramLocalParameter4fARB");
      _mesa_unmarshal_ProgramLocalParameter4fARB(ctx, (const struct marshal_cmd_ProgramLocalParameter4fARB *) cmd);
      break;
   case DISPATCH_CMD_PauseTransformFeedback:
      debug_print_unmarshal("PauseTransformFeedback");
      _mesa_unmarshal_PauseTransformFeedback(ctx, (const struct marshal_cmd_PauseTransformFeedback *) cmd);
      break;
   case DISPATCH_CMD_DeleteShader:
      debug_print_unmarshal("DeleteShader");
      _mesa_unmarshal_DeleteShader(ctx, (const struct marshal_cmd_DeleteShader *) cmd);
      break;
   case DISPATCH_CMD_NamedFramebufferRenderbuffer:
      debug_print_unmarshal("NamedFramebufferRenderbuffer");
      _mesa_unmarshal_NamedFramebufferRenderbuffer(ctx, (const struct marshal_cmd_NamedFramebufferRenderbuffer *) cmd);
      break;
   case DISPATCH_CMD_CompileShader:
      debug_print_unmarshal("CompileShader");
      _mesa_unmarshal_CompileShader(ctx, (const struct marshal_cmd_CompileShader *) cmd);
      break;
   case DISPATCH_CMD_Vertex2iv:
      debug_print_unmarshal("Vertex2iv");
      _mesa_unmarshal_Vertex2iv(ctx, (const struct marshal_cmd_Vertex2iv *) cmd);
      break;
   case DISPATCH_CMD_ResetMinmax:
      debug_print_unmarshal("ResetMinmax");
      _mesa_unmarshal_ResetMinmax(ctx, (const struct marshal_cmd_ResetMinmax *) cmd);
      break;
   case DISPATCH_CMD_SampleCoverage:
      debug_print_unmarshal("SampleCoverage");
      _mesa_unmarshal_SampleCoverage(ctx, (const struct marshal_cmd_SampleCoverage *) cmd);
      break;
   case DISPATCH_CMD_GenerateTextureMipmap:
      debug_print_unmarshal("GenerateTextureMipmap");
      _mesa_unmarshal_GenerateTextureMipmap(ctx, (const struct marshal_cmd_GenerateTextureMipmap *) cmd);
      break;
   case DISPATCH_CMD_DeleteProgramsARB:
      debug_print_unmarshal("DeleteProgramsARB");
      _mesa_unmarshal_DeleteProgramsARB(ctx, (const struct marshal_cmd_DeleteProgramsARB *) cmd);
      break;
   case DISPATCH_CMD_ShadeModel:
      debug_print_unmarshal("ShadeModel");
      _mesa_unmarshal_ShadeModel(ctx, (const struct marshal_cmd_ShadeModel *) cmd);
      break;
   case DISPATCH_CMD_DispatchCompute:
      debug_print_unmarshal("DispatchCompute");
      _mesa_unmarshal_DispatchCompute(ctx, (const struct marshal_cmd_DispatchCompute *) cmd);
      break;
   case DISPATCH_CMD_UseProgramStages:
      debug_print_unmarshal("UseProgramStages");
      _mesa_unmarshal_UseProgramStages(ctx, (const struct marshal_cmd_UseProgramStages *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix4fv:
      debug_print_unmarshal("ProgramUniformMatrix4fv");
      _mesa_unmarshal_ProgramUniformMatrix4fv(ctx, (const struct marshal_cmd_ProgramUniformMatrix4fv *) cmd);
      break;
   case DISPATCH_CMD_FramebufferRenderbuffer:
      debug_print_unmarshal("FramebufferRenderbuffer");
      _mesa_unmarshal_FramebufferRenderbuffer(ctx, (const struct marshal_cmd_FramebufferRenderbuffer *) cmd);
      break;
   case DISPATCH_CMD_ProgramStringARB:
      debug_print_unmarshal("ProgramStringARB");
      _mesa_unmarshal_ProgramStringARB(ctx, (const struct marshal_cmd_ProgramStringARB *) cmd);
      break;
   case DISPATCH_CMD_CopyTextureSubImage2D:
      debug_print_unmarshal("CopyTextureSubImage2D");
      _mesa_unmarshal_CopyTextureSubImage2D(ctx, (const struct marshal_cmd_CopyTextureSubImage2D *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord4s:
      debug_print_unmarshal("MultiTexCoord4s");
      _mesa_unmarshal_MultiTexCoord4s(ctx, (const struct marshal_cmd_MultiTexCoord4s *) cmd);
      break;
   case DISPATCH_CMD_ViewportIndexedf:
      debug_print_unmarshal("ViewportIndexedf");
      _mesa_unmarshal_ViewportIndexedf(ctx, (const struct marshal_cmd_ViewportIndexedf *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord4i:
      debug_print_unmarshal("MultiTexCoord4i");
      _mesa_unmarshal_MultiTexCoord4i(ctx, (const struct marshal_cmd_MultiTexCoord4i *) cmd);
      break;
   case DISPATCH_CMD_DebugMessageControl:
      debug_print_unmarshal("DebugMessageControl");
      _mesa_unmarshal_DebugMessageControl(ctx, (const struct marshal_cmd_DebugMessageControl *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord4d:
      debug_print_unmarshal("MultiTexCoord4d");
      _mesa_unmarshal_MultiTexCoord4d(ctx, (const struct marshal_cmd_MultiTexCoord4d *) cmd);
      break;
   case DISPATCH_CMD_Translatex:
      debug_print_unmarshal("Translatex");
      _mesa_unmarshal_Translatex(ctx, (const struct marshal_cmd_Translatex *) cmd);
      break;
   case DISPATCH_CMD_MultiDrawElementsIndirectCountARB:
      debug_print_unmarshal("MultiDrawElementsIndirectCountARB");
      _mesa_unmarshal_MultiDrawElementsIndirectCountARB(ctx, (const struct marshal_cmd_MultiDrawElementsIndirectCountARB *) cmd);
      break;
   case DISPATCH_CMD_Indexsv:
      debug_print_unmarshal("Indexsv");
      _mesa_unmarshal_Indexsv(ctx, (const struct marshal_cmd_Indexsv *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib1fvARB:
      debug_print_unmarshal("VertexAttrib1fvARB");
      _mesa_unmarshal_VertexAttrib1fvARB(ctx, (const struct marshal_cmd_VertexAttrib1fvARB *) cmd);
      break;
   case DISPATCH_CMD_TexCoord2dv:
      debug_print_unmarshal("TexCoord2dv");
      _mesa_unmarshal_TexCoord2dv(ctx, (const struct marshal_cmd_TexCoord2dv *) cmd);
      break;
   case DISPATCH_CMD_Translated:
      debug_print_unmarshal("Translated");
      _mesa_unmarshal_Translated(ctx, (const struct marshal_cmd_Translated *) cmd);
      break;
   case DISPATCH_CMD_Translatef:
      debug_print_unmarshal("Translatef");
      _mesa_unmarshal_Translatef(ctx, (const struct marshal_cmd_Translatef *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform4uiv:
      debug_print_unmarshal("ProgramUniform4uiv");
      _mesa_unmarshal_ProgramUniform4uiv(ctx, (const struct marshal_cmd_ProgramUniform4uiv *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord1fARB:
      debug_print_unmarshal("MultiTexCoord1fARB");
      _mesa_unmarshal_MultiTexCoord1fARB(ctx, (const struct marshal_cmd_MultiTexCoord1fARB *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColor3d:
      debug_print_unmarshal("SecondaryColor3d");
      _mesa_unmarshal_SecondaryColor3d(ctx, (const struct marshal_cmd_SecondaryColor3d *) cmd);
      break;
   case DISPATCH_CMD_FramebufferParameteri:
      debug_print_unmarshal("FramebufferParameteri");
      _mesa_unmarshal_FramebufferParameteri(ctx, (const struct marshal_cmd_FramebufferParameteri *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribs4ubvNV:
      debug_print_unmarshal("VertexAttribs4ubvNV");
      _mesa_unmarshal_VertexAttribs4ubvNV(ctx, (const struct marshal_cmd_VertexAttribs4ubvNV *) cmd);
      break;
   case DISPATCH_CMD_CopyTexSubImage1D:
      debug_print_unmarshal("CopyTexSubImage1D");
      _mesa_unmarshal_CopyTexSubImage1D(ctx, (const struct marshal_cmd_CopyTexSubImage1D *) cmd);
      break;
   case DISPATCH_CMD_StencilFunc:
      debug_print_unmarshal("StencilFunc");
      _mesa_unmarshal_StencilFunc(ctx, (const struct marshal_cmd_StencilFunc *) cmd);
      break;
   case DISPATCH_CMD_CopyPixels:
      debug_print_unmarshal("CopyPixels");
      _mesa_unmarshal_CopyPixels(ctx, (const struct marshal_cmd_CopyPixels *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4Nubv:
      debug_print_unmarshal("VertexAttrib4Nubv");
      _mesa_unmarshal_VertexAttrib4Nubv(ctx, (const struct marshal_cmd_VertexAttrib4Nubv *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix4x2dv:
      debug_print_unmarshal("UniformMatrix4x2dv");
      _mesa_unmarshal_UniformMatrix4x2dv(ctx, (const struct marshal_cmd_UniformMatrix4x2dv *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribPointer:
      debug_print_unmarshal("VertexAttribPointer");
      _mesa_unmarshal_VertexAttribPointer(ctx, (const struct marshal_cmd_VertexAttribPointer *) cmd);
      break;
   case DISPATCH_CMD_IndexMask:
      debug_print_unmarshal("IndexMask");
      _mesa_unmarshal_IndexMask(ctx, (const struct marshal_cmd_IndexMask *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribIFormat:
      debug_print_unmarshal("VertexAttribIFormat");
      _mesa_unmarshal_VertexAttribIFormat(ctx, (const struct marshal_cmd_VertexAttribIFormat *) cmd);
      break;
   case DISPATCH_CMD_DrawArraysInstancedBaseInstance:
      debug_print_unmarshal("DrawArraysInstancedBaseInstance");
      _mesa_unmarshal_DrawArraysInstancedBaseInstance(ctx, (const struct marshal_cmd_DrawArraysInstancedBaseInstance *) cmd);
      break;
   case DISPATCH_CMD_TextureStorageMem3DMultisampleEXT:
      debug_print_unmarshal("TextureStorageMem3DMultisampleEXT");
      _mesa_unmarshal_TextureStorageMem3DMultisampleEXT(ctx, (const struct marshal_cmd_TextureStorageMem3DMultisampleEXT *) cmd);
      break;
   case DISPATCH_CMD_PopAttrib:
      debug_print_unmarshal("PopAttrib");
      _mesa_unmarshal_PopAttrib(ctx, (const struct marshal_cmd_PopAttrib *) cmd);
      break;
   case DISPATCH_CMD_Uniform3ui:
      debug_print_unmarshal("Uniform3ui");
      _mesa_unmarshal_Uniform3ui(ctx, (const struct marshal_cmd_Uniform3ui *) cmd);
      break;
   case DISPATCH_CMD_Color4dv:
      debug_print_unmarshal("Color4dv");
      _mesa_unmarshal_Color4dv(ctx, (const struct marshal_cmd_Color4dv *) cmd);
      break;
   case DISPATCH_CMD_DisableVertexAttribArray:
      debug_print_unmarshal("DisableVertexAttribArray");
      _mesa_unmarshal_DisableVertexAttribArray(ctx, (const struct marshal_cmd_DisableVertexAttribArray *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix3x2fv:
      debug_print_unmarshal("ProgramUniformMatrix3x2fv");
      _mesa_unmarshal_ProgramUniformMatrix3x2fv(ctx, (const struct marshal_cmd_ProgramUniformMatrix3x2fv *) cmd);
      break;
   case DISPATCH_CMD_ClipPlanex:
      debug_print_unmarshal("ClipPlanex");
      _mesa_unmarshal_ClipPlanex(ctx, (const struct marshal_cmd_ClipPlanex *) cmd);
      break;
   case DISPATCH_CMD_ClipPlanef:
      debug_print_unmarshal("ClipPlanef");
      _mesa_unmarshal_ClipPlanef(ctx, (const struct marshal_cmd_ClipPlanef *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform1ui:
      debug_print_unmarshal("ProgramUniform1ui");
      _mesa_unmarshal_ProgramUniform1ui(ctx, (const struct marshal_cmd_ProgramUniform1ui *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColorPointer:
      debug_print_unmarshal("SecondaryColorPointer");
      _mesa_unmarshal_SecondaryColorPointer(ctx, (const struct marshal_cmd_SecondaryColorPointer *) cmd);
      break;
   case DISPATCH_CMD_LineStipple:
      debug_print_unmarshal("LineStipple");
      _mesa_unmarshal_LineStipple(ctx, (const struct marshal_cmd_LineStipple *) cmd);
      break;
   case DISPATCH_CMD_BeginFragmentShaderATI:
      debug_print_unmarshal("BeginFragmentShaderATI");
      _mesa_unmarshal_BeginFragmentShaderATI(ctx, (const struct marshal_cmd_BeginFragmentShaderATI *) cmd);
      break;
   case DISPATCH_CMD_TextureStorageMem2DEXT:
      debug_print_unmarshal("TextureStorageMem2DEXT");
      _mesa_unmarshal_TextureStorageMem2DEXT(ctx, (const struct marshal_cmd_TextureStorageMem2DEXT *) cmd);
      break;
   case DISPATCH_CMD_WaitSync:
      debug_print_unmarshal("WaitSync");
      _mesa_unmarshal_WaitSync(ctx, (const struct marshal_cmd_WaitSync *) cmd);
      break;
   case DISPATCH_CMD_Uniform1i64vARB:
      debug_print_unmarshal("Uniform1i64vARB");
      _mesa_unmarshal_Uniform1i64vARB(ctx, (const struct marshal_cmd_Uniform1i64vARB *) cmd);
      break;
   case DISPATCH_CMD_NewList:
      debug_print_unmarshal("NewList");
      _mesa_unmarshal_NewList(ctx, (const struct marshal_cmd_NewList *) cmd);
      break;
   case DISPATCH_CMD_TexBuffer:
      debug_print_unmarshal("TexBuffer");
      _mesa_unmarshal_TexBuffer(ctx, (const struct marshal_cmd_TexBuffer *) cmd);
      break;
   case DISPATCH_CMD_TexCoord4sv:
      debug_print_unmarshal("TexCoord4sv");
      _mesa_unmarshal_TexCoord4sv(ctx, (const struct marshal_cmd_TexCoord4sv *) cmd);
      break;
   case DISPATCH_CMD_TexCoord1f:
      debug_print_unmarshal("TexCoord1f");
      _mesa_unmarshal_TexCoord1f(ctx, (const struct marshal_cmd_TexCoord1f *) cmd);
      break;
   case DISPATCH_CMD_TexCoord1d:
      debug_print_unmarshal("TexCoord1d");
      _mesa_unmarshal_TexCoord1d(ctx, (const struct marshal_cmd_TexCoord1d *) cmd);
      break;
   case DISPATCH_CMD_TexCoord1i:
      debug_print_unmarshal("TexCoord1i");
      _mesa_unmarshal_TexCoord1i(ctx, (const struct marshal_cmd_TexCoord1i *) cmd);
      break;
   case DISPATCH_CMD_TexCoord1s:
      debug_print_unmarshal("TexCoord1s");
      _mesa_unmarshal_TexCoord1s(ctx, (const struct marshal_cmd_TexCoord1s *) cmd);
      break;
   case DISPATCH_CMD_Uniform1ui:
      debug_print_unmarshal("Uniform1ui");
      _mesa_unmarshal_Uniform1ui(ctx, (const struct marshal_cmd_Uniform1ui *) cmd);
      break;
   case DISPATCH_CMD_TexStorage1D:
      debug_print_unmarshal("TexStorage1D");
      _mesa_unmarshal_TexStorage1D(ctx, (const struct marshal_cmd_TexStorage1D *) cmd);
      break;
   case DISPATCH_CMD_BlitFramebuffer:
      debug_print_unmarshal("BlitFramebuffer");
      _mesa_unmarshal_BlitFramebuffer(ctx, (const struct marshal_cmd_BlitFramebuffer *) cmd);
      break;
   case DISPATCH_CMD_TextureParameterf:
      debug_print_unmarshal("TextureParameterf");
      _mesa_unmarshal_TextureParameterf(ctx, (const struct marshal_cmd_TextureParameterf *) cmd);
      break;
   case DISPATCH_CMD_FramebufferTexture1D:
      debug_print_unmarshal("FramebufferTexture1D");
      _mesa_unmarshal_FramebufferTexture1D(ctx, (const struct marshal_cmd_FramebufferTexture1D *) cmd);
      break;
   case DISPATCH_CMD_TextureParameteri:
      debug_print_unmarshal("TextureParameteri");
      _mesa_unmarshal_TextureParameteri(ctx, (const struct marshal_cmd_TextureParameteri *) cmd);
      break;
   case DISPATCH_CMD_TexCoordP4ui:
      debug_print_unmarshal("TexCoordP4ui");
      _mesa_unmarshal_TexCoordP4ui(ctx, (const struct marshal_cmd_TexCoordP4ui *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib1sv:
      debug_print_unmarshal("VertexAttrib1sv");
      _mesa_unmarshal_VertexAttrib1sv(ctx, (const struct marshal_cmd_VertexAttrib1sv *) cmd);
      break;
   case DISPATCH_CMD_WindowPos4dMESA:
      debug_print_unmarshal("WindowPos4dMESA");
      _mesa_unmarshal_WindowPos4dMESA(ctx, (const struct marshal_cmd_WindowPos4dMESA *) cmd);
      break;
   case DISPATCH_CMD_Vertex3dv:
      debug_print_unmarshal("Vertex3dv");
      _mesa_unmarshal_Vertex3dv(ctx, (const struct marshal_cmd_Vertex3dv *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribL2d:
      debug_print_unmarshal("VertexAttribL2d");
      _mesa_unmarshal_VertexAttribL2d(ctx, (const struct marshal_cmd_VertexAttribL2d *) cmd);
      break;
   case DISPATCH_CMD_BlendColor:
      debug_print_unmarshal("BlendColor");
      _mesa_unmarshal_BlendColor(ctx, (const struct marshal_cmd_BlendColor *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribs2dvNV:
      debug_print_unmarshal("VertexAttribs2dvNV");
      _mesa_unmarshal_VertexAttribs2dvNV(ctx, (const struct marshal_cmd_VertexAttribs2dvNV *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib2dvNV:
      debug_print_unmarshal("VertexAttrib2dvNV");
      _mesa_unmarshal_VertexAttrib2dvNV(ctx, (const struct marshal_cmd_VertexAttrib2dvNV *) cmd);
      break;
   case DISPATCH_CMD_ResetHistogram:
      debug_print_unmarshal("ResetHistogram");
      _mesa_unmarshal_ResetHistogram(ctx, (const struct marshal_cmd_ResetHistogram *) cmd);
      break;
   case DISPATCH_CMD_TexCoord2sv:
      debug_print_unmarshal("TexCoord2sv");
      _mesa_unmarshal_TexCoord2sv(ctx, (const struct marshal_cmd_TexCoord2sv *) cmd);
      break;
   case DISPATCH_CMD_StencilMaskSeparate:
      debug_print_unmarshal("StencilMaskSeparate");
      _mesa_unmarshal_StencilMaskSeparate(ctx, (const struct marshal_cmd_StencilMaskSeparate *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord3sv:
      debug_print_unmarshal("MultiTexCoord3sv");
      _mesa_unmarshal_MultiTexCoord3sv(ctx, (const struct marshal_cmd_MultiTexCoord3sv *) cmd);
      break;
   case DISPATCH_CMD_TexCoord3iv:
      debug_print_unmarshal("TexCoord3iv");
      _mesa_unmarshal_TexCoord3iv(ctx, (const struct marshal_cmd_TexCoord3iv *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord4sv:
      debug_print_unmarshal("MultiTexCoord4sv");
      _mesa_unmarshal_MultiTexCoord4sv(ctx, (const struct marshal_cmd_MultiTexCoord4sv *) cmd);
      break;
   case DISPATCH_CMD_VertexBindingDivisor:
      debug_print_unmarshal("VertexBindingDivisor");
      _mesa_unmarshal_VertexBindingDivisor(ctx, (const struct marshal_cmd_VertexBindingDivisor *) cmd);
      break;
   case DISPATCH_CMD_PrimitiveBoundingBox:
      debug_print_unmarshal("PrimitiveBoundingBox");
      _mesa_unmarshal_PrimitiveBoundingBox(ctx, (const struct marshal_cmd_PrimitiveBoundingBox *) cmd);
      break;
   case DISPATCH_CMD_UniformBlockBinding:
      debug_print_unmarshal("UniformBlockBinding");
      _mesa_unmarshal_UniformBlockBinding(ctx, (const struct marshal_cmd_UniformBlockBinding *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4Nusv:
      debug_print_unmarshal("VertexAttrib4Nusv");
      _mesa_unmarshal_VertexAttrib4Nusv(ctx, (const struct marshal_cmd_VertexAttrib4Nusv *) cmd);
      break;
   case DISPATCH_CMD_VertexP2ui:
      debug_print_unmarshal("VertexP2ui");
      _mesa_unmarshal_VertexP2ui(ctx, (const struct marshal_cmd_VertexP2ui *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform2fv:
      debug_print_unmarshal("ProgramUniform2fv");
      _mesa_unmarshal_ProgramUniform2fv(ctx, (const struct marshal_cmd_ProgramUniform2fv *) cmd);
      break;
   case DISPATCH_CMD_TextureStorage2DEXT:
      debug_print_unmarshal("TextureStorage2DEXT");
      _mesa_unmarshal_TextureStorage2DEXT(ctx, (const struct marshal_cmd_TextureStorage2DEXT *) cmd);
      break;
   case DISPATCH_CMD_DrawTransformFeedbackInstanced:
      debug_print_unmarshal("DrawTransformFeedbackInstanced");
      _mesa_unmarshal_DrawTransformFeedbackInstanced(ctx, (const struct marshal_cmd_DrawTransformFeedbackInstanced *) cmd);
      break;
   case DISPATCH_CMD_CopyTextureSubImage1D:
      debug_print_unmarshal("CopyTextureSubImage1D");
      _mesa_unmarshal_CopyTextureSubImage1D(ctx, (const struct marshal_cmd_CopyTextureSubImage1D *) cmd);
      break;
   case DISPATCH_CMD_ResumeTransformFeedback:
      debug_print_unmarshal("ResumeTransformFeedback");
      _mesa_unmarshal_ResumeTransformFeedback(ctx, (const struct marshal_cmd_ResumeTransformFeedback *) cmd);
      break;
   case DISPATCH_CMD_Vertex2dv:
      debug_print_unmarshal("Vertex2dv");
      _mesa_unmarshal_Vertex2dv(ctx, (const struct marshal_cmd_Vertex2dv *) cmd);
      break;
   case DISPATCH_CMD_SampleMaski:
      debug_print_unmarshal("SampleMaski");
      _mesa_unmarshal_SampleMaski(ctx, (const struct marshal_cmd_SampleMaski *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord2iv:
      debug_print_unmarshal("MultiTexCoord2iv");
      _mesa_unmarshal_MultiTexCoord2iv(ctx, (const struct marshal_cmd_MultiTexCoord2iv *) cmd);
      break;
   case DISPATCH_CMD_DrawTransformFeedback:
      debug_print_unmarshal("DrawTransformFeedback");
      _mesa_unmarshal_DrawTransformFeedback(ctx, (const struct marshal_cmd_DrawTransformFeedback *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribs3fvNV:
      debug_print_unmarshal("VertexAttribs3fvNV");
      _mesa_unmarshal_VertexAttribs3fvNV(ctx, (const struct marshal_cmd_VertexAttribs3fvNV *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform2ui64vARB:
      debug_print_unmarshal("ProgramUniform2ui64vARB");
      _mesa_unmarshal_ProgramUniform2ui64vARB(ctx, (const struct marshal_cmd_ProgramUniform2ui64vARB *) cmd);
      break;
   case DISPATCH_CMD_MapGrid2d:
      debug_print_unmarshal("MapGrid2d");
      _mesa_unmarshal_MapGrid2d(ctx, (const struct marshal_cmd_MapGrid2d *) cmd);
      break;
   case DISPATCH_CMD_MapGrid2f:
      debug_print_unmarshal("MapGrid2f");
      _mesa_unmarshal_MapGrid2f(ctx, (const struct marshal_cmd_MapGrid2f *) cmd);
      break;
   case DISPATCH_CMD_SampleMapATI:
      debug_print_unmarshal("SampleMapATI");
      _mesa_unmarshal_SampleMapATI(ctx, (const struct marshal_cmd_SampleMapATI *) cmd);
      break;
   case DISPATCH_CMD_Color3usv:
      debug_print_unmarshal("Color3usv");
      _mesa_unmarshal_Color3usv(ctx, (const struct marshal_cmd_Color3usv *) cmd);
      break;
   case DISPATCH_CMD_CopyImageSubData:
      debug_print_unmarshal("CopyImageSubData");
      _mesa_unmarshal_CopyImageSubData(ctx, (const struct marshal_cmd_CopyImageSubData *) cmd);
      break;
   case DISPATCH_CMD_StencilOpSeparate:
      debug_print_unmarshal("StencilOpSeparate");
      _mesa_unmarshal_StencilOpSeparate(ctx, (const struct marshal_cmd_StencilOpSeparate *) cmd);
      break;
   case DISPATCH_CMD_ClipControl:
      debug_print_unmarshal("ClipControl");
      _mesa_unmarshal_ClipControl(ctx, (const struct marshal_cmd_ClipControl *) cmd);
      break;
   case DISPATCH_CMD_DrawTexfOES:
      debug_print_unmarshal("DrawTexfOES");
      _mesa_unmarshal_DrawTexfOES(ctx, (const struct marshal_cmd_DrawTexfOES *) cmd);
      break;
   case DISPATCH_CMD_Uniform4i64vARB:
      debug_print_unmarshal("Uniform4i64vARB");
      _mesa_unmarshal_Uniform4i64vARB(ctx, (const struct marshal_cmd_Uniform4i64vARB *) cmd);
      break;
   case DISPATCH_CMD_AttachObjectARB:
      debug_print_unmarshal("AttachObjectARB");
      _mesa_unmarshal_AttachObjectARB(ctx, (const struct marshal_cmd_AttachObjectARB *) cmd);
      break;
   case DISPATCH_CMD_Accum:
      debug_print_unmarshal("Accum");
      _mesa_unmarshal_Accum(ctx, (const struct marshal_cmd_Accum *) cmd);
      break;
   case DISPATCH_CMD_Color4x:
      debug_print_unmarshal("Color4x");
      _mesa_unmarshal_Color4x(ctx, (const struct marshal_cmd_Color4x *) cmd);
      break;
   case DISPATCH_CMD_Color4s:
      debug_print_unmarshal("Color4s");
      _mesa_unmarshal_Color4s(ctx, (const struct marshal_cmd_Color4s *) cmd);
      break;
   case DISPATCH_CMD_EnableVertexAttribArray:
      debug_print_unmarshal("EnableVertexAttribArray");
      _mesa_unmarshal_EnableVertexAttribArray(ctx, (const struct marshal_cmd_EnableVertexAttribArray *) cmd);
      break;
   case DISPATCH_CMD_Color4i:
      debug_print_unmarshal("Color4i");
      _mesa_unmarshal_Color4i(ctx, (const struct marshal_cmd_Color4i *) cmd);
      break;
   case DISPATCH_CMD_Color4f:
      debug_print_unmarshal("Color4f");
      _mesa_unmarshal_Color4f(ctx, (const struct marshal_cmd_Color4f *) cmd);
      break;
   case DISPATCH_CMD_ShaderStorageBlockBinding:
      debug_print_unmarshal("ShaderStorageBlockBinding");
      _mesa_unmarshal_ShaderStorageBlockBinding(ctx, (const struct marshal_cmd_ShaderStorageBlockBinding *) cmd);
      break;
   case DISPATCH_CMD_Color4d:
      debug_print_unmarshal("Color4d");
      _mesa_unmarshal_Color4d(ctx, (const struct marshal_cmd_Color4d *) cmd);
      break;
   case DISPATCH_CMD_Color4b:
      debug_print_unmarshal("Color4b");
      _mesa_unmarshal_Color4b(ctx, (const struct marshal_cmd_Color4b *) cmd);
      break;
   case DISPATCH_CMD_EvalCoord1fv:
      debug_print_unmarshal("EvalCoord1fv");
      _mesa_unmarshal_EvalCoord1fv(ctx, (const struct marshal_cmd_EvalCoord1fv *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribLFormat:
      debug_print_unmarshal("VertexAttribLFormat");
      _mesa_unmarshal_VertexAttribLFormat(ctx, (const struct marshal_cmd_VertexAttribLFormat *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribL3d:
      debug_print_unmarshal("VertexAttribL3d");
      _mesa_unmarshal_VertexAttribL3d(ctx, (const struct marshal_cmd_VertexAttribL3d *) cmd);
      break;
   case DISPATCH_CMD_StencilFuncSeparate:
      debug_print_unmarshal("StencilFuncSeparate");
      _mesa_unmarshal_StencilFuncSeparate(ctx, (const struct marshal_cmd_StencilFuncSeparate *) cmd);
      break;
   case DISPATCH_CMD_ShaderSource:
      debug_print_unmarshal("ShaderSource");
      _mesa_unmarshal_ShaderSource(ctx, (const struct marshal_cmd_ShaderSource *) cmd);
      break;
   case DISPATCH_CMD_Normal3fv:
      debug_print_unmarshal("Normal3fv");
      _mesa_unmarshal_Normal3fv(ctx, (const struct marshal_cmd_Normal3fv *) cmd);
      break;
   case DISPATCH_CMD_NormalP3ui:
      debug_print_unmarshal("NormalP3ui");
      _mesa_unmarshal_NormalP3ui(ctx, (const struct marshal_cmd_NormalP3ui *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord3fvARB:
      debug_print_unmarshal("MultiTexCoord3fvARB");
      _mesa_unmarshal_MultiTexCoord3fvARB(ctx, (const struct marshal_cmd_MultiTexCoord3fvARB *) cmd);
      break;
   case DISPATCH_CMD_BufferData:
      debug_print_unmarshal("BufferData");
      _mesa_unmarshal_BufferData(ctx, (const struct marshal_cmd_BufferData *) cmd);
      break;
   case DISPATCH_CMD_Uniform3fv:
      debug_print_unmarshal("Uniform3fv");
      _mesa_unmarshal_Uniform3fv(ctx, (const struct marshal_cmd_Uniform3fv *) cmd);
      break;
   case DISPATCH_CMD_BlendEquation:
      debug_print_unmarshal("BlendEquation");
      _mesa_unmarshal_BlendEquation(ctx, (const struct marshal_cmd_BlendEquation *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib3dNV:
      debug_print_unmarshal("VertexAttrib3dNV");
      _mesa_unmarshal_VertexAttrib3dNV(ctx, (const struct marshal_cmd_VertexAttrib3dNV *) cmd);
      break;
   case DISPATCH_CMD_PushName:
      debug_print_unmarshal("PushName");
      _mesa_unmarshal_PushName(ctx, (const struct marshal_cmd_PushName *) cmd);
      break;
   case DISPATCH_CMD_DeleteRenderbuffers:
      debug_print_unmarshal("DeleteRenderbuffers");
      _mesa_unmarshal_DeleteRenderbuffers(ctx, (const struct marshal_cmd_DeleteRenderbuffers *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib1dv:
      debug_print_unmarshal("VertexAttrib1dv");
      _mesa_unmarshal_VertexAttrib1dv(ctx, (const struct marshal_cmd_VertexAttrib1dv *) cmd);
      break;
   case DISPATCH_CMD_Rotated:
      debug_print_unmarshal("Rotated");
      _mesa_unmarshal_Rotated(ctx, (const struct marshal_cmd_Rotated *) cmd);
      break;
   case DISPATCH_CMD_Color4iv:
      debug_print_unmarshal("Color4iv");
      _mesa_unmarshal_Color4iv(ctx, (const struct marshal_cmd_Color4iv *) cmd);
      break;
   case DISPATCH_CMD_Rotatex:
      debug_print_unmarshal("Rotatex");
      _mesa_unmarshal_Rotatex(ctx, (const struct marshal_cmd_Rotatex *) cmd);
      break;
   case DISPATCH_CMD_FramebufferTextureLayer:
      debug_print_unmarshal("FramebufferTextureLayer");
      _mesa_unmarshal_FramebufferTextureLayer(ctx, (const struct marshal_cmd_FramebufferTextureLayer *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix3fv:
      debug_print_unmarshal("ProgramUniformMatrix3fv");
      _mesa_unmarshal_ProgramUniformMatrix3fv(ctx, (const struct marshal_cmd_ProgramUniformMatrix3fv *) cmd);
      break;
   case DISPATCH_CMD_LoadMatrixf:
      debug_print_unmarshal("LoadMatrixf");
      _mesa_unmarshal_LoadMatrixf(ctx, (const struct marshal_cmd_LoadMatrixf *) cmd);
      break;
   case DISPATCH_CMD_MakeTextureHandleResidentARB:
      debug_print_unmarshal("MakeTextureHandleResidentARB");
      _mesa_unmarshal_MakeTextureHandleResidentARB(ctx, (const struct marshal_cmd_MakeTextureHandleResidentARB *) cmd);
      break;
   case DISPATCH_CMD_DrawRangeElementsBaseVertex:
      debug_print_unmarshal("DrawRangeElementsBaseVertex");
      _mesa_unmarshal_DrawRangeElementsBaseVertex(ctx, (const struct marshal_cmd_DrawRangeElementsBaseVertex *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix4dv:
      debug_print_unmarshal("ProgramUniformMatrix4dv");
      _mesa_unmarshal_ProgramUniformMatrix4dv(ctx, (const struct marshal_cmd_ProgramUniformMatrix4dv *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColor3bv:
      debug_print_unmarshal("SecondaryColor3bv");
      _mesa_unmarshal_SecondaryColor3bv(ctx, (const struct marshal_cmd_SecondaryColor3bv *) cmd);
      break;
   case DISPATCH_CMD_DrawTexxvOES:
      debug_print_unmarshal("DrawTexxvOES");
      _mesa_unmarshal_DrawTexxvOES(ctx, (const struct marshal_cmd_DrawTexxvOES *) cmd);
      break;
   case DISPATCH_CMD_Color4ubv:
      debug_print_unmarshal("Color4ubv");
      _mesa_unmarshal_Color4ubv(ctx, (const struct marshal_cmd_Color4ubv *) cmd);
      break;
   case DISPATCH_CMD_TexCoord2fv:
      debug_print_unmarshal("TexCoord2fv");
      _mesa_unmarshal_TexCoord2fv(ctx, (const struct marshal_cmd_TexCoord2fv *) cmd);
      break;
   case DISPATCH_CMD_FogCoorddv:
      debug_print_unmarshal("FogCoorddv");
      _mesa_unmarshal_FogCoorddv(ctx, (const struct marshal_cmd_FogCoorddv *) cmd);
      break;
   case DISPATCH_CMD_VDPAUUnregisterSurfaceNV:
      debug_print_unmarshal("VDPAUUnregisterSurfaceNV");
      _mesa_unmarshal_VDPAUUnregisterSurfaceNV(ctx, (const struct marshal_cmd_VDPAUUnregisterSurfaceNV *) cmd);
      break;
   case DISPATCH_CMD_ColorP3ui:
      debug_print_unmarshal("ColorP3ui");
      _mesa_unmarshal_ColorP3ui(ctx, (const struct marshal_cmd_ColorP3ui *) cmd);
      break;
   case DISPATCH_CMD_ClearBufferuiv:
      debug_print_unmarshal("ClearBufferuiv");
      _mesa_unmarshal_ClearBufferuiv(ctx, (const struct marshal_cmd_ClearBufferuiv *) cmd);
      break;
   case DISPATCH_CMD_Flush:
      debug_print_unmarshal("Flush");
      _mesa_unmarshal_Flush(ctx, (const struct marshal_cmd_Flush *) cmd);
      break;
   case DISPATCH_CMD_MakeTextureHandleNonResidentARB:
      debug_print_unmarshal("MakeTextureHandleNonResidentARB");
      _mesa_unmarshal_MakeTextureHandleNonResidentARB(ctx, (const struct marshal_cmd_MakeTextureHandleNonResidentARB *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribI4iEXT:
      debug_print_unmarshal("VertexAttribI4iEXT");
      _mesa_unmarshal_VertexAttribI4iEXT(ctx, (const struct marshal_cmd_VertexAttribI4iEXT *) cmd);
      break;
   case DISPATCH_CMD_FogCoordd:
      debug_print_unmarshal("FogCoordd");
      _mesa_unmarshal_FogCoordd(ctx, (const struct marshal_cmd_FogCoordd *) cmd);
      break;
   case DISPATCH_CMD_BindFramebufferEXT:
      debug_print_unmarshal("BindFramebufferEXT");
      _mesa_unmarshal_BindFramebufferEXT(ctx, (const struct marshal_cmd_BindFramebufferEXT *) cmd);
      break;
   case DISPATCH_CMD_Uniform3iv:
      debug_print_unmarshal("Uniform3iv");
      _mesa_unmarshal_Uniform3iv(ctx, (const struct marshal_cmd_Uniform3iv *) cmd);
      break;
   case DISPATCH_CMD_TexStorage2DMultisample:
      debug_print_unmarshal("TexStorage2DMultisample");
      _mesa_unmarshal_TexStorage2DMultisample(ctx, (const struct marshal_cmd_TexStorage2DMultisample *) cmd);
      break;
   case DISPATCH_CMD_UnlockArraysEXT:
      debug_print_unmarshal("UnlockArraysEXT");
      _mesa_unmarshal_UnlockArraysEXT(ctx, (const struct marshal_cmd_UnlockArraysEXT *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4iv:
      debug_print_unmarshal("VertexAttrib4iv");
      _mesa_unmarshal_VertexAttrib4iv(ctx, (const struct marshal_cmd_VertexAttrib4iv *) cmd);
      break;
   case DISPATCH_CMD_CopyTexSubImage3D:
      debug_print_unmarshal("CopyTexSubImage3D");
      _mesa_unmarshal_CopyTexSubImage3D(ctx, (const struct marshal_cmd_CopyTexSubImage3D *) cmd);
      break;
   case DISPATCH_CMD_PolygonOffsetClampEXT:
      debug_print_unmarshal("PolygonOffsetClampEXT");
      _mesa_unmarshal_PolygonOffsetClampEXT(ctx, (const struct marshal_cmd_PolygonOffsetClampEXT *) cmd);
      break;
   case DISPATCH_CMD_DetachObjectARB:
      debug_print_unmarshal("DetachObjectARB");
      _mesa_unmarshal_DetachObjectARB(ctx, (const struct marshal_cmd_DetachObjectARB *) cmd);
      break;
   case DISPATCH_CMD_Indexiv:
      debug_print_unmarshal("Indexiv");
      _mesa_unmarshal_Indexiv(ctx, (const struct marshal_cmd_Indexiv *) cmd);
      break;
   case DISPATCH_CMD_TexEnvi:
      debug_print_unmarshal("TexEnvi");
      _mesa_unmarshal_TexEnvi(ctx, (const struct marshal_cmd_TexEnvi *) cmd);
      break;
   case DISPATCH_CMD_TexEnvf:
      debug_print_unmarshal("TexEnvf");
      _mesa_unmarshal_TexEnvf(ctx, (const struct marshal_cmd_TexEnvf *) cmd);
      break;
   case DISPATCH_CMD_TexEnvx:
      debug_print_unmarshal("TexEnvx");
      _mesa_unmarshal_TexEnvx(ctx, (const struct marshal_cmd_TexEnvx *) cmd);
      break;
   case DISPATCH_CMD_InvalidateBufferSubData:
      debug_print_unmarshal("InvalidateBufferSubData");
      _mesa_unmarshal_InvalidateBufferSubData(ctx, (const struct marshal_cmd_InvalidateBufferSubData *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix4x2fv:
      debug_print_unmarshal("UniformMatrix4x2fv");
      _mesa_unmarshal_UniformMatrix4x2fv(ctx, (const struct marshal_cmd_UniformMatrix4x2fv *) cmd);
      break;
   case DISPATCH_CMD_PolygonOffset:
      debug_print_unmarshal("PolygonOffset");
      _mesa_unmarshal_PolygonOffset(ctx, (const struct marshal_cmd_PolygonOffset *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix4x2dv:
      debug_print_unmarshal("ProgramUniformMatrix4x2dv");
      _mesa_unmarshal_ProgramUniformMatrix4x2dv(ctx, (const struct marshal_cmd_ProgramUniformMatrix4x2dv *) cmd);
      break;
   case DISPATCH_CMD_ProgramEnvParameter4fARB:
      debug_print_unmarshal("ProgramEnvParameter4fARB");
      _mesa_unmarshal_ProgramEnvParameter4fARB(ctx, (const struct marshal_cmd_ProgramEnvParameter4fARB *) cmd);
      break;
   case DISPATCH_CMD_ClearDepth:
      debug_print_unmarshal("ClearDepth");
      _mesa_unmarshal_ClearDepth(ctx, (const struct marshal_cmd_ClearDepth *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib3dvNV:
      debug_print_unmarshal("VertexAttrib3dvNV");
      _mesa_unmarshal_VertexAttrib3dvNV(ctx, (const struct marshal_cmd_VertexAttrib3dvNV *) cmd);
      break;
   case DISPATCH_CMD_Color4fv:
      debug_print_unmarshal("Color4fv");
      _mesa_unmarshal_Color4fv(ctx, (const struct marshal_cmd_Color4fv *) cmd);
      break;
   case DISPATCH_CMD_ColorPointer:
      debug_print_unmarshal("ColorPointer");
      _mesa_unmarshal_ColorPointer(ctx, (const struct marshal_cmd_ColorPointer *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform2ui64ARB:
      debug_print_unmarshal("ProgramUniform2ui64ARB");
      _mesa_unmarshal_ProgramUniform2ui64ARB(ctx, (const struct marshal_cmd_ProgramUniform2ui64ARB *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib3sv:
      debug_print_unmarshal("VertexAttrib3sv");
      _mesa_unmarshal_VertexAttrib3sv(ctx, (const struct marshal_cmd_VertexAttrib3sv *) cmd);
      break;
   case DISPATCH_CMD_Uniform4i64ARB:
      debug_print_unmarshal("Uniform4i64ARB");
      _mesa_unmarshal_Uniform4i64ARB(ctx, (const struct marshal_cmd_Uniform4i64ARB *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform3ui64ARB:
      debug_print_unmarshal("ProgramUniform3ui64ARB");
      _mesa_unmarshal_ProgramUniform3ui64ARB(ctx, (const struct marshal_cmd_ProgramUniform3ui64ARB *) cmd);
      break;
   case DISPATCH_CMD_PushClientAttrib:
      debug_print_unmarshal("PushClientAttrib");
      _mesa_unmarshal_PushClientAttrib(ctx, (const struct marshal_cmd_PushClientAttrib *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform4ui:
      debug_print_unmarshal("ProgramUniform4ui");
      _mesa_unmarshal_ProgramUniform4ui(ctx, (const struct marshal_cmd_ProgramUniform4ui *) cmd);
      break;
   case DISPATCH_CMD_Uniform1f:
      debug_print_unmarshal("Uniform1f");
      _mesa_unmarshal_Uniform1f(ctx, (const struct marshal_cmd_Uniform1f *) cmd);
      break;
   case DISPATCH_CMD_Uniform1d:
      debug_print_unmarshal("Uniform1d");
      _mesa_unmarshal_Uniform1d(ctx, (const struct marshal_cmd_Uniform1d *) cmd);
      break;
   case DISPATCH_CMD_Uniform1i:
      debug_print_unmarshal("Uniform1i");
      _mesa_unmarshal_Uniform1i(ctx, (const struct marshal_cmd_Uniform1i *) cmd);
      break;
   case DISPATCH_CMD_BlitNamedFramebuffer:
      debug_print_unmarshal("BlitNamedFramebuffer");
      _mesa_unmarshal_BlitNamedFramebuffer(ctx, (const struct marshal_cmd_BlitNamedFramebuffer *) cmd);
      break;
   case DISPATCH_CMD_UseProgram:
      debug_print_unmarshal("UseProgram");
      _mesa_unmarshal_UseProgram(ctx, (const struct marshal_cmd_UseProgram *) cmd);
      break;
   case DISPATCH_CMD_TexStorageMem2DMultisampleEXT:
      debug_print_unmarshal("TexStorageMem2DMultisampleEXT");
      _mesa_unmarshal_TexStorageMem2DMultisampleEXT(ctx, (const struct marshal_cmd_TexStorageMem2DMultisampleEXT *) cmd);
      break;
   case DISPATCH_CMD_Color3s:
      debug_print_unmarshal("Color3s");
      _mesa_unmarshal_Color3s(ctx, (const struct marshal_cmd_Color3s *) cmd);
      break;
   case DISPATCH_CMD_TextureStorage2DMultisample:
      debug_print_unmarshal("TextureStorage2DMultisample");
      _mesa_unmarshal_TextureStorage2DMultisample(ctx, (const struct marshal_cmd_TextureStorage2DMultisample *) cmd);
      break;
   case DISPATCH_CMD_TexCoordPointer:
      debug_print_unmarshal("TexCoordPointer");
      _mesa_unmarshal_TexCoordPointer(ctx, (const struct marshal_cmd_TexCoordPointer *) cmd);
      break;
   case DISPATCH_CMD_Color3i:
      debug_print_unmarshal("Color3i");
      _mesa_unmarshal_Color3i(ctx, (const struct marshal_cmd_Color3i *) cmd);
      break;
   case DISPATCH_CMD_EvalCoord2d:
      debug_print_unmarshal("EvalCoord2d");
      _mesa_unmarshal_EvalCoord2d(ctx, (const struct marshal_cmd_EvalCoord2d *) cmd);
      break;
   case DISPATCH_CMD_EvalCoord2f:
      debug_print_unmarshal("EvalCoord2f");
      _mesa_unmarshal_EvalCoord2f(ctx, (const struct marshal_cmd_EvalCoord2f *) cmd);
      break;
   case DISPATCH_CMD_Color3b:
      debug_print_unmarshal("Color3b");
      _mesa_unmarshal_Color3b(ctx, (const struct marshal_cmd_Color3b *) cmd);
      break;
   case DISPATCH_CMD_Color3f:
      debug_print_unmarshal("Color3f");
      _mesa_unmarshal_Color3f(ctx, (const struct marshal_cmd_Color3f *) cmd);
      break;
   case DISPATCH_CMD_Color3d:
      debug_print_unmarshal("Color3d");
      _mesa_unmarshal_Color3d(ctx, (const struct marshal_cmd_Color3d *) cmd);
      break;
   case DISPATCH_CMD_ClearDepthx:
      debug_print_unmarshal("ClearDepthx");
      _mesa_unmarshal_ClearDepthx(ctx, (const struct marshal_cmd_ClearDepthx *) cmd);
      break;
   case DISPATCH_CMD_EnableVertexArrayAttrib:
      debug_print_unmarshal("EnableVertexArrayAttrib");
      _mesa_unmarshal_EnableVertexArrayAttrib(ctx, (const struct marshal_cmd_EnableVertexArrayAttrib *) cmd);
      break;
   case DISPATCH_CMD_BlendEquationSeparate:
      debug_print_unmarshal("BlendEquationSeparate");
      _mesa_unmarshal_BlendEquationSeparate(ctx, (const struct marshal_cmd_BlendEquationSeparate *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoordP4ui:
      debug_print_unmarshal("MultiTexCoordP4ui");
      _mesa_unmarshal_MultiTexCoordP4ui(ctx, (const struct marshal_cmd_MultiTexCoordP4ui *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribs1fvNV:
      debug_print_unmarshal("VertexAttribs1fvNV");
      _mesa_unmarshal_VertexAttribs1fvNV(ctx, (const struct marshal_cmd_VertexAttribs1fvNV *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribIPointer:
      debug_print_unmarshal("VertexAttribIPointer");
      _mesa_unmarshal_VertexAttribIPointer(ctx, (const struct marshal_cmd_VertexAttribIPointer *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform4fv:
      debug_print_unmarshal("ProgramUniform4fv");
      _mesa_unmarshal_ProgramUniform4fv(ctx, (const struct marshal_cmd_ProgramUniform4fv *) cmd);
      break;
   case DISPATCH_CMD_RasterPos4sv:
      debug_print_unmarshal("RasterPos4sv");
      _mesa_unmarshal_RasterPos4sv(ctx, (const struct marshal_cmd_RasterPos4sv *) cmd);
      break;
   case DISPATCH_CMD_CopyTextureSubImage3D:
      debug_print_unmarshal("CopyTextureSubImage3D");
      _mesa_unmarshal_CopyTextureSubImage3D(ctx, (const struct marshal_cmd_CopyTextureSubImage3D *) cmd);
      break;
   case DISPATCH_CMD_TextureView:
      debug_print_unmarshal("TextureView");
      _mesa_unmarshal_TextureView(ctx, (const struct marshal_cmd_TextureView *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribDivisor:
      debug_print_unmarshal("VertexAttribDivisor");
      _mesa_unmarshal_VertexAttribDivisor(ctx, (const struct marshal_cmd_VertexAttribDivisor *) cmd);
      break;
   case DISPATCH_CMD_DrawTransformFeedbackStream:
      debug_print_unmarshal("DrawTransformFeedbackStream");
      _mesa_unmarshal_DrawTransformFeedbackStream(ctx, (const struct marshal_cmd_DrawTransformFeedbackStream *) cmd);
      break;
   case DISPATCH_CMD_EndPerfQueryINTEL:
      debug_print_unmarshal("EndPerfQueryINTEL");
      _mesa_unmarshal_EndPerfQueryINTEL(ctx, (const struct marshal_cmd_EndPerfQueryINTEL *) cmd);
      break;
   case DISPATCH_CMD_NamedBufferPageCommitmentARB:
      debug_print_unmarshal("NamedBufferPageCommitmentARB");
      _mesa_unmarshal_NamedBufferPageCommitmentARB(ctx, (const struct marshal_cmd_NamedBufferPageCommitmentARB *) cmd);
      break;
   case DISPATCH_CMD_AlphaFuncx:
      debug_print_unmarshal("AlphaFuncx");
      _mesa_unmarshal_AlphaFuncx(ctx, (const struct marshal_cmd_AlphaFuncx *) cmd);
      break;
   case DISPATCH_CMD_VertexArrayVertexBuffer:
      debug_print_unmarshal("VertexArrayVertexBuffer");
      _mesa_unmarshal_VertexArrayVertexBuffer(ctx, (const struct marshal_cmd_VertexArrayVertexBuffer *) cmd);
      break;
   case DISPATCH_CMD_PixelTransferf:
      debug_print_unmarshal("PixelTransferf");
      _mesa_unmarshal_PixelTransferf(ctx, (const struct marshal_cmd_PixelTransferf *) cmd);
      break;
   case DISPATCH_CMD_PixelTransferi:
      debug_print_unmarshal("PixelTransferi");
      _mesa_unmarshal_PixelTransferi(ctx, (const struct marshal_cmd_PixelTransferi *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib3fvNV:
      debug_print_unmarshal("VertexAttrib3fvNV");
      _mesa_unmarshal_VertexAttrib3fvNV(ctx, (const struct marshal_cmd_VertexAttrib3fvNV *) cmd);
      break;
   case DISPATCH_CMD_SecondaryColorP3ui:
      debug_print_unmarshal("SecondaryColorP3ui");
      _mesa_unmarshal_SecondaryColorP3ui(ctx, (const struct marshal_cmd_SecondaryColorP3ui *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib4fvNV:
      debug_print_unmarshal("VertexAttrib4fvNV");
      _mesa_unmarshal_VertexAttrib4fvNV(ctx, (const struct marshal_cmd_VertexAttrib4fvNV *) cmd);
      break;
   case DISPATCH_CMD_Rectiv:
      debug_print_unmarshal("Rectiv");
      _mesa_unmarshal_Rectiv(ctx, (const struct marshal_cmd_Rectiv *) cmd);
      break;
   case DISPATCH_CMD_MultiTexCoord1iv:
      debug_print_unmarshal("MultiTexCoord1iv");
      _mesa_unmarshal_MultiTexCoord1iv(ctx, (const struct marshal_cmd_MultiTexCoord1iv *) cmd);
      break;
   case DISPATCH_CMD_PassTexCoordATI:
      debug_print_unmarshal("PassTexCoordATI");
      _mesa_unmarshal_PassTexCoordATI(ctx, (const struct marshal_cmd_PassTexCoordATI *) cmd);
      break;
   case DISPATCH_CMD_Vertex2fv:
      debug_print_unmarshal("Vertex2fv");
      _mesa_unmarshal_Vertex2fv(ctx, (const struct marshal_cmd_Vertex2fv *) cmd);
      break;
   case DISPATCH_CMD_BindRenderbufferEXT:
      debug_print_unmarshal("BindRenderbufferEXT");
      _mesa_unmarshal_BindRenderbufferEXT(ctx, (const struct marshal_cmd_BindRenderbufferEXT *) cmd);
      break;
   case DISPATCH_CMD_Vertex3sv:
      debug_print_unmarshal("Vertex3sv");
      _mesa_unmarshal_Vertex3sv(ctx, (const struct marshal_cmd_Vertex3sv *) cmd);
      break;
   case DISPATCH_CMD_EvalMesh1:
      debug_print_unmarshal("EvalMesh1");
      _mesa_unmarshal_EvalMesh1(ctx, (const struct marshal_cmd_EvalMesh1 *) cmd);
      break;
   case DISPATCH_CMD_DiscardFramebufferEXT:
      debug_print_unmarshal("DiscardFramebufferEXT");
      _mesa_unmarshal_DiscardFramebufferEXT(ctx, (const struct marshal_cmd_DiscardFramebufferEXT *) cmd);
      break;
   case DISPATCH_CMD_Uniform2f:
      debug_print_unmarshal("Uniform2f");
      _mesa_unmarshal_Uniform2f(ctx, (const struct marshal_cmd_Uniform2f *) cmd);
      break;
   case DISPATCH_CMD_Uniform2d:
      debug_print_unmarshal("Uniform2d");
      _mesa_unmarshal_Uniform2d(ctx, (const struct marshal_cmd_Uniform2d *) cmd);
      break;
   case DISPATCH_CMD_ColorPointerEXT:
      debug_print_unmarshal("ColorPointerEXT");
      _mesa_unmarshal_ColorPointerEXT(ctx, (const struct marshal_cmd_ColorPointerEXT *) cmd);
      break;
   case DISPATCH_CMD_LineWidth:
      debug_print_unmarshal("LineWidth");
      _mesa_unmarshal_LineWidth(ctx, (const struct marshal_cmd_LineWidth *) cmd);
      break;
   case DISPATCH_CMD_Uniform2i:
      debug_print_unmarshal("Uniform2i");
      _mesa_unmarshal_Uniform2i(ctx, (const struct marshal_cmd_Uniform2i *) cmd);
      break;
   case DISPATCH_CMD_DepthRangeIndexed:
      debug_print_unmarshal("DepthRangeIndexed");
      _mesa_unmarshal_DepthRangeIndexed(ctx, (const struct marshal_cmd_DepthRangeIndexed *) cmd);
      break;
   case DISPATCH_CMD_TexImage3DMultisample:
      debug_print_unmarshal("TexImage3DMultisample");
      _mesa_unmarshal_TexImage3DMultisample(ctx, (const struct marshal_cmd_TexImage3DMultisample *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib1fvNV:
      debug_print_unmarshal("VertexAttrib1fvNV");
      _mesa_unmarshal_VertexAttrib1fvNV(ctx, (const struct marshal_cmd_VertexAttrib1fvNV *) cmd);
      break;
   case DISPATCH_CMD_DetachShader:
      debug_print_unmarshal("DetachShader");
      _mesa_unmarshal_DetachShader(ctx, (const struct marshal_cmd_DetachShader *) cmd);
      break;
   case DISPATCH_CMD_CopyTexSubImage2D:
      debug_print_unmarshal("CopyTexSubImage2D");
      _mesa_unmarshal_CopyTexSubImage2D(ctx, (const struct marshal_cmd_CopyTexSubImage2D *) cmd);
      break;
   case DISPATCH_CMD_Color3iv:
      debug_print_unmarshal("Color3iv");
      _mesa_unmarshal_Color3iv(ctx, (const struct marshal_cmd_Color3iv *) cmd);
      break;
   case DISPATCH_CMD_DrawElements:
      debug_print_unmarshal("DrawElements");
      _mesa_unmarshal_DrawElements(ctx, (const struct marshal_cmd_DrawElements *) cmd);
      break;
   case DISPATCH_CMD_ScissorArrayv:
      debug_print_unmarshal("ScissorArrayv");
      _mesa_unmarshal_ScissorArrayv(ctx, (const struct marshal_cmd_ScissorArrayv *) cmd);
      break;
   case DISPATCH_CMD_EvalPoint2:
      debug_print_unmarshal("EvalPoint2");
      _mesa_unmarshal_EvalPoint2(ctx, (const struct marshal_cmd_EvalPoint2 *) cmd);
      break;
   case DISPATCH_CMD_EvalPoint1:
      debug_print_unmarshal("EvalPoint1");
      _mesa_unmarshal_EvalPoint1(ctx, (const struct marshal_cmd_EvalPoint1 *) cmd);
      break;
   case DISPATCH_CMD_PopMatrix:
      debug_print_unmarshal("PopMatrix");
      _mesa_unmarshal_PopMatrix(ctx, (const struct marshal_cmd_PopMatrix *) cmd);
      break;
   case DISPATCH_CMD_NamedBufferData:
      debug_print_unmarshal("NamedBufferData");
      _mesa_unmarshal_NamedBufferData(ctx, (const struct marshal_cmd_NamedBufferData *) cmd);
      break;
   case DISPATCH_CMD_EvalCoord1d:
      debug_print_unmarshal("EvalCoord1d");
      _mesa_unmarshal_EvalCoord1d(ctx, (const struct marshal_cmd_EvalCoord1d *) cmd);
      break;
   case DISPATCH_CMD_VertexAttribL1d:
      debug_print_unmarshal("VertexAttribL1d");
      _mesa_unmarshal_VertexAttribL1d(ctx, (const struct marshal_cmd_VertexAttribL1d *) cmd);
      break;
   case DISPATCH_CMD_EvalCoord1f:
      debug_print_unmarshal("EvalCoord1f");
      _mesa_unmarshal_EvalCoord1f(ctx, (const struct marshal_cmd_EvalCoord1f *) cmd);
      break;
   case DISPATCH_CMD_Materialf:
      debug_print_unmarshal("Materialf");
      _mesa_unmarshal_Materialf(ctx, (const struct marshal_cmd_Materialf *) cmd);
      break;
   case DISPATCH_CMD_Materiali:
      debug_print_unmarshal("Materiali");
      _mesa_unmarshal_Materiali(ctx, (const struct marshal_cmd_Materiali *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform1uiv:
      debug_print_unmarshal("ProgramUniform1uiv");
      _mesa_unmarshal_ProgramUniform1uiv(ctx, (const struct marshal_cmd_ProgramUniform1uiv *) cmd);
      break;
   case DISPATCH_CMD_EvalCoord1dv:
      debug_print_unmarshal("EvalCoord1dv");
      _mesa_unmarshal_EvalCoord1dv(ctx, (const struct marshal_cmd_EvalCoord1dv *) cmd);
      break;
   case DISPATCH_CMD_Materialx:
      debug_print_unmarshal("Materialx");
      _mesa_unmarshal_Materialx(ctx, (const struct marshal_cmd_Materialx *) cmd);
      break;
   case DISPATCH_CMD_GetQueryBufferObjectiv:
      debug_print_unmarshal("GetQueryBufferObjectiv");
      _mesa_unmarshal_GetQueryBufferObjectiv(ctx, (const struct marshal_cmd_GetQueryBufferObjectiv *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform3i64ARB:
      debug_print_unmarshal("ProgramUniform3i64ARB");
      _mesa_unmarshal_ProgramUniform3i64ARB(ctx, (const struct marshal_cmd_ProgramUniform3i64ARB *) cmd);
      break;
   case DISPATCH_CMD_BindBuffer:
      debug_print_unmarshal("BindBuffer");
      _mesa_unmarshal_BindBuffer(ctx, (const struct marshal_cmd_BindBuffer *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform1i:
      debug_print_unmarshal("ProgramUniform1i");
      _mesa_unmarshal_ProgramUniform1i(ctx, (const struct marshal_cmd_ProgramUniform1i *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform1f:
      debug_print_unmarshal("ProgramUniform1f");
      _mesa_unmarshal_ProgramUniform1f(ctx, (const struct marshal_cmd_ProgramUniform1f *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform1d:
      debug_print_unmarshal("ProgramUniform1d");
      _mesa_unmarshal_ProgramUniform1d(ctx, (const struct marshal_cmd_ProgramUniform1d *) cmd);
      break;
   case DISPATCH_CMD_CopyConvolutionFilter2D:
      debug_print_unmarshal("CopyConvolutionFilter2D");
      _mesa_unmarshal_CopyConvolutionFilter2D(ctx, (const struct marshal_cmd_CopyConvolutionFilter2D *) cmd);
      break;
   case DISPATCH_CMD_CopyBufferSubData:
      debug_print_unmarshal("CopyBufferSubData");
      _mesa_unmarshal_CopyBufferSubData(ctx, (const struct marshal_cmd_CopyBufferSubData *) cmd);
      break;
   case DISPATCH_CMD_UniformMatrix3x4fv:
      debug_print_unmarshal("UniformMatrix3x4fv");
      _mesa_unmarshal_UniformMatrix3x4fv(ctx, (const struct marshal_cmd_UniformMatrix3x4fv *) cmd);
      break;
   case DISPATCH_CMD_Recti:
      debug_print_unmarshal("Recti");
      _mesa_unmarshal_Recti(ctx, (const struct marshal_cmd_Recti *) cmd);
      break;
   case DISPATCH_CMD_SamplerParameteri:
      debug_print_unmarshal("SamplerParameteri");
      _mesa_unmarshal_SamplerParameteri(ctx, (const struct marshal_cmd_SamplerParameteri *) cmd);
      break;
   case DISPATCH_CMD_Rectf:
      debug_print_unmarshal("Rectf");
      _mesa_unmarshal_Rectf(ctx, (const struct marshal_cmd_Rectf *) cmd);
      break;
   case DISPATCH_CMD_Rectd:
      debug_print_unmarshal("Rectd");
      _mesa_unmarshal_Rectd(ctx, (const struct marshal_cmd_Rectd *) cmd);
      break;
   case DISPATCH_CMD_MultMatrixx:
      debug_print_unmarshal("MultMatrixx");
      _mesa_unmarshal_MultMatrixx(ctx, (const struct marshal_cmd_MultMatrixx *) cmd);
      break;
   case DISPATCH_CMD_TexStorageMem3DMultisampleEXT:
      debug_print_unmarshal("TexStorageMem3DMultisampleEXT");
      _mesa_unmarshal_TexStorageMem3DMultisampleEXT(ctx, (const struct marshal_cmd_TexStorageMem3DMultisampleEXT *) cmd);
      break;
   case DISPATCH_CMD_Rects:
      debug_print_unmarshal("Rects");
      _mesa_unmarshal_Rects(ctx, (const struct marshal_cmd_Rects *) cmd);
      break;
   case DISPATCH_CMD_TexCoord4s:
      debug_print_unmarshal("TexCoord4s");
      _mesa_unmarshal_TexCoord4s(ctx, (const struct marshal_cmd_TexCoord4s *) cmd);
      break;
   case DISPATCH_CMD_TexCoord4i:
      debug_print_unmarshal("TexCoord4i");
      _mesa_unmarshal_TexCoord4i(ctx, (const struct marshal_cmd_TexCoord4i *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniform1ui64vARB:
      debug_print_unmarshal("ProgramUniform1ui64vARB");
      _mesa_unmarshal_ProgramUniform1ui64vARB(ctx, (const struct marshal_cmd_ProgramUniform1ui64vARB *) cmd);
      break;
   case DISPATCH_CMD_TexCoord4d:
      debug_print_unmarshal("TexCoord4d");
      _mesa_unmarshal_TexCoord4d(ctx, (const struct marshal_cmd_TexCoord4d *) cmd);
      break;
   case DISPATCH_CMD_TexCoord4f:
      debug_print_unmarshal("TexCoord4f");
      _mesa_unmarshal_TexCoord4f(ctx, (const struct marshal_cmd_TexCoord4f *) cmd);
      break;
   case DISPATCH_CMD_ProgramUniformMatrix3dv:
      debug_print_unmarshal("ProgramUniformMatrix3dv");
      _mesa_unmarshal_ProgramUniformMatrix3dv(ctx, (const struct marshal_cmd_ProgramUniformMatrix3dv *) cmd);
      break;
   case DISPATCH_CMD_LockArraysEXT:
      debug_print_unmarshal("LockArraysEXT");
      _mesa_unmarshal_LockArraysEXT(ctx, (const struct marshal_cmd_LockArraysEXT *) cmd);
      break;
   case DISPATCH_CMD_Rectfv:
      debug_print_unmarshal("Rectfv");
      _mesa_unmarshal_Rectfv(ctx, (const struct marshal_cmd_Rectfv *) cmd);
      break;
   case DISPATCH_CMD_BindImageTexture:
      debug_print_unmarshal("BindImageTexture");
      _mesa_unmarshal_BindImageTexture(ctx, (const struct marshal_cmd_BindImageTexture *) cmd);
      break;
   case DISPATCH_CMD_MinSampleShading:
      debug_print_unmarshal("MinSampleShading");
      _mesa_unmarshal_MinSampleShading(ctx, (const struct marshal_cmd_MinSampleShading *) cmd);
      break;
   case DISPATCH_CMD_VertexAttrib1dNV:
      debug_print_unmarshal("VertexAttrib1dNV");
      _mesa_unmarshal_VertexAttrib1dNV(ctx, (const struct marshal_cmd_VertexAttrib1dNV *) cmd);
      break;
   case DISPATCH_CMD_EndFragmentShaderATI:
      debug_print_unmarshal("EndFragmentShaderATI");
      _mesa_unmarshal_EndFragmentShaderATI(ctx, (const struct marshal_cmd_EndFragmentShaderATI *) cmd);
      break;
   case DISPATCH_CMD_Uniform4iv:
      debug_print_unmarshal("Uniform4iv");
      _mesa_unmarshal_Uniform4iv(ctx, (const struct marshal_cmd_Uniform4iv *) cmd);
      break;
   default:
      assert(!"Unrecognized command ID");
      break;
   }

   return cmd_base->cmd_size;
}


struct _glapi_table *
_mesa_create_marshal_table(const struct gl_context *ctx)
{
   struct _glapi_table *table;

   table = _mesa_alloc_dispatch_table();
   if (table == NULL)
      return NULL;

   SET_MapGrid1d(table, _mesa_marshal_MapGrid1d);
   SET_MapGrid1f(table, _mesa_marshal_MapGrid1f);
   SET_ProgramUniform3i64vARB(table, _mesa_marshal_ProgramUniform3i64vARB);
   SET_GetProgramResourceLocationIndex(table, _mesa_marshal_GetProgramResourceLocationIndex);
   SET_TexCoordP1ui(table, _mesa_marshal_TexCoordP1ui);
   SET_PolygonStipple(table, _mesa_marshal_PolygonStipple);
   SET_MultiTexCoord1dv(table, _mesa_marshal_MultiTexCoord1dv);
   SET_IsEnabled(table, _mesa_marshal_IsEnabled);
   SET_AttachShader(table, _mesa_marshal_AttachShader);
   SET_VertexAttrib3fARB(table, _mesa_marshal_VertexAttrib3fARB);
   SET_Indexubv(table, _mesa_marshal_Indexubv);
   SET_GetCompressedTextureImage(table, _mesa_marshal_GetCompressedTextureImage);
   SET_MultiTexCoordP3uiv(table, _mesa_marshal_MultiTexCoordP3uiv);
   SET_VertexAttribI4usv(table, _mesa_marshal_VertexAttribI4usv);
   SET_Color3ubv(table, _mesa_marshal_Color3ubv);
   SET_GetClipPlanex(table, _mesa_marshal_GetClipPlanex);
   SET_ProgramUniform2ui(table, _mesa_marshal_ProgramUniform2ui);
   SET_TexCoordP1uiv(table, _mesa_marshal_TexCoordP1uiv);
   SET_RenderbufferStorage(table, _mesa_marshal_RenderbufferStorage);
   SET_GetClipPlanef(table, _mesa_marshal_GetClipPlanef);
   SET_GetPerfQueryDataINTEL(table, _mesa_marshal_GetPerfQueryDataINTEL);
   SET_DrawArraysIndirect(table, _mesa_marshal_DrawArraysIndirect);
   SET_Uniform3i(table, _mesa_marshal_Uniform3i);
   SET_VDPAUGetSurfaceivNV(table, _mesa_marshal_VDPAUGetSurfaceivNV);
   SET_Uniform3d(table, _mesa_marshal_Uniform3d);
   SET_Uniform3f(table, _mesa_marshal_Uniform3f);
   SET_UniformMatrix2x4fv(table, _mesa_marshal_UniformMatrix2x4fv);
   SET_QueryMatrixxOES(table, _mesa_marshal_QueryMatrixxOES);
   SET_Normal3iv(table, _mesa_marshal_Normal3iv);
   SET_DrawTexiOES(table, _mesa_marshal_DrawTexiOES);
   SET_Viewport(table, _mesa_marshal_Viewport);
   SET_CreateProgramPipelines(table, _mesa_marshal_CreateProgramPipelines);
   SET_DeleteVertexArrays(table, _mesa_marshal_DeleteVertexArrays);
   SET_ClearColorIuiEXT(table, _mesa_marshal_ClearColorIuiEXT);
   SET_GetnConvolutionFilterARB(table, _mesa_marshal_GetnConvolutionFilterARB);
   SET_PolygonOffsetx(table, _mesa_marshal_PolygonOffsetx);
   SET_GetLightxv(table, _mesa_marshal_GetLightxv);
   SET_GetConvolutionParameteriv(table, _mesa_marshal_GetConvolutionParameteriv);
   SET_DepthRangeIndexedfOES(table, _mesa_marshal_DepthRangeIndexedfOES);
   SET_GetProgramResourceLocation(table, _mesa_marshal_GetProgramResourceLocation);
   SET_GetSubroutineUniformLocation(table, _mesa_marshal_GetSubroutineUniformLocation);
   SET_VertexAttrib4usv(table, _mesa_marshal_VertexAttrib4usv);
   SET_TextureStorage1DEXT(table, _mesa_marshal_TextureStorage1DEXT);
   SET_VertexAttrib4Nub(table, _mesa_marshal_VertexAttrib4Nub);
   SET_VertexAttribP3ui(table, _mesa_marshal_VertexAttribP3ui);
   SET_PointSize(table, _mesa_marshal_PointSize);
   SET_PopName(table, _mesa_marshal_PopName);
   SET_FramebufferTexture(table, _mesa_marshal_FramebufferTexture);
   SET_CreateTransformFeedbacks(table, _mesa_marshal_CreateTransformFeedbacks);
   SET_VertexAttrib4ubNV(table, _mesa_marshal_VertexAttrib4ubNV);
   SET_ValidateProgramPipeline(table, _mesa_marshal_ValidateProgramPipeline);
   SET_BindFragDataLocationIndexed(table, _mesa_marshal_BindFragDataLocationIndexed);
   SET_GetClipPlane(table, _mesa_marshal_GetClipPlane);
   SET_DeleteSemaphoresEXT(table, _mesa_marshal_DeleteSemaphoresEXT);
   SET_TexCoordP4uiv(table, _mesa_marshal_TexCoordP4uiv);
   SET_VertexAttribs3dvNV(table, _mesa_marshal_VertexAttribs3dvNV);
   SET_ProgramUniformMatrix2x4dv(table, _mesa_marshal_ProgramUniformMatrix2x4dv);
   SET_GenQueries(table, _mesa_marshal_GenQueries);
   SET_ProgramUniform4iv(table, _mesa_marshal_ProgramUniform4iv);
   SET_ObjectUnpurgeableAPPLE(table, _mesa_marshal_ObjectUnpurgeableAPPLE);
   SET_GetCompressedTextureSubImage(table, _mesa_marshal_GetCompressedTextureSubImage);
   SET_TexCoord2iv(table, _mesa_marshal_TexCoord2iv);
   SET_TexImage2DMultisample(table, _mesa_marshal_TexImage2DMultisample);
   SET_TexParameterx(table, _mesa_marshal_TexParameterx);
   SET_Rotatef(table, _mesa_marshal_Rotatef);
   SET_TexParameterf(table, _mesa_marshal_TexParameterf);
   SET_TexParameteri(table, _mesa_marshal_TexParameteri);
   SET_GetUniformiv(table, _mesa_marshal_GetUniformiv);
   SET_ClearBufferSubData(table, _mesa_marshal_ClearBufferSubData);
   SET_TextureParameterfv(table, _mesa_marshal_TextureParameterfv);
   SET_VDPAUFiniNV(table, _mesa_marshal_VDPAUFiniNV);
   SET_ProgramUniformMatrix4x2fv(table, _mesa_marshal_ProgramUniformMatrix4x2fv);
   SET_ProgramUniform2f(table, _mesa_marshal_ProgramUniform2f);
   SET_ProgramUniform2d(table, _mesa_marshal_ProgramUniform2d);
   SET_ProgramUniform2i(table, _mesa_marshal_ProgramUniform2i);
   SET_Fogx(table, _mesa_marshal_Fogx);
   SET_Uniform3ui64ARB(table, _mesa_marshal_Uniform3ui64ARB);
   SET_Fogf(table, _mesa_marshal_Fogf);
   SET_TexSubImage1D(table, _mesa_marshal_TexSubImage1D);
   SET_ProgramUniform3ui64vARB(table, _mesa_marshal_ProgramUniform3ui64vARB);
   SET_Color4usv(table, _mesa_marshal_Color4usv);
   SET_Fogi(table, _mesa_marshal_Fogi);
   SET_DepthFunc(table, _mesa_marshal_DepthFunc);
   SET_GetSamplerParameterIiv(table, _mesa_marshal_GetSamplerParameterIiv);
   SET_VertexArrayAttribLFormat(table, _mesa_marshal_VertexArrayAttribLFormat);
   SET_VertexAttribI4uiEXT(table, _mesa_marshal_VertexAttribI4uiEXT);
   SET_DrawElementsInstancedBaseVertexBaseInstance(table, _mesa_marshal_DrawElementsInstancedBaseVertexBaseInstance);
   SET_ProgramEnvParameter4dvARB(table, _mesa_marshal_ProgramEnvParameter4dvARB);
   SET_ColorTableParameteriv(table, _mesa_marshal_ColorTableParameteriv);
   SET_BindSamplers(table, _mesa_marshal_BindSamplers);
   SET_GetnCompressedTexImageARB(table, _mesa_marshal_GetnCompressedTexImageARB);
   SET_CopyNamedBufferSubData(table, _mesa_marshal_CopyNamedBufferSubData);
   SET_BindSampler(table, _mesa_marshal_BindSampler);
   SET_GetUniformuiv(table, _mesa_marshal_GetUniformuiv);
   SET_GetQueryBufferObjectuiv(table, _mesa_marshal_GetQueryBufferObjectuiv);
   SET_MultiTexCoord2fARB(table, _mesa_marshal_MultiTexCoord2fARB);
   SET_Uniform1ui64ARB(table, _mesa_marshal_Uniform1ui64ARB);
   SET_IndexPointer(table, _mesa_marshal_IndexPointer);
   SET_MultiTexCoord3iv(table, _mesa_marshal_MultiTexCoord3iv);
   SET_Finish(table, _mesa_marshal_Finish);
   SET_ClearStencil(table, _mesa_marshal_ClearStencil);
   SET_ClearColorIiEXT(table, _mesa_marshal_ClearColorIiEXT);
   SET_LoadMatrixd(table, _mesa_marshal_LoadMatrixd);
   SET_VDPAURegisterOutputSurfaceNV(table, _mesa_marshal_VDPAURegisterOutputSurfaceNV);
   SET_VertexP4ui(table, _mesa_marshal_VertexP4ui);
   SET_GetProgramResourceIndex(table, _mesa_marshal_GetProgramResourceIndex);
   SET_TextureStorage3DMultisample(table, _mesa_marshal_TextureStorage3DMultisample);
   SET_GetnUniformivARB(table, _mesa_marshal_GetnUniformivARB);
   SET_ReleaseShaderCompiler(table, _mesa_marshal_ReleaseShaderCompiler);
   SET_BlendFuncSeparate(table, _mesa_marshal_BlendFuncSeparate);
   SET_Color3us(table, _mesa_marshal_Color3us);
   SET_LoadMatrixx(table, _mesa_marshal_LoadMatrixx);
   SET_BufferStorage(table, _mesa_marshal_BufferStorage);
   SET_Color3ub(table, _mesa_marshal_Color3ub);
   SET_Color3ui(table, _mesa_marshal_Color3ui);
   SET_VertexAttrib4dvNV(table, _mesa_marshal_VertexAttrib4dvNV);
   SET_AlphaFragmentOp2ATI(table, _mesa_marshal_AlphaFragmentOp2ATI);
   SET_RasterPos4dv(table, _mesa_marshal_RasterPos4dv);
   SET_DeleteProgramPipelines(table, _mesa_marshal_DeleteProgramPipelines);
   SET_LineWidthx(table, _mesa_marshal_LineWidthx);
   SET_GetTransformFeedbacki_v(table, _mesa_marshal_GetTransformFeedbacki_v);
   SET_Indexdv(table, _mesa_marshal_Indexdv);
   SET_GetnPixelMapfvARB(table, _mesa_marshal_GetnPixelMapfvARB);
   SET_EGLImageTargetTexture2DOES(table, _mesa_marshal_EGLImageTargetTexture2DOES);
   SET_DepthMask(table, _mesa_marshal_DepthMask);
   SET_WindowPos4ivMESA(table, _mesa_marshal_WindowPos4ivMESA);
   SET_GetShaderInfoLog(table, _mesa_marshal_GetShaderInfoLog);
   SET_BindFragmentShaderATI(table, _mesa_marshal_BindFragmentShaderATI);
   SET_BlendFuncSeparateiARB(table, _mesa_marshal_BlendFuncSeparateiARB);
   SET_EGLImageTargetRenderbufferStorageOES(table, _mesa_marshal_EGLImageTargetRenderbufferStorageOES);
   SET_GenTransformFeedbacks(table, _mesa_marshal_GenTransformFeedbacks);
   SET_VertexPointer(table, _mesa_marshal_VertexPointer);
   SET_GetCompressedTexImage(table, _mesa_marshal_GetCompressedTexImage);
   SET_ProgramLocalParameter4dvARB(table, _mesa_marshal_ProgramLocalParameter4dvARB);
   SET_UniformMatrix2dv(table, _mesa_marshal_UniformMatrix2dv);
   SET_GetQueryObjectui64v(table, _mesa_marshal_GetQueryObjectui64v);
   SET_VertexAttribP1uiv(table, _mesa_marshal_VertexAttribP1uiv);
   SET_IsProgram(table, _mesa_marshal_IsProgram);
   SET_BindBuffersBase(table, _mesa_marshal_BindBuffersBase);
   SET_GenTextures(table, _mesa_marshal_GenTextures);
   SET_UnmapNamedBuffer(table, _mesa_marshal_UnmapNamedBuffer);
   SET_UniformMatrix3x2dv(table, _mesa_marshal_UniformMatrix3x2dv);
   SET_WindowPos4fMESA(table, _mesa_marshal_WindowPos4fMESA);
   SET_VertexAttribs2fvNV(table, _mesa_marshal_VertexAttribs2fvNV);
   SET_VertexAttribP4ui(table, _mesa_marshal_VertexAttribP4ui);
   SET_StringMarkerGREMEDY(table, _mesa_marshal_StringMarkerGREMEDY);
   SET_Uniform4i(table, _mesa_marshal_Uniform4i);
   SET_Uniform4d(table, _mesa_marshal_Uniform4d);
   SET_Uniform4f(table, _mesa_marshal_Uniform4f);
   SET_ProgramUniform3dv(table, _mesa_marshal_ProgramUniform3dv);
   SET_GetNamedBufferParameteri64v(table, _mesa_marshal_GetNamedBufferParameteri64v);
   SET_NamedFramebufferTexture(table, _mesa_marshal_NamedFramebufferTexture);
   SET_ProgramUniform3d(table, _mesa_marshal_ProgramUniform3d);
   SET_ProgramUniform3f(table, _mesa_marshal_ProgramUniform3f);
   SET_ProgramUniform3i(table, _mesa_marshal_ProgramUniform3i);
   SET_PointParameterfv(table, _mesa_marshal_PointParameterfv);
   SET_GetHistogramParameterfv(table, _mesa_marshal_GetHistogramParameterfv);
   SET_GetString(table, _mesa_marshal_GetString);
   SET_VDPAUUnmapSurfacesNV(table, _mesa_marshal_VDPAUUnmapSurfacesNV);
   SET_GetnHistogramARB(table, _mesa_marshal_GetnHistogramARB);
   SET_SecondaryColor3s(table, _mesa_marshal_SecondaryColor3s);
   SET_TexStorageMem2DEXT(table, _mesa_marshal_TexStorageMem2DEXT);
   SET_VertexAttribP2uiv(table, _mesa_marshal_VertexAttribP2uiv);
   SET_UniformMatrix3x4dv(table, _mesa_marshal_UniformMatrix3x4dv);
   SET_VertexAttrib3fNV(table, _mesa_marshal_VertexAttrib3fNV);
   SET_SecondaryColor3b(table, _mesa_marshal_SecondaryColor3b);
   SET_EnableClientState(table, _mesa_marshal_EnableClientState);
   SET_GetActiveSubroutineName(table, _mesa_marshal_GetActiveSubroutineName);
   SET_SecondaryColor3i(table, _mesa_marshal_SecondaryColor3i);
   SET_FlushMappedBufferRange(table, _mesa_marshal_FlushMappedBufferRange);
   SET_TexStorageMem3DEXT(table, _mesa_marshal_TexStorageMem3DEXT);
   SET_Lightfv(table, _mesa_marshal_Lightfv);
   SET_GetFramebufferAttachmentParameteriv(table, _mesa_marshal_GetFramebufferAttachmentParameteriv);
   SET_ColorSubTable(table, _mesa_marshal_ColorSubTable);
   SET_GetVertexArrayIndexed64iv(table, _mesa_marshal_GetVertexArrayIndexed64iv);
   SET_EndPerfMonitorAMD(table, _mesa_marshal_EndPerfMonitorAMD);
   SET_CreateBuffers(table, _mesa_marshal_CreateBuffers);
   SET_VertexAttribs4dvNV(table, _mesa_marshal_VertexAttribs4dvNV);
   SET_Uniform2i64vARB(table, _mesa_marshal_Uniform2i64vARB);
   SET_GetMultisamplefv(table, _mesa_marshal_GetMultisamplefv);
   SET_GetActiveSubroutineUniformName(table, _mesa_marshal_GetActiveSubroutineUniformName);
   SET_Rectdv(table, _mesa_marshal_Rectdv);
   SET_DrawArraysInstancedARB(table, _mesa_marshal_DrawArraysInstancedARB);
   SET_MakeImageHandleNonResidentARB(table, _mesa_marshal_MakeImageHandleNonResidentARB);
   SET_ImportMemoryFdEXT(table, _mesa_marshal_ImportMemoryFdEXT);
   SET_ProgramEnvParameters4fvEXT(table, _mesa_marshal_ProgramEnvParameters4fvEXT);
   SET_TexStorageMem1DEXT(table, _mesa_marshal_TexStorageMem1DEXT);
   SET_BlendBarrier(table, _mesa_marshal_BlendBarrier);
   SET_VertexAttrib2svNV(table, _mesa_marshal_VertexAttrib2svNV);
   SET_SecondaryColorP3uiv(table, _mesa_marshal_SecondaryColorP3uiv);
   SET_GetnPixelMapuivARB(table, _mesa_marshal_GetnPixelMapuivARB);
   SET_GetSamplerParameterIuiv(table, _mesa_marshal_GetSamplerParameterIuiv);
   SET_Disablei(table, _mesa_marshal_Disablei);
   SET_CompressedTexSubImage3D(table, _mesa_marshal_CompressedTexSubImage3D);
   SET_WindowPos4svMESA(table, _mesa_marshal_WindowPos4svMESA);
   SET_ObjectLabel(table, _mesa_marshal_ObjectLabel);
   SET_Color3dv(table, _mesa_marshal_Color3dv);
   SET_ProgramUniform1ui64ARB(table, _mesa_marshal_ProgramUniform1ui64ARB);
   SET_BeginQuery(table, _mesa_marshal_BeginQuery);
   SET_VertexP3uiv(table, _mesa_marshal_VertexP3uiv);
   SET_GetUniformLocation(table, _mesa_marshal_GetUniformLocation);
   SET_PixelStoref(table, _mesa_marshal_PixelStoref);
   SET_WindowPos2iv(table, _mesa_marshal_WindowPos2iv);
   SET_PixelStorei(table, _mesa_marshal_PixelStorei);
   SET_VertexAttribs1svNV(table, _mesa_marshal_VertexAttribs1svNV);
   SET_CheckNamedFramebufferStatus(table, _mesa_marshal_CheckNamedFramebufferStatus);
   SET_UniformSubroutinesuiv(table, _mesa_marshal_UniformSubroutinesuiv);
   SET_CheckFramebufferStatus(table, _mesa_marshal_CheckFramebufferStatus);
   SET_DispatchComputeIndirect(table, _mesa_marshal_DispatchComputeIndirect);
   SET_InvalidateBufferData(table, _mesa_marshal_InvalidateBufferData);
   SET_GetUniformdv(table, _mesa_marshal_GetUniformdv);
   SET_ProgramLocalParameters4fvEXT(table, _mesa_marshal_ProgramLocalParameters4fvEXT);
   SET_VertexAttribL1dv(table, _mesa_marshal_VertexAttribL1dv);
   SET_Uniform1ui64vARB(table, _mesa_marshal_Uniform1ui64vARB);
   SET_IsFramebuffer(table, _mesa_marshal_IsFramebuffer);
   SET_GetDoublev(table, _mesa_marshal_GetDoublev);
   SET_GetObjectLabel(table, _mesa_marshal_GetObjectLabel);
   SET_ColorP3uiv(table, _mesa_marshal_ColorP3uiv);
   SET_GetTextureSubImage(table, _mesa_marshal_GetTextureSubImage);
   SET_VertexAttribI4ivEXT(table, _mesa_marshal_VertexAttribI4ivEXT);
   SET_VertexAttrib1svNV(table, _mesa_marshal_VertexAttrib1svNV);
   SET_SecondaryColor3ubv(table, _mesa_marshal_SecondaryColor3ubv);
   SET_GetDebugMessageLog(table, _mesa_marshal_GetDebugMessageLog);
   SET_Uniform4ui64ARB(table, _mesa_marshal_Uniform4ui64ARB);
   SET_RasterPos3fv(table, _mesa_marshal_RasterPos3fv);
   SET_GetShaderSource(table, _mesa_marshal_GetShaderSource);
   SET_BindProgramARB(table, _mesa_marshal_BindProgramARB);
   SET_VertexAttrib3sNV(table, _mesa_marshal_VertexAttrib3sNV);
   SET_ColorFragmentOp1ATI(table, _mesa_marshal_ColorFragmentOp1ATI);
   SET_ProgramUniformMatrix4x3fv(table, _mesa_marshal_ProgramUniformMatrix4x3fv);
   SET_PopClientAttrib(table, _mesa_marshal_PopClientAttrib);
   SET_DrawElementsInstancedARB(table, _mesa_marshal_DrawElementsInstancedARB);
   SET_GetQueryObjectuiv(table, _mesa_marshal_GetQueryObjectuiv);
   SET_VertexAttribI4bv(table, _mesa_marshal_VertexAttribI4bv);
   SET_DisableVertexArrayAttrib(table, _mesa_marshal_DisableVertexArrayAttrib);
   SET_VertexAttribL4d(table, _mesa_marshal_VertexAttribL4d);
   SET_ListBase(table, _mesa_marshal_ListBase);
   SET_GenerateMipmap(table, _mesa_marshal_GenerateMipmap);
   SET_BindBufferRange(table, _mesa_marshal_BindBufferRange);
   SET_ProgramUniformMatrix2x4fv(table, _mesa_marshal_ProgramUniformMatrix2x4fv);
   SET_BindBufferBase(table, _mesa_marshal_BindBufferBase);
   SET_GetQueryObjectiv(table, _mesa_marshal_GetQueryObjectiv);
   SET_VertexAttrib2s(table, _mesa_marshal_VertexAttrib2s);
   SET_SecondaryColor3fvEXT(table, _mesa_marshal_SecondaryColor3fvEXT);
   SET_VertexAttrib2d(table, _mesa_marshal_VertexAttrib2d);
   SET_ClearNamedFramebufferiv(table, _mesa_marshal_ClearNamedFramebufferiv);
   SET_Uniform1fv(table, _mesa_marshal_Uniform1fv);
   SET_GetProgramPipelineInfoLog(table, _mesa_marshal_GetProgramPipelineInfoLog);
   SET_DepthBoundsEXT(table, _mesa_marshal_DepthBoundsEXT);
   SET_BufferStorageMemEXT(table, _mesa_marshal_BufferStorageMemEXT);
   SET_WindowPos3fv(table, _mesa_marshal_WindowPos3fv);
   SET_GetHistogramParameteriv(table, _mesa_marshal_GetHistogramParameteriv);
   SET_PointParameteriv(table, _mesa_marshal_PointParameteriv);
   SET_NamedRenderbufferStorage(table, _mesa_marshal_NamedRenderbufferStorage);
   SET_GetProgramivARB(table, _mesa_marshal_GetProgramivARB);
   SET_BindRenderbuffer(table, _mesa_marshal_BindRenderbuffer);
   SET_SecondaryColor3fEXT(table, _mesa_marshal_SecondaryColor3fEXT);
   SET_PrimitiveRestartIndex(table, _mesa_marshal_PrimitiveRestartIndex);
   SET_TextureStorageMem3DEXT(table, _mesa_marshal_TextureStorageMem3DEXT);
   SET_VertexAttribI4ubv(table, _mesa_marshal_VertexAttribI4ubv);
   SET_GetGraphicsResetStatusARB(table, _mesa_marshal_GetGraphicsResetStatusARB);
   SET_CreateRenderbuffers(table, _mesa_marshal_CreateRenderbuffers);
   SET_ActiveStencilFaceEXT(table, _mesa_marshal_ActiveStencilFaceEXT);
   SET_VertexAttrib4dNV(table, _mesa_marshal_VertexAttrib4dNV);
   SET_DepthRange(table, _mesa_marshal_DepthRange);
   SET_VertexAttrib4fNV(table, _mesa_marshal_VertexAttrib4fNV);
   SET_Uniform4fv(table, _mesa_marshal_Uniform4fv);
   SET_SamplerParameterIiv(table, _mesa_marshal_SamplerParameterIiv);
   SET_Frustumf(table, _mesa_marshal_Frustumf);
   SET_GetQueryBufferObjectui64v(table, _mesa_marshal_GetQueryBufferObjectui64v);
   SET_ProgramUniform2uiv(table, _mesa_marshal_ProgramUniform2uiv);
   SET_Rectsv(table, _mesa_marshal_Rectsv);
   SET_Frustumx(table, _mesa_marshal_Frustumx);
   SET_CullFace(table, _mesa_marshal_CullFace);
   SET_BindTexture(table, _mesa_marshal_BindTexture);
   SET_MultiTexCoord4fARB(table, _mesa_marshal_MultiTexCoord4fARB);
   SET_Uniform2ui64ARB(table, _mesa_marshal_Uniform2ui64ARB);
   SET_MultiTexCoordP2uiv(table, _mesa_marshal_MultiTexCoordP2uiv);
   SET_BeginPerfQueryINTEL(table, _mesa_marshal_BeginPerfQueryINTEL);
   SET_NormalPointer(table, _mesa_marshal_NormalPointer);
   SET_WindowPos4iMESA(table, _mesa_marshal_WindowPos4iMESA);
   SET_VertexAttrib4bv(table, _mesa_marshal_VertexAttrib4bv);
   SET_SecondaryColor3usv(table, _mesa_marshal_SecondaryColor3usv);
   SET_GetPixelMapuiv(table, _mesa_marshal_GetPixelMapuiv);
   SET_MapNamedBuffer(table, _mesa_marshal_MapNamedBuffer);
   SET_Indexfv(table, _mesa_marshal_Indexfv);
   SET_AlphaFragmentOp1ATI(table, _mesa_marshal_AlphaFragmentOp1ATI);
   SET_GetFloatv(table, _mesa_marshal_GetFloatv);
   SET_ProgramUniform2dv(table, _mesa_marshal_ProgramUniform2dv);
   SET_MultiTexCoord3i(table, _mesa_marshal_MultiTexCoord3i);
   SET_ProgramUniform1fv(table, _mesa_marshal_ProgramUniform1fv);
   SET_MultiTexCoord3d(table, _mesa_marshal_MultiTexCoord3d);
   SET_TexCoord3sv(table, _mesa_marshal_TexCoord3sv);
   SET_Fogfv(table, _mesa_marshal_Fogfv);
   SET_Minmax(table, _mesa_marshal_Minmax);
   SET_MultiTexCoord3s(table, _mesa_marshal_MultiTexCoord3s);
   SET_Vertex4iv(table, _mesa_marshal_Vertex4iv);
   SET_BufferSubData(table, _mesa_marshal_BufferSubData);
   SET_TexCoord4dv(table, _mesa_marshal_TexCoord4dv);
   SET_Begin(table, _mesa_marshal_Begin);
   SET_LightModeli(table, _mesa_marshal_LightModeli);
   SET_UniformMatrix2fv(table, _mesa_marshal_UniformMatrix2fv);
   SET_LightModelf(table, _mesa_marshal_LightModelf);
   SET_GetTexParameterfv(table, _mesa_marshal_GetTexParameterfv);
   SET_TextureStorage1D(table, _mesa_marshal_TextureStorage1D);
   SET_MultiTexCoord2fvARB(table, _mesa_marshal_MultiTexCoord2fvARB);
   SET_VertexAttrib4ubv(table, _mesa_marshal_VertexAttrib4ubv);
   SET_GetnTexImageARB(table, _mesa_marshal_GetnTexImageARB);
   SET_ColorMask(table, _mesa_marshal_ColorMask);
   SET_MultiTexCoord4x(table, _mesa_marshal_MultiTexCoord4x);
   SET_UniformHandleui64ARB(table, _mesa_marshal_UniformHandleui64ARB);
   SET_VertexAttribs4svNV(table, _mesa_marshal_VertexAttribs4svNV);
   SET_DrawElementsInstancedBaseInstance(table, _mesa_marshal_DrawElementsInstancedBaseInstance);
   SET_UniformMatrix4fv(table, _mesa_marshal_UniformMatrix4fv);
   SET_UniformMatrix3x2fv(table, _mesa_marshal_UniformMatrix3x2fv);
   SET_VertexAttrib4Nuiv(table, _mesa_marshal_VertexAttrib4Nuiv);
   SET_ClientActiveTexture(table, _mesa_marshal_ClientActiveTexture);
   SET_GetUniformIndices(table, _mesa_marshal_GetUniformIndices);
   SET_MultiTexCoord2sv(table, _mesa_marshal_MultiTexCoord2sv);
   SET_NamedBufferStorage(table, _mesa_marshal_NamedBufferStorage);
   SET_NamedFramebufferDrawBuffer(table, _mesa_marshal_NamedFramebufferDrawBuffer);
   SET_NamedFramebufferTextureLayer(table, _mesa_marshal_NamedFramebufferTextureLayer);
   SET_LoadIdentity(table, _mesa_marshal_LoadIdentity);
   SET_ActiveShaderProgram(table, _mesa_marshal_ActiveShaderProgram);
   SET_BindImageTextures(table, _mesa_marshal_BindImageTextures);
   SET_DeleteTransformFeedbacks(table, _mesa_marshal_DeleteTransformFeedbacks);
   SET_VertexAttrib4ubvNV(table, _mesa_marshal_VertexAttrib4ubvNV);
   SET_FogCoordfEXT(table, _mesa_marshal_FogCoordfEXT);
   SET_GetMapfv(table, _mesa_marshal_GetMapfv);
   SET_GetProgramInfoLog(table, _mesa_marshal_GetProgramInfoLog);
   SET_BindTransformFeedback(table, _mesa_marshal_BindTransformFeedback);
   SET_GetPixelMapfv(table, _mesa_marshal_GetPixelMapfv);
   SET_TextureBufferRange(table, _mesa_marshal_TextureBufferRange);
   SET_VertexAttrib4svNV(table, _mesa_marshal_VertexAttrib4svNV);
   SET_PatchParameteri(table, _mesa_marshal_PatchParameteri);
   SET_NamedFramebufferParameteri(table, _mesa_marshal_NamedFramebufferParameteri);
   SET_VDPAUSurfaceAccessNV(table, _mesa_marshal_VDPAUSurfaceAccessNV);
   SET_EdgeFlagPointer(table, _mesa_marshal_EdgeFlagPointer);
   SET_WindowPos2f(table, _mesa_marshal_WindowPos2f);
   SET_WindowPos2d(table, _mesa_marshal_WindowPos2d);
   SET_GetVertexAttribLdv(table, _mesa_marshal_GetVertexAttribLdv);
   SET_WindowPos2i(table, _mesa_marshal_WindowPos2i);
   SET_WindowPos2s(table, _mesa_marshal_WindowPos2s);
   SET_VertexAttribI1uiEXT(table, _mesa_marshal_VertexAttribI1uiEXT);
   SET_DeleteSync(table, _mesa_marshal_DeleteSync);
   SET_WindowPos4fvMESA(table, _mesa_marshal_WindowPos4fvMESA);
   SET_CompressedTexImage3D(table, _mesa_marshal_CompressedTexImage3D);
   SET_GenSemaphoresEXT(table, _mesa_marshal_GenSemaphoresEXT);
   SET_VertexAttribI1uiv(table, _mesa_marshal_VertexAttribI1uiv);
   SET_SecondaryColor3dv(table, _mesa_marshal_SecondaryColor3dv);
   SET_GetnPixelMapusvARB(table, _mesa_marshal_GetnPixelMapusvARB);
   SET_VertexAttrib3s(table, _mesa_marshal_VertexAttrib3s);
   SET_UniformMatrix4x3fv(table, _mesa_marshal_UniformMatrix4x3fv);
   SET_GetQueryiv(table, _mesa_marshal_GetQueryiv);
   SET_VertexAttrib3d(table, _mesa_marshal_VertexAttrib3d);
   SET_MapNamedBufferRange(table, _mesa_marshal_MapNamedBufferRange);
   SET_MapBuffer(table, _mesa_marshal_MapBuffer);
   SET_GetProgramStageiv(table, _mesa_marshal_GetProgramStageiv);
   SET_VertexAttrib4Nbv(table, _mesa_marshal_VertexAttrib4Nbv);
   SET_ProgramBinary(table, _mesa_marshal_ProgramBinary);
   SET_InvalidateTexImage(table, _mesa_marshal_InvalidateTexImage);
   SET_Uniform4ui(table, _mesa_marshal_Uniform4ui);
   SET_VertexArrayAttribFormat(table, _mesa_marshal_VertexArrayAttribFormat);
   SET_VertexAttrib1fARB(table, _mesa_marshal_VertexAttrib1fARB);
   SET_GetBooleani_v(table, _mesa_marshal_GetBooleani_v);
   SET_DrawTexsOES(table, _mesa_marshal_DrawTexsOES);
   SET_GetObjectPtrLabel(table, _mesa_marshal_GetObjectPtrLabel);
   SET_ProgramParameteri(table, _mesa_marshal_ProgramParameteri);
   SET_Color3fv(table, _mesa_marshal_Color3fv);
   SET_GetnMapfvARB(table, _mesa_marshal_GetnMapfvARB);
   SET_MultiTexCoord2i(table, _mesa_marshal_MultiTexCoord2i);
   SET_MultiTexCoord2d(table, _mesa_marshal_MultiTexCoord2d);
   SET_SamplerParameterIuiv(table, _mesa_marshal_SamplerParameterIuiv);
   SET_MultiTexCoord2s(table, _mesa_marshal_MultiTexCoord2s);
   SET_GetInternalformati64v(table, _mesa_marshal_GetInternalformati64v);
   SET_VDPAURegisterVideoSurfaceNV(table, _mesa_marshal_VDPAURegisterVideoSurfaceNV);
   SET_Indexub(table, _mesa_marshal_Indexub);
   SET_GetPerfMonitorCounterDataAMD(table, _mesa_marshal_GetPerfMonitorCounterDataAMD);
   SET_MultTransposeMatrixf(table, _mesa_marshal_MultTransposeMatrixf);
   SET_PolygonOffsetEXT(table, _mesa_marshal_PolygonOffsetEXT);
   SET_Scalex(table, _mesa_marshal_Scalex);
   SET_Scaled(table, _mesa_marshal_Scaled);
   SET_Scalef(table, _mesa_marshal_Scalef);
   SET_IndexPointerEXT(table, _mesa_marshal_IndexPointerEXT);
   SET_GetUniformfv(table, _mesa_marshal_GetUniformfv);
   SET_ColorFragmentOp2ATI(table, _mesa_marshal_ColorFragmentOp2ATI);
   SET_VertexAttrib2sNV(table, _mesa_marshal_VertexAttrib2sNV);
   SET_ReadPixels(table, _mesa_marshal_ReadPixels);
   SET_QueryCounter(table, _mesa_marshal_QueryCounter);
   SET_NormalPointerEXT(table, _mesa_marshal_NormalPointerEXT);
   SET_GetSubroutineIndex(table, _mesa_marshal_GetSubroutineIndex);
   SET_ProgramUniform3iv(table, _mesa_marshal_ProgramUniform3iv);
   SET_ProgramUniformMatrix2dv(table, _mesa_marshal_ProgramUniformMatrix2dv);
   SET_ClearTexSubImage(table, _mesa_marshal_ClearTexSubImage);
   SET_GetActiveUniformBlockName(table, _mesa_marshal_GetActiveUniformBlockName);
   SET_DrawElementsBaseVertex(table, _mesa_marshal_DrawElementsBaseVertex);
   SET_RasterPos3iv(table, _mesa_marshal_RasterPos3iv);
   SET_ColorMaski(table, _mesa_marshal_ColorMaski);
   SET_Uniform2uiv(table, _mesa_marshal_Uniform2uiv);
   SET_RasterPos3s(table, _mesa_marshal_RasterPos3s);
   SET_RasterPos3d(table, _mesa_marshal_RasterPos3d);
   SET_RasterPos3f(table, _mesa_marshal_RasterPos3f);
   SET_BindVertexArray(table, _mesa_marshal_BindVertexArray);
   SET_RasterPos3i(table, _mesa_marshal_RasterPos3i);
   SET_VertexAttribL3dv(table, _mesa_marshal_VertexAttribL3dv);
   SET_GetTexParameteriv(table, _mesa_marshal_GetTexParameteriv);
   SET_DrawTransformFeedbackStreamInstanced(table, _mesa_marshal_DrawTransformFeedbackStreamInstanced);
   SET_VertexAttrib2fvARB(table, _mesa_marshal_VertexAttrib2fvARB);
   SET_GetProgramResourceName(table, _mesa_marshal_GetProgramResourceName);
   SET_ProgramUniformMatrix4x3dv(table, _mesa_marshal_ProgramUniformMatrix4x3dv);
   SET_ColorTable(table, _mesa_marshal_ColorTable);
   SET_LoadName(table, _mesa_marshal_LoadName);
   SET_GetnUniformuivARB(table, _mesa_marshal_GetnUniformuivARB);
   SET_ClearIndex(table, _mesa_marshal_ClearIndex);
   SET_ConvolutionParameterfv(table, _mesa_marshal_ConvolutionParameterfv);
   SET_GetTexGendv(table, _mesa_marshal_GetTexGendv);
   SET_FlushMappedNamedBufferRange(table, _mesa_marshal_FlushMappedNamedBufferRange);
   SET_MultiTexCoordP1ui(table, _mesa_marshal_MultiTexCoordP1ui);
   SET_EvalMesh2(table, _mesa_marshal_EvalMesh2);
   SET_Vertex4fv(table, _mesa_marshal_Vertex4fv);
   SET_ProgramUniform4i64ARB(table, _mesa_marshal_ProgramUniform4i64ARB);
   SET_SelectPerfMonitorCountersAMD(table, _mesa_marshal_SelectPerfMonitorCountersAMD);
   SET_TextureStorage2D(table, _mesa_marshal_TextureStorage2D);
   SET_GetTextureParameterIiv(table, _mesa_marshal_GetTextureParameterIiv);
   SET_BindFramebuffer(table, _mesa_marshal_BindFramebuffer);
   SET_GetMinmax(table, _mesa_marshal_GetMinmax);
   SET_VertexAttribs3svNV(table, _mesa_marshal_VertexAttribs3svNV);
   SET_GetActiveUniformsiv(table, _mesa_marshal_GetActiveUniformsiv);
   SET_VertexAttrib2sv(table, _mesa_marshal_VertexAttrib2sv);
   SET_GetProgramEnvParameterdvARB(table, _mesa_marshal_GetProgramEnvParameterdvARB);
   SET_Uniform1dv(table, _mesa_marshal_Uniform1dv);
   SET_TransformFeedbackBufferRange(table, _mesa_marshal_TransformFeedbackBufferRange);
   SET_PushDebugGroup(table, _mesa_marshal_PushDebugGroup);
   SET_GetPerfMonitorGroupStringAMD(table, _mesa_marshal_GetPerfMonitorGroupStringAMD);
   SET_GetError(table, _mesa_marshal_GetError);
   SET_PassThrough(table, _mesa_marshal_PassThrough);
   SET_PatchParameterfv(table, _mesa_marshal_PatchParameterfv);
   SET_GetObjectParameterivAPPLE(table, _mesa_marshal_GetObjectParameterivAPPLE);
   SET_BindBuffersRange(table, _mesa_marshal_BindBuffersRange);
   SET_VertexAttrib4fvARB(table, _mesa_marshal_VertexAttrib4fvARB);
   SET_Uniform3i64vARB(table, _mesa_marshal_Uniform3i64vARB);
   SET_WindowPos3dv(table, _mesa_marshal_WindowPos3dv);
   SET_TexGenxOES(table, _mesa_marshal_TexGenxOES);
   SET_VertexArrayAttribIFormat(table, _mesa_marshal_VertexArrayAttribIFormat);
   SET_StencilOp(table, _mesa_marshal_StencilOp);
   SET_ProgramUniform1iv(table, _mesa_marshal_ProgramUniform1iv);
   SET_ProgramUniform3ui(table, _mesa_marshal_ProgramUniform3ui);
   SET_SecondaryColor3sv(table, _mesa_marshal_SecondaryColor3sv);
   SET_TexCoordP3ui(table, _mesa_marshal_TexCoordP3ui);
   SET_VertexArrayElementBuffer(table, _mesa_marshal_VertexArrayElementBuffer);
   SET_Fogxv(table, _mesa_marshal_Fogxv);
   SET_Uniform3i64ARB(table, _mesa_marshal_Uniform3i64ARB);
   SET_VertexAttribP1ui(table, _mesa_marshal_VertexAttribP1ui);
   SET_GetImageHandleARB(table, _mesa_marshal_GetImageHandleARB);
   SET_DeleteLists(table, _mesa_marshal_DeleteLists);
   SET_LogicOp(table, _mesa_marshal_LogicOp);
   SET_RenderbufferStorageMultisample(table, _mesa_marshal_RenderbufferStorageMultisample);
   SET_GetTransformFeedbacki64_v(table, _mesa_marshal_GetTransformFeedbacki64_v);
   SET_WindowPos3d(table, _mesa_marshal_WindowPos3d);
   SET_Enablei(table, _mesa_marshal_Enablei);
   SET_WindowPos3f(table, _mesa_marshal_WindowPos3f);
   SET_GenProgramsARB(table, _mesa_marshal_GenProgramsARB);
   SET_RasterPos2sv(table, _mesa_marshal_RasterPos2sv);
   SET_WindowPos3i(table, _mesa_marshal_WindowPos3i);
   SET_MultiTexCoord4iv(table, _mesa_marshal_MultiTexCoord4iv);
   SET_TexCoord1sv(table, _mesa_marshal_TexCoord1sv);
   SET_WindowPos3s(table, _mesa_marshal_WindowPos3s);
   SET_PixelMapusv(table, _mesa_marshal_PixelMapusv);
   SET_DebugMessageInsert(table, _mesa_marshal_DebugMessageInsert);
   SET_Orthof(table, _mesa_marshal_Orthof);
   SET_CompressedTexImage2D(table, _mesa_marshal_CompressedTexImage2D);
   SET_DeleteObjectARB(table, _mesa_marshal_DeleteObjectARB);
   SET_ProgramUniformMatrix2x3dv(table, _mesa_marshal_ProgramUniformMatrix2x3dv);
   SET_GetVertexArrayiv(table, _mesa_marshal_GetVertexArrayiv);
   SET_IsSync(table, _mesa_marshal_IsSync);
   SET_Color4uiv(table, _mesa_marshal_Color4uiv);
   SET_MultiTexCoord1sv(table, _mesa_marshal_MultiTexCoord1sv);
   SET_Orthox(table, _mesa_marshal_Orthox);
   SET_PushAttrib(table, _mesa_marshal_PushAttrib);
   SET_RasterPos2i(table, _mesa_marshal_RasterPos2i);
   SET_ClipPlane(table, _mesa_marshal_ClipPlane);
   SET_RasterPos2f(table, _mesa_marshal_RasterPos2f);
   SET_GetActiveSubroutineUniformiv(table, _mesa_marshal_GetActiveSubroutineUniformiv);
   SET_RasterPos2d(table, _mesa_marshal_RasterPos2d);
   SET_MakeImageHandleResidentARB(table, _mesa_marshal_MakeImageHandleResidentARB);
   SET_InvalidateSubFramebuffer(table, _mesa_marshal_InvalidateSubFramebuffer);
   SET_Color4ub(table, _mesa_marshal_Color4ub);
   SET_UniformMatrix2x4dv(table, _mesa_marshal_UniformMatrix2x4dv);
   SET_RasterPos2s(table, _mesa_marshal_RasterPos2s);
   SET_DispatchComputeGroupSizeARB(table, _mesa_marshal_DispatchComputeGroupSizeARB);
   SET_VertexP2uiv(table, _mesa_marshal_VertexP2uiv);
   SET_VertexArrayBindingDivisor(table, _mesa_marshal_VertexArrayBindingDivisor);
   SET_MultiTexCoord3dv(table, _mesa_marshal_MultiTexCoord3dv);
   SET_BindProgramPipeline(table, _mesa_marshal_BindProgramPipeline);
   SET_VertexAttribP4uiv(table, _mesa_marshal_VertexAttribP4uiv);
   SET_DebugMessageCallback(table, _mesa_marshal_DebugMessageCallback);
   SET_MultiTexCoord1i(table, _mesa_marshal_MultiTexCoord1i);
   SET_WindowPos2dv(table, _mesa_marshal_WindowPos2dv);
   SET_TexParameterIuiv(table, _mesa_marshal_TexParameterIuiv);
   SET_DeletePerfQueryINTEL(table, _mesa_marshal_DeletePerfQueryINTEL);
   SET_MultiTexCoord1d(table, _mesa_marshal_MultiTexCoord1d);
   SET_MultiTexCoord1s(table, _mesa_marshal_MultiTexCoord1s);
   SET_BeginConditionalRender(table, _mesa_marshal_BeginConditionalRender);
   SET_GetShaderiv(table, _mesa_marshal_GetShaderiv);
   SET_CopyConvolutionFilter1D(table, _mesa_marshal_CopyConvolutionFilter1D);
   SET_ClearBufferfv(table, _mesa_marshal_ClearBufferfv);
   SET_UniformMatrix4dv(table, _mesa_marshal_UniformMatrix4dv);
   SET_CreateShaderObjectARB(table, _mesa_marshal_CreateShaderObjectARB);
   SET_GetTexParameterxv(table, _mesa_marshal_GetTexParameterxv);
   SET_GetAttachedShaders(table, _mesa_marshal_GetAttachedShaders);
   SET_ClearBufferfi(table, _mesa_marshal_ClearBufferfi);
   SET_Materialiv(table, _mesa_marshal_Materialiv);
   SET_DeleteFragmentShaderATI(table, _mesa_marshal_DeleteFragmentShaderATI);
   SET_VertexArrayVertexBuffers(table, _mesa_marshal_VertexArrayVertexBuffers);
   SET_DrawElementsInstancedBaseVertex(table, _mesa_marshal_DrawElementsInstancedBaseVertex);
   SET_DisableClientState(table, _mesa_marshal_DisableClientState);
   SET_TexGeni(table, _mesa_marshal_TexGeni);
   SET_TexGenf(table, _mesa_marshal_TexGenf);
   SET_TexGend(table, _mesa_marshal_TexGend);
   SET_ProgramUniform4i64vARB(table, _mesa_marshal_ProgramUniform4i64vARB);
   SET_Color4sv(table, _mesa_marshal_Color4sv);
   SET_LoadTransposeMatrixf(table, _mesa_marshal_LoadTransposeMatrixf);
   SET_LoadTransposeMatrixd(table, _mesa_marshal_LoadTransposeMatrixd);
   SET_PixelZoom(table, _mesa_marshal_PixelZoom);
   SET_ProgramEnvParameter4dARB(table, _mesa_marshal_ProgramEnvParameter4dARB);
   SET_ColorTableParameterfv(table, _mesa_marshal_ColorTableParameterfv);
   SET_IsSemaphoreEXT(table, _mesa_marshal_IsSemaphoreEXT);
   SET_IsTexture(table, _mesa_marshal_IsTexture);
   SET_ProgramUniform3uiv(table, _mesa_marshal_ProgramUniform3uiv);
   SET_GetTextureImage(table, _mesa_marshal_GetTextureImage);
   SET_VertexAttrib4sNV(table, _mesa_marshal_VertexAttrib4sNV);
   SET_GetMapdv(table, _mesa_marshal_GetMapdv);
   SET_Uniform3ui64vARB(table, _mesa_marshal_Uniform3ui64vARB);
   SET_GetInteger64i_v(table, _mesa_marshal_GetInteger64i_v);
   SET_BufferPageCommitmentARB(table, _mesa_marshal_BufferPageCommitmentARB);
   SET_IsBuffer(table, _mesa_marshal_IsBuffer);
   SET_ColorP4ui(table, _mesa_marshal_ColorP4ui);
   SET_TextureStorage3D(table, _mesa_marshal_TextureStorage3D);
   SET_TexCoordP3uiv(table, _mesa_marshal_TexCoordP3uiv);
   SET_GetnUniformui64vARB(table, _mesa_marshal_GetnUniformui64vARB);
   SET_TextureStorageMem2DMultisampleEXT(table, _mesa_marshal_TextureStorageMem2DMultisampleEXT);
   SET_Uniform1iv(table, _mesa_marshal_Uniform1iv);
   SET_Uniform4uiv(table, _mesa_marshal_Uniform4uiv);
   SET_PopDebugGroup(table, _mesa_marshal_PopDebugGroup);
   SET_VertexAttrib1d(table, _mesa_marshal_VertexAttrib1d);
   SET_CompressedTexImage1D(table, _mesa_marshal_CompressedTexImage1D);
   SET_NamedBufferSubData(table, _mesa_marshal_NamedBufferSubData);
   SET_TexBufferRange(table, _mesa_marshal_TexBufferRange);
   SET_VertexAttrib1s(table, _mesa_marshal_VertexAttrib1s);
   SET_MultiDrawElementsIndirect(table, _mesa_marshal_MultiDrawElementsIndirect);
   SET_UniformMatrix4x3dv(table, _mesa_marshal_UniformMatrix4x3dv);
   SET_TransformFeedbackBufferBase(table, _mesa_marshal_TransformFeedbackBufferBase);
   SET_FogCoordfvEXT(table, _mesa_marshal_FogCoordfvEXT);
   SET_Uniform2ui64vARB(table, _mesa_marshal_Uniform2ui64vARB);
   SET_GetColorTableParameterfv(table, _mesa_marshal_GetColorTableParameterfv);
   SET_MultiTexCoord3fARB(table, _mesa_marshal_MultiTexCoord3fARB);
   SET_GetTexLevelParameterfv(table, _mesa_marshal_GetTexLevelParameterfv);
   SET_Vertex2sv(table, _mesa_marshal_Vertex2sv);
   SET_GetnMapdvARB(table, _mesa_marshal_GetnMapdvARB);
   SET_VertexAttrib2dNV(table, _mesa_marshal_VertexAttrib2dNV);
   SET_VertexAttrib3svNV(table, _mesa_marshal_VertexAttrib3svNV);
   SET_GetTexEnviv(table, _mesa_marshal_GetTexEnviv);
   SET_ViewportArrayv(table, _mesa_marshal_ViewportArrayv);
   SET_SeparableFilter2D(table, _mesa_marshal_SeparableFilter2D);
   SET_ArrayElement(table, _mesa_marshal_ArrayElement);
   SET_TexImage2D(table, _mesa_marshal_TexImage2D);
   SET_RasterPos2dv(table, _mesa_marshal_RasterPos2dv);
   SET_Fogiv(table, _mesa_marshal_Fogiv);
   SET_EndQuery(table, _mesa_marshal_EndQuery);
   SET_TexCoord1dv(table, _mesa_marshal_TexCoord1dv);
   SET_AlphaFragmentOp3ATI(table, _mesa_marshal_AlphaFragmentOp3ATI);
   SET_Clear(table, _mesa_marshal_Clear);
   SET_VertexAttrib4sv(table, _mesa_marshal_VertexAttrib4sv);
   SET_Ortho(table, _mesa_marshal_Ortho);
   SET_Uniform3uiv(table, _mesa_marshal_Uniform3uiv);
   SET_GetUniformi64vARB(table, _mesa_marshal_GetUniformi64vARB);
   SET_EndQueryIndexed(table, _mesa_marshal_EndQueryIndexed);
   SET_TexParameterxv(table, _mesa_marshal_TexParameterxv);
   SET_MultiDrawArraysIndirectCountARB(table, _mesa_marshal_MultiDrawArraysIndirectCountARB);
   SET_ProgramUniformMatrix2fv(table, _mesa_marshal_ProgramUniformMatrix2fv);
   SET_ProgramLocalParameter4fvARB(table, _mesa_marshal_ProgramLocalParameter4fvARB);
   SET_Uniform4dv(table, _mesa_marshal_Uniform4dv);
   SET_GetUnsignedBytevEXT(table, _mesa_marshal_GetUnsignedBytevEXT);
   SET_LightModelx(table, _mesa_marshal_LightModelx);
   SET_VertexAttribI3iEXT(table, _mesa_marshal_VertexAttribI3iEXT);
   SET_ClearColorx(table, _mesa_marshal_ClearColorx);
   SET_EndTransformFeedback(table, _mesa_marshal_EndTransformFeedback);
   SET_VertexAttribL2dv(table, _mesa_marshal_VertexAttribL2dv);
   SET_GetActiveUniformName(table, _mesa_marshal_GetActiveUniformName);
   SET_GetProgramBinary(table, _mesa_marshal_GetProgramBinary);
   SET_ViewportIndexedfv(table, _mesa_marshal_ViewportIndexedfv);
   SET_BindTextureUnit(table, _mesa_marshal_BindTextureUnit);
   SET_CallList(table, _mesa_marshal_CallList);
   SET_Materialfv(table, _mesa_marshal_Materialfv);
   SET_DeleteProgram(table, _mesa_marshal_DeleteProgram);
   SET_GetActiveAtomicCounterBufferiv(table, _mesa_marshal_GetActiveAtomicCounterBufferiv);
   SET_ClearDepthf(table, _mesa_marshal_ClearDepthf);
   SET_GetTextureHandleARB(table, _mesa_marshal_GetTextureHandleARB);
   SET_GetConvolutionFilter(table, _mesa_marshal_GetConvolutionFilter);
   SET_MultiModeDrawElementsIBM(table, _mesa_marshal_MultiModeDrawElementsIBM);
   SET_Uniform2iv(table, _mesa_marshal_Uniform2iv);
   SET_GetFixedv(table, _mesa_marshal_GetFixedv);
   SET_SampleCoveragex(table, _mesa_marshal_SampleCoveragex);
   SET_GetPerfQueryInfoINTEL(table, _mesa_marshal_GetPerfQueryInfoINTEL);
   SET_DeleteFramebuffers(table, _mesa_marshal_DeleteFramebuffers);
   SET_VertexAttrib4uiv(table, _mesa_marshal_VertexAttrib4uiv);
   SET_VertexAttrib4Nsv(table, _mesa_marshal_VertexAttrib4Nsv);
   SET_Vertex4s(table, _mesa_marshal_Vertex4s);
   SET_VertexAttribI2iEXT(table, _mesa_marshal_VertexAttribI2iEXT);
   SET_Vertex4f(table, _mesa_marshal_Vertex4f);
   SET_Vertex4d(table, _mesa_marshal_Vertex4d);
   SET_VertexAttribL4dv(table, _mesa_marshal_VertexAttribL4dv);
   SET_GetnUniformi64vARB(table, _mesa_marshal_GetnUniformi64vARB);
   SET_GetTexGenfv(table, _mesa_marshal_GetTexGenfv);
   SET_Vertex4i(table, _mesa_marshal_Vertex4i);
   SET_MemoryBarrierByRegion(table, _mesa_marshal_MemoryBarrierByRegion);
   SET_StencilFuncSeparateATI(table, _mesa_marshal_StencilFuncSeparateATI);
   SET_GetVertexAttribIuiv(table, _mesa_marshal_GetVertexAttribIuiv);
   SET_LightModelfv(table, _mesa_marshal_LightModelfv);
   SET_Vertex4dv(table, _mesa_marshal_Vertex4dv);
   SET_GetInfoLogARB(table, _mesa_marshal_GetInfoLogARB);
   SET_StencilMask(table, _mesa_marshal_StencilMask);
   SET_NamedFramebufferReadBuffer(table, _mesa_marshal_NamedFramebufferReadBuffer);
   SET_ProgramUniformHandleui64ARB(table, _mesa_marshal_ProgramUniformHandleui64ARB);
   SET_ProgramUniform2i64ARB(table, _mesa_marshal_ProgramUniform2i64ARB);
   SET_IsList(table, _mesa_marshal_IsList);
   SET_ClearBufferiv(table, _mesa_marshal_ClearBufferiv);
   SET_GetIntegeri_v(table, _mesa_marshal_GetIntegeri_v);
   SET_ProgramUniform2iv(table, _mesa_marshal_ProgramUniform2iv);
   SET_CreateVertexArrays(table, _mesa_marshal_CreateVertexArrays);
   SET_FogCoordPointer(table, _mesa_marshal_FogCoordPointer);
   SET_SecondaryColor3us(table, _mesa_marshal_SecondaryColor3us);
   SET_TextureStorageMem1DEXT(table, _mesa_marshal_TextureStorageMem1DEXT);
   SET_SecondaryColor3ub(table, _mesa_marshal_SecondaryColor3ub);
   SET_NamedBufferStorageMemEXT(table, _mesa_marshal_NamedBufferStorageMemEXT);
   SET_SecondaryColor3ui(table, _mesa_marshal_SecondaryColor3ui);
   SET_ProgramUniform4ui64ARB(table, _mesa_marshal_ProgramUniform4ui64ARB);
   SET_VertexAttrib1sNV(table, _mesa_marshal_VertexAttrib1sNV);
   SET_SignalSemaphoreEXT(table, _mesa_marshal_SignalSemaphoreEXT);
   SET_TextureBuffer(table, _mesa_marshal_TextureBuffer);
   SET_InitNames(table, _mesa_marshal_InitNames);
   SET_Normal3sv(table, _mesa_marshal_Normal3sv);
   SET_DeleteQueries(table, _mesa_marshal_DeleteQueries);
   SET_InvalidateFramebuffer(table, _mesa_marshal_InvalidateFramebuffer);
   SET_Hint(table, _mesa_marshal_Hint);
   SET_MemoryBarrier(table, _mesa_marshal_MemoryBarrier);
   SET_CopyColorSubTable(table, _mesa_marshal_CopyColorSubTable);
   SET_GetObjectParameterfvARB(table, _mesa_marshal_GetObjectParameterfvARB);
   SET_GetTexEnvxv(table, _mesa_marshal_GetTexEnvxv);
   SET_DrawTexsvOES(table, _mesa_marshal_DrawTexsvOES);
   SET_Disable(table, _mesa_marshal_Disable);
   SET_ClearColor(table, _mesa_marshal_ClearColor);
   SET_GetTextureParameterIuiv(table, _mesa_marshal_GetTextureParameterIuiv);
   SET_RasterPos4iv(table, _mesa_marshal_RasterPos4iv);
   SET_VDPAUIsSurfaceNV(table, _mesa_marshal_VDPAUIsSurfaceNV);
   SET_ProgramUniformMatrix2x3fv(table, _mesa_marshal_ProgramUniformMatrix2x3fv);
   SET_BindVertexBuffer(table, _mesa_marshal_BindVertexBuffer);
   SET_RasterPos4i(table, _mesa_marshal_RasterPos4i);
   SET_RasterPos4d(table, _mesa_marshal_RasterPos4d);
   SET_RasterPos4f(table, _mesa_marshal_RasterPos4f);
   SET_VDPAUMapSurfacesNV(table, _mesa_marshal_VDPAUMapSurfacesNV);
   SET_GetQueryIndexediv(table, _mesa_marshal_GetQueryIndexediv);
   SET_RasterPos3dv(table, _mesa_marshal_RasterPos3dv);
   SET_GetProgramiv(table, _mesa_marshal_GetProgramiv);
   SET_TexCoord1iv(table, _mesa_marshal_TexCoord1iv);
   SET_RasterPos4s(table, _mesa_marshal_RasterPos4s);
   SET_VertexAttrib3dv(table, _mesa_marshal_VertexAttrib3dv);
   SET_Histogram(table, _mesa_marshal_Histogram);
   SET_Uniform2fv(table, _mesa_marshal_Uniform2fv);
   SET_ProgramUniformMatrix3x4dv(table, _mesa_marshal_ProgramUniformMatrix3x4dv);
   SET_DrawBuffers(table, _mesa_marshal_DrawBuffers);
   SET_VertexAttribL1ui64ARB(table, _mesa_marshal_VertexAttribL1ui64ARB);
   SET_GetnPolygonStippleARB(table, _mesa_marshal_GetnPolygonStippleARB);
   SET_Color3uiv(table, _mesa_marshal_Color3uiv);
   SET_EvalCoord2fv(table, _mesa_marshal_EvalCoord2fv);
   SET_TextureStorage3DEXT(table, _mesa_marshal_TextureStorage3DEXT);
   SET_VertexAttrib2fARB(table, _mesa_marshal_VertexAttrib2fARB);
   SET_SpecializeShaderARB(table, _mesa_marshal_SpecializeShaderARB);
   SET_BeginPerfMonitorAMD(table, _mesa_marshal_BeginPerfMonitorAMD);
   SET_WindowPos2fv(table, _mesa_marshal_WindowPos2fv);
   SET_TexImage3D(table, _mesa_marshal_TexImage3D);
   SET_GetPerfQueryIdByNameINTEL(table, _mesa_marshal_GetPerfQueryIdByNameINTEL);
   SET_BindFragDataLocation(table, _mesa_marshal_BindFragDataLocation);
   SET_LightModeliv(table, _mesa_marshal_LightModeliv);
   SET_Normal3bv(table, _mesa_marshal_Normal3bv);
   SET_BeginQueryIndexed(table, _mesa_marshal_BeginQueryIndexed);
   SET_ClearNamedBufferData(table, _mesa_marshal_ClearNamedBufferData);
   SET_Vertex3iv(table, _mesa_marshal_Vertex3iv);
   SET_UniformMatrix2x3dv(table, _mesa_marshal_UniformMatrix2x3dv);
   SET_UniformHandleui64vARB(table, _mesa_marshal_UniformHandleui64vARB);
   SET_TexCoord3dv(table, _mesa_marshal_TexCoord3dv);
   SET_GetProgramStringARB(table, _mesa_marshal_GetProgramStringARB);
   SET_VertexP3ui(table, _mesa_marshal_VertexP3ui);
   SET_CreateProgramObjectARB(table, _mesa_marshal_CreateProgramObjectARB);
   SET_UniformMatrix3fv(table, _mesa_marshal_UniformMatrix3fv);
   SET_PrioritizeTextures(table, _mesa_marshal_PrioritizeTextures);
   SET_VertexAttribI3uiEXT(table, _mesa_marshal_VertexAttribI3uiEXT);
   SET_ProgramUniform1i64ARB(table, _mesa_marshal_ProgramUniform1i64ARB);
   SET_GetMaterialxv(table, _mesa_marshal_GetMaterialxv);
   SET_SecondaryColor3uiv(table, _mesa_marshal_SecondaryColor3uiv);
   SET_EndConditionalRender(table, _mesa_marshal_EndConditionalRender);
   SET_ProgramLocalParameter4dARB(table, _mesa_marshal_ProgramLocalParameter4dARB);
   SET_Color3sv(table, _mesa_marshal_Color3sv);
   SET_GenFragmentShadersATI(table, _mesa_marshal_GenFragmentShadersATI);
   SET_GetNamedBufferParameteriv(table, _mesa_marshal_GetNamedBufferParameteriv);
   SET_BlendEquationSeparateiARB(table, _mesa_marshal_BlendEquationSeparateiARB);
   SET_MultiTexCoord1fvARB(table, _mesa_marshal_MultiTexCoord1fvARB);
   SET_TexStorage2D(table, _mesa_marshal_TexStorage2D);
   SET_FramebufferTexture2D(table, _mesa_marshal_FramebufferTexture2D);
   SET_GetSamplerParameterfv(table, _mesa_marshal_GetSamplerParameterfv);
   SET_VertexAttrib2dv(table, _mesa_marshal_VertexAttrib2dv);
   SET_Vertex4sv(table, _mesa_marshal_Vertex4sv);
   SET_GetQueryObjecti64v(table, _mesa_marshal_GetQueryObjecti64v);
   SET_ClampColor(table, _mesa_marshal_ClampColor);
   SET_Uniform1i64ARB(table, _mesa_marshal_Uniform1i64ARB);
   SET_DepthRangeArrayfvOES(table, _mesa_marshal_DepthRangeArrayfvOES);
   SET_ConvolutionFilter1D(table, _mesa_marshal_ConvolutionFilter1D);
   SET_DrawElementsIndirect(table, _mesa_marshal_DrawElementsIndirect);
   SET_WindowPos3sv(table, _mesa_marshal_WindowPos3sv);
   SET_CallLists(table, _mesa_marshal_CallLists);
   SET_AlphaFunc(table, _mesa_marshal_AlphaFunc);
   SET_GetTextureParameterfv(table, _mesa_marshal_GetTextureParameterfv);
   SET_EdgeFlag(table, _mesa_marshal_EdgeFlag);
   SET_EdgeFlagv(table, _mesa_marshal_EdgeFlagv);
   SET_DepthRangex(table, _mesa_marshal_DepthRangex);
   SET_ProgramUniformHandleui64vARB(table, _mesa_marshal_ProgramUniformHandleui64vARB);
   SET_VDPAUInitNV(table, _mesa_marshal_VDPAUInitNV);
   SET_GetBufferParameteri64v(table, _mesa_marshal_GetBufferParameteri64v);
   SET_CreateProgram(table, _mesa_marshal_CreateProgram);
   SET_DepthRangef(table, _mesa_marshal_DepthRangef);
   SET_TextureParameteriv(table, _mesa_marshal_TextureParameteriv);
   SET_ColorFragmentOp3ATI(table, _mesa_marshal_ColorFragmentOp3ATI);
   SET_ValidateProgram(table, _mesa_marshal_ValidateProgram);
   SET_VertexPointerEXT(table, _mesa_marshal_VertexPointerEXT);
   SET_VertexAttribI4sv(table, _mesa_marshal_VertexAttribI4sv);
   SET_Scissor(table, _mesa_marshal_Scissor);
   SET_BeginTransformFeedback(table, _mesa_marshal_BeginTransformFeedback);
   SET_TexCoord2i(table, _mesa_marshal_TexCoord2i);
   SET_VertexArrayAttribBinding(table, _mesa_marshal_VertexArrayAttribBinding);
   SET_Color4ui(table, _mesa_marshal_Color4ui);
   SET_TexCoord2f(table, _mesa_marshal_TexCoord2f);
   SET_TexCoord2d(table, _mesa_marshal_TexCoord2d);
   SET_GetTransformFeedbackiv(table, _mesa_marshal_GetTransformFeedbackiv);
   SET_TexCoord2s(table, _mesa_marshal_TexCoord2s);
   SET_PointSizePointerOES(table, _mesa_marshal_PointSizePointerOES);
   SET_Color4us(table, _mesa_marshal_Color4us);
   SET_Color3bv(table, _mesa_marshal_Color3bv);
   SET_PrimitiveRestartNV(table, _mesa_marshal_PrimitiveRestartNV);
   SET_BindBufferOffsetEXT(table, _mesa_marshal_BindBufferOffsetEXT);
   SET_ProvokingVertex(table, _mesa_marshal_ProvokingVertex);
   SET_VertexAttribs4fvNV(table, _mesa_marshal_VertexAttribs4fvNV);
   SET_Vertex2i(table, _mesa_marshal_Vertex2i);
   SET_GetQueryBufferObjecti64v(table, _mesa_marshal_GetQueryBufferObjecti64v);
   SET_InterleavedArrays(table, _mesa_marshal_InterleavedArrays);
   SET_RasterPos2fv(table, _mesa_marshal_RasterPos2fv);
   SET_TexCoord1fv(table, _mesa_marshal_TexCoord1fv);
   SET_MultiTexCoord4dv(table, _mesa_marshal_MultiTexCoord4dv);
   SET_ProgramEnvParameter4fvARB(table, _mesa_marshal_ProgramEnvParameter4fvARB);
   SET_RasterPos4fv(table, _mesa_marshal_RasterPos4fv);
   SET_PushMatrix(table, _mesa_marshal_PushMatrix);
   SET_EndList(table, _mesa_marshal_EndList);
   SET_DrawRangeElements(table, _mesa_marshal_DrawRangeElements);
   SET_GetTexGenxvOES(table, _mesa_marshal_GetTexGenxvOES);
   SET_GetHandleARB(table, _mesa_marshal_GetHandleARB);
   SET_DrawTexfvOES(table, _mesa_marshal_DrawTexfvOES);
   SET_BlendFunciARB(table, _mesa_marshal_BlendFunciARB);
   SET_ClearNamedFramebufferfi(table, _mesa_marshal_ClearNamedFramebufferfi);
   SET_ClearNamedFramebufferfv(table, _mesa_marshal_ClearNamedFramebufferfv);
   SET_Uniform2ui(table, _mesa_marshal_Uniform2ui);
   SET_ScissorIndexed(table, _mesa_marshal_ScissorIndexed);
   SET_End(table, _mesa_marshal_End);
   SET_GetNamedBufferSubData(table, _mesa_marshal_GetNamedBufferSubData);
   SET_BindVertexBuffers(table, _mesa_marshal_BindVertexBuffers);
   SET_GetSamplerParameteriv(table, _mesa_marshal_GetSamplerParameteriv);
   SET_GenProgramPipelines(table, _mesa_marshal_GenProgramPipelines);
   SET_Enable(table, _mesa_marshal_Enable);
   SET_IsProgramPipeline(table, _mesa_marshal_IsProgramPipeline);
   SET_ShaderBinary(table, _mesa_marshal_ShaderBinary);
   SET_TextureSubImage1D(table, _mesa_marshal_TextureSubImage1D);
   SET_Normal3x(table, _mesa_marshal_Normal3x);
   SET_VertexAttrib4fARB(table, _mesa_marshal_VertexAttrib4fARB);
   SET_TexCoord4fv(table, _mesa_marshal_TexCoord4fv);
   SET_ReadnPixelsARB(table, _mesa_marshal_ReadnPixelsARB);
   SET_InvalidateTexSubImage(table, _mesa_marshal_InvalidateTexSubImage);
   SET_Normal3s(table, _mesa_marshal_Normal3s);
   SET_Materialxv(table, _mesa_marshal_Materialxv);
   SET_Normal3i(table, _mesa_marshal_Normal3i);
   SET_Normal3b(table, _mesa_marshal_Normal3b);
   SET_Normal3d(table, _mesa_marshal_Normal3d);
   SET_Normal3f(table, _mesa_marshal_Normal3f);
   SET_Indexi(table, _mesa_marshal_Indexi);
   SET_Uniform1uiv(table, _mesa_marshal_Uniform1uiv);
   SET_VertexAttribI2uiEXT(table, _mesa_marshal_VertexAttribI2uiEXT);
   SET_IsRenderbuffer(table, _mesa_marshal_IsRenderbuffer);
   SET_NormalP3uiv(table, _mesa_marshal_NormalP3uiv);
   SET_Indexf(table, _mesa_marshal_Indexf);
   SET_Indexd(table, _mesa_marshal_Indexd);
   SET_GetMaterialiv(table, _mesa_marshal_GetMaterialiv);
   SET_Indexs(table, _mesa_marshal_Indexs);
   SET_MultiTexCoordP1uiv(table, _mesa_marshal_MultiTexCoordP1uiv);
   SET_ConvolutionFilter2D(table, _mesa_marshal_ConvolutionFilter2D);
   SET_Vertex2d(table, _mesa_marshal_Vertex2d);
   SET_Vertex2f(table, _mesa_marshal_Vertex2f);
   SET_Color4bv(table, _mesa_marshal_Color4bv);
   SET_ProgramUniformMatrix3x2dv(table, _mesa_marshal_ProgramUniformMatrix3x2dv);
   SET_VertexAttrib2fvNV(table, _mesa_marshal_VertexAttrib2fvNV);
   SET_Vertex2s(table, _mesa_marshal_Vertex2s);
   SET_ActiveTexture(table, _mesa_marshal_ActiveTexture);
   SET_InvalidateNamedFramebufferSubData(table, _mesa_marshal_InvalidateNamedFramebufferSubData);
   SET_ColorP4uiv(table, _mesa_marshal_ColorP4uiv);
   SET_DrawTexxOES(table, _mesa_marshal_DrawTexxOES);
   SET_MultiTexCoordP3ui(table, _mesa_marshal_MultiTexCoordP3ui);
   SET_GetAttribLocation(table, _mesa_marshal_GetAttribLocation);
   SET_DrawBuffer(table, _mesa_marshal_DrawBuffer);
   SET_GetPointerv(table, _mesa_marshal_GetPointerv);
   SET_MultiTexCoord2dv(table, _mesa_marshal_MultiTexCoord2dv);
   SET_IsSampler(table, _mesa_marshal_IsSampler);
   SET_BlendFunc(table, _mesa_marshal_BlendFunc);
   SET_NamedRenderbufferStorageMultisample(table, _mesa_marshal_NamedRenderbufferStorageMultisample);
   SET_ColorMaterial(table, _mesa_marshal_ColorMaterial);
   SET_RasterPos3sv(table, _mesa_marshal_RasterPos3sv);
   SET_TexCoordP2ui(table, _mesa_marshal_TexCoordP2ui);
   SET_TexParameteriv(table, _mesa_marshal_TexParameteriv);
   SET_WaitSemaphoreEXT(table, _mesa_marshal_WaitSemaphoreEXT);
   SET_VertexAttrib3fvARB(table, _mesa_marshal_VertexAttrib3fvARB);
   SET_ProgramUniformMatrix3x4fv(table, _mesa_marshal_ProgramUniformMatrix3x4fv);
   SET_GetColorTable(table, _mesa_marshal_GetColorTable);
   SET_TexCoord3i(table, _mesa_marshal_TexCoord3i);
   SET_CopyColorTable(table, _mesa_marshal_CopyColorTable);
   SET_Frustum(table, _mesa_marshal_Frustum);
   SET_TexCoord3d(table, _mesa_marshal_TexCoord3d);
   SET_GetTextureParameteriv(table, _mesa_marshal_GetTextureParameteriv);
   SET_TexCoord3f(table, _mesa_marshal_TexCoord3f);
   SET_DepthRangeArrayv(table, _mesa_marshal_DepthRangeArrayv);
   SET_DeleteTextures(table, _mesa_marshal_DeleteTextures);
   SET_TexCoordPointerEXT(table, _mesa_marshal_TexCoordPointerEXT);
   SET_TexCoord3s(table, _mesa_marshal_TexCoord3s);
   SET_GetTexLevelParameteriv(table, _mesa_marshal_GetTexLevelParameteriv);
   SET_TextureParameterIuiv(table, _mesa_marshal_TextureParameterIuiv);
   SET_GenPerfMonitorsAMD(table, _mesa_marshal_GenPerfMonitorsAMD);
   SET_ClearAccum(table, _mesa_marshal_ClearAccum);
   SET_TexCoord4iv(table, _mesa_marshal_TexCoord4iv);
   SET_TexStorage3D(table, _mesa_marshal_TexStorage3D);
   SET_Uniform2i64ARB(table, _mesa_marshal_Uniform2i64ARB);
   SET_FramebufferTexture3D(table, _mesa_marshal_FramebufferTexture3D);
   SET_GetBufferParameteriv(table, _mesa_marshal_GetBufferParameteriv);
   SET_VertexAttrib2fNV(table, _mesa_marshal_VertexAttrib2fNV);
   SET_CopyTexImage2D(table, _mesa_marshal_CopyTexImage2D);
   SET_Vertex3fv(table, _mesa_marshal_Vertex3fv);
   SET_WindowPos4dvMESA(table, _mesa_marshal_WindowPos4dvMESA);
   SET_ProgramUniform2i64vARB(table, _mesa_marshal_ProgramUniform2i64vARB);
   SET_MultiTexCoordP2ui(table, _mesa_marshal_MultiTexCoordP2ui);
   SET_VertexAttribs1dvNV(table, _mesa_marshal_VertexAttribs1dvNV);
   SET_ImportSemaphoreFdEXT(table, _mesa_marshal_ImportSemaphoreFdEXT);
   SET_IsQuery(table, _mesa_marshal_IsQuery);
   SET_EdgeFlagPointerEXT(table, _mesa_marshal_EdgeFlagPointerEXT);
   SET_VertexAttribs2svNV(table, _mesa_marshal_VertexAttribs2svNV);
   SET_CreateShaderProgramv(table, _mesa_marshal_CreateShaderProgramv);
   SET_BlendEquationiARB(table, _mesa_marshal_BlendEquationiARB);
   SET_VertexAttribI4uivEXT(table, _mesa_marshal_VertexAttribI4uivEXT);
   SET_PointSizex(table, _mesa_marshal_PointSizex);
   SET_PolygonMode(table, _mesa_marshal_PolygonMode);
   SET_SecondaryColor3iv(table, _mesa_marshal_SecondaryColor3iv);
   SET_VertexAttribI1iEXT(table, _mesa_marshal_VertexAttribI1iEXT);
   SET_VertexAttrib4Niv(table, _mesa_marshal_VertexAttrib4Niv);
   SET_GetnUniformdvARB(table, _mesa_marshal_GetnUniformdvARB);
   SET_LinkProgram(table, _mesa_marshal_LinkProgram);
   SET_ProgramUniform4d(table, _mesa_marshal_ProgramUniform4d);
   SET_ProgramUniform4f(table, _mesa_marshal_ProgramUniform4f);
   SET_ProgramUniform4i(table, _mesa_marshal_ProgramUniform4i);
   SET_GetFramebufferParameteriv(table, _mesa_marshal_GetFramebufferParameteriv);
   SET_GetNamedBufferPointerv(table, _mesa_marshal_GetNamedBufferPointerv);
   SET_VertexAttrib4d(table, _mesa_marshal_VertexAttrib4d);
   SET_ProgramUniform4ui64vARB(table, _mesa_marshal_ProgramUniform4ui64vARB);
   SET_WindowPos4sMESA(table, _mesa_marshal_WindowPos4sMESA);
   SET_VertexAttrib4s(table, _mesa_marshal_VertexAttrib4s);
   SET_ProgramUniform1i64vARB(table, _mesa_marshal_ProgramUniform1i64vARB);
   SET_VertexAttrib1dvNV(table, _mesa_marshal_VertexAttrib1dvNV);
   SET_GetSemaphoreParameterui64vEXT(table, _mesa_marshal_GetSemaphoreParameterui64vEXT);
   SET_TexStorage3DMultisample(table, _mesa_marshal_TexStorage3DMultisample);
   SET_SamplerParameteriv(table, _mesa_marshal_SamplerParameteriv);
   SET_VertexAttribP3uiv(table, _mesa_marshal_VertexAttribP3uiv);
   SET_ScissorIndexedv(table, _mesa_marshal_ScissorIndexedv);
   SET_GetStringi(table, _mesa_marshal_GetStringi);
   SET_Uniform2dv(table, _mesa_marshal_Uniform2dv);
   SET_VertexAttrib4dv(table, _mesa_marshal_VertexAttrib4dv);
   SET_CreateTextures(table, _mesa_marshal_CreateTextures);
   SET_EvalCoord2dv(table, _mesa_marshal_EvalCoord2dv);
   SET_VertexAttrib1fNV(table, _mesa_marshal_VertexAttrib1fNV);
   SET_CompressedTexSubImage1D(table, _mesa_marshal_CompressedTexSubImage1D);
   SET_GetSeparableFilter(table, _mesa_marshal_GetSeparableFilter);
   SET_FeedbackBuffer(table, _mesa_marshal_FeedbackBuffer);
   SET_RasterPos2iv(table, _mesa_marshal_RasterPos2iv);
   SET_TexImage1D(table, _mesa_marshal_TexImage1D);
   SET_MultiDrawElementsEXT(table, _mesa_marshal_MultiDrawElementsEXT);
   SET_GetnSeparableFilterARB(table, _mesa_marshal_GetnSeparableFilterARB);
   SET_FrontFace(table, _mesa_marshal_FrontFace);
   SET_MultiModeDrawArraysIBM(table, _mesa_marshal_MultiModeDrawArraysIBM);
   SET_Normal3dv(table, _mesa_marshal_Normal3dv);
   SET_Lightf(table, _mesa_marshal_Lightf);
   SET_MatrixMode(table, _mesa_marshal_MatrixMode);
   SET_GetPixelMapusv(table, _mesa_marshal_GetPixelMapusv);
   SET_Lighti(table, _mesa_marshal_Lighti);
   SET_GetFragDataIndex(table, _mesa_marshal_GetFragDataIndex);
   SET_Lightx(table, _mesa_marshal_Lightx);
   SET_ProgramUniform3fv(table, _mesa_marshal_ProgramUniform3fv);
   SET_MultMatrixd(table, _mesa_marshal_MultMatrixd);
   SET_MultMatrixf(table, _mesa_marshal_MultMatrixf);
   SET_Uniform4ui64vARB(table, _mesa_marshal_Uniform4ui64vARB);
   SET_MultiTexCoord4fvARB(table, _mesa_marshal_MultiTexCoord4fvARB);
   SET_UniformMatrix2x3fv(table, _mesa_marshal_UniformMatrix2x3fv);
   SET_SamplerParameterf(table, _mesa_marshal_SamplerParameterf);
   SET_UniformMatrix3dv(table, _mesa_marshal_UniformMatrix3dv);
   SET_PointParameterx(table, _mesa_marshal_PointParameterx);
   SET_DrawArrays(table, _mesa_marshal_DrawArrays);
   SET_Uniform3dv(table, _mesa_marshal_Uniform3dv);
   SET_PointParameteri(table, _mesa_marshal_PointParameteri);
   SET_PointParameterf(table, _mesa_marshal_PointParameterf);
   SET_VertexAttribBinding(table, _mesa_marshal_VertexAttribBinding);
   SET_TextureSubImage2D(table, _mesa_marshal_TextureSubImage2D);
   SET_CreateShader(table, _mesa_marshal_CreateShader);
   SET_ProgramUniform1dv(table, _mesa_marshal_ProgramUniform1dv);
   SET_GetProgramEnvParameterfvARB(table, _mesa_marshal_GetProgramEnvParameterfvARB);
   SET_DeleteBuffers(table, _mesa_marshal_DeleteBuffers);
   SET_GetBufferSubData(table, _mesa_marshal_GetBufferSubData);
   SET_GetNamedRenderbufferParameteriv(table, _mesa_marshal_GetNamedRenderbufferParameteriv);
   SET_GetPerfMonitorGroupsAMD(table, _mesa_marshal_GetPerfMonitorGroupsAMD);
   SET_VertexAttribP2ui(table, _mesa_marshal_VertexAttribP2ui);
   SET_ProgramUniform4dv(table, _mesa_marshal_ProgramUniform4dv);
   SET_GetMinmaxParameteriv(table, _mesa_marshal_GetMinmaxParameteriv);
   SET_DrawTexivOES(table, _mesa_marshal_DrawTexivOES);
   SET_CopyTexImage1D(table, _mesa_marshal_CopyTexImage1D);
   SET_InvalidateNamedFramebufferData(table, _mesa_marshal_InvalidateNamedFramebufferData);
   SET_SemaphoreParameterui64vEXT(table, _mesa_marshal_SemaphoreParameterui64vEXT);
   SET_GetnColorTableARB(table, _mesa_marshal_GetnColorTableARB);
   SET_VertexAttribFormat(table, _mesa_marshal_VertexAttribFormat);
   SET_Vertex3i(table, _mesa_marshal_Vertex3i);
   SET_Vertex3f(table, _mesa_marshal_Vertex3f);
   SET_Vertex3d(table, _mesa_marshal_Vertex3d);
   SET_GetProgramPipelineiv(table, _mesa_marshal_GetProgramPipelineiv);
   SET_ReadBuffer(table, _mesa_marshal_ReadBuffer);
   SET_ConvolutionParameteri(table, _mesa_marshal_ConvolutionParameteri);
   SET_GetTexParameterIiv(table, _mesa_marshal_GetTexParameterIiv);
   SET_Vertex3s(table, _mesa_marshal_Vertex3s);
   SET_ConvolutionParameterf(table, _mesa_marshal_ConvolutionParameterf);
   SET_GetColorTableParameteriv(table, _mesa_marshal_GetColorTableParameteriv);
   SET_GetTransformFeedbackVarying(table, _mesa_marshal_GetTransformFeedbackVarying);
   SET_GetNextPerfQueryIdINTEL(table, _mesa_marshal_GetNextPerfQueryIdINTEL);
   SET_TexCoord3fv(table, _mesa_marshal_TexCoord3fv);
   SET_TextureBarrierNV(table, _mesa_marshal_TextureBarrierNV);
   SET_GetProgramInterfaceiv(table, _mesa_marshal_GetProgramInterfaceiv);
   SET_VertexAttribL1ui64vARB(table, _mesa_marshal_VertexAttribL1ui64vARB);
   SET_ProgramLocalParameter4fARB(table, _mesa_marshal_ProgramLocalParameter4fARB);
   SET_PauseTransformFeedback(table, _mesa_marshal_PauseTransformFeedback);
   SET_DeleteShader(table, _mesa_marshal_DeleteShader);
   SET_NamedFramebufferRenderbuffer(table, _mesa_marshal_NamedFramebufferRenderbuffer);
   SET_CompileShader(table, _mesa_marshal_CompileShader);
   SET_Vertex2iv(table, _mesa_marshal_Vertex2iv);
   SET_GetVertexArrayIndexediv(table, _mesa_marshal_GetVertexArrayIndexediv);
   SET_TexParameterIiv(table, _mesa_marshal_TexParameterIiv);
   SET_TexGendv(table, _mesa_marshal_TexGendv);
   SET_ResetMinmax(table, _mesa_marshal_ResetMinmax);
   SET_SampleCoverage(table, _mesa_marshal_SampleCoverage);
   SET_GenerateTextureMipmap(table, _mesa_marshal_GenerateTextureMipmap);
   SET_DeleteProgramsARB(table, _mesa_marshal_DeleteProgramsARB);
   SET_ShadeModel(table, _mesa_marshal_ShadeModel);
   SET_CreateQueries(table, _mesa_marshal_CreateQueries);
   SET_MultiDrawArrays(table, _mesa_marshal_MultiDrawArrays);
   SET_GetProgramLocalParameterdvARB(table, _mesa_marshal_GetProgramLocalParameterdvARB);
   SET_MapBufferRange(table, _mesa_marshal_MapBufferRange);
   SET_DispatchCompute(table, _mesa_marshal_DispatchCompute);
   SET_UseProgramStages(table, _mesa_marshal_UseProgramStages);
   SET_ProgramUniformMatrix4fv(table, _mesa_marshal_ProgramUniformMatrix4fv);
   SET_FramebufferRenderbuffer(table, _mesa_marshal_FramebufferRenderbuffer);
   SET_IsProgramARB(table, _mesa_marshal_IsProgramARB);
   SET_Map2d(table, _mesa_marshal_Map2d);
   SET_Map2f(table, _mesa_marshal_Map2f);
   SET_ProgramStringARB(table, _mesa_marshal_ProgramStringARB);
   SET_CopyTextureSubImage2D(table, _mesa_marshal_CopyTextureSubImage2D);
   SET_MultiTexCoord4s(table, _mesa_marshal_MultiTexCoord4s);
   SET_ViewportIndexedf(table, _mesa_marshal_ViewportIndexedf);
   SET_MultiTexCoord4i(table, _mesa_marshal_MultiTexCoord4i);
   SET_DebugMessageControl(table, _mesa_marshal_DebugMessageControl);
   SET_MultiTexCoord4d(table, _mesa_marshal_MultiTexCoord4d);
   SET_GetHistogram(table, _mesa_marshal_GetHistogram);
   SET_Translatex(table, _mesa_marshal_Translatex);
   SET_MultiDrawElementsIndirectCountARB(table, _mesa_marshal_MultiDrawElementsIndirectCountARB);
   SET_Indexsv(table, _mesa_marshal_Indexsv);
   SET_VertexAttrib1fvARB(table, _mesa_marshal_VertexAttrib1fvARB);
   SET_TexCoord2dv(table, _mesa_marshal_TexCoord2dv);
   SET_Translated(table, _mesa_marshal_Translated);
   SET_Translatef(table, _mesa_marshal_Translatef);
   SET_MultTransposeMatrixd(table, _mesa_marshal_MultTransposeMatrixd);
   SET_ProgramUniform4uiv(table, _mesa_marshal_ProgramUniform4uiv);
   SET_GetPerfCounterInfoINTEL(table, _mesa_marshal_GetPerfCounterInfoINTEL);
   SET_RenderMode(table, _mesa_marshal_RenderMode);
   SET_MultiTexCoord1fARB(table, _mesa_marshal_MultiTexCoord1fARB);
   SET_SecondaryColor3d(table, _mesa_marshal_SecondaryColor3d);
   SET_FramebufferParameteri(table, _mesa_marshal_FramebufferParameteri);
   SET_VertexAttribs4ubvNV(table, _mesa_marshal_VertexAttribs4ubvNV);
   SET_LightModelxv(table, _mesa_marshal_LightModelxv);
   SET_CopyTexSubImage1D(table, _mesa_marshal_CopyTexSubImage1D);
   SET_TextureSubImage3D(table, _mesa_marshal_TextureSubImage3D);
   SET_StencilFunc(table, _mesa_marshal_StencilFunc);
   SET_CopyPixels(table, _mesa_marshal_CopyPixels);
   SET_TexGenxvOES(table, _mesa_marshal_TexGenxvOES);
   SET_GetTextureLevelParameterfv(table, _mesa_marshal_GetTextureLevelParameterfv);
   SET_VertexAttrib4Nubv(table, _mesa_marshal_VertexAttrib4Nubv);
   SET_UniformMatrix4x2dv(table, _mesa_marshal_UniformMatrix4x2dv);
   SET_VertexAttribPointer(table, _mesa_marshal_VertexAttribPointer);
   SET_IndexMask(table, _mesa_marshal_IndexMask);
   SET_VertexAttribIFormat(table, _mesa_marshal_VertexAttribIFormat);
   SET_DrawArraysInstancedBaseInstance(table, _mesa_marshal_DrawArraysInstancedBaseInstance);
   SET_TextureStorageMem3DMultisampleEXT(table, _mesa_marshal_TextureStorageMem3DMultisampleEXT);
   SET_CompressedTextureSubImage3D(table, _mesa_marshal_CompressedTextureSubImage3D);
   SET_PopAttrib(table, _mesa_marshal_PopAttrib);
   SET_Uniform3ui(table, _mesa_marshal_Uniform3ui);
   SET_DeletePerfMonitorsAMD(table, _mesa_marshal_DeletePerfMonitorsAMD);
   SET_Color4dv(table, _mesa_marshal_Color4dv);
   SET_DisableVertexAttribArray(table, _mesa_marshal_DisableVertexAttribArray);
   SET_ProgramUniformMatrix3x2fv(table, _mesa_marshal_ProgramUniformMatrix3x2fv);
   SET_GetDoublei_v(table, _mesa_marshal_GetDoublei_v);
   SET_IsTransformFeedback(table, _mesa_marshal_IsTransformFeedback);
   SET_GetMemoryObjectParameterivEXT(table, _mesa_marshal_GetMemoryObjectParameterivEXT);
   SET_ClipPlanex(table, _mesa_marshal_ClipPlanex);
   SET_GetLightfv(table, _mesa_marshal_GetLightfv);
   SET_ClipPlanef(table, _mesa_marshal_ClipPlanef);
   SET_ProgramUniform1ui(table, _mesa_marshal_ProgramUniform1ui);
   SET_SecondaryColorPointer(table, _mesa_marshal_SecondaryColorPointer);
   SET_LineStipple(table, _mesa_marshal_LineStipple);
   SET_BeginFragmentShaderATI(table, _mesa_marshal_BeginFragmentShaderATI);
   SET_GenRenderbuffers(table, _mesa_marshal_GenRenderbuffers);
   SET_GetMinmaxParameterfv(table, _mesa_marshal_GetMinmaxParameterfv);
   SET_TextureStorageMem2DEXT(table, _mesa_marshal_TextureStorageMem2DEXT);
   SET_IsEnabledi(table, _mesa_marshal_IsEnabledi);
   SET_WaitSync(table, _mesa_marshal_WaitSync);
   SET_GetVertexAttribPointerv(table, _mesa_marshal_GetVertexAttribPointerv);
   SET_Uniform1i64vARB(table, _mesa_marshal_Uniform1i64vARB);
   SET_CreatePerfQueryINTEL(table, _mesa_marshal_CreatePerfQueryINTEL);
   SET_NewList(table, _mesa_marshal_NewList);
   SET_TexBuffer(table, _mesa_marshal_TexBuffer);
   SET_TexCoord4sv(table, _mesa_marshal_TexCoord4sv);
   SET_TexCoord1f(table, _mesa_marshal_TexCoord1f);
   SET_TexCoord1d(table, _mesa_marshal_TexCoord1d);
   SET_TexCoord1i(table, _mesa_marshal_TexCoord1i);
   SET_GetnUniformfvARB(table, _mesa_marshal_GetnUniformfvARB);
   SET_TexCoord1s(table, _mesa_marshal_TexCoord1s);
   SET_Uniform1ui(table, _mesa_marshal_Uniform1ui);
   SET_TexStorage1D(table, _mesa_marshal_TexStorage1D);
   SET_BlitFramebuffer(table, _mesa_marshal_BlitFramebuffer);
   SET_TextureParameterf(table, _mesa_marshal_TextureParameterf);
   SET_FramebufferTexture1D(table, _mesa_marshal_FramebufferTexture1D);
   SET_TextureParameteri(table, _mesa_marshal_TextureParameteri);
   SET_GetMapiv(table, _mesa_marshal_GetMapiv);
   SET_GetUniformui64vARB(table, _mesa_marshal_GetUniformui64vARB);
   SET_TexCoordP4ui(table, _mesa_marshal_TexCoordP4ui);
   SET_VertexAttrib1sv(table, _mesa_marshal_VertexAttrib1sv);
   SET_WindowPos4dMESA(table, _mesa_marshal_WindowPos4dMESA);
   SET_Vertex3dv(table, _mesa_marshal_Vertex3dv);
   SET_VertexAttribL2d(table, _mesa_marshal_VertexAttribL2d);
   SET_GetnMapivARB(table, _mesa_marshal_GetnMapivARB);
   SET_GetVertexAttribfv(table, _mesa_marshal_GetVertexAttribfv);
   SET_MultiTexCoordP4uiv(table, _mesa_marshal_MultiTexCoordP4uiv);
   SET_TexGeniv(table, _mesa_marshal_TexGeniv);
   SET_IsMemoryObjectEXT(table, _mesa_marshal_IsMemoryObjectEXT);
   SET_BlendColor(table, _mesa_marshal_BlendColor);
   SET_VertexAttribs2dvNV(table, _mesa_marshal_VertexAttribs2dvNV);
   SET_VertexAttrib2dvNV(table, _mesa_marshal_VertexAttrib2dvNV);
   SET_NamedFramebufferDrawBuffers(table, _mesa_marshal_NamedFramebufferDrawBuffers);
   SET_ResetHistogram(table, _mesa_marshal_ResetHistogram);
   SET_CompressedTexSubImage2D(table, _mesa_marshal_CompressedTexSubImage2D);
   SET_TexCoord2sv(table, _mesa_marshal_TexCoord2sv);
   SET_StencilMaskSeparate(table, _mesa_marshal_StencilMaskSeparate);
   SET_MultiTexCoord3sv(table, _mesa_marshal_MultiTexCoord3sv);
   SET_TexCoord3iv(table, _mesa_marshal_TexCoord3iv);
   SET_MultiTexCoord4sv(table, _mesa_marshal_MultiTexCoord4sv);
   SET_VertexBindingDivisor(table, _mesa_marshal_VertexBindingDivisor);
   SET_PrimitiveBoundingBox(table, _mesa_marshal_PrimitiveBoundingBox);
   SET_GetPerfMonitorCounterInfoAMD(table, _mesa_marshal_GetPerfMonitorCounterInfoAMD);
   SET_UniformBlockBinding(table, _mesa_marshal_UniformBlockBinding);
   SET_FenceSync(table, _mesa_marshal_FenceSync);
   SET_CompressedTextureSubImage2D(table, _mesa_marshal_CompressedTextureSubImage2D);
   SET_VertexAttrib4Nusv(table, _mesa_marshal_VertexAttrib4Nusv);
   SET_SetFragmentShaderConstantATI(table, _mesa_marshal_SetFragmentShaderConstantATI);
   SET_VertexP2ui(table, _mesa_marshal_VertexP2ui);
   SET_ProgramUniform2fv(table, _mesa_marshal_ProgramUniform2fv);
   SET_GetTextureLevelParameteriv(table, _mesa_marshal_GetTextureLevelParameteriv);
   SET_GetTexEnvfv(table, _mesa_marshal_GetTexEnvfv);
   SET_BindAttribLocation(table, _mesa_marshal_BindAttribLocation);
   SET_TextureStorage2DEXT(table, _mesa_marshal_TextureStorage2DEXT);
   SET_TextureParameterIiv(table, _mesa_marshal_TextureParameterIiv);
   SET_DrawTransformFeedbackInstanced(table, _mesa_marshal_DrawTransformFeedbackInstanced);
   SET_CopyTextureSubImage1D(table, _mesa_marshal_CopyTextureSubImage1D);
   SET_ResumeTransformFeedback(table, _mesa_marshal_ResumeTransformFeedback);
   SET_VertexAttribI1iv(table, _mesa_marshal_VertexAttribI1iv);
   SET_Vertex2dv(table, _mesa_marshal_Vertex2dv);
   SET_VertexAttribI2uivEXT(table, _mesa_marshal_VertexAttribI2uivEXT);
   SET_SampleMaski(table, _mesa_marshal_SampleMaski);
   SET_GetFloati_v(table, _mesa_marshal_GetFloati_v);
   SET_MultiTexCoord2iv(table, _mesa_marshal_MultiTexCoord2iv);
   SET_DrawPixels(table, _mesa_marshal_DrawPixels);
   SET_CreateFramebuffers(table, _mesa_marshal_CreateFramebuffers);
   SET_DrawTransformFeedback(table, _mesa_marshal_DrawTransformFeedback);
   SET_VertexAttribs3fvNV(table, _mesa_marshal_VertexAttribs3fvNV);
   SET_GenLists(table, _mesa_marshal_GenLists);
   SET_ProgramUniform2ui64vARB(table, _mesa_marshal_ProgramUniform2ui64vARB);
   SET_MapGrid2d(table, _mesa_marshal_MapGrid2d);
   SET_MapGrid2f(table, _mesa_marshal_MapGrid2f);
   SET_SampleMapATI(table, _mesa_marshal_SampleMapATI);
   SET_GetActiveAttrib(table, _mesa_marshal_GetActiveAttrib);
   SET_PixelMapfv(table, _mesa_marshal_PixelMapfv);
   SET_ClearBufferData(table, _mesa_marshal_ClearBufferData);
   SET_Color3usv(table, _mesa_marshal_Color3usv);
   SET_CopyImageSubData(table, _mesa_marshal_CopyImageSubData);
   SET_StencilOpSeparate(table, _mesa_marshal_StencilOpSeparate);
   SET_GenSamplers(table, _mesa_marshal_GenSamplers);
   SET_ClipControl(table, _mesa_marshal_ClipControl);
   SET_DrawTexfOES(table, _mesa_marshal_DrawTexfOES);
   SET_Uniform4i64vARB(table, _mesa_marshal_Uniform4i64vARB);
   SET_AttachObjectARB(table, _mesa_marshal_AttachObjectARB);
   SET_Accum(table, _mesa_marshal_Accum);
   SET_GetTexImage(table, _mesa_marshal_GetTexImage);
   SET_Color4x(table, _mesa_marshal_Color4x);
   SET_ConvolutionParameteriv(table, _mesa_marshal_ConvolutionParameteriv);
   SET_Color4s(table, _mesa_marshal_Color4s);
   SET_EnableVertexAttribArray(table, _mesa_marshal_EnableVertexAttribArray);
   SET_Color4i(table, _mesa_marshal_Color4i);
   SET_Color4f(table, _mesa_marshal_Color4f);
   SET_ShaderStorageBlockBinding(table, _mesa_marshal_ShaderStorageBlockBinding);
   SET_Color4d(table, _mesa_marshal_Color4d);
   SET_Color4b(table, _mesa_marshal_Color4b);
   SET_MemoryObjectParameterivEXT(table, _mesa_marshal_MemoryObjectParameterivEXT);
   SET_GetAttachedObjectsARB(table, _mesa_marshal_GetAttachedObjectsARB);
   SET_EvalCoord1fv(table, _mesa_marshal_EvalCoord1fv);
   SET_VertexAttribLFormat(table, _mesa_marshal_VertexAttribLFormat);
   SET_VertexAttribL3d(table, _mesa_marshal_VertexAttribL3d);
   SET_ClearNamedFramebufferuiv(table, _mesa_marshal_ClearNamedFramebufferuiv);
   SET_StencilFuncSeparate(table, _mesa_marshal_StencilFuncSeparate);
   SET_ShaderSource(table, _mesa_marshal_ShaderSource);
   SET_Normal3fv(table, _mesa_marshal_Normal3fv);
   SET_NormalP3ui(table, _mesa_marshal_NormalP3ui);
   SET_CreateSamplers(table, _mesa_marshal_CreateSamplers);
   SET_MultiTexCoord3fvARB(table, _mesa_marshal_MultiTexCoord3fvARB);
   SET_BufferData(table, _mesa_marshal_BufferData);
   SET_TexSubImage2D(table, _mesa_marshal_TexSubImage2D);
   SET_TexGenfv(table, _mesa_marshal_TexGenfv);
   SET_GetVertexAttribiv(table, _mesa_marshal_GetVertexAttribiv);
   SET_TexCoordP2uiv(table, _mesa_marshal_TexCoordP2uiv);
   SET_Uniform3fv(table, _mesa_marshal_Uniform3fv);
   SET_BlendEquation(table, _mesa_marshal_BlendEquation);
   SET_VertexAttrib3dNV(table, _mesa_marshal_VertexAttrib3dNV);
   SET_PushName(table, _mesa_marshal_PushName);
   SET_DeleteRenderbuffers(table, _mesa_marshal_DeleteRenderbuffers);
   SET_VertexAttrib1dv(table, _mesa_marshal_VertexAttrib1dv);
   SET_IsShader(table, _mesa_marshal_IsShader);
   SET_Rotated(table, _mesa_marshal_Rotated);
   SET_Color4iv(table, _mesa_marshal_Color4iv);
   SET_PointParameterxv(table, _mesa_marshal_PointParameterxv);
   SET_Rotatex(table, _mesa_marshal_Rotatex);
   SET_FramebufferTextureLayer(table, _mesa_marshal_FramebufferTextureLayer);
   SET_TexEnvfv(table, _mesa_marshal_TexEnvfv);
   SET_ProgramUniformMatrix3fv(table, _mesa_marshal_ProgramUniformMatrix3fv);
   SET_DeleteMemoryObjectsEXT(table, _mesa_marshal_DeleteMemoryObjectsEXT);
   SET_LoadMatrixf(table, _mesa_marshal_LoadMatrixf);
   SET_GetProgramLocalParameterfvARB(table, _mesa_marshal_GetProgramLocalParameterfvARB);
   SET_MakeTextureHandleResidentARB(table, _mesa_marshal_MakeTextureHandleResidentARB);
   SET_MultiDrawArraysIndirect(table, _mesa_marshal_MultiDrawArraysIndirect);
   SET_DrawRangeElementsBaseVertex(table, _mesa_marshal_DrawRangeElementsBaseVertex);
   SET_ProgramUniformMatrix4dv(table, _mesa_marshal_ProgramUniformMatrix4dv);
   SET_SecondaryColor3bv(table, _mesa_marshal_SecondaryColor3bv);
   SET_DrawTexxvOES(table, _mesa_marshal_DrawTexxvOES);
   SET_TexParameterfv(table, _mesa_marshal_TexParameterfv);
   SET_Color4ubv(table, _mesa_marshal_Color4ubv);
   SET_TexCoord2fv(table, _mesa_marshal_TexCoord2fv);
   SET_FogCoorddv(table, _mesa_marshal_FogCoorddv);
   SET_VDPAUUnregisterSurfaceNV(table, _mesa_marshal_VDPAUUnregisterSurfaceNV);
   SET_ColorP3ui(table, _mesa_marshal_ColorP3ui);
   SET_ClearBufferuiv(table, _mesa_marshal_ClearBufferuiv);
   SET_GetUnsignedBytei_vEXT(table, _mesa_marshal_GetUnsignedBytei_vEXT);
   SET_GetShaderPrecisionFormat(table, _mesa_marshal_GetShaderPrecisionFormat);
   SET_Flush(table, _mesa_marshal_Flush);
   SET_MakeTextureHandleNonResidentARB(table, _mesa_marshal_MakeTextureHandleNonResidentARB);
   SET_VertexAttribI4iEXT(table, _mesa_marshal_VertexAttribI4iEXT);
   SET_VertexAttribI3uivEXT(table, _mesa_marshal_VertexAttribI3uivEXT);
   SET_FogCoordd(table, _mesa_marshal_FogCoordd);
   SET_BindFramebufferEXT(table, _mesa_marshal_BindFramebufferEXT);
   SET_Uniform3iv(table, _mesa_marshal_Uniform3iv);
   SET_TexStorage2DMultisample(table, _mesa_marshal_TexStorage2DMultisample);
   SET_UnlockArraysEXT(table, _mesa_marshal_UnlockArraysEXT);
   SET_GetVertexAttribLui64vARB(table, _mesa_marshal_GetVertexAttribLui64vARB);
   SET_VertexAttrib4iv(table, _mesa_marshal_VertexAttrib4iv);
   SET_CopyTexSubImage3D(table, _mesa_marshal_CopyTexSubImage3D);
   SET_PolygonOffsetClampEXT(table, _mesa_marshal_PolygonOffsetClampEXT);
   SET_GetInteger64v(table, _mesa_marshal_GetInteger64v);
   SET_DetachObjectARB(table, _mesa_marshal_DetachObjectARB);
   SET_Indexiv(table, _mesa_marshal_Indexiv);
   SET_TexEnvi(table, _mesa_marshal_TexEnvi);
   SET_TexEnvf(table, _mesa_marshal_TexEnvf);
   SET_TexEnvx(table, _mesa_marshal_TexEnvx);
   SET_InvalidateBufferSubData(table, _mesa_marshal_InvalidateBufferSubData);
   SET_UniformMatrix4x2fv(table, _mesa_marshal_UniformMatrix4x2fv);
   SET_ClearTexImage(table, _mesa_marshal_ClearTexImage);
   SET_PolygonOffset(table, _mesa_marshal_PolygonOffset);
   SET_SamplerParameterfv(table, _mesa_marshal_SamplerParameterfv);
   SET_CompressedTextureSubImage1D(table, _mesa_marshal_CompressedTextureSubImage1D);
   SET_ProgramUniformMatrix4x2dv(table, _mesa_marshal_ProgramUniformMatrix4x2dv);
   SET_ProgramEnvParameter4fARB(table, _mesa_marshal_ProgramEnvParameter4fARB);
   SET_ClearDepth(table, _mesa_marshal_ClearDepth);
   SET_VertexAttrib3dvNV(table, _mesa_marshal_VertexAttrib3dvNV);
   SET_Color4fv(table, _mesa_marshal_Color4fv);
   SET_GetnMinmaxARB(table, _mesa_marshal_GetnMinmaxARB);
   SET_IsImageHandleResidentARB(table, _mesa_marshal_IsImageHandleResidentARB);
   SET_ColorPointer(table, _mesa_marshal_ColorPointer);
   SET_ProgramUniform2ui64ARB(table, _mesa_marshal_ProgramUniform2ui64ARB);
   SET_Lightiv(table, _mesa_marshal_Lightiv);
   SET_GetTexParameterIuiv(table, _mesa_marshal_GetTexParameterIuiv);
   SET_TransformFeedbackVaryings(table, _mesa_marshal_TransformFeedbackVaryings);
   SET_VertexAttrib3sv(table, _mesa_marshal_VertexAttrib3sv);
   SET_Uniform4i64ARB(table, _mesa_marshal_Uniform4i64ARB);
   SET_IsVertexArray(table, _mesa_marshal_IsVertexArray);
   SET_ProgramUniform3ui64ARB(table, _mesa_marshal_ProgramUniform3ui64ARB);
   SET_PushClientAttrib(table, _mesa_marshal_PushClientAttrib);
   SET_ProgramUniform4ui(table, _mesa_marshal_ProgramUniform4ui);
   SET_Uniform1f(table, _mesa_marshal_Uniform1f);
   SET_Uniform1d(table, _mesa_marshal_Uniform1d);
   SET_Uniform1i(table, _mesa_marshal_Uniform1i);
   SET_GetPolygonStipple(table, _mesa_marshal_GetPolygonStipple);
   SET_BlitNamedFramebuffer(table, _mesa_marshal_BlitNamedFramebuffer);
   SET_UseProgram(table, _mesa_marshal_UseProgram);
   SET_GetFragDataLocation(table, _mesa_marshal_GetFragDataLocation);
   SET_PixelMapuiv(table, _mesa_marshal_PixelMapuiv);
   SET_ClearNamedBufferSubData(table, _mesa_marshal_ClearNamedBufferSubData);
   SET_GetNamedFramebufferAttachmentParameteriv(table, _mesa_marshal_GetNamedFramebufferAttachmentParameteriv);
   SET_GenVertexArrays(table, _mesa_marshal_GenVertexArrays);
   SET_TexStorageMem2DMultisampleEXT(table, _mesa_marshal_TexStorageMem2DMultisampleEXT);
   SET_Color3s(table, _mesa_marshal_Color3s);
   SET_TextureStorage2DMultisample(table, _mesa_marshal_TextureStorage2DMultisample);
   SET_TexCoordPointer(table, _mesa_marshal_TexCoordPointer);
   SET_Color3i(table, _mesa_marshal_Color3i);
   SET_EvalCoord2d(table, _mesa_marshal_EvalCoord2d);
   SET_EvalCoord2f(table, _mesa_marshal_EvalCoord2f);
   SET_Color3b(table, _mesa_marshal_Color3b);
   SET_Color3f(table, _mesa_marshal_Color3f);
   SET_Color3d(table, _mesa_marshal_Color3d);
   SET_GetVertexAttribdv(table, _mesa_marshal_GetVertexAttribdv);
   SET_GetBufferPointerv(table, _mesa_marshal_GetBufferPointerv);
   SET_GenFramebuffers(table, _mesa_marshal_GenFramebuffers);
   SET_IsTextureHandleResidentARB(table, _mesa_marshal_IsTextureHandleResidentARB);
   SET_GenBuffers(table, _mesa_marshal_GenBuffers);
   SET_ClearDepthx(table, _mesa_marshal_ClearDepthx);
   SET_EnableVertexArrayAttrib(table, _mesa_marshal_EnableVertexArrayAttrib);
   SET_BlendEquationSeparate(table, _mesa_marshal_BlendEquationSeparate);
   SET_MultiTexCoordP4ui(table, _mesa_marshal_MultiTexCoordP4ui);
   SET_VertexAttribs1fvNV(table, _mesa_marshal_VertexAttribs1fvNV);
   SET_VertexAttribIPointer(table, _mesa_marshal_VertexAttribIPointer);
   SET_ProgramUniform4fv(table, _mesa_marshal_ProgramUniform4fv);
   SET_RasterPos4sv(table, _mesa_marshal_RasterPos4sv);
   SET_CopyTextureSubImage3D(table, _mesa_marshal_CopyTextureSubImage3D);
   SET_SelectBuffer(table, _mesa_marshal_SelectBuffer);
   SET_GetSynciv(table, _mesa_marshal_GetSynciv);
   SET_TextureView(table, _mesa_marshal_TextureView);
   SET_TexEnviv(table, _mesa_marshal_TexEnviv);
   SET_TexSubImage3D(table, _mesa_marshal_TexSubImage3D);
   SET_Bitmap(table, _mesa_marshal_Bitmap);
   SET_VertexAttribDivisor(table, _mesa_marshal_VertexAttribDivisor);
   SET_DrawTransformFeedbackStream(table, _mesa_marshal_DrawTransformFeedbackStream);
   SET_GetIntegerv(table, _mesa_marshal_GetIntegerv);
   SET_EndPerfQueryINTEL(table, _mesa_marshal_EndPerfQueryINTEL);
   SET_NamedBufferPageCommitmentARB(table, _mesa_marshal_NamedBufferPageCommitmentARB);
   SET_GetActiveUniform(table, _mesa_marshal_GetActiveUniform);
   SET_AlphaFuncx(table, _mesa_marshal_AlphaFuncx);
   SET_VertexAttribI2ivEXT(table, _mesa_marshal_VertexAttribI2ivEXT);
   SET_Map1d(table, _mesa_marshal_Map1d);
   SET_Map1f(table, _mesa_marshal_Map1f);
   SET_AreTexturesResident(table, _mesa_marshal_AreTexturesResident);
   SET_VertexArrayVertexBuffer(table, _mesa_marshal_VertexArrayVertexBuffer);
   SET_PixelTransferf(table, _mesa_marshal_PixelTransferf);
   SET_PixelTransferi(table, _mesa_marshal_PixelTransferi);
   SET_GetProgramResourceiv(table, _mesa_marshal_GetProgramResourceiv);
   SET_VertexAttrib3fvNV(table, _mesa_marshal_VertexAttrib3fvNV);
   SET_SecondaryColorP3ui(table, _mesa_marshal_SecondaryColorP3ui);
   SET_BindTextures(table, _mesa_marshal_BindTextures);
   SET_VertexAttrib4fvNV(table, _mesa_marshal_VertexAttrib4fvNV);
   SET_Rectiv(table, _mesa_marshal_Rectiv);
   SET_MultiTexCoord1iv(table, _mesa_marshal_MultiTexCoord1iv);
   SET_PassTexCoordATI(table, _mesa_marshal_PassTexCoordATI);
   SET_Vertex2fv(table, _mesa_marshal_Vertex2fv);
   SET_BindRenderbufferEXT(table, _mesa_marshal_BindRenderbufferEXT);
   SET_Vertex3sv(table, _mesa_marshal_Vertex3sv);
   SET_EvalMesh1(table, _mesa_marshal_EvalMesh1);
   SET_DiscardFramebufferEXT(table, _mesa_marshal_DiscardFramebufferEXT);
   SET_Uniform2f(table, _mesa_marshal_Uniform2f);
   SET_Uniform2d(table, _mesa_marshal_Uniform2d);
   SET_ColorPointerEXT(table, _mesa_marshal_ColorPointerEXT);
   SET_LineWidth(table, _mesa_marshal_LineWidth);
   SET_Uniform2i(table, _mesa_marshal_Uniform2i);
   SET_MultiDrawElementsBaseVertex(table, _mesa_marshal_MultiDrawElementsBaseVertex);
   SET_Lightxv(table, _mesa_marshal_Lightxv);
   SET_DepthRangeIndexed(table, _mesa_marshal_DepthRangeIndexed);
   SET_GetConvolutionParameterfv(table, _mesa_marshal_GetConvolutionParameterfv);
   SET_GetMaterialfv(table, _mesa_marshal_GetMaterialfv);
   SET_TexImage3DMultisample(table, _mesa_marshal_TexImage3DMultisample);
   SET_VertexAttrib1fvNV(table, _mesa_marshal_VertexAttrib1fvNV);
   SET_GetUniformBlockIndex(table, _mesa_marshal_GetUniformBlockIndex);
   SET_DetachShader(table, _mesa_marshal_DetachShader);
   SET_CopyTexSubImage2D(table, _mesa_marshal_CopyTexSubImage2D);
   SET_GetNamedFramebufferParameteriv(table, _mesa_marshal_GetNamedFramebufferParameteriv);
   SET_GetObjectParameterivARB(table, _mesa_marshal_GetObjectParameterivARB);
   SET_Color3iv(table, _mesa_marshal_Color3iv);
   SET_DrawElements(table, _mesa_marshal_DrawElements);
   SET_ScissorArrayv(table, _mesa_marshal_ScissorArrayv);
   SET_GetInternalformativ(table, _mesa_marshal_GetInternalformativ);
   SET_EvalPoint2(table, _mesa_marshal_EvalPoint2);
   SET_EvalPoint1(table, _mesa_marshal_EvalPoint1);
   SET_VertexAttribLPointer(table, _mesa_marshal_VertexAttribLPointer);
   SET_PopMatrix(table, _mesa_marshal_PopMatrix);
   SET_NamedBufferData(table, _mesa_marshal_NamedBufferData);
   SET_GetTexGeniv(table, _mesa_marshal_GetTexGeniv);
   SET_GetFirstPerfQueryIdINTEL(table, _mesa_marshal_GetFirstPerfQueryIdINTEL);
   SET_UnmapBuffer(table, _mesa_marshal_UnmapBuffer);
   SET_EvalCoord1d(table, _mesa_marshal_EvalCoord1d);
   SET_VertexAttribL1d(table, _mesa_marshal_VertexAttribL1d);
   SET_EvalCoord1f(table, _mesa_marshal_EvalCoord1f);
   SET_Materialf(table, _mesa_marshal_Materialf);
   SET_Materiali(table, _mesa_marshal_Materiali);
   SET_ProgramUniform1uiv(table, _mesa_marshal_ProgramUniform1uiv);
   SET_EvalCoord1dv(table, _mesa_marshal_EvalCoord1dv);
   SET_Materialx(table, _mesa_marshal_Materialx);
   SET_GetQueryBufferObjectiv(table, _mesa_marshal_GetQueryBufferObjectiv);
   SET_GetTextureSamplerHandleARB(table, _mesa_marshal_GetTextureSamplerHandleARB);
   SET_GetLightiv(table, _mesa_marshal_GetLightiv);
   SET_ProgramUniform3i64ARB(table, _mesa_marshal_ProgramUniform3i64ARB);
   SET_BindBuffer(table, _mesa_marshal_BindBuffer);
   SET_ProgramUniform1i(table, _mesa_marshal_ProgramUniform1i);
   SET_ProgramUniform1f(table, _mesa_marshal_ProgramUniform1f);
   SET_ProgramUniform1d(table, _mesa_marshal_ProgramUniform1d);
   SET_WindowPos3iv(table, _mesa_marshal_WindowPos3iv);
   SET_CopyConvolutionFilter2D(table, _mesa_marshal_CopyConvolutionFilter2D);
   SET_CopyBufferSubData(table, _mesa_marshal_CopyBufferSubData);
   SET_UniformMatrix3x4fv(table, _mesa_marshal_UniformMatrix3x4fv);
   SET_Recti(table, _mesa_marshal_Recti);
   SET_VertexAttribI3ivEXT(table, _mesa_marshal_VertexAttribI3ivEXT);
   SET_DeleteSamplers(table, _mesa_marshal_DeleteSamplers);
   SET_SamplerParameteri(table, _mesa_marshal_SamplerParameteri);
   SET_WindowRectanglesEXT(table, _mesa_marshal_WindowRectanglesEXT);
   SET_Rectf(table, _mesa_marshal_Rectf);
   SET_Rectd(table, _mesa_marshal_Rectd);
   SET_MultMatrixx(table, _mesa_marshal_MultMatrixx);
   SET_TexStorageMem3DMultisampleEXT(table, _mesa_marshal_TexStorageMem3DMultisampleEXT);
   SET_Rects(table, _mesa_marshal_Rects);
   SET_GetVertexAttribIiv(table, _mesa_marshal_GetVertexAttribIiv);
   SET_ClientWaitSync(table, _mesa_marshal_ClientWaitSync);
   SET_TexCoord4s(table, _mesa_marshal_TexCoord4s);
   SET_TexEnvxv(table, _mesa_marshal_TexEnvxv);
   SET_TexCoord4i(table, _mesa_marshal_TexCoord4i);
   SET_ObjectPurgeableAPPLE(table, _mesa_marshal_ObjectPurgeableAPPLE);
   SET_ProgramUniform1ui64vARB(table, _mesa_marshal_ProgramUniform1ui64vARB);
   SET_TexCoord4d(table, _mesa_marshal_TexCoord4d);
   SET_TexCoord4f(table, _mesa_marshal_TexCoord4f);
   SET_GetBooleanv(table, _mesa_marshal_GetBooleanv);
   SET_ProgramUniformMatrix3dv(table, _mesa_marshal_ProgramUniformMatrix3dv);
   SET_LockArraysEXT(table, _mesa_marshal_LockArraysEXT);
   SET_GetActiveUniformBlockiv(table, _mesa_marshal_GetActiveUniformBlockiv);
   SET_GetPerfMonitorCountersAMD(table, _mesa_marshal_GetPerfMonitorCountersAMD);
   SET_ObjectPtrLabel(table, _mesa_marshal_ObjectPtrLabel);
   SET_Rectfv(table, _mesa_marshal_Rectfv);
   SET_BindImageTexture(table, _mesa_marshal_BindImageTexture);
   SET_VertexP4uiv(table, _mesa_marshal_VertexP4uiv);
   SET_GetUniformSubroutineuiv(table, _mesa_marshal_GetUniformSubroutineuiv);
   SET_MinSampleShading(table, _mesa_marshal_MinSampleShading);
   SET_GetRenderbufferParameteriv(table, _mesa_marshal_GetRenderbufferParameteriv);
   SET_VertexAttrib1dNV(table, _mesa_marshal_VertexAttrib1dNV);
   SET_WindowPos2sv(table, _mesa_marshal_WindowPos2sv);
   SET_GetPerfMonitorCounterStringAMD(table, _mesa_marshal_GetPerfMonitorCounterStringAMD);
   SET_EndFragmentShaderATI(table, _mesa_marshal_EndFragmentShaderATI);
   SET_Uniform4iv(table, _mesa_marshal_Uniform4iv);
   SET_CreateMemoryObjectsEXT(table, _mesa_marshal_CreateMemoryObjectsEXT);

   return table;
}


