Merge branch 'master' into gallium-texture-transfer

Conflicts:

	src/mesa/state_tracker/st_cb_accum.c
	src/mesa/state_tracker/st_cb_drawpixels.c

26 files changed, 5963 insertions, 63 deletions

diff --git a/src/gallium/auxiliary/draw/draw_pipe_pstipple.c b/src/gallium/auxiliary/draw/draw_pipe_pstipple.c
index 41910c6165..e68c824c86 100644
--- a/src/gallium/auxiliary/draw/draw_pipe_pstipple.c
+++ b/src/gallium/auxiliary/draw/draw_pipe_pstipple.c
@@ -256,7 +256,7 @@ pstip_transform_inst(struct tgsi_transform_context *ctx,
          struct tgsi_full_immediate immed;
          uint size = 4;
          immed = tgsi_default_full_immediate();
-         immed.Immediate.Size = 1 + size; /* one for the token itself */
+         immed.Immediate.NrTokens = 1 + size; /* one for the token itself */
          immed.u.Pointer = (void *) value;
          ctx->emit_immediate(ctx, &immed);
       }
diff --git a/src/gallium/auxiliary/draw/draw_pipe_vbuf.c b/src/gallium/auxiliary/draw/draw_pipe_vbuf.c
index 5ead25efff..9153bc2f86 100644
--- a/src/gallium/auxiliary/draw/draw_pipe_vbuf.c
+++ b/src/gallium/auxiliary/draw/draw_pipe_vbuf.c
@@ -394,13 +394,14 @@ vbuf_alloc_vertices( struct vbuf_stage *vbuf )
    /* even number */
    vbuf->max_vertices = vbuf->max_vertices & ~1;
 
+   if(vbuf->max_vertices >= UNDEFINED_VERTEX_ID)
+      vbuf->max_vertices = UNDEFINED_VERTEX_ID - 1;
+
    /* Must always succeed -- driver gives us a
     * 'max_vertex_buffer_bytes' which it guarantees it can allocate,
     * and it will flush itself if necessary to do so.  If this does
     * fail, we are basically without usable hardware.
     */
-   assert(vbuf->max_vertices < UNDEFINED_VERTEX_ID);
-
    vbuf->vertices = (uint *) vbuf->render->allocate_vertices(vbuf->render,
 							     (ushort) vbuf->vertex_size,
 							     (ushort) vbuf->max_vertices);
diff --git a/src/gallium/auxiliary/draw/draw_vs_aos.c b/src/gallium/auxiliary/draw/draw_vs_aos.c
index 6817f29c2a..0c693a4a65 100644
--- a/src/gallium/auxiliary/draw/draw_vs_aos.c
+++ b/src/gallium/auxiliary/draw/draw_vs_aos.c
@@ -1870,7 +1870,7 @@ static boolean note_immediate( struct aos_compilation *cp,
    unsigned pos = cp->num_immediates++;
    unsigned j;
 
-   for (j = 0; j < imm->Immediate.Size; j++) {
+   for (j = 0; j < imm->Immediate.NrTokens - 1; j++) {
       cp->vaos->machine->immediate[pos][j] = imm->u.ImmediateFloat32[j].Float;
    }
 
diff --git a/src/gallium/auxiliary/gallivm/tgsitollvm.cpp b/src/gallium/auxiliary/gallivm/tgsitollvm.cpp
index 6b18a68fe6..5b08200d14 100644
--- a/src/gallium/auxiliary/gallivm/tgsitollvm.cpp
+++ b/src/gallium/auxiliary/gallivm/tgsitollvm.cpp
@@ -160,7 +160,7 @@ translate_immediate(Storage *storage,
 {
    float vec[4];
    int i;
-   for (i = 0; i < imm->Immediate.Size - 1; ++i) {
+   for (i = 0; i < imm->Immediate.NrTokens - 1; ++i) {
       switch (imm->Immediate.DataType) {
       case TGSI_IMM_FLOAT32:
          vec[i] = imm->u.ImmediateFloat32[i].Float;
@@ -179,7 +179,7 @@ translate_immediateir(StorageSoa *storage,
 {
    float vec[4];
    int i;
-   for (i = 0; i < imm->Immediate.Size - 1; ++i) {
+   for (i = 0; i < imm->Immediate.NrTokens - 1; ++i) {
       switch (imm->Immediate.DataType) {
       case TGSI_IMM_FLOAT32:
          vec[i] = imm->u.ImmediateFloat32[i].Float;
diff --git a/src/gallium/auxiliary/indices/Makefile b/src/gallium/auxiliary/indices/Makefile
new file mode 100644
index 0000000000..8fa61d265e
--- /dev/null
+++ b/src/gallium/auxiliary/indices/Makefile
@@ -0,0 +1,16 @@
+TOP = ../../../..
+include $(TOP)/configs/current
+
+LIBNAME = indices
+
+C_SOURCES = \
+	u_indices_gen.c 
+
+include ../../Makefile.template
+
+u_indices_gen.c: u_indices_gen.py
+	python $< > $@
+
+
+symlinks:
+
diff --git a/src/gallium/auxiliary/indices/SConscript b/src/gallium/auxiliary/indices/SConscript
new file mode 100644
index 0000000000..65a43a9f64
--- /dev/null
+++ b/src/gallium/auxiliary/indices/SConscript
@@ -0,0 +1,17 @@
+Import('*')
+
+env.CodeGenerate(
+	target = 'u_indices_gen.c', 
+	script = 'u_indices_gen.py', 
+	source = [],
+	command = 'python $SCRIPT > $TARGET'
+)
+
+indices = env.ConvenienceLibrary(
+	target = 'indices',
+	source = [
+#               'u_indices.c',
+               'u_indices_gen.c',
+	])
+
+auxiliaries.insert(0, indices)
diff --git a/src/gallium/auxiliary/indices/u_indices.c b/src/gallium/auxiliary/indices/u_indices.c
new file mode 100644
index 0000000000..0cf7d88653
--- /dev/null
+++ b/src/gallium/auxiliary/indices/u_indices.c
@@ -0,0 +1,253 @@
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on 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
+ * VMWARE 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 "u_indices.h"
+#include "u_indices_priv.h"
+
+static void translate_memcpy_ushort( const void *in,
+                                     unsigned nr,
+                                     void *out )
+{
+   memcpy(out, in, nr*sizeof(short));
+}
+                              
+static void translate_memcpy_uint( const void *in,
+                                   unsigned nr,
+                                   void *out )
+{
+   memcpy(out, in, nr*sizeof(int));
+}
+                              
+
+int u_index_translator( unsigned hw_mask,
+                        unsigned prim,
+                        unsigned in_index_size,
+                        unsigned nr,
+                        unsigned in_pv,
+                        unsigned out_pv,
+                        unsigned *out_prim,
+                        unsigned *out_index_size,
+                        unsigned *out_nr,
+                        u_translate_func *out_translate )
+{
+   unsigned in_idx;
+   unsigned out_idx;
+   int ret = U_TRANSLATE_NORMAL;
+
+   u_index_init();
+
+   in_idx = in_size_idx(in_index_size);
+   *out_index_size = (in_index_size == 4) ? 4 : 2;
+   out_idx = out_size_idx(*out_index_size);
+
+   if ((hw_mask & (1<<prim)) && 
+       in_index_size == *out_index_size &&
+       in_pv == out_pv) 
+   {
+      if (in_index_size == 4)
+         *out_translate = translate_memcpy_uint;
+      else
+         *out_translate = translate_memcpy_ushort;
+
+      *out_prim = prim;
+      *out_nr = nr;
+
+      return U_TRANSLATE_MEMCPY;
+   }
+   else {
+      switch (prim) {
+      case PIPE_PRIM_POINTS:
+         *out_translate = translate[in_idx][out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_POINTS;
+         *out_nr = nr;
+         break;
+
+      case PIPE_PRIM_LINES:
+         *out_translate = translate[in_idx][out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_LINES;
+         *out_nr = nr;
+         break;
+
+      case PIPE_PRIM_LINE_STRIP:
+         *out_translate = translate[in_idx][out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_LINES;
+         *out_nr = (nr - 1) * 2;
+         break;
+
+      case PIPE_PRIM_LINE_LOOP:
+         *out_translate = translate[in_idx][out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_LINES;
+         *out_nr = nr * 2;
+         break;
+
+      case PIPE_PRIM_TRIANGLES:
+         *out_translate = translate[in_idx][out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_TRIANGLES;
+         *out_nr = nr;
+         break;
+
+      case PIPE_PRIM_TRIANGLE_STRIP:
+         *out_translate = translate[in_idx][out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_TRIANGLES;
+         *out_nr = (nr - 2) * 3;
+         break;
+
+      case PIPE_PRIM_TRIANGLE_FAN:
+         *out_translate = translate[in_idx][out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_TRIANGLES;
+         *out_nr = (nr - 2) * 3;
+         break;
+
+      case PIPE_PRIM_QUADS:
+         *out_translate = translate[in_idx][out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_TRIANGLES;
+         *out_nr = (nr / 4) * 6;
+         break;
+
+      case PIPE_PRIM_QUAD_STRIP:
+         *out_translate = translate[in_idx][out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_TRIANGLES;
+         *out_nr = (nr - 2) * 3;
+         break;
+
+      case PIPE_PRIM_POLYGON:
+         *out_translate = translate[in_idx][out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_TRIANGLES;
+         *out_nr = (nr - 2) * 3;
+         break;
+
+      default:
+         assert(0);
+         *out_translate = translate[in_idx][out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_POINTS;
+         *out_nr = nr;
+         return U_TRANSLATE_ERROR;
+      }
+   }
+
+   return ret;
+}
+
+
+
+
+
+int u_index_generator( unsigned hw_mask,
+                       unsigned prim,
+                       unsigned start,
+                       unsigned nr,
+                       unsigned in_pv,
+                       unsigned out_pv,
+                       unsigned *out_prim,
+                       unsigned *out_index_size,
+                       unsigned *out_nr,
+                       u_generate_func *out_generate )
+
+{
+   unsigned out_idx;
+
+   u_index_init();
+
+   *out_index_size = ((start + nr) > 0xfffe) ? 4 : 2;
+   out_idx = out_size_idx(*out_index_size);
+
+   if ((hw_mask & (1<<prim)) && 
+       (in_pv == out_pv)) {
+       
+      *out_generate = generate[out_idx][in_pv][out_pv][PIPE_PRIM_POINTS];
+      *out_prim = prim;
+      *out_nr = nr;
+      return U_GENERATE_LINEAR;
+   }
+   else {
+      switch (prim) {
+      case PIPE_PRIM_POINTS:
+         *out_generate = generate[out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_POINTS;
+         *out_nr = nr;
+         return U_GENERATE_REUSABLE;
+
+      case PIPE_PRIM_LINES:
+         *out_generate = generate[out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_LINES;
+         *out_nr = nr;
+         return U_GENERATE_REUSABLE;
+
+      case PIPE_PRIM_LINE_STRIP:
+         *out_generate = generate[out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_LINES;
+         *out_nr = (nr - 1) * 2;
+         return U_GENERATE_REUSABLE;
+
+      case PIPE_PRIM_LINE_LOOP:
+         *out_generate = generate[out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_LINES;
+         *out_nr = nr * 2;
+         return U_GENERATE_ONE_OFF;
+
+      case PIPE_PRIM_TRIANGLES:
+         *out_generate = generate[out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_TRIANGLES;
+         *out_nr = nr;
+         return U_GENERATE_REUSABLE;
+
+      case PIPE_PRIM_TRIANGLE_STRIP:
+         *out_generate = generate[out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_TRIANGLES;
+         *out_nr = (nr - 2) * 3;
+         return U_GENERATE_REUSABLE;
+
+      case PIPE_PRIM_TRIANGLE_FAN:
+         *out_generate = generate[out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_TRIANGLES;
+         *out_nr = (nr - 2) * 3;
+         return U_GENERATE_REUSABLE;
+
+      case PIPE_PRIM_QUADS:
+         *out_generate = generate[out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_TRIANGLES;
+         *out_nr = (nr / 4) * 6;
+         return U_GENERATE_REUSABLE;
+
+      case PIPE_PRIM_QUAD_STRIP:
+         *out_generate = generate[out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_TRIANGLES;
+         *out_nr = (nr - 2) * 3;
+         return U_GENERATE_REUSABLE;
+
+      case PIPE_PRIM_POLYGON:
+         *out_generate = generate[out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_TRIANGLES;
+         *out_nr = (nr - 2) * 3;
+         return U_GENERATE_REUSABLE;
+
+      default:
+         assert(0);
+         *out_generate = generate[out_idx][in_pv][out_pv][prim];
+         *out_prim = PIPE_PRIM_POINTS;
+         *out_nr = nr;
+         return U_TRANSLATE_ERROR;
+      }
+   }
+}
diff --git a/src/gallium/auxiliary/indices/u_indices.h b/src/gallium/auxiliary/indices/u_indices.h
new file mode 100644
index 0000000000..abf5a3037d
--- /dev/null
+++ b/src/gallium/auxiliary/indices/u_indices.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on 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
+ * TUNGSTEN GRAPHICS 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.
+ */
+
+#ifndef U_INDICES_H
+#define U_INDICES_H
+
+#include "pipe/p_compiler.h"
+
+#define PV_FIRST      0
+#define PV_LAST       1
+#define PV_COUNT      2
+
+typedef void (*u_translate_func)( const void *in,
+                                  unsigned nr,
+                                  void *out );
+
+typedef void (*u_generate_func)( unsigned nr,
+                                 void *out );
+
+
+/* Return codes describe the translate/generate operation.  Caller may
+ * be able to reuse translated indices under some circumstances.
+ */
+#define U_TRANSLATE_ERROR  -1
+#define U_TRANSLATE_NORMAL  1
+#define U_TRANSLATE_MEMCPY  2
+#define U_GENERATE_LINEAR   3
+#define U_GENERATE_REUSABLE 4
+#define U_GENERATE_ONE_OFF  5
+
+
+void u_index_init( void );
+
+int u_index_translator( unsigned hw_mask,
+                        unsigned prim,
+                        unsigned in_index_size,
+                        unsigned nr,
+                        unsigned in_pv,   /* API */
+                        unsigned out_pv,  /* hardware */
+                        unsigned *out_prim,
+                        unsigned *out_index_size,
+                        unsigned *out_nr,
+                        u_translate_func *out_translate );
+
+/* Note that even when generating it is necessary to know what the
+ * API's PV is, as the indices generated will depend on whether it is
+ * the same as hardware or not, and in the case of triangle strips,
+ * whether it is first or last.
+ */
+int u_index_generator( unsigned hw_mask,
+                       unsigned prim,
+                       unsigned start,
+                       unsigned nr,
+                       unsigned in_pv,   /* API */
+                       unsigned out_pv,  /* hardware */
+                       unsigned *out_prim,
+                       unsigned *out_index_size,
+                       unsigned *out_nr,
+                       u_generate_func *out_generate );
+
+
+#endif
diff --git a/src/gallium/auxiliary/indices/u_indices_gen.c b/src/gallium/auxiliary/indices/u_indices_gen.c
new file mode 100644
index 0000000000..4c05b3eedb
--- /dev/null
+++ b/src/gallium/auxiliary/indices/u_indices_gen.c
@@ -0,0 +1,5129 @@
+/* File automatically generated by indices.py */
+
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on 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
+ * VMWARE 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.
+ */
+
+
+
+/**
+ * @file
+ * Functions to translate and generate index lists
+ */
+
+#include "indices/u_indices.h"
+#include "indices/u_indices_priv.h"
+#include "pipe/p_compiler.h"
+#include "pipe/p_debug.h"
+#include "pipe/p_defines.h"
+#include "util/u_memory.h"
+
+
+static unsigned out_size_idx( unsigned index_size )
+{
+   switch (index_size) {
+   case 4: return OUT_UINT;
+   case 2: return OUT_USHORT;
+   default: assert(0); return OUT_USHORT;
+   }
+}
+
+static unsigned in_size_idx( unsigned index_size )
+{
+   switch (index_size) {
+   case 4: return IN_UINT;
+   case 2: return IN_USHORT;
+   case 1: return IN_UBYTE;
+   default: assert(0); return IN_UBYTE;
+   }
+}
+
+
+static u_translate_func translate[IN_COUNT][OUT_COUNT][PV_COUNT][PV_COUNT][PRIM_COUNT];
+static u_generate_func  generate[OUT_COUNT][PV_COUNT][PV_COUNT][PRIM_COUNT];
+
+
+
+static void generate_points_ushort_first2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (ushort)(i);
+   }
+}
+static void generate_lines_ushort_first2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (ushort)(i);
+      (out+i)[1] = (ushort)(i+1);
+   }
+}
+static void generate_linestrip_ushort_first2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (ushort)(i);
+      (out+j)[1] = (ushort)(i+1);
+   }
+}
+static void generate_lineloop_ushort_first2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (ushort)(i);
+      (out+j)[1] = (ushort)(i+1);
+   }
+      (out+j)[0] = (ushort)(i);
+      (out+j)[1] = (ushort)(0);
+}
+static void generate_tris_ushort_first2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (ushort)(i);
+      (out+i)[1] = (ushort)(i+1);
+      (out+i)[2] = (ushort)(i+2);
+   }
+}
+static void generate_tristrip_ushort_first2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)(i);
+      (out+j)[1] = (ushort)(i+1+(i&1));
+      (out+j)[2] = (ushort)(i+2-(i&1));
+   }
+}
+static void generate_trifan_ushort_first2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)(0);
+      (out+j)[1] = (ushort)(i+1);
+      (out+j)[2] = (ushort)(i+2);
+   }
+}
+static void generate_quads_ushort_first2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (ushort)(i+0);
+      (out+j+0)[1] = (ushort)(i+1);
+      (out+j+0)[2] = (ushort)(i+3);
+      (out+j+3)[0] = (ushort)(i+1);
+      (out+j+3)[1] = (ushort)(i+2);
+      (out+j+3)[2] = (ushort)(i+3);
+   }
+}
+static void generate_quadstrip_ushort_first2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (ushort)(i+2);
+      (out+j+0)[1] = (ushort)(i+0);
+      (out+j+0)[2] = (ushort)(i+3);
+      (out+j+3)[0] = (ushort)(i+0);
+      (out+j+3)[1] = (ushort)(i+1);
+      (out+j+3)[2] = (ushort)(i+3);
+   }
+}
+static void generate_polygon_ushort_first2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)(0);
+      (out+j)[1] = (ushort)(i+1);
+      (out+j)[2] = (ushort)(i+2);
+   }
+}
+static void generate_points_ushort_first2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (ushort)(i);
+   }
+}
+static void generate_lines_ushort_first2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (ushort)(i+1);
+      (out+i)[1] = (ushort)(i);
+   }
+}
+static void generate_linestrip_ushort_first2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (ushort)(i+1);
+      (out+j)[1] = (ushort)(i);
+   }
+}
+static void generate_lineloop_ushort_first2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (ushort)(i+1);
+      (out+j)[1] = (ushort)(i);
+   }
+      (out+j)[0] = (ushort)(0);
+      (out+j)[1] = (ushort)(i);
+}
+static void generate_tris_ushort_first2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (ushort)(i+1);
+      (out+i)[1] = (ushort)(i+2);
+      (out+i)[2] = (ushort)(i);
+   }
+}
+static void generate_tristrip_ushort_first2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)(i+1+(i&1));
+      (out+j)[1] = (ushort)(i+2-(i&1));
+      (out+j)[2] = (ushort)(i);
+   }
+}
+static void generate_trifan_ushort_first2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)(i+1);
+      (out+j)[1] = (ushort)(i+2);
+      (out+j)[2] = (ushort)(0);
+   }
+}
+static void generate_quads_ushort_first2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (ushort)(i+1);
+      (out+j+0)[1] = (ushort)(i+3);
+      (out+j+0)[2] = (ushort)(i+0);
+      (out+j+3)[0] = (ushort)(i+2);
+      (out+j+3)[1] = (ushort)(i+3);
+      (out+j+3)[2] = (ushort)(i+1);
+   }
+}
+static void generate_quadstrip_ushort_first2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (ushort)(i+0);
+      (out+j+0)[1] = (ushort)(i+3);
+      (out+j+0)[2] = (ushort)(i+2);
+      (out+j+3)[0] = (ushort)(i+1);
+      (out+j+3)[1] = (ushort)(i+3);
+      (out+j+3)[2] = (ushort)(i+0);
+   }
+}
+static void generate_polygon_ushort_first2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)(i+1);
+      (out+j)[1] = (ushort)(i+2);
+      (out+j)[2] = (ushort)(0);
+   }
+}
+static void generate_points_ushort_last2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (ushort)(i);
+   }
+}
+static void generate_lines_ushort_last2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (ushort)(i+1);
+      (out+i)[1] = (ushort)(i);
+   }
+}
+static void generate_linestrip_ushort_last2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (ushort)(i+1);
+      (out+j)[1] = (ushort)(i);
+   }
+}
+static void generate_lineloop_ushort_last2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (ushort)(i+1);
+      (out+j)[1] = (ushort)(i);
+   }
+      (out+j)[0] = (ushort)(0);
+      (out+j)[1] = (ushort)(i);
+}
+static void generate_tris_ushort_last2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (ushort)(i+2);
+      (out+i)[1] = (ushort)(i);
+      (out+i)[2] = (ushort)(i+1);
+   }
+}
+static void generate_tristrip_ushort_last2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)(i+2);
+      (out+j)[1] = (ushort)(i+(i&1));
+      (out+j)[2] = (ushort)(i+1-(i&1));
+   }
+}
+static void generate_trifan_ushort_last2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)(i+2);
+      (out+j)[1] = (ushort)(0);
+      (out+j)[2] = (ushort)(i+1);
+   }
+}
+static void generate_quads_ushort_last2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (ushort)(i+3);
+      (out+j+0)[1] = (ushort)(i+0);
+      (out+j+0)[2] = (ushort)(i+1);
+      (out+j+3)[0] = (ushort)(i+3);
+      (out+j+3)[1] = (ushort)(i+1);
+      (out+j+3)[2] = (ushort)(i+2);
+   }
+}
+static void generate_quadstrip_ushort_last2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (ushort)(i+3);
+      (out+j+0)[1] = (ushort)(i+2);
+      (out+j+0)[2] = (ushort)(i+0);
+      (out+j+3)[0] = (ushort)(i+3);
+      (out+j+3)[1] = (ushort)(i+0);
+      (out+j+3)[2] = (ushort)(i+1);
+   }
+}
+static void generate_polygon_ushort_last2first(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)(0);
+      (out+j)[1] = (ushort)(i+1);
+      (out+j)[2] = (ushort)(i+2);
+   }
+}
+static void generate_points_ushort_last2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (ushort)(i);
+   }
+}
+static void generate_lines_ushort_last2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (ushort)(i);
+      (out+i)[1] = (ushort)(i+1);
+   }
+}
+static void generate_linestrip_ushort_last2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (ushort)(i);
+      (out+j)[1] = (ushort)(i+1);
+   }
+}
+static void generate_lineloop_ushort_last2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (ushort)(i);
+      (out+j)[1] = (ushort)(i+1);
+   }
+      (out+j)[0] = (ushort)(i);
+      (out+j)[1] = (ushort)(0);
+}
+static void generate_tris_ushort_last2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (ushort)(i);
+      (out+i)[1] = (ushort)(i+1);
+      (out+i)[2] = (ushort)(i+2);
+   }
+}
+static void generate_tristrip_ushort_last2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)(i+(i&1));
+      (out+j)[1] = (ushort)(i+1-(i&1));
+      (out+j)[2] = (ushort)(i+2);
+   }
+}
+static void generate_trifan_ushort_last2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)(0);
+      (out+j)[1] = (ushort)(i+1);
+      (out+j)[2] = (ushort)(i+2);
+   }
+}
+static void generate_quads_ushort_last2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (ushort)(i+0);
+      (out+j+0)[1] = (ushort)(i+1);
+      (out+j+0)[2] = (ushort)(i+3);
+      (out+j+3)[0] = (ushort)(i+1);
+      (out+j+3)[1] = (ushort)(i+2);
+      (out+j+3)[2] = (ushort)(i+3);
+   }
+}
+static void generate_quadstrip_ushort_last2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (ushort)(i+2);
+      (out+j+0)[1] = (ushort)(i+0);
+      (out+j+0)[2] = (ushort)(i+3);
+      (out+j+3)[0] = (ushort)(i+0);
+      (out+j+3)[1] = (ushort)(i+1);
+      (out+j+3)[2] = (ushort)(i+3);
+   }
+}
+static void generate_polygon_ushort_last2last(
+    unsigned nr,
+    void *_out )
+{
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)(i+1);
+      (out+j)[1] = (ushort)(i+2);
+      (out+j)[2] = (ushort)(0);
+   }
+}
+static void generate_points_uint_first2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (uint)(i);
+   }
+}
+static void generate_lines_uint_first2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (uint)(i);
+      (out+i)[1] = (uint)(i+1);
+   }
+}
+static void generate_linestrip_uint_first2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (uint)(i);
+      (out+j)[1] = (uint)(i+1);
+   }
+}
+static void generate_lineloop_uint_first2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (uint)(i);
+      (out+j)[1] = (uint)(i+1);
+   }
+      (out+j)[0] = (uint)(i);
+      (out+j)[1] = (uint)(0);
+}
+static void generate_tris_uint_first2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (uint)(i);
+      (out+i)[1] = (uint)(i+1);
+      (out+i)[2] = (uint)(i+2);
+   }
+}
+static void generate_tristrip_uint_first2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)(i);
+      (out+j)[1] = (uint)(i+1+(i&1));
+      (out+j)[2] = (uint)(i+2-(i&1));
+   }
+}
+static void generate_trifan_uint_first2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)(0);
+      (out+j)[1] = (uint)(i+1);
+      (out+j)[2] = (uint)(i+2);
+   }
+}
+static void generate_quads_uint_first2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (uint)(i+0);
+      (out+j+0)[1] = (uint)(i+1);
+      (out+j+0)[2] = (uint)(i+3);
+      (out+j+3)[0] = (uint)(i+1);
+      (out+j+3)[1] = (uint)(i+2);
+      (out+j+3)[2] = (uint)(i+3);
+   }
+}
+static void generate_quadstrip_uint_first2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (uint)(i+2);
+      (out+j+0)[1] = (uint)(i+0);
+      (out+j+0)[2] = (uint)(i+3);
+      (out+j+3)[0] = (uint)(i+0);
+      (out+j+3)[1] = (uint)(i+1);
+      (out+j+3)[2] = (uint)(i+3);
+   }
+}
+static void generate_polygon_uint_first2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)(0);
+      (out+j)[1] = (uint)(i+1);
+      (out+j)[2] = (uint)(i+2);
+   }
+}
+static void generate_points_uint_first2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (uint)(i);
+   }
+}
+static void generate_lines_uint_first2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (uint)(i+1);
+      (out+i)[1] = (uint)(i);
+   }
+}
+static void generate_linestrip_uint_first2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (uint)(i+1);
+      (out+j)[1] = (uint)(i);
+   }
+}
+static void generate_lineloop_uint_first2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (uint)(i+1);
+      (out+j)[1] = (uint)(i);
+   }
+      (out+j)[0] = (uint)(0);
+      (out+j)[1] = (uint)(i);
+}
+static void generate_tris_uint_first2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (uint)(i+1);
+      (out+i)[1] = (uint)(i+2);
+      (out+i)[2] = (uint)(i);
+   }
+}
+static void generate_tristrip_uint_first2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)(i+1+(i&1));
+      (out+j)[1] = (uint)(i+2-(i&1));
+      (out+j)[2] = (uint)(i);
+   }
+}
+static void generate_trifan_uint_first2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)(i+1);
+      (out+j)[1] = (uint)(i+2);
+      (out+j)[2] = (uint)(0);
+   }
+}
+static void generate_quads_uint_first2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (uint)(i+1);
+      (out+j+0)[1] = (uint)(i+3);
+      (out+j+0)[2] = (uint)(i+0);
+      (out+j+3)[0] = (uint)(i+2);
+      (out+j+3)[1] = (uint)(i+3);
+      (out+j+3)[2] = (uint)(i+1);
+   }
+}
+static void generate_quadstrip_uint_first2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (uint)(i+0);
+      (out+j+0)[1] = (uint)(i+3);
+      (out+j+0)[2] = (uint)(i+2);
+      (out+j+3)[0] = (uint)(i+1);
+      (out+j+3)[1] = (uint)(i+3);
+      (out+j+3)[2] = (uint)(i+0);
+   }
+}
+static void generate_polygon_uint_first2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)(i+1);
+      (out+j)[1] = (uint)(i+2);
+      (out+j)[2] = (uint)(0);
+   }
+}
+static void generate_points_uint_last2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (uint)(i);
+   }
+}
+static void generate_lines_uint_last2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (uint)(i+1);
+      (out+i)[1] = (uint)(i);
+   }
+}
+static void generate_linestrip_uint_last2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (uint)(i+1);
+      (out+j)[1] = (uint)(i);
+   }
+}
+static void generate_lineloop_uint_last2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (uint)(i+1);
+      (out+j)[1] = (uint)(i);
+   }
+      (out+j)[0] = (uint)(0);
+      (out+j)[1] = (uint)(i);
+}
+static void generate_tris_uint_last2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (uint)(i+2);
+      (out+i)[1] = (uint)(i);
+      (out+i)[2] = (uint)(i+1);
+   }
+}
+static void generate_tristrip_uint_last2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)(i+2);
+      (out+j)[1] = (uint)(i+(i&1));
+      (out+j)[2] = (uint)(i+1-(i&1));
+   }
+}
+static void generate_trifan_uint_last2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)(i+2);
+      (out+j)[1] = (uint)(0);
+      (out+j)[2] = (uint)(i+1);
+   }
+}
+static void generate_quads_uint_last2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (uint)(i+3);
+      (out+j+0)[1] = (uint)(i+0);
+      (out+j+0)[2] = (uint)(i+1);
+      (out+j+3)[0] = (uint)(i+3);
+      (out+j+3)[1] = (uint)(i+1);
+      (out+j+3)[2] = (uint)(i+2);
+   }
+}
+static void generate_quadstrip_uint_last2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (uint)(i+3);
+      (out+j+0)[1] = (uint)(i+2);
+      (out+j+0)[2] = (uint)(i+0);
+      (out+j+3)[0] = (uint)(i+3);
+      (out+j+3)[1] = (uint)(i+0);
+      (out+j+3)[2] = (uint)(i+1);
+   }
+}
+static void generate_polygon_uint_last2first(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)(0);
+      (out+j)[1] = (uint)(i+1);
+      (out+j)[2] = (uint)(i+2);
+   }
+}
+static void generate_points_uint_last2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (uint)(i);
+   }
+}
+static void generate_lines_uint_last2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (uint)(i);
+      (out+i)[1] = (uint)(i+1);
+   }
+}
+static void generate_linestrip_uint_last2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (uint)(i);
+      (out+j)[1] = (uint)(i+1);
+   }
+}
+static void generate_lineloop_uint_last2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (uint)(i);
+      (out+j)[1] = (uint)(i+1);
+   }
+      (out+j)[0] = (uint)(i);
+      (out+j)[1] = (uint)(0);
+}
+static void generate_tris_uint_last2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (uint)(i);
+      (out+i)[1] = (uint)(i+1);
+      (out+i)[2] = (uint)(i+2);
+   }
+}
+static void generate_tristrip_uint_last2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)(i+(i&1));
+      (out+j)[1] = (uint)(i+1-(i&1));
+      (out+j)[2] = (uint)(i+2);
+   }
+}
+static void generate_trifan_uint_last2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)(0);
+      (out+j)[1] = (uint)(i+1);
+      (out+j)[2] = (uint)(i+2);
+   }
+}
+static void generate_quads_uint_last2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (uint)(i+0);
+      (out+j+0)[1] = (uint)(i+1);
+      (out+j+0)[2] = (uint)(i+3);
+      (out+j+3)[0] = (uint)(i+1);
+      (out+j+3)[1] = (uint)(i+2);
+      (out+j+3)[2] = (uint)(i+3);
+   }
+}
+static void generate_quadstrip_uint_last2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (uint)(i+2);
+      (out+j+0)[1] = (uint)(i+0);
+      (out+j+0)[2] = (uint)(i+3);
+      (out+j+3)[0] = (uint)(i+0);
+      (out+j+3)[1] = (uint)(i+1);
+      (out+j+3)[2] = (uint)(i+3);
+   }
+}
+static void generate_polygon_uint_last2last(
+    unsigned nr,
+    void *_out )
+{
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)(i+1);
+      (out+j)[1] = (uint)(i+2);
+      (out+j)[2] = (uint)(0);
+   }
+}
+static void translate_points_ubyte2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (ushort)in[i];
+   }
+}
+static void translate_lines_ubyte2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (ushort)in[i];
+      (out+i)[1] = (ushort)in[i+1];
+   }
+}
+static void translate_linestrip_ubyte2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[i+1];
+   }
+}
+static void translate_lineloop_ubyte2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[i+1];
+   }
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[0];
+}
+static void translate_tris_ubyte2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (ushort)in[i];
+      (out+i)[1] = (ushort)in[i+1];
+      (out+i)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_tristrip_ubyte2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[i+1+(i&1)];
+      (out+j)[2] = (ushort)in[i+2-(i&1)];
+   }
+}
+static void translate_trifan_ubyte2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i+1];
+      (out+j)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_quads_ubyte2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (ushort)in[i+0];
+      (out+j+0)[1] = (ushort)in[i+1];
+      (out+j+0)[2] = (ushort)in[i+3];
+      (out+j+3)[0] = (ushort)in[i+1];
+      (out+j+3)[1] = (ushort)in[i+2];
+      (out+j+3)[2] = (ushort)in[i+3];
+   }
+}
+static void translate_quadstrip_ubyte2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (ushort)in[i+2];
+      (out+j+0)[1] = (ushort)in[i+0];
+      (out+j+0)[2] = (ushort)in[i+3];
+      (out+j+3)[0] = (ushort)in[i+0];
+      (out+j+3)[1] = (ushort)in[i+1];
+      (out+j+3)[2] = (ushort)in[i+3];
+   }
+}
+static void translate_polygon_ubyte2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i+1];
+      (out+j)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_points_ubyte2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (ushort)in[i];
+   }
+}
+static void translate_lines_ubyte2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (ushort)in[i+1];
+      (out+i)[1] = (ushort)in[i];
+   }
+}
+static void translate_linestrip_ubyte2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i];
+   }
+}
+static void translate_lineloop_ubyte2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i];
+   }
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i];
+}
+static void translate_tris_ubyte2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (ushort)in[i+1];
+      (out+i)[1] = (ushort)in[i+2];
+      (out+i)[2] = (ushort)in[i];
+   }
+}
+static void translate_tristrip_ubyte2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+1+(i&1)];
+      (out+j)[1] = (ushort)in[i+2-(i&1)];
+      (out+j)[2] = (ushort)in[i];
+   }
+}
+static void translate_trifan_ubyte2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i+2];
+      (out+j)[2] = (ushort)in[0];
+   }
+}
+static void translate_quads_ubyte2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (ushort)in[i+1];
+      (out+j+0)[1] = (ushort)in[i+3];
+      (out+j+0)[2] = (ushort)in[i+0];
+      (out+j+3)[0] = (ushort)in[i+2];
+      (out+j+3)[1] = (ushort)in[i+3];
+      (out+j+3)[2] = (ushort)in[i+1];
+   }
+}
+static void translate_quadstrip_ubyte2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (ushort)in[i+0];
+      (out+j+0)[1] = (ushort)in[i+3];
+      (out+j+0)[2] = (ushort)in[i+2];
+      (out+j+3)[0] = (ushort)in[i+1];
+      (out+j+3)[1] = (ushort)in[i+3];
+      (out+j+3)[2] = (ushort)in[i+0];
+   }
+}
+static void translate_polygon_ubyte2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i+2];
+      (out+j)[2] = (ushort)in[0];
+   }
+}
+static void translate_points_ubyte2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (ushort)in[i];
+   }
+}
+static void translate_lines_ubyte2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (ushort)in[i+1];
+      (out+i)[1] = (ushort)in[i];
+   }
+}
+static void translate_linestrip_ubyte2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i];
+   }
+}
+static void translate_lineloop_ubyte2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i];
+   }
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i];
+}
+static void translate_tris_ubyte2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (ushort)in[i+2];
+      (out+i)[1] = (ushort)in[i];
+      (out+i)[2] = (ushort)in[i+1];
+   }
+}
+static void translate_tristrip_ubyte2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+2];
+      (out+j)[1] = (ushort)in[i+(i&1)];
+      (out+j)[2] = (ushort)in[i+1-(i&1)];
+   }
+}
+static void translate_trifan_ubyte2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+2];
+      (out+j)[1] = (ushort)in[0];
+      (out+j)[2] = (ushort)in[i+1];
+   }
+}
+static void translate_quads_ubyte2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (ushort)in[i+3];
+      (out+j+0)[1] = (ushort)in[i+0];
+      (out+j+0)[2] = (ushort)in[i+1];
+      (out+j+3)[0] = (ushort)in[i+3];
+      (out+j+3)[1] = (ushort)in[i+1];
+      (out+j+3)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_quadstrip_ubyte2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (ushort)in[i+3];
+      (out+j+0)[1] = (ushort)in[i+2];
+      (out+j+0)[2] = (ushort)in[i+0];
+      (out+j+3)[0] = (ushort)in[i+3];
+      (out+j+3)[1] = (ushort)in[i+0];
+      (out+j+3)[2] = (ushort)in[i+1];
+   }
+}
+static void translate_polygon_ubyte2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i+1];
+      (out+j)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_points_ubyte2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (ushort)in[i];
+   }
+}
+static void translate_lines_ubyte2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (ushort)in[i];
+      (out+i)[1] = (ushort)in[i+1];
+   }
+}
+static void translate_linestrip_ubyte2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[i+1];
+   }
+}
+static void translate_lineloop_ubyte2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[i+1];
+   }
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[0];
+}
+static void translate_tris_ubyte2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (ushort)in[i];
+      (out+i)[1] = (ushort)in[i+1];
+      (out+i)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_tristrip_ubyte2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+(i&1)];
+      (out+j)[1] = (ushort)in[i+1-(i&1)];
+      (out+j)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_trifan_ubyte2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i+1];
+      (out+j)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_quads_ubyte2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (ushort)in[i+0];
+      (out+j+0)[1] = (ushort)in[i+1];
+      (out+j+0)[2] = (ushort)in[i+3];
+      (out+j+3)[0] = (ushort)in[i+1];
+      (out+j+3)[1] = (ushort)in[i+2];
+      (out+j+3)[2] = (ushort)in[i+3];
+   }
+}
+static void translate_quadstrip_ubyte2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (ushort)in[i+2];
+      (out+j+0)[1] = (ushort)in[i+0];
+      (out+j+0)[2] = (ushort)in[i+3];
+      (out+j+3)[0] = (ushort)in[i+0];
+      (out+j+3)[1] = (ushort)in[i+1];
+      (out+j+3)[2] = (ushort)in[i+3];
+   }
+}
+static void translate_polygon_ubyte2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i+2];
+      (out+j)[2] = (ushort)in[0];
+   }
+}
+static void translate_points_ubyte2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (uint)in[i];
+   }
+}
+static void translate_lines_ubyte2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (uint)in[i];
+      (out+i)[1] = (uint)in[i+1];
+   }
+}
+static void translate_linestrip_ubyte2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[i+1];
+   }
+}
+static void translate_lineloop_ubyte2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[i+1];
+   }
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[0];
+}
+static void translate_tris_ubyte2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (uint)in[i];
+      (out+i)[1] = (uint)in[i+1];
+      (out+i)[2] = (uint)in[i+2];
+   }
+}
+static void translate_tristrip_ubyte2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[i+1+(i&1)];
+      (out+j)[2] = (uint)in[i+2-(i&1)];
+   }
+}
+static void translate_trifan_ubyte2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i+1];
+      (out+j)[2] = (uint)in[i+2];
+   }
+}
+static void translate_quads_ubyte2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (uint)in[i+0];
+      (out+j+0)[1] = (uint)in[i+1];
+      (out+j+0)[2] = (uint)in[i+3];
+      (out+j+3)[0] = (uint)in[i+1];
+      (out+j+3)[1] = (uint)in[i+2];
+      (out+j+3)[2] = (uint)in[i+3];
+   }
+}
+static void translate_quadstrip_ubyte2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (uint)in[i+2];
+      (out+j+0)[1] = (uint)in[i+0];
+      (out+j+0)[2] = (uint)in[i+3];
+      (out+j+3)[0] = (uint)in[i+0];
+      (out+j+3)[1] = (uint)in[i+1];
+      (out+j+3)[2] = (uint)in[i+3];
+   }
+}
+static void translate_polygon_ubyte2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i+1];
+      (out+j)[2] = (uint)in[i+2];
+   }
+}
+static void translate_points_ubyte2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (uint)in[i];
+   }
+}
+static void translate_lines_ubyte2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (uint)in[i+1];
+      (out+i)[1] = (uint)in[i];
+   }
+}
+static void translate_linestrip_ubyte2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i];
+   }
+}
+static void translate_lineloop_ubyte2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i];
+   }
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i];
+}
+static void translate_tris_ubyte2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (uint)in[i+1];
+      (out+i)[1] = (uint)in[i+2];
+      (out+i)[2] = (uint)in[i];
+   }
+}
+static void translate_tristrip_ubyte2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+1+(i&1)];
+      (out+j)[1] = (uint)in[i+2-(i&1)];
+      (out+j)[2] = (uint)in[i];
+   }
+}
+static void translate_trifan_ubyte2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i+2];
+      (out+j)[2] = (uint)in[0];
+   }
+}
+static void translate_quads_ubyte2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (uint)in[i+1];
+      (out+j+0)[1] = (uint)in[i+3];
+      (out+j+0)[2] = (uint)in[i+0];
+      (out+j+3)[0] = (uint)in[i+2];
+      (out+j+3)[1] = (uint)in[i+3];
+      (out+j+3)[2] = (uint)in[i+1];
+   }
+}
+static void translate_quadstrip_ubyte2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (uint)in[i+0];
+      (out+j+0)[1] = (uint)in[i+3];
+      (out+j+0)[2] = (uint)in[i+2];
+      (out+j+3)[0] = (uint)in[i+1];
+      (out+j+3)[1] = (uint)in[i+3];
+      (out+j+3)[2] = (uint)in[i+0];
+   }
+}
+static void translate_polygon_ubyte2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i+2];
+      (out+j)[2] = (uint)in[0];
+   }
+}
+static void translate_points_ubyte2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (uint)in[i];
+   }
+}
+static void translate_lines_ubyte2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (uint)in[i+1];
+      (out+i)[1] = (uint)in[i];
+   }
+}
+static void translate_linestrip_ubyte2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i];
+   }
+}
+static void translate_lineloop_ubyte2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i];
+   }
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i];
+}
+static void translate_tris_ubyte2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (uint)in[i+2];
+      (out+i)[1] = (uint)in[i];
+      (out+i)[2] = (uint)in[i+1];
+   }
+}
+static void translate_tristrip_ubyte2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+2];
+      (out+j)[1] = (uint)in[i+(i&1)];
+      (out+j)[2] = (uint)in[i+1-(i&1)];
+   }
+}
+static void translate_trifan_ubyte2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+2];
+      (out+j)[1] = (uint)in[0];
+      (out+j)[2] = (uint)in[i+1];
+   }
+}
+static void translate_quads_ubyte2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (uint)in[i+3];
+      (out+j+0)[1] = (uint)in[i+0];
+      (out+j+0)[2] = (uint)in[i+1];
+      (out+j+3)[0] = (uint)in[i+3];
+      (out+j+3)[1] = (uint)in[i+1];
+      (out+j+3)[2] = (uint)in[i+2];
+   }
+}
+static void translate_quadstrip_ubyte2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (uint)in[i+3];
+      (out+j+0)[1] = (uint)in[i+2];
+      (out+j+0)[2] = (uint)in[i+0];
+      (out+j+3)[0] = (uint)in[i+3];
+      (out+j+3)[1] = (uint)in[i+0];
+      (out+j+3)[2] = (uint)in[i+1];
+   }
+}
+static void translate_polygon_ubyte2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i+1];
+      (out+j)[2] = (uint)in[i+2];
+   }
+}
+static void translate_points_ubyte2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (uint)in[i];
+   }
+}
+static void translate_lines_ubyte2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (uint)in[i];
+      (out+i)[1] = (uint)in[i+1];
+   }
+}
+static void translate_linestrip_ubyte2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[i+1];
+   }
+}
+static void translate_lineloop_ubyte2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[i+1];
+   }
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[0];
+}
+static void translate_tris_ubyte2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (uint)in[i];
+      (out+i)[1] = (uint)in[i+1];
+      (out+i)[2] = (uint)in[i+2];
+   }
+}
+static void translate_tristrip_ubyte2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+(i&1)];
+      (out+j)[1] = (uint)in[i+1-(i&1)];
+      (out+j)[2] = (uint)in[i+2];
+   }
+}
+static void translate_trifan_ubyte2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i+1];
+      (out+j)[2] = (uint)in[i+2];
+   }
+}
+static void translate_quads_ubyte2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (uint)in[i+0];
+      (out+j+0)[1] = (uint)in[i+1];
+      (out+j+0)[2] = (uint)in[i+3];
+      (out+j+3)[0] = (uint)in[i+1];
+      (out+j+3)[1] = (uint)in[i+2];
+      (out+j+3)[2] = (uint)in[i+3];
+   }
+}
+static void translate_quadstrip_ubyte2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (uint)in[i+2];
+      (out+j+0)[1] = (uint)in[i+0];
+      (out+j+0)[2] = (uint)in[i+3];
+      (out+j+3)[0] = (uint)in[i+0];
+      (out+j+3)[1] = (uint)in[i+1];
+      (out+j+3)[2] = (uint)in[i+3];
+   }
+}
+static void translate_polygon_ubyte2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ubyte*in = (const ubyte*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i+2];
+      (out+j)[2] = (uint)in[0];
+   }
+}
+static void translate_points_ushort2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (ushort)in[i];
+   }
+}
+static void translate_lines_ushort2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (ushort)in[i];
+      (out+i)[1] = (ushort)in[i+1];
+   }
+}
+static void translate_linestrip_ushort2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[i+1];
+   }
+}
+static void translate_lineloop_ushort2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[i+1];
+   }
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[0];
+}
+static void translate_tris_ushort2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (ushort)in[i];
+      (out+i)[1] = (ushort)in[i+1];
+      (out+i)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_tristrip_ushort2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[i+1+(i&1)];
+      (out+j)[2] = (ushort)in[i+2-(i&1)];
+   }
+}
+static void translate_trifan_ushort2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i+1];
+      (out+j)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_quads_ushort2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (ushort)in[i+0];
+      (out+j+0)[1] = (ushort)in[i+1];
+      (out+j+0)[2] = (ushort)in[i+3];
+      (out+j+3)[0] = (ushort)in[i+1];
+      (out+j+3)[1] = (ushort)in[i+2];
+      (out+j+3)[2] = (ushort)in[i+3];
+   }
+}
+static void translate_quadstrip_ushort2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (ushort)in[i+2];
+      (out+j+0)[1] = (ushort)in[i+0];
+      (out+j+0)[2] = (ushort)in[i+3];
+      (out+j+3)[0] = (ushort)in[i+0];
+      (out+j+3)[1] = (ushort)in[i+1];
+      (out+j+3)[2] = (ushort)in[i+3];
+   }
+}
+static void translate_polygon_ushort2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i+1];
+      (out+j)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_points_ushort2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (ushort)in[i];
+   }
+}
+static void translate_lines_ushort2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (ushort)in[i+1];
+      (out+i)[1] = (ushort)in[i];
+   }
+}
+static void translate_linestrip_ushort2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i];
+   }
+}
+static void translate_lineloop_ushort2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i];
+   }
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i];
+}
+static void translate_tris_ushort2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (ushort)in[i+1];
+      (out+i)[1] = (ushort)in[i+2];
+      (out+i)[2] = (ushort)in[i];
+   }
+}
+static void translate_tristrip_ushort2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+1+(i&1)];
+      (out+j)[1] = (ushort)in[i+2-(i&1)];
+      (out+j)[2] = (ushort)in[i];
+   }
+}
+static void translate_trifan_ushort2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i+2];
+      (out+j)[2] = (ushort)in[0];
+   }
+}
+static void translate_quads_ushort2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (ushort)in[i+1];
+      (out+j+0)[1] = (ushort)in[i+3];
+      (out+j+0)[2] = (ushort)in[i+0];
+      (out+j+3)[0] = (ushort)in[i+2];
+      (out+j+3)[1] = (ushort)in[i+3];
+      (out+j+3)[2] = (ushort)in[i+1];
+   }
+}
+static void translate_quadstrip_ushort2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (ushort)in[i+0];
+      (out+j+0)[1] = (ushort)in[i+3];
+      (out+j+0)[2] = (ushort)in[i+2];
+      (out+j+3)[0] = (ushort)in[i+1];
+      (out+j+3)[1] = (ushort)in[i+3];
+      (out+j+3)[2] = (ushort)in[i+0];
+   }
+}
+static void translate_polygon_ushort2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i+2];
+      (out+j)[2] = (ushort)in[0];
+   }
+}
+static void translate_points_ushort2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (ushort)in[i];
+   }
+}
+static void translate_lines_ushort2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (ushort)in[i+1];
+      (out+i)[1] = (ushort)in[i];
+   }
+}
+static void translate_linestrip_ushort2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i];
+   }
+}
+static void translate_lineloop_ushort2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i];
+   }
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i];
+}
+static void translate_tris_ushort2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (ushort)in[i+2];
+      (out+i)[1] = (ushort)in[i];
+      (out+i)[2] = (ushort)in[i+1];
+   }
+}
+static void translate_tristrip_ushort2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+2];
+      (out+j)[1] = (ushort)in[i+(i&1)];
+      (out+j)[2] = (ushort)in[i+1-(i&1)];
+   }
+}
+static void translate_trifan_ushort2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+2];
+      (out+j)[1] = (ushort)in[0];
+      (out+j)[2] = (ushort)in[i+1];
+   }
+}
+static void translate_quads_ushort2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (ushort)in[i+3];
+      (out+j+0)[1] = (ushort)in[i+0];
+      (out+j+0)[2] = (ushort)in[i+1];
+      (out+j+3)[0] = (ushort)in[i+3];
+      (out+j+3)[1] = (ushort)in[i+1];
+      (out+j+3)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_quadstrip_ushort2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (ushort)in[i+3];
+      (out+j+0)[1] = (ushort)in[i+2];
+      (out+j+0)[2] = (ushort)in[i+0];
+      (out+j+3)[0] = (ushort)in[i+3];
+      (out+j+3)[1] = (ushort)in[i+0];
+      (out+j+3)[2] = (ushort)in[i+1];
+   }
+}
+static void translate_polygon_ushort2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i+1];
+      (out+j)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_points_ushort2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (ushort)in[i];
+   }
+}
+static void translate_lines_ushort2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (ushort)in[i];
+      (out+i)[1] = (ushort)in[i+1];
+   }
+}
+static void translate_linestrip_ushort2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[i+1];
+   }
+}
+static void translate_lineloop_ushort2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[i+1];
+   }
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[0];
+}
+static void translate_tris_ushort2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (ushort)in[i];
+      (out+i)[1] = (ushort)in[i+1];
+      (out+i)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_tristrip_ushort2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+(i&1)];
+      (out+j)[1] = (ushort)in[i+1-(i&1)];
+      (out+j)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_trifan_ushort2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i+1];
+      (out+j)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_quads_ushort2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (ushort)in[i+0];
+      (out+j+0)[1] = (ushort)in[i+1];
+      (out+j+0)[2] = (ushort)in[i+3];
+      (out+j+3)[0] = (ushort)in[i+1];
+      (out+j+3)[1] = (ushort)in[i+2];
+      (out+j+3)[2] = (ushort)in[i+3];
+   }
+}
+static void translate_quadstrip_ushort2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (ushort)in[i+2];
+      (out+j+0)[1] = (ushort)in[i+0];
+      (out+j+0)[2] = (ushort)in[i+3];
+      (out+j+3)[0] = (ushort)in[i+0];
+      (out+j+3)[1] = (ushort)in[i+1];
+      (out+j+3)[2] = (ushort)in[i+3];
+   }
+}
+static void translate_polygon_ushort2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i+2];
+      (out+j)[2] = (ushort)in[0];
+   }
+}
+static void translate_points_ushort2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (uint)in[i];
+   }
+}
+static void translate_lines_ushort2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (uint)in[i];
+      (out+i)[1] = (uint)in[i+1];
+   }
+}
+static void translate_linestrip_ushort2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[i+1];
+   }
+}
+static void translate_lineloop_ushort2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[i+1];
+   }
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[0];
+}
+static void translate_tris_ushort2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (uint)in[i];
+      (out+i)[1] = (uint)in[i+1];
+      (out+i)[2] = (uint)in[i+2];
+   }
+}
+static void translate_tristrip_ushort2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[i+1+(i&1)];
+      (out+j)[2] = (uint)in[i+2-(i&1)];
+   }
+}
+static void translate_trifan_ushort2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i+1];
+      (out+j)[2] = (uint)in[i+2];
+   }
+}
+static void translate_quads_ushort2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (uint)in[i+0];
+      (out+j+0)[1] = (uint)in[i+1];
+      (out+j+0)[2] = (uint)in[i+3];
+      (out+j+3)[0] = (uint)in[i+1];
+      (out+j+3)[1] = (uint)in[i+2];
+      (out+j+3)[2] = (uint)in[i+3];
+   }
+}
+static void translate_quadstrip_ushort2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (uint)in[i+2];
+      (out+j+0)[1] = (uint)in[i+0];
+      (out+j+0)[2] = (uint)in[i+3];
+      (out+j+3)[0] = (uint)in[i+0];
+      (out+j+3)[1] = (uint)in[i+1];
+      (out+j+3)[2] = (uint)in[i+3];
+   }
+}
+static void translate_polygon_ushort2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i+1];
+      (out+j)[2] = (uint)in[i+2];
+   }
+}
+static void translate_points_ushort2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (uint)in[i];
+   }
+}
+static void translate_lines_ushort2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (uint)in[i+1];
+      (out+i)[1] = (uint)in[i];
+   }
+}
+static void translate_linestrip_ushort2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i];
+   }
+}
+static void translate_lineloop_ushort2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i];
+   }
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i];
+}
+static void translate_tris_ushort2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (uint)in[i+1];
+      (out+i)[1] = (uint)in[i+2];
+      (out+i)[2] = (uint)in[i];
+   }
+}
+static void translate_tristrip_ushort2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+1+(i&1)];
+      (out+j)[1] = (uint)in[i+2-(i&1)];
+      (out+j)[2] = (uint)in[i];
+   }
+}
+static void translate_trifan_ushort2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i+2];
+      (out+j)[2] = (uint)in[0];
+   }
+}
+static void translate_quads_ushort2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (uint)in[i+1];
+      (out+j+0)[1] = (uint)in[i+3];
+      (out+j+0)[2] = (uint)in[i+0];
+      (out+j+3)[0] = (uint)in[i+2];
+      (out+j+3)[1] = (uint)in[i+3];
+      (out+j+3)[2] = (uint)in[i+1];
+   }
+}
+static void translate_quadstrip_ushort2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (uint)in[i+0];
+      (out+j+0)[1] = (uint)in[i+3];
+      (out+j+0)[2] = (uint)in[i+2];
+      (out+j+3)[0] = (uint)in[i+1];
+      (out+j+3)[1] = (uint)in[i+3];
+      (out+j+3)[2] = (uint)in[i+0];
+   }
+}
+static void translate_polygon_ushort2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i+2];
+      (out+j)[2] = (uint)in[0];
+   }
+}
+static void translate_points_ushort2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (uint)in[i];
+   }
+}
+static void translate_lines_ushort2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (uint)in[i+1];
+      (out+i)[1] = (uint)in[i];
+   }
+}
+static void translate_linestrip_ushort2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i];
+   }
+}
+static void translate_lineloop_ushort2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i];
+   }
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i];
+}
+static void translate_tris_ushort2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (uint)in[i+2];
+      (out+i)[1] = (uint)in[i];
+      (out+i)[2] = (uint)in[i+1];
+   }
+}
+static void translate_tristrip_ushort2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+2];
+      (out+j)[1] = (uint)in[i+(i&1)];
+      (out+j)[2] = (uint)in[i+1-(i&1)];
+   }
+}
+static void translate_trifan_ushort2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+2];
+      (out+j)[1] = (uint)in[0];
+      (out+j)[2] = (uint)in[i+1];
+   }
+}
+static void translate_quads_ushort2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (uint)in[i+3];
+      (out+j+0)[1] = (uint)in[i+0];
+      (out+j+0)[2] = (uint)in[i+1];
+      (out+j+3)[0] = (uint)in[i+3];
+      (out+j+3)[1] = (uint)in[i+1];
+      (out+j+3)[2] = (uint)in[i+2];
+   }
+}
+static void translate_quadstrip_ushort2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (uint)in[i+3];
+      (out+j+0)[1] = (uint)in[i+2];
+      (out+j+0)[2] = (uint)in[i+0];
+      (out+j+3)[0] = (uint)in[i+3];
+      (out+j+3)[1] = (uint)in[i+0];
+      (out+j+3)[2] = (uint)in[i+1];
+   }
+}
+static void translate_polygon_ushort2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i+1];
+      (out+j)[2] = (uint)in[i+2];
+   }
+}
+static void translate_points_ushort2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (uint)in[i];
+   }
+}
+static void translate_lines_ushort2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (uint)in[i];
+      (out+i)[1] = (uint)in[i+1];
+   }
+}
+static void translate_linestrip_ushort2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[i+1];
+   }
+}
+static void translate_lineloop_ushort2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[i+1];
+   }
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[0];
+}
+static void translate_tris_ushort2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (uint)in[i];
+      (out+i)[1] = (uint)in[i+1];
+      (out+i)[2] = (uint)in[i+2];
+   }
+}
+static void translate_tristrip_ushort2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+(i&1)];
+      (out+j)[1] = (uint)in[i+1-(i&1)];
+      (out+j)[2] = (uint)in[i+2];
+   }
+}
+static void translate_trifan_ushort2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i+1];
+      (out+j)[2] = (uint)in[i+2];
+   }
+}
+static void translate_quads_ushort2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (uint)in[i+0];
+      (out+j+0)[1] = (uint)in[i+1];
+      (out+j+0)[2] = (uint)in[i+3];
+      (out+j+3)[0] = (uint)in[i+1];
+      (out+j+3)[1] = (uint)in[i+2];
+      (out+j+3)[2] = (uint)in[i+3];
+   }
+}
+static void translate_quadstrip_ushort2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (uint)in[i+2];
+      (out+j+0)[1] = (uint)in[i+0];
+      (out+j+0)[2] = (uint)in[i+3];
+      (out+j+3)[0] = (uint)in[i+0];
+      (out+j+3)[1] = (uint)in[i+1];
+      (out+j+3)[2] = (uint)in[i+3];
+   }
+}
+static void translate_polygon_ushort2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const ushort*in = (const ushort*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i+2];
+      (out+j)[2] = (uint)in[0];
+   }
+}
+static void translate_points_uint2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (ushort)in[i];
+   }
+}
+static void translate_lines_uint2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (ushort)in[i];
+      (out+i)[1] = (ushort)in[i+1];
+   }
+}
+static void translate_linestrip_uint2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[i+1];
+   }
+}
+static void translate_lineloop_uint2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[i+1];
+   }
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[0];
+}
+static void translate_tris_uint2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (ushort)in[i];
+      (out+i)[1] = (ushort)in[i+1];
+      (out+i)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_tristrip_uint2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[i+1+(i&1)];
+      (out+j)[2] = (ushort)in[i+2-(i&1)];
+   }
+}
+static void translate_trifan_uint2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i+1];
+      (out+j)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_quads_uint2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (ushort)in[i+0];
+      (out+j+0)[1] = (ushort)in[i+1];
+      (out+j+0)[2] = (ushort)in[i+3];
+      (out+j+3)[0] = (ushort)in[i+1];
+      (out+j+3)[1] = (ushort)in[i+2];
+      (out+j+3)[2] = (ushort)in[i+3];
+   }
+}
+static void translate_quadstrip_uint2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (ushort)in[i+2];
+      (out+j+0)[1] = (ushort)in[i+0];
+      (out+j+0)[2] = (ushort)in[i+3];
+      (out+j+3)[0] = (ushort)in[i+0];
+      (out+j+3)[1] = (ushort)in[i+1];
+      (out+j+3)[2] = (ushort)in[i+3];
+   }
+}
+static void translate_polygon_uint2ushort_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i+1];
+      (out+j)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_points_uint2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (ushort)in[i];
+   }
+}
+static void translate_lines_uint2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (ushort)in[i+1];
+      (out+i)[1] = (ushort)in[i];
+   }
+}
+static void translate_linestrip_uint2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i];
+   }
+}
+static void translate_lineloop_uint2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i];
+   }
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i];
+}
+static void translate_tris_uint2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (ushort)in[i+1];
+      (out+i)[1] = (ushort)in[i+2];
+      (out+i)[2] = (ushort)in[i];
+   }
+}
+static void translate_tristrip_uint2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+1+(i&1)];
+      (out+j)[1] = (ushort)in[i+2-(i&1)];
+      (out+j)[2] = (ushort)in[i];
+   }
+}
+static void translate_trifan_uint2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i+2];
+      (out+j)[2] = (ushort)in[0];
+   }
+}
+static void translate_quads_uint2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (ushort)in[i+1];
+      (out+j+0)[1] = (ushort)in[i+3];
+      (out+j+0)[2] = (ushort)in[i+0];
+      (out+j+3)[0] = (ushort)in[i+2];
+      (out+j+3)[1] = (ushort)in[i+3];
+      (out+j+3)[2] = (ushort)in[i+1];
+   }
+}
+static void translate_quadstrip_uint2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (ushort)in[i+0];
+      (out+j+0)[1] = (ushort)in[i+3];
+      (out+j+0)[2] = (ushort)in[i+2];
+      (out+j+3)[0] = (ushort)in[i+1];
+      (out+j+3)[1] = (ushort)in[i+3];
+      (out+j+3)[2] = (ushort)in[i+0];
+   }
+}
+static void translate_polygon_uint2ushort_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i+2];
+      (out+j)[2] = (ushort)in[0];
+   }
+}
+static void translate_points_uint2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (ushort)in[i];
+   }
+}
+static void translate_lines_uint2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (ushort)in[i+1];
+      (out+i)[1] = (ushort)in[i];
+   }
+}
+static void translate_linestrip_uint2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i];
+   }
+}
+static void translate_lineloop_uint2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i];
+   }
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i];
+}
+static void translate_tris_uint2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (ushort)in[i+2];
+      (out+i)[1] = (ushort)in[i];
+      (out+i)[2] = (ushort)in[i+1];
+   }
+}
+static void translate_tristrip_uint2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+2];
+      (out+j)[1] = (ushort)in[i+(i&1)];
+      (out+j)[2] = (ushort)in[i+1-(i&1)];
+   }
+}
+static void translate_trifan_uint2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+2];
+      (out+j)[1] = (ushort)in[0];
+      (out+j)[2] = (ushort)in[i+1];
+   }
+}
+static void translate_quads_uint2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (ushort)in[i+3];
+      (out+j+0)[1] = (ushort)in[i+0];
+      (out+j+0)[2] = (ushort)in[i+1];
+      (out+j+3)[0] = (ushort)in[i+3];
+      (out+j+3)[1] = (ushort)in[i+1];
+      (out+j+3)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_quadstrip_uint2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (ushort)in[i+3];
+      (out+j+0)[1] = (ushort)in[i+2];
+      (out+j+0)[2] = (ushort)in[i+0];
+      (out+j+3)[0] = (ushort)in[i+3];
+      (out+j+3)[1] = (ushort)in[i+0];
+      (out+j+3)[2] = (ushort)in[i+1];
+   }
+}
+static void translate_polygon_uint2ushort_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i+1];
+      (out+j)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_points_uint2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (ushort)in[i];
+   }
+}
+static void translate_lines_uint2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (ushort)in[i];
+      (out+i)[1] = (ushort)in[i+1];
+   }
+}
+static void translate_linestrip_uint2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[i+1];
+   }
+}
+static void translate_lineloop_uint2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[i+1];
+   }
+      (out+j)[0] = (ushort)in[i];
+      (out+j)[1] = (ushort)in[0];
+}
+static void translate_tris_uint2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (ushort)in[i];
+      (out+i)[1] = (ushort)in[i+1];
+      (out+i)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_tristrip_uint2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+(i&1)];
+      (out+j)[1] = (ushort)in[i+1-(i&1)];
+      (out+j)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_trifan_uint2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[0];
+      (out+j)[1] = (ushort)in[i+1];
+      (out+j)[2] = (ushort)in[i+2];
+   }
+}
+static void translate_quads_uint2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (ushort)in[i+0];
+      (out+j+0)[1] = (ushort)in[i+1];
+      (out+j+0)[2] = (ushort)in[i+3];
+      (out+j+3)[0] = (ushort)in[i+1];
+      (out+j+3)[1] = (ushort)in[i+2];
+      (out+j+3)[2] = (ushort)in[i+3];
+   }
+}
+static void translate_quadstrip_uint2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (ushort)in[i+2];
+      (out+j+0)[1] = (ushort)in[i+0];
+      (out+j+0)[2] = (ushort)in[i+3];
+      (out+j+3)[0] = (ushort)in[i+0];
+      (out+j+3)[1] = (ushort)in[i+1];
+      (out+j+3)[2] = (ushort)in[i+3];
+   }
+}
+static void translate_polygon_uint2ushort_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  ushort *out = (ushort*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (ushort)in[i+1];
+      (out+j)[1] = (ushort)in[i+2];
+      (out+j)[2] = (ushort)in[0];
+   }
+}
+static void translate_points_uint2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (uint)in[i];
+   }
+}
+static void translate_lines_uint2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (uint)in[i];
+      (out+i)[1] = (uint)in[i+1];
+   }
+}
+static void translate_linestrip_uint2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[i+1];
+   }
+}
+static void translate_lineloop_uint2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[i+1];
+   }
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[0];
+}
+static void translate_tris_uint2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (uint)in[i];
+      (out+i)[1] = (uint)in[i+1];
+      (out+i)[2] = (uint)in[i+2];
+   }
+}
+static void translate_tristrip_uint2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[i+1+(i&1)];
+      (out+j)[2] = (uint)in[i+2-(i&1)];
+   }
+}
+static void translate_trifan_uint2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i+1];
+      (out+j)[2] = (uint)in[i+2];
+   }
+}
+static void translate_quads_uint2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (uint)in[i+0];
+      (out+j+0)[1] = (uint)in[i+1];
+      (out+j+0)[2] = (uint)in[i+3];
+      (out+j+3)[0] = (uint)in[i+1];
+      (out+j+3)[1] = (uint)in[i+2];
+      (out+j+3)[2] = (uint)in[i+3];
+   }
+}
+static void translate_quadstrip_uint2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (uint)in[i+2];
+      (out+j+0)[1] = (uint)in[i+0];
+      (out+j+0)[2] = (uint)in[i+3];
+      (out+j+3)[0] = (uint)in[i+0];
+      (out+j+3)[1] = (uint)in[i+1];
+      (out+j+3)[2] = (uint)in[i+3];
+   }
+}
+static void translate_polygon_uint2uint_first2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i+1];
+      (out+j)[2] = (uint)in[i+2];
+   }
+}
+static void translate_points_uint2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (uint)in[i];
+   }
+}
+static void translate_lines_uint2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (uint)in[i+1];
+      (out+i)[1] = (uint)in[i];
+   }
+}
+static void translate_linestrip_uint2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i];
+   }
+}
+static void translate_lineloop_uint2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i];
+   }
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i];
+}
+static void translate_tris_uint2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (uint)in[i+1];
+      (out+i)[1] = (uint)in[i+2];
+      (out+i)[2] = (uint)in[i];
+   }
+}
+static void translate_tristrip_uint2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+1+(i&1)];
+      (out+j)[1] = (uint)in[i+2-(i&1)];
+      (out+j)[2] = (uint)in[i];
+   }
+}
+static void translate_trifan_uint2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i+2];
+      (out+j)[2] = (uint)in[0];
+   }
+}
+static void translate_quads_uint2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (uint)in[i+1];
+      (out+j+0)[1] = (uint)in[i+3];
+      (out+j+0)[2] = (uint)in[i+0];
+      (out+j+3)[0] = (uint)in[i+2];
+      (out+j+3)[1] = (uint)in[i+3];
+      (out+j+3)[2] = (uint)in[i+1];
+   }
+}
+static void translate_quadstrip_uint2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (uint)in[i+0];
+      (out+j+0)[1] = (uint)in[i+3];
+      (out+j+0)[2] = (uint)in[i+2];
+      (out+j+3)[0] = (uint)in[i+1];
+      (out+j+3)[1] = (uint)in[i+3];
+      (out+j+3)[2] = (uint)in[i+0];
+   }
+}
+static void translate_polygon_uint2uint_first2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i+2];
+      (out+j)[2] = (uint)in[0];
+   }
+}
+static void translate_points_uint2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (uint)in[i];
+   }
+}
+static void translate_lines_uint2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (uint)in[i+1];
+      (out+i)[1] = (uint)in[i];
+   }
+}
+static void translate_linestrip_uint2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i];
+   }
+}
+static void translate_lineloop_uint2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i];
+   }
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i];
+}
+static void translate_tris_uint2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (uint)in[i+2];
+      (out+i)[1] = (uint)in[i];
+      (out+i)[2] = (uint)in[i+1];
+   }
+}
+static void translate_tristrip_uint2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+2];
+      (out+j)[1] = (uint)in[i+(i&1)];
+      (out+j)[2] = (uint)in[i+1-(i&1)];
+   }
+}
+static void translate_trifan_uint2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+2];
+      (out+j)[1] = (uint)in[0];
+      (out+j)[2] = (uint)in[i+1];
+   }
+}
+static void translate_quads_uint2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (uint)in[i+3];
+      (out+j+0)[1] = (uint)in[i+0];
+      (out+j+0)[2] = (uint)in[i+1];
+      (out+j+3)[0] = (uint)in[i+3];
+      (out+j+3)[1] = (uint)in[i+1];
+      (out+j+3)[2] = (uint)in[i+2];
+   }
+}
+static void translate_quadstrip_uint2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (uint)in[i+3];
+      (out+j+0)[1] = (uint)in[i+2];
+      (out+j+0)[2] = (uint)in[i+0];
+      (out+j+3)[0] = (uint)in[i+3];
+      (out+j+3)[1] = (uint)in[i+0];
+      (out+j+3)[2] = (uint)in[i+1];
+   }
+}
+static void translate_polygon_uint2uint_last2first(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i+1];
+      (out+j)[2] = (uint)in[i+2];
+   }
+}
+static void translate_points_uint2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i++) { 
+      (out+i)[0] = (uint)in[i];
+   }
+}
+static void translate_lines_uint2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=2) { 
+      (out+i)[0] = (uint)in[i];
+      (out+i)[1] = (uint)in[i+1];
+   }
+}
+static void translate_linestrip_uint2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[i+1];
+   }
+}
+static void translate_lineloop_uint2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr - 2; j+=2, i++) { 
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[i+1];
+   }
+      (out+j)[0] = (uint)in[i];
+      (out+j)[1] = (uint)in[0];
+}
+static void translate_tris_uint2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (i = 0; i < nr; i+=3) { 
+      (out+i)[0] = (uint)in[i];
+      (out+i)[1] = (uint)in[i+1];
+      (out+i)[2] = (uint)in[i+2];
+   }
+}
+static void translate_tristrip_uint2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+(i&1)];
+      (out+j)[1] = (uint)in[i+1-(i&1)];
+      (out+j)[2] = (uint)in[i+2];
+   }
+}
+static void translate_trifan_uint2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[0];
+      (out+j)[1] = (uint)in[i+1];
+      (out+j)[2] = (uint)in[i+2];
+   }
+}
+static void translate_quads_uint2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=4) { 
+      (out+j+0)[0] = (uint)in[i+0];
+      (out+j+0)[1] = (uint)in[i+1];
+      (out+j+0)[2] = (uint)in[i+3];
+      (out+j+3)[0] = (uint)in[i+1];
+      (out+j+3)[1] = (uint)in[i+2];
+      (out+j+3)[2] = (uint)in[i+3];
+   }
+}
+static void translate_quadstrip_uint2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=6, i+=2) { 
+      (out+j+0)[0] = (uint)in[i+2];
+      (out+j+0)[1] = (uint)in[i+0];
+      (out+j+0)[2] = (uint)in[i+3];
+      (out+j+3)[0] = (uint)in[i+0];
+      (out+j+3)[1] = (uint)in[i+1];
+      (out+j+3)[2] = (uint)in[i+3];
+   }
+}
+static void translate_polygon_uint2uint_last2last(
+    const void * _in,
+    unsigned nr,
+    void *_out )
+{
+  const uint*in = (const uint*)_in;
+  uint *out = (uint*)_out;
+  unsigned i, j;
+  (void)j;
+  for (j = i = 0; j < nr; j+=3, i++) { 
+      (out+j)[0] = (uint)in[i+1];
+      (out+j)[1] = (uint)in[i+2];
+      (out+j)[2] = (uint)in[0];
+   }
+}
+void u_index_init( void )
+{
+  static int firsttime = 1;
+  if (!firsttime) return;
+  firsttime = 0;
+generate[OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_POINTS] = generate_points_ushort_first2first;
+generate[OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINES] = generate_lines_ushort_first2first;
+generate[OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINE_STRIP] = generate_linestrip_ushort_first2first;
+generate[OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINE_LOOP] = generate_lineloop_ushort_first2first;
+generate[OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLES] = generate_tris_ushort_first2first;
+generate[OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLE_FAN] = generate_trifan_ushort_first2first;
+generate[OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLE_STRIP] = generate_tristrip_ushort_first2first;
+generate[OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_QUADS] = generate_quads_ushort_first2first;
+generate[OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_QUAD_STRIP] = generate_quadstrip_ushort_first2first;
+generate[OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_POLYGON] = generate_polygon_ushort_first2first;
+generate[OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_POINTS] = generate_points_ushort_first2last;
+generate[OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_LINES] = generate_lines_ushort_first2last;
+generate[OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_LINE_STRIP] = generate_linestrip_ushort_first2last;
+generate[OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_LINE_LOOP] = generate_lineloop_ushort_first2last;
+generate[OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLES] = generate_tris_ushort_first2last;
+generate[OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLE_FAN] = generate_trifan_ushort_first2last;
+generate[OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLE_STRIP] = generate_tristrip_ushort_first2last;
+generate[OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_QUADS] = generate_quads_ushort_first2last;
+generate[OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_QUAD_STRIP] = generate_quadstrip_ushort_first2last;
+generate[OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_POLYGON] = generate_polygon_ushort_first2last;
+generate[OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_POINTS] = generate_points_ushort_last2first;
+generate[OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_LINES] = generate_lines_ushort_last2first;
+generate[OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_LINE_STRIP] = generate_linestrip_ushort_last2first;
+generate[OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_LINE_LOOP] = generate_lineloop_ushort_last2first;
+generate[OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLES] = generate_tris_ushort_last2first;
+generate[OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLE_FAN] = generate_trifan_ushort_last2first;
+generate[OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLE_STRIP] = generate_tristrip_ushort_last2first;
+generate[OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_QUADS] = generate_quads_ushort_last2first;
+generate[OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_QUAD_STRIP] = generate_quadstrip_ushort_last2first;
+generate[OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_POLYGON] = generate_polygon_ushort_last2first;
+generate[OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_POINTS] = generate_points_ushort_last2last;
+generate[OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_LINES] = generate_lines_ushort_last2last;
+generate[OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_LINE_STRIP] = generate_linestrip_ushort_last2last;
+generate[OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_LINE_LOOP] = generate_lineloop_ushort_last2last;
+generate[OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLES] = generate_tris_ushort_last2last;
+generate[OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLE_FAN] = generate_trifan_ushort_last2last;
+generate[OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLE_STRIP] = generate_tristrip_ushort_last2last;
+generate[OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_QUADS] = generate_quads_ushort_last2last;
+generate[OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_QUAD_STRIP] = generate_quadstrip_ushort_last2last;
+generate[OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_POLYGON] = generate_polygon_ushort_last2last;
+generate[OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_POINTS] = generate_points_uint_first2first;
+generate[OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINES] = generate_lines_uint_first2first;
+generate[OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINE_STRIP] = generate_linestrip_uint_first2first;
+generate[OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINE_LOOP] = generate_lineloop_uint_first2first;
+generate[OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLES] = generate_tris_uint_first2first;
+generate[OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLE_FAN] = generate_trifan_uint_first2first;
+generate[OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLE_STRIP] = generate_tristrip_uint_first2first;
+generate[OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_QUADS] = generate_quads_uint_first2first;
+generate[OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_QUAD_STRIP] = generate_quadstrip_uint_first2first;
+generate[OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_POLYGON] = generate_polygon_uint_first2first;
+generate[OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_POINTS] = generate_points_uint_first2last;
+generate[OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_LINES] = generate_lines_uint_first2last;
+generate[OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_LINE_STRIP] = generate_linestrip_uint_first2last;
+generate[OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_LINE_LOOP] = generate_lineloop_uint_first2last;
+generate[OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLES] = generate_tris_uint_first2last;
+generate[OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLE_FAN] = generate_trifan_uint_first2last;
+generate[OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLE_STRIP] = generate_tristrip_uint_first2last;
+generate[OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_QUADS] = generate_quads_uint_first2last;
+generate[OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_QUAD_STRIP] = generate_quadstrip_uint_first2last;
+generate[OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_POLYGON] = generate_polygon_uint_first2last;
+generate[OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_POINTS] = generate_points_uint_last2first;
+generate[OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_LINES] = generate_lines_uint_last2first;
+generate[OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_LINE_STRIP] = generate_linestrip_uint_last2first;
+generate[OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_LINE_LOOP] = generate_lineloop_uint_last2first;
+generate[OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLES] = generate_tris_uint_last2first;
+generate[OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLE_FAN] = generate_trifan_uint_last2first;
+generate[OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLE_STRIP] = generate_tristrip_uint_last2first;
+generate[OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_QUADS] = generate_quads_uint_last2first;
+generate[OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_QUAD_STRIP] = generate_quadstrip_uint_last2first;
+generate[OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_POLYGON] = generate_polygon_uint_last2first;
+generate[OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_POINTS] = generate_points_uint_last2last;
+generate[OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_LINES] = generate_lines_uint_last2last;
+generate[OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_LINE_STRIP] = generate_linestrip_uint_last2last;
+generate[OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_LINE_LOOP] = generate_lineloop_uint_last2last;
+generate[OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLES] = generate_tris_uint_last2last;
+generate[OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLE_FAN] = generate_trifan_uint_last2last;
+generate[OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLE_STRIP] = generate_tristrip_uint_last2last;
+generate[OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_QUADS] = generate_quads_uint_last2last;
+generate[OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_QUAD_STRIP] = generate_quadstrip_uint_last2last;
+generate[OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_POLYGON] = generate_polygon_uint_last2last;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_POINTS] = translate_points_ubyte2ushort_first2first;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINES] = translate_lines_ubyte2ushort_first2first;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_ubyte2ushort_first2first;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_ubyte2ushort_first2first;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLES] = translate_tris_ubyte2ushort_first2first;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_ubyte2ushort_first2first;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_ubyte2ushort_first2first;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_QUADS] = translate_quads_ubyte2ushort_first2first;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_ubyte2ushort_first2first;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_POLYGON] = translate_polygon_ubyte2ushort_first2first;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_POINTS] = translate_points_ubyte2ushort_first2last;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_LINES] = translate_lines_ubyte2ushort_first2last;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_ubyte2ushort_first2last;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_ubyte2ushort_first2last;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLES] = translate_tris_ubyte2ushort_first2last;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_ubyte2ushort_first2last;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_ubyte2ushort_first2last;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_QUADS] = translate_quads_ubyte2ushort_first2last;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_ubyte2ushort_first2last;
+translate[IN_UBYTE][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_POLYGON] = translate_polygon_ubyte2ushort_first2last;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_POINTS] = translate_points_ubyte2ushort_last2first;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_LINES] = translate_lines_ubyte2ushort_last2first;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_ubyte2ushort_last2first;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_ubyte2ushort_last2first;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLES] = translate_tris_ubyte2ushort_last2first;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_ubyte2ushort_last2first;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_ubyte2ushort_last2first;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_QUADS] = translate_quads_ubyte2ushort_last2first;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_ubyte2ushort_last2first;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_POLYGON] = translate_polygon_ubyte2ushort_last2first;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_POINTS] = translate_points_ubyte2ushort_last2last;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_LINES] = translate_lines_ubyte2ushort_last2last;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_ubyte2ushort_last2last;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_ubyte2ushort_last2last;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLES] = translate_tris_ubyte2ushort_last2last;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_ubyte2ushort_last2last;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_ubyte2ushort_last2last;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_QUADS] = translate_quads_ubyte2ushort_last2last;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_ubyte2ushort_last2last;
+translate[IN_UBYTE][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_POLYGON] = translate_polygon_ubyte2ushort_last2last;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_POINTS] = translate_points_ubyte2uint_first2first;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINES] = translate_lines_ubyte2uint_first2first;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_ubyte2uint_first2first;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_ubyte2uint_first2first;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLES] = translate_tris_ubyte2uint_first2first;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_ubyte2uint_first2first;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_ubyte2uint_first2first;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_QUADS] = translate_quads_ubyte2uint_first2first;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_ubyte2uint_first2first;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_POLYGON] = translate_polygon_ubyte2uint_first2first;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_POINTS] = translate_points_ubyte2uint_first2last;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_LINES] = translate_lines_ubyte2uint_first2last;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_ubyte2uint_first2last;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_ubyte2uint_first2last;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLES] = translate_tris_ubyte2uint_first2last;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_ubyte2uint_first2last;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_ubyte2uint_first2last;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_QUADS] = translate_quads_ubyte2uint_first2last;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_ubyte2uint_first2last;
+translate[IN_UBYTE][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_POLYGON] = translate_polygon_ubyte2uint_first2last;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_POINTS] = translate_points_ubyte2uint_last2first;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_LINES] = translate_lines_ubyte2uint_last2first;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_ubyte2uint_last2first;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_ubyte2uint_last2first;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLES] = translate_tris_ubyte2uint_last2first;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_ubyte2uint_last2first;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_ubyte2uint_last2first;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_QUADS] = translate_quads_ubyte2uint_last2first;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_ubyte2uint_last2first;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_POLYGON] = translate_polygon_ubyte2uint_last2first;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_POINTS] = translate_points_ubyte2uint_last2last;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_LINES] = translate_lines_ubyte2uint_last2last;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_ubyte2uint_last2last;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_ubyte2uint_last2last;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLES] = translate_tris_ubyte2uint_last2last;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_ubyte2uint_last2last;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_ubyte2uint_last2last;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_QUADS] = translate_quads_ubyte2uint_last2last;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_ubyte2uint_last2last;
+translate[IN_UBYTE][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_POLYGON] = translate_polygon_ubyte2uint_last2last;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_POINTS] = translate_points_ushort2ushort_first2first;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINES] = translate_lines_ushort2ushort_first2first;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_ushort2ushort_first2first;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_ushort2ushort_first2first;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLES] = translate_tris_ushort2ushort_first2first;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_ushort2ushort_first2first;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_ushort2ushort_first2first;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_QUADS] = translate_quads_ushort2ushort_first2first;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_ushort2ushort_first2first;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_POLYGON] = translate_polygon_ushort2ushort_first2first;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_POINTS] = translate_points_ushort2ushort_first2last;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_LINES] = translate_lines_ushort2ushort_first2last;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_ushort2ushort_first2last;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_ushort2ushort_first2last;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLES] = translate_tris_ushort2ushort_first2last;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_ushort2ushort_first2last;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_ushort2ushort_first2last;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_QUADS] = translate_quads_ushort2ushort_first2last;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_ushort2ushort_first2last;
+translate[IN_USHORT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_POLYGON] = translate_polygon_ushort2ushort_first2last;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_POINTS] = translate_points_ushort2ushort_last2first;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_LINES] = translate_lines_ushort2ushort_last2first;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_ushort2ushort_last2first;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_ushort2ushort_last2first;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLES] = translate_tris_ushort2ushort_last2first;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_ushort2ushort_last2first;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_ushort2ushort_last2first;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_QUADS] = translate_quads_ushort2ushort_last2first;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_ushort2ushort_last2first;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_POLYGON] = translate_polygon_ushort2ushort_last2first;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_POINTS] = translate_points_ushort2ushort_last2last;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_LINES] = translate_lines_ushort2ushort_last2last;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_ushort2ushort_last2last;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_ushort2ushort_last2last;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLES] = translate_tris_ushort2ushort_last2last;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_ushort2ushort_last2last;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_ushort2ushort_last2last;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_QUADS] = translate_quads_ushort2ushort_last2last;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_ushort2ushort_last2last;
+translate[IN_USHORT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_POLYGON] = translate_polygon_ushort2ushort_last2last;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_POINTS] = translate_points_ushort2uint_first2first;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINES] = translate_lines_ushort2uint_first2first;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_ushort2uint_first2first;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_ushort2uint_first2first;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLES] = translate_tris_ushort2uint_first2first;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_ushort2uint_first2first;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_ushort2uint_first2first;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_QUADS] = translate_quads_ushort2uint_first2first;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_ushort2uint_first2first;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_POLYGON] = translate_polygon_ushort2uint_first2first;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_POINTS] = translate_points_ushort2uint_first2last;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_LINES] = translate_lines_ushort2uint_first2last;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_ushort2uint_first2last;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_ushort2uint_first2last;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLES] = translate_tris_ushort2uint_first2last;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_ushort2uint_first2last;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_ushort2uint_first2last;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_QUADS] = translate_quads_ushort2uint_first2last;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_ushort2uint_first2last;
+translate[IN_USHORT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_POLYGON] = translate_polygon_ushort2uint_first2last;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_POINTS] = translate_points_ushort2uint_last2first;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_LINES] = translate_lines_ushort2uint_last2first;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_ushort2uint_last2first;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_ushort2uint_last2first;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLES] = translate_tris_ushort2uint_last2first;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_ushort2uint_last2first;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_ushort2uint_last2first;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_QUADS] = translate_quads_ushort2uint_last2first;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_ushort2uint_last2first;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_POLYGON] = translate_polygon_ushort2uint_last2first;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_POINTS] = translate_points_ushort2uint_last2last;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_LINES] = translate_lines_ushort2uint_last2last;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_ushort2uint_last2last;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_ushort2uint_last2last;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLES] = translate_tris_ushort2uint_last2last;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_ushort2uint_last2last;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_ushort2uint_last2last;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_QUADS] = translate_quads_ushort2uint_last2last;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_ushort2uint_last2last;
+translate[IN_USHORT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_POLYGON] = translate_polygon_ushort2uint_last2last;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_POINTS] = translate_points_uint2ushort_first2first;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINES] = translate_lines_uint2ushort_first2first;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_uint2ushort_first2first;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_uint2ushort_first2first;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLES] = translate_tris_uint2ushort_first2first;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_uint2ushort_first2first;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_uint2ushort_first2first;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_QUADS] = translate_quads_uint2ushort_first2first;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_uint2ushort_first2first;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_FIRST][PIPE_PRIM_POLYGON] = translate_polygon_uint2ushort_first2first;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_POINTS] = translate_points_uint2ushort_first2last;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_LINES] = translate_lines_uint2ushort_first2last;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_uint2ushort_first2last;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_uint2ushort_first2last;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLES] = translate_tris_uint2ushort_first2last;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_uint2ushort_first2last;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_uint2ushort_first2last;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_QUADS] = translate_quads_uint2ushort_first2last;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_uint2ushort_first2last;
+translate[IN_UINT][OUT_USHORT][PV_FIRST][PV_LAST][PIPE_PRIM_POLYGON] = translate_polygon_uint2ushort_first2last;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_POINTS] = translate_points_uint2ushort_last2first;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_LINES] = translate_lines_uint2ushort_last2first;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_uint2ushort_last2first;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_uint2ushort_last2first;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLES] = translate_tris_uint2ushort_last2first;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_uint2ushort_last2first;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_uint2ushort_last2first;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_QUADS] = translate_quads_uint2ushort_last2first;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_uint2ushort_last2first;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_FIRST][PIPE_PRIM_POLYGON] = translate_polygon_uint2ushort_last2first;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_POINTS] = translate_points_uint2ushort_last2last;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_LINES] = translate_lines_uint2ushort_last2last;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_uint2ushort_last2last;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_uint2ushort_last2last;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLES] = translate_tris_uint2ushort_last2last;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_uint2ushort_last2last;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_uint2ushort_last2last;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_QUADS] = translate_quads_uint2ushort_last2last;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_uint2ushort_last2last;
+translate[IN_UINT][OUT_USHORT][PV_LAST][PV_LAST][PIPE_PRIM_POLYGON] = translate_polygon_uint2ushort_last2last;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_POINTS] = translate_points_uint2uint_first2first;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINES] = translate_lines_uint2uint_first2first;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_uint2uint_first2first;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_uint2uint_first2first;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLES] = translate_tris_uint2uint_first2first;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_uint2uint_first2first;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_uint2uint_first2first;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_QUADS] = translate_quads_uint2uint_first2first;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_uint2uint_first2first;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_FIRST][PIPE_PRIM_POLYGON] = translate_polygon_uint2uint_first2first;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_POINTS] = translate_points_uint2uint_first2last;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_LINES] = translate_lines_uint2uint_first2last;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_uint2uint_first2last;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_uint2uint_first2last;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLES] = translate_tris_uint2uint_first2last;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_uint2uint_first2last;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_uint2uint_first2last;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_QUADS] = translate_quads_uint2uint_first2last;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_uint2uint_first2last;
+translate[IN_UINT][OUT_UINT][PV_FIRST][PV_LAST][PIPE_PRIM_POLYGON] = translate_polygon_uint2uint_first2last;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_POINTS] = translate_points_uint2uint_last2first;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_LINES] = translate_lines_uint2uint_last2first;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_uint2uint_last2first;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_uint2uint_last2first;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLES] = translate_tris_uint2uint_last2first;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_uint2uint_last2first;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_uint2uint_last2first;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_QUADS] = translate_quads_uint2uint_last2first;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_uint2uint_last2first;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_FIRST][PIPE_PRIM_POLYGON] = translate_polygon_uint2uint_last2first;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_POINTS] = translate_points_uint2uint_last2last;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_LINES] = translate_lines_uint2uint_last2last;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_LINE_STRIP] = translate_linestrip_uint2uint_last2last;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_LINE_LOOP] = translate_lineloop_uint2uint_last2last;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLES] = translate_tris_uint2uint_last2last;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLE_FAN] = translate_trifan_uint2uint_last2last;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_TRIANGLE_STRIP] = translate_tristrip_uint2uint_last2last;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_QUADS] = translate_quads_uint2uint_last2last;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_QUAD_STRIP] = translate_quadstrip_uint2uint_last2last;
+translate[IN_UINT][OUT_UINT][PV_LAST][PV_LAST][PIPE_PRIM_POLYGON] = translate_polygon_uint2uint_last2last;
+}
+#include "indices/u_indices.c"
diff --git a/src/gallium/auxiliary/indices/u_indices_gen.py b/src/gallium/auxiliary/indices/u_indices_gen.py
new file mode 100644
index 0000000000..0dc58d0cd0
--- /dev/null
+++ b/src/gallium/auxiliary/indices/u_indices_gen.py
@@ -0,0 +1,319 @@
+#!/usr/bin/env python
+copyright = '''
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on 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
+ * VMWARE 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.
+ */
+'''
+
+GENERATE, UBYTE, USHORT, UINT = 'generate', 'ubyte', 'ushort', 'uint'
+FIRST, LAST = 'first', 'last'
+
+INTYPES = (GENERATE, UBYTE, USHORT, UINT)
+OUTTYPES = (USHORT, UINT)
+PVS=(FIRST, LAST)
+PRIMS=('points', 
+       'lines', 
+       'linestrip', 
+       'lineloop', 
+       'tris', 
+       'trifan', 
+       'tristrip', 
+       'quads', 
+       'quadstrip', 
+       'polygon')
+
+LONGPRIMS=('PIPE_PRIM_POINTS', 
+           'PIPE_PRIM_LINES', 
+           'PIPE_PRIM_LINE_STRIP', 
+           'PIPE_PRIM_LINE_LOOP', 
+           'PIPE_PRIM_TRIANGLES', 
+           'PIPE_PRIM_TRIANGLE_FAN', 
+           'PIPE_PRIM_TRIANGLE_STRIP', 
+           'PIPE_PRIM_QUADS', 
+           'PIPE_PRIM_QUAD_STRIP', 
+           'PIPE_PRIM_POLYGON')
+
+longprim = dict(zip(PRIMS, LONGPRIMS))
+intype_idx = dict(ubyte='IN_UBYTE', ushort='IN_USHORT', uint='IN_UINT')
+outtype_idx = dict(ushort='OUT_USHORT', uint='OUT_UINT')
+pv_idx = dict(first='PV_FIRST', last='PV_LAST')
+
+
+def prolog():
+    print '''/* File automatically generated by indices.py */'''
+    print copyright
+    print r'''
+
+/**
+ * @file
+ * Functions to translate and generate index lists
+ */
+
+#include "indices/u_indices.h"
+#include "indices/u_indices_priv.h"
+#include "pipe/p_compiler.h"
+#include "pipe/p_debug.h"
+#include "pipe/p_defines.h"
+#include "util/u_memory.h"
+
+
+static unsigned out_size_idx( unsigned index_size )
+{
+   switch (index_size) {
+   case 4: return OUT_UINT;
+   case 2: return OUT_USHORT;
+   default: assert(0); return OUT_USHORT;
+   }
+}
+
+static unsigned in_size_idx( unsigned index_size )
+{
+   switch (index_size) {
+   case 4: return IN_UINT;
+   case 2: return IN_USHORT;
+   case 1: return IN_UBYTE;
+   default: assert(0); return IN_UBYTE;
+   }
+}
+
+
+static u_translate_func translate[IN_COUNT][OUT_COUNT][PV_COUNT][PV_COUNT][PRIM_COUNT];
+static u_generate_func  generate[OUT_COUNT][PV_COUNT][PV_COUNT][PRIM_COUNT];
+
+
+'''
+
+def vert( intype, outtype, v0 ):
+    if intype == GENERATE:
+        return '(' + outtype + ')(' + v0 + ')'
+    else:
+        return '(' + outtype + ')in[' + v0 + ']'
+
+def point( intype, outtype, ptr, v0 ):
+    print '      (' + ptr + ')[0] = ' + vert( intype, outtype, v0 ) + ';'
+
+def line( intype, outtype, ptr, v0, v1 ):
+    print '      (' + ptr + ')[0] = ' + vert( intype, outtype, v0 ) + ';'
+    print '      (' + ptr + ')[1] = ' + vert( intype, outtype, v1 ) + ';'
+
+def tri( intype, outtype, ptr, v0, v1, v2 ):
+    print '      (' + ptr + ')[0] = ' + vert( intype, outtype, v0 ) + ';'
+    print '      (' + ptr + ')[1] = ' + vert( intype, outtype, v1 ) + ';'
+    print '      (' + ptr + ')[2] = ' + vert( intype, outtype, v2 ) + ';'
+
+def do_point( intype, outtype, ptr, v0 ):
+    point( intype, outtype, ptr, v0 )
+
+def do_line( intype, outtype, ptr, v0, v1, inpv, outpv ):
+    if inpv == outpv:
+        line( intype, outtype, ptr, v0, v1 )
+    else:
+        line( intype, outtype, ptr, v1, v0 )
+
+def do_tri( intype, outtype, ptr, v0, v1, v2, inpv, outpv ):
+    if inpv == outpv:
+        tri( intype, outtype, ptr, v0, v1, v2 )
+    else: 
+        if inpv == FIRST:
+            tri( intype, outtype, ptr, v1, v2, v0 )
+        else:
+            tri( intype, outtype, ptr, v2, v0, v1 )
+
+def do_quad( intype, outtype, ptr, v0, v1, v2, v3, inpv, outpv ):
+    do_tri( intype, outtype, ptr+'+0',  v0, v1, v3, inpv, outpv );
+    do_tri( intype, outtype, ptr+'+3',  v1, v2, v3, inpv, outpv );
+
+def name(intype, outtype, inpv, outpv, prim):
+    if intype == GENERATE:
+        return 'generate_' + prim + '_' + outtype + '_' + inpv + '2' + outpv
+    else:
+        return 'translate_' + prim + '_' + intype + '2' + outtype + '_' + inpv + '2' + outpv
+
+def preamble(intype, outtype, inpv, outpv, prim):
+    print 'static void ' + name( intype, outtype, inpv, outpv, prim ) + '('
+    if intype != GENERATE:
+        print '    const void * _in,'
+    print '    unsigned nr,'
+    print '    void *_out )'
+    print '{'
+    if intype != GENERATE:
+        print '  const ' + intype + '*in = (const ' + intype + '*)_in;'
+    print '  ' + outtype + ' *out = (' + outtype + '*)_out;'
+    print '  unsigned i, j;'
+    print '  (void)j;'
+
+def postamble():
+    print '}'
+
+
+def points(intype, outtype, inpv, outpv):
+    preamble(intype, outtype, inpv, outpv, prim='points')
+    print '  for (i = 0; i < nr; i++) { '
+    do_point( intype, outtype, 'out+i',  'i' );
+    print '   }'
+    postamble()
+
+def lines(intype, outtype, inpv, outpv):
+    preamble(intype, outtype, inpv, outpv, prim='lines')
+    print '  for (i = 0; i < nr; i+=2) { '
+    do_line( intype, outtype, 'out+i',  'i', 'i+1', inpv, outpv );
+    print '   }'
+    postamble()
+
+def linestrip(intype, outtype, inpv, outpv):
+    preamble(intype, outtype, inpv, outpv, prim='linestrip')
+    print '  for (j = i = 0; j < nr; j+=2, i++) { '
+    do_line( intype, outtype, 'out+j',  'i', 'i+1', inpv, outpv );
+    print '   }'
+    postamble()
+
+def lineloop(intype, outtype, inpv, outpv):
+    preamble(intype, outtype, inpv, outpv, prim='lineloop')
+    print '  for (j = i = 0; j < nr - 2; j+=2, i++) { '
+    do_line( intype, outtype, 'out+j',  'i', 'i+1', inpv, outpv );
+    print '   }'
+    do_line( intype, outtype, 'out+j',  'i', '0', inpv, outpv );
+    postamble()
+
+def tris(intype, outtype, inpv, outpv):
+    preamble(intype, outtype, inpv, outpv, prim='tris')
+    print '  for (i = 0; i < nr; i+=3) { '
+    do_tri( intype, outtype, 'out+i',  'i', 'i+1', 'i+2', inpv, outpv );
+    print '   }'
+    postamble()
+
+
+def tristrip(intype, outtype, inpv, outpv):
+    preamble(intype, outtype, inpv, outpv, prim='tristrip')
+    print '  for (j = i = 0; j < nr; j+=3, i++) { '
+    if inpv == FIRST:
+        do_tri( intype, outtype, 'out+j',  'i', 'i+1+(i&1)', 'i+2-(i&1)', inpv, outpv );
+    else:
+        do_tri( intype, outtype, 'out+j',  'i+(i&1)', 'i+1-(i&1)', 'i+2', inpv, outpv );
+    print '   }'
+    postamble()
+
+
+def trifan(intype, outtype, inpv, outpv):
+    preamble(intype, outtype, inpv, outpv, prim='trifan')
+    print '  for (j = i = 0; j < nr; j+=3, i++) { '
+    do_tri( intype, outtype, 'out+j',  '0', 'i+1', 'i+2', inpv, outpv );
+    print '   }'
+    postamble()
+
+
+
+def polygon(intype, outtype, inpv, outpv):
+    preamble(intype, outtype, inpv, outpv, prim='polygon')
+    print '  for (j = i = 0; j < nr; j+=3, i++) { '
+    if inpv == FIRST:
+        do_tri( intype, outtype, 'out+j',  '0', 'i+1', 'i+2', inpv, outpv );
+    else:
+        do_tri( intype, outtype, 'out+j',  'i+1', 'i+2', '0', inpv, outpv );
+    print '   }'
+    postamble()
+
+
+def quads(intype, outtype, inpv, outpv):
+    preamble(intype, outtype, inpv, outpv, prim='quads')
+    print '  for (j = i = 0; j < nr; j+=6, i+=4) { '
+    do_quad( intype, outtype, 'out+j', 'i+0', 'i+1', 'i+2', 'i+3', inpv, outpv );
+    print '   }'
+    postamble()
+
+
+def quadstrip(intype, outtype, inpv, outpv):
+    preamble(intype, outtype, inpv, outpv, prim='quadstrip')
+    print '  for (j = i = 0; j < nr; j+=6, i+=2) { '
+    do_quad( intype, outtype, 'out+j', 'i+2', 'i+0', 'i+1', 'i+3', inpv, outpv );
+    print '   }'
+    postamble()
+
+
+def emit_funcs():
+    for intype in INTYPES:
+        for outtype in OUTTYPES:
+            for inpv in (FIRST, LAST):
+                for outpv in (FIRST, LAST):
+                    points(intype, outtype, inpv, outpv)
+                    lines(intype, outtype, inpv, outpv)
+                    linestrip(intype, outtype, inpv, outpv)
+                    lineloop(intype, outtype, inpv, outpv)
+                    tris(intype, outtype, inpv, outpv)
+                    tristrip(intype, outtype, inpv, outpv)
+                    trifan(intype, outtype, inpv, outpv)
+                    quads(intype, outtype, inpv, outpv)
+                    quadstrip(intype, outtype, inpv, outpv)
+                    polygon(intype, outtype, inpv, outpv)
+
+def init(intype, outtype, inpv, outpv, prim):
+    if intype == GENERATE:
+        print ('generate[' + 
+               outtype_idx[outtype] + 
+               '][' + pv_idx[inpv] + 
+               '][' + pv_idx[outpv] + 
+               '][' + longprim[prim] + 
+               '] = ' + name( intype, outtype, inpv, outpv, prim ) + ';')
+    else:
+        print ('translate[' + 
+               intype_idx[intype] + 
+               '][' + outtype_idx[outtype] + 
+               '][' + pv_idx[inpv] + 
+               '][' + pv_idx[outpv] + 
+               '][' + longprim[prim] + 
+               '] = ' + name( intype, outtype, inpv, outpv, prim ) + ';')
+
+
+def emit_all_inits():
+    for intype in INTYPES:
+        for outtype in OUTTYPES:
+            for inpv in PVS:
+                for outpv in PVS:
+                    for prim in PRIMS:
+                        init(intype, outtype, inpv, outpv, prim)
+
+def emit_init():
+    print 'void u_index_init( void )'
+    print '{'
+    print '  static int firsttime = 1;'
+    print '  if (!firsttime) return;'
+    print '  firsttime = 0;'
+    emit_all_inits()
+    print '}'
+
+
+    
+
+def epilog():
+    print '#include "indices/u_indices.c"'
+
+
+def main():
+    prolog()
+    emit_funcs()
+    emit_init()
+    epilog()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/src/gallium/auxiliary/indices/u_indices_priv.h b/src/gallium/auxiliary/indices/u_indices_priv.h
new file mode 100644
index 0000000000..9c3298c24d
--- /dev/null
+++ b/src/gallium/auxiliary/indices/u_indices_priv.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2009 VMware, Inc.
+ * All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * on 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
+ * TUNGSTEN GRAPHICS 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.
+ */
+
+#ifndef U_INDICES_PRIV_H
+#define U_INDICES_PRIV_H
+
+#include "pipe/p_compiler.h"
+#include "u_indices.h"
+
+#define IN_UBYTE      0
+#define IN_USHORT     1
+#define IN_UINT       2
+#define IN_COUNT      3
+
+#define OUT_USHORT    0
+#define OUT_UINT      1
+#define OUT_COUNT     2
+
+
+#define PRIM_COUNT   (PIPE_PRIM_POLYGON + 1)
+
+#endif
diff --git a/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.c b/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.c
index 61afdfe82a..f9e6226436 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.c
@@ -44,7 +44,6 @@
 #include "pipe/p_compiler.h"
 #include "pipe/p_error.h"
 #include "pipe/p_debug.h"
-#include "pipe/internal/p_winsys_screen.h"
 #include "pipe/p_thread.h"
 #include "util/u_memory.h"
 #include "util/u_double_list.h"
@@ -64,7 +63,7 @@ struct fenced_buffer_list
 {
    pipe_mutex mutex;
    
-   struct pipe_winsys *winsys;
+   struct pb_fence_ops *ops;
    
    size_t numDelayed;
    
@@ -140,12 +139,12 @@ static INLINE void
 _fenced_buffer_remove(struct fenced_buffer_list *fenced_list,
                       struct fenced_buffer *fenced_buf)
 {
-   struct pipe_winsys *winsys = fenced_list->winsys;
+   struct pb_fence_ops *ops = fenced_list->ops;
 
    assert(fenced_buf->fence);
    assert(fenced_buf->list == fenced_list);
    
-   winsys->fence_reference(winsys, &fenced_buf->fence, NULL);
+   ops->fence_reference(ops, &fenced_buf->fence, NULL);
    fenced_buf->flags &= ~PIPE_BUFFER_USAGE_GPU_READ_WRITE;
    
    assert(fenced_buf->head.prev);
@@ -168,7 +167,7 @@ static INLINE enum pipe_error
 _fenced_buffer_finish(struct fenced_buffer *fenced_buf)
 {
    struct fenced_buffer_list *fenced_list = fenced_buf->list;
-   struct pipe_winsys *winsys = fenced_list->winsys;
+   struct pb_fence_ops *ops = fenced_list->ops;
 
 #if 0
    debug_warning("waiting for GPU");
@@ -176,7 +175,7 @@ _fenced_buffer_finish(struct fenced_buffer *fenced_buf)
 
    assert(fenced_buf->fence);
    if(fenced_buf->fence) {
-      if(winsys->fence_finish(winsys, fenced_buf->fence, 0) != 0) {
+      if(ops->fence_finish(ops, fenced_buf->fence, 0) != 0) {
 	 return PIPE_ERROR;
       }
       /* Remove from the fenced list */
@@ -196,7 +195,7 @@ static void
 _fenced_buffer_list_check_free(struct fenced_buffer_list *fenced_list, 
                                int wait)
 {
-   struct pipe_winsys *winsys = fenced_list->winsys;
+   struct pb_fence_ops *ops = fenced_list->ops;
    struct list_head *curr, *next;
    struct fenced_buffer *fenced_buf;
    struct pipe_fence_handle *prev_fence = NULL;
@@ -209,15 +208,15 @@ _fenced_buffer_list_check_free(struct fenced_buffer_list *fenced_list,
       if(fenced_buf->fence != prev_fence) {
 	 int signaled;
 	 if (wait)
-	    signaled = winsys->fence_finish(winsys, fenced_buf->fence, 0);
+	    signaled = ops->fence_finish(ops, fenced_buf->fence, 0);
 	 else
-	    signaled = winsys->fence_signalled(winsys, fenced_buf->fence, 0);
+	    signaled = ops->fence_signalled(ops, fenced_buf->fence, 0);
 	 if (signaled != 0)
 	    break;
 	 prev_fence = fenced_buf->fence;
       }
       else {
-	 assert(winsys->fence_signalled(winsys, fenced_buf->fence, 0) == 0);
+	 assert(ops->fence_signalled(ops, fenced_buf->fence, 0) == 0);
       }
 
       _fenced_buffer_remove(fenced_list, fenced_buf);
@@ -237,14 +236,14 @@ fenced_buffer_destroy(struct pb_buffer *buf)
    pipe_mutex_lock(fenced_list->mutex);
    assert(fenced_buf->base.base.refcount == 0);
    if (fenced_buf->fence) {
-      struct pipe_winsys *winsys = fenced_list->winsys;
-      if(winsys->fence_signalled(winsys, fenced_buf->fence, 0) == 0) {
+      struct pb_fence_ops *ops = fenced_list->ops;
+      if(ops->fence_signalled(ops, fenced_buf->fence, 0) == 0) {
 	 struct list_head *curr, *prev;
 	 curr = &fenced_buf->head;
 	 prev = curr->prev;
 	 do {
 	    fenced_buf = LIST_ENTRY(struct fenced_buffer, curr, head);
-	    assert(winsys->fence_signalled(winsys, fenced_buf->fence, 0) == 0);
+	    assert(ops->fence_signalled(ops, fenced_buf->fence, 0) == 0);
 	    _fenced_buffer_remove(fenced_list, fenced_buf);
 	    curr = prev;
 	    prev = curr->prev;
@@ -366,11 +365,11 @@ fenced_buffer_fence(struct pb_buffer *buf,
 {
    struct fenced_buffer *fenced_buf;
    struct fenced_buffer_list *fenced_list;
-   struct pipe_winsys *winsys;
+   struct pb_fence_ops *ops;
 
    fenced_buf = fenced_buffer(buf);
    fenced_list = fenced_buf->list;
-   winsys = fenced_list->winsys;
+   ops = fenced_list->ops;
    
    if(fence == fenced_buf->fence) {
       /* Nothing to do */
@@ -384,7 +383,7 @@ fenced_buffer_fence(struct pb_buffer *buf,
    if (fenced_buf->fence)
       _fenced_buffer_remove(fenced_list, fenced_buf);
    if (fence) {
-      winsys->fence_reference(winsys, &fenced_buf->fence, fence);
+      ops->fence_reference(ops, &fenced_buf->fence, fence);
       fenced_buf->flags |= fenced_buf->validation_flags;
       _fenced_buffer_add(fenced_buf);
    }
@@ -447,7 +446,7 @@ fenced_buffer_create(struct fenced_buffer_list *fenced_list,
 
 
 struct fenced_buffer_list *
-fenced_buffer_list_create(struct pipe_winsys *winsys) 
+fenced_buffer_list_create(struct pb_fence_ops *ops) 
 {
    struct fenced_buffer_list *fenced_list;
 
@@ -455,7 +454,7 @@ fenced_buffer_list_create(struct pipe_winsys *winsys)
    if (!fenced_list)
       return NULL;
 
-   fenced_list->winsys = winsys;
+   fenced_list->ops = ops;
 
    LIST_INITHEAD(&fenced_list->delayed);
 
@@ -494,6 +493,8 @@ fenced_buffer_list_destroy(struct fenced_buffer_list *fenced_list)
 
    pipe_mutex_unlock(fenced_list->mutex);
    
+   fenced_list->ops->destroy(fenced_list->ops);
+   
    FREE(fenced_list);
 }
 
diff --git a/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.h b/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.h
index b15c676194..d1c9d4c17d 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.h
+++ b/src/gallium/auxiliary/pipebuffer/pb_buffer_fenced.h
@@ -59,7 +59,6 @@ extern "C" {
 #endif
 
 
-struct pipe_winsys;
 struct pipe_buffer;
 struct pipe_fence_handle;
 
@@ -70,13 +69,42 @@ struct pipe_fence_handle;
 struct fenced_buffer_list;
 
 
+struct pb_fence_ops
+{
+   void (*destroy)( struct pb_fence_ops *ops );
+
+   /** Set ptr = fence, with reference counting */
+   void (*fence_reference)( struct pb_fence_ops *ops,
+                            struct pipe_fence_handle **ptr,
+                            struct pipe_fence_handle *fence );
+
+   /**
+    * Checks whether the fence has been signalled.
+    * \param flags  driver-specific meaning
+    * \return zero on success.
+    */
+   int (*fence_signalled)( struct pb_fence_ops *ops,
+                           struct pipe_fence_handle *fence,
+                           unsigned flag );
+
+   /**
+    * Wait for the fence to finish.
+    * \param flags  driver-specific meaning
+    * \return zero on success.
+    */
+   int (*fence_finish)( struct pb_fence_ops *ops,
+                        struct pipe_fence_handle *fence,
+                        unsigned flag );
+};
+
+
 /**
  * Create a fenced buffer list.
  * 
  * See also fenced_bufmgr_create for a more convenient way to use this.
  */
 struct fenced_buffer_list *
-fenced_buffer_list_create(struct pipe_winsys *winsys);
+fenced_buffer_list_create(struct pb_fence_ops *ops);
 
 
 /**
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr.h b/src/gallium/auxiliary/pipebuffer/pb_bufmgr.h
index 0a8264a924..fec8db91c7 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr.h
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr.h
@@ -61,7 +61,6 @@ extern "C" {
 
 struct pb_desc;
 struct pipe_buffer;
-struct pipe_winsys;
 
 
 /** 
@@ -163,6 +162,8 @@ pb_cache_manager_create(struct pb_manager *provider,
                      	unsigned usecs); 
 
 
+struct pb_fence_ops;
+
 /** 
  * Fenced buffer manager.
  *
@@ -174,7 +175,7 @@ pb_cache_manager_create(struct pb_manager *provider,
  */
 struct pb_manager *
 fenced_bufmgr_create(struct pb_manager *provider,
-                     struct pipe_winsys *winsys);
+                     struct pb_fence_ops *ops);
 
 
 struct pb_manager *
diff --git a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_fenced.c b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_fenced.c
index 513ed28ca6..47e9fee533 100644
--- a/src/gallium/auxiliary/pipebuffer/pb_bufmgr_fenced.c
+++ b/src/gallium/auxiliary/pipebuffer/pb_bufmgr_fenced.c
@@ -122,7 +122,7 @@ fenced_bufmgr_destroy(struct pb_manager *mgr)
 
 struct pb_manager *
 fenced_bufmgr_create(struct pb_manager *provider, 
-                     struct pipe_winsys *winsys) 
+                     struct pb_fence_ops *ops) 
 {
    struct fenced_pb_manager *fenced_mgr;
 
@@ -138,7 +138,7 @@ fenced_bufmgr_create(struct pb_manager *provider,
    fenced_mgr->base.flush = fenced_bufmgr_flush;
 
    fenced_mgr->provider = provider;
-   fenced_mgr->fenced_list = fenced_buffer_list_create(winsys);
+   fenced_mgr->fenced_list = fenced_buffer_list_create(ops);
    if(!fenced_mgr->fenced_list) {
       FREE(fenced_mgr);
       return NULL;
diff --git a/src/gallium/auxiliary/tgsi/tgsi_build.c b/src/gallium/auxiliary/tgsi/tgsi_build.c
index fd02c2c87c..17886540cf 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_build.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_build.c
@@ -114,7 +114,7 @@ tgsi_default_declaration( void )
    struct tgsi_declaration declaration;
 
    declaration.Type = TGSI_TOKEN_TYPE_DECLARATION;
-   declaration.Size = 1;
+   declaration.NrTokens = 1;
    declaration.File = TGSI_FILE_NULL;
    declaration.UsageMask = TGSI_WRITEMASK_XYZW;
    declaration.Interpolate = TGSI_INTERPOLATE_CONSTANT;
@@ -160,9 +160,9 @@ declaration_grow(
    struct tgsi_declaration *declaration,
    struct tgsi_header *header )
 {
-   assert( declaration->Size < 0xFF );
+   assert( declaration->NrTokens < 0xFF );
 
-   declaration->Size++;
+   declaration->NrTokens++;
 
    header_bodysize_grow( header );
 }
@@ -308,7 +308,7 @@ tgsi_default_immediate( void )
    struct tgsi_immediate immediate;
 
    immediate.Type = TGSI_TOKEN_TYPE_IMMEDIATE;
-   immediate.Size = 1;
+   immediate.NrTokens = 1;
    immediate.DataType = TGSI_IMM_FLOAT32;
    immediate.Padding = 0;
    immediate.Extended = 0;
@@ -345,9 +345,9 @@ immediate_grow(
    struct tgsi_immediate *immediate,
    struct tgsi_header *header )
 {
-   assert( immediate->Size < 0xFF );
+   assert( immediate->NrTokens < 0xFF );
 
-   immediate->Size++;
+   immediate->NrTokens++;
 
    header_bodysize_grow( header );
 }
@@ -384,7 +384,7 @@ tgsi_build_full_immediate(
 
    *immediate = tgsi_build_immediate( header );
 
-   for( i = 0; i < full_imm->Immediate.Size - 1; i++ ) {
+   for( i = 0; i < full_imm->Immediate.NrTokens - 1; i++ ) {
       struct tgsi_immediate_float32 *if32;
 
       if( maxsize <= size )
@@ -411,7 +411,7 @@ tgsi_default_instruction( void )
    struct tgsi_instruction instruction;
 
    instruction.Type = TGSI_TOKEN_TYPE_INSTRUCTION;
-   instruction.Size = 1;
+   instruction.NrTokens = 1;
    instruction.Opcode = TGSI_OPCODE_MOV;
    instruction.Saturate = TGSI_SAT_NONE;
    instruction.NumDstRegs = 1;
@@ -453,9 +453,9 @@ instruction_grow(
    struct tgsi_instruction *instruction,
    struct tgsi_header *header )
 {
-   assert (instruction->Size <   0xFF);
+   assert (instruction->NrTokens <   0xFF);
 
-   instruction->Size++;
+   instruction->NrTokens++;
 
    header_bodysize_grow( header );
 }
diff --git a/src/gallium/auxiliary/tgsi/tgsi_dump.c b/src/gallium/auxiliary/tgsi/tgsi_dump.c
index 2ed8c2bf07..ab2b1f2c58 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_dump.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_dump.c
@@ -285,7 +285,7 @@ iter_immediate(
    ENM( imm->Immediate.DataType, immediate_type_names );
 
    TXT( " { " );
-   for (i = 0; i < imm->Immediate.Size - 1; i++) {
+   for (i = 0; i < imm->Immediate.NrTokens - 1; i++) {
       switch (imm->Immediate.DataType) {
       case TGSI_IMM_FLOAT32:
          FLT( imm->u.ImmediateFloat32[i].Float );
@@ -294,7 +294,7 @@ iter_immediate(
          assert( 0 );
       }
 
-      if (i < imm->Immediate.Size - 2)
+      if (i < imm->Immediate.NrTokens - 2)
          TXT( ", " );
    }
    TXT( " }" );
diff --git a/src/gallium/auxiliary/tgsi/tgsi_dump_c.c b/src/gallium/auxiliary/tgsi/tgsi_dump_c.c
index c575b6c3e1..2ecf1e2f14 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_dump_c.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_dump_c.c
@@ -283,7 +283,7 @@ dump_immediate_verbose(
       UIX( imm->Immediate.Padding );
    }
 
-   for( i = 0; i < imm->Immediate.Size - 1; i++ ) {
+   for( i = 0; i < imm->Immediate.NrTokens - 1; i++ ) {
       EOL();
       switch( imm->Immediate.DataType ) {
       case TGSI_IMM_FLOAT32:
@@ -675,7 +675,7 @@ tgsi_dump_c(
       ENM( parse.FullToken.Token.Type, TGSI_TOKEN_TYPES );
       if( ignored ) {
          TXT( "\nSize       : " );
-         UID( parse.FullToken.Token.Size );
+         UID( parse.FullToken.Token.NrTokens );
          if( deflt || parse.FullToken.Token.Extended ) {
             TXT( "\nExtended   : " );
             UID( parse.FullToken.Token.Extended );
diff --git a/src/gallium/auxiliary/tgsi/tgsi_exec.c b/src/gallium/auxiliary/tgsi/tgsi_exec.c
index a182e679da..ab641efb60 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_exec.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_exec.c
@@ -202,7 +202,7 @@ tgsi_exec_machine_bind_shader(
 
       case TGSI_TOKEN_TYPE_IMMEDIATE:
          {
-            uint size = parse.FullToken.FullImmediate.Immediate.Size - 1;
+            uint size = parse.FullToken.FullImmediate.Immediate.NrTokens - 1;
             assert( size % 4 == 0 );
             assert( mach->ImmLimit + size / 4 <= TGSI_EXEC_NUM_IMMEDIATES );
 
diff --git a/src/gallium/auxiliary/tgsi/tgsi_parse.c b/src/gallium/auxiliary/tgsi/tgsi_parse.c
index 2cd56e413a..d374b16f9a 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_parse.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_parse.c
@@ -155,8 +155,8 @@ tgsi_parse_token(
       switch (imm->Immediate.DataType) {
       case TGSI_IMM_FLOAT32:
          imm->u.Pointer = MALLOC(
-            sizeof( struct tgsi_immediate_float32 ) * (imm->Immediate.Size - 1) );
-         for( i = 0; i < imm->Immediate.Size - 1; i++ ) {
+            sizeof( struct tgsi_immediate_float32 ) * (imm->Immediate.NrTokens - 1) );
+         for( i = 0; i < imm->Immediate.NrTokens - 1; i++ ) {
             next_token( ctx, (struct tgsi_immediate_float32 *) &imm->u.ImmediateFloat32[i] );
          }
          break;
diff --git a/src/gallium/auxiliary/tgsi/tgsi_ppc.c b/src/gallium/auxiliary/tgsi/tgsi_ppc.c
index 1a4db47501..f365030e52 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_ppc.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_ppc.c
@@ -1327,7 +1327,7 @@ tgsi_emit_ppc(const struct tgsi_token *tokens,
       case TGSI_TOKEN_TYPE_IMMEDIATE:
          /* splat each immediate component into a float[4] vector for SoA */
          {
-            const uint size = parse.FullToken.FullImmediate.Immediate.Size - 1;
+            const uint size = parse.FullToken.FullImmediate.Immediate.NrTokens - 1;
             uint i;
             assert(size <= 4);
             assert(num_immediates < TGSI_EXEC_NUM_IMMEDIATES);
diff --git a/src/gallium/auxiliary/tgsi/tgsi_scan.c b/src/gallium/auxiliary/tgsi/tgsi_scan.c
index d02205a63e..c535788819 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_scan.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_scan.c
@@ -151,7 +151,14 @@ tgsi_scan_shader(const struct tgsi_token *tokens,
          break;
 
       case TGSI_TOKEN_TYPE_IMMEDIATE:
-         info->immediate_count++;
+         {
+            uint reg = info->immediate_count++;
+            uint file = TGSI_FILE_IMMEDIATE;
+
+            info->file_mask[file] |= (1 << reg);
+            info->file_count[file]++;
+            info->file_max[file] = MAX2(info->file_max[file], (int)reg);
+         }
          break;
 
       default:
diff --git a/src/gallium/auxiliary/tgsi/tgsi_sse2.c b/src/gallium/auxiliary/tgsi/tgsi_sse2.c
index cac44af7f4..481ba89c5e 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_sse2.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_sse2.c
@@ -2671,7 +2671,7 @@ tgsi_emit_sse2(
       case TGSI_TOKEN_TYPE_IMMEDIATE:
          /* simply copy the immediate values into the next immediates[] slot */
          {
-            const uint size = parse.FullToken.FullImmediate.Immediate.Size - 1;
+            const uint size = parse.FullToken.FullImmediate.Immediate.NrTokens - 1;
             uint i;
             assert(size <= 4);
             assert(num_immediates < TGSI_EXEC_NUM_IMMEDIATES);
diff --git a/src/gallium/auxiliary/tgsi/tgsi_text.c b/src/gallium/auxiliary/tgsi/tgsi_text.c
index 9454563361..1e822fbbea 100644
--- a/src/gallium/auxiliary/tgsi/tgsi_text.c
+++ b/src/gallium/auxiliary/tgsi/tgsi_text.c
@@ -1023,7 +1023,7 @@ static boolean parse_immediate( struct translate_ctx *ctx )
    ctx->cur++;
 
    imm = tgsi_default_full_immediate();
-   imm.Immediate.Size += 4;
+   imm.Immediate.NrTokens += 4;
    imm.Immediate.DataType = TGSI_IMM_FLOAT32;
    imm.u.Pointer = values;
 
diff --git a/src/gallium/auxiliary/util/u_linear.c b/src/gallium/auxiliary/util/u_linear.c
index a76704ffc7..e999cefe74 100644
--- a/src/gallium/auxiliary/util/u_linear.c
+++ b/src/gallium/auxiliary/util/u_linear.c
@@ -3,13 +3,13 @@
 #include "u_linear.h"
 
 void
-pipe_linear_to_tile(size_t src_stride, void *src_ptr,
+pipe_linear_to_tile(size_t src_stride, const void *src_ptr,
 		    struct pipe_tile_info *t, void *dst_ptr)
 {
    int x, y, z;
    char *ptr;
    size_t bytes = t->cols * t->block.size;
-
+   char *dst_ptr2 = (char *) dst_ptr;
 
    assert(pipe_linear_check_tile(t));
 
@@ -19,20 +19,21 @@ pipe_linear_to_tile(size_t src_stride, void *src_ptr,
 	 /* this inner loop could be replace with SSE magic */
 	 ptr = (char*)src_ptr + src_stride * t->rows * y + bytes * x;
 	 for (z = 0; z < t->rows; z++) {
-	    memcpy(dst_ptr, ptr, bytes);
-	    dst_ptr += bytes;
+	    memcpy(dst_ptr2, ptr, bytes);
+	    dst_ptr2 += bytes;
 	    ptr += src_stride;
 	 }
       }
    }
 }
 
-void pipe_linear_from_tile(struct pipe_tile_info *t, void  *src_ptr,
+void pipe_linear_from_tile(struct pipe_tile_info *t, const void *src_ptr,
 			   size_t dst_stride, void *dst_ptr)
 {
    int x, y, z;
    char *ptr;
    size_t bytes = t->cols * t->block.size;
+   const char *src_ptr2 = (const char *) src_ptr;
 
    /* lets read lineary from the tiled buffer */
    for (y = 0; y < t->tiles_y; y++) {
@@ -40,8 +41,8 @@ void pipe_linear_from_tile(struct pipe_tile_info *t, void  *src_ptr,
 	 /* this inner loop could be replace with SSE magic */
 	 ptr = (char*)dst_ptr + dst_stride * t->rows * y + bytes * x;
 	 for (z = 0; z < t->rows; z++) {
-	    memcpy(ptr, src_ptr, bytes);
-	    src_ptr += bytes;
+	    memcpy(ptr, src_ptr2, bytes);
+	    src_ptr2 += bytes;
 	    ptr += dst_stride;
 	 }
       }
@@ -50,7 +51,7 @@ void pipe_linear_from_tile(struct pipe_tile_info *t, void  *src_ptr,
 
 void
 pipe_linear_fill_info(struct pipe_tile_info *t,
-		      struct pipe_format_block *block,
+		      const struct pipe_format_block *block,
 		      unsigned tile_width, unsigned tile_height,
 		      unsigned tiles_x, unsigned tiles_y)
 {
diff --git a/src/gallium/auxiliary/util/u_linear.h b/src/gallium/auxiliary/util/u_linear.h
index e337cfd770..1589f029bc 100644
--- a/src/gallium/auxiliary/util/u_linear.h
+++ b/src/gallium/auxiliary/util/u_linear.h
@@ -3,6 +3,7 @@
 #define U_LINEAR_H
 
 #include "pipe/p_format.h"
+
 struct pipe_tile_info
 {
    unsigned size;
@@ -23,10 +24,10 @@ struct pipe_tile_info
    struct pipe_format_block block;
 };
 
-void pipe_linear_to_tile(size_t src_stride, void *src_ptr,
+void pipe_linear_to_tile(size_t src_stride, const void *src_ptr,
 			 struct pipe_tile_info *t, void  *dst_ptr);
 
-void pipe_linear_from_tile(struct pipe_tile_info *t, void  *src_ptr,
+void pipe_linear_from_tile(struct pipe_tile_info *t, const void *src_ptr,
 			   size_t dst_stride, void *dst_ptr);
 
 /**
@@ -39,11 +40,11 @@ void pipe_linear_from_tile(struct pipe_tile_info *t, void  *src_ptr,
  * @tiles_y number of tiles in y axis
  */
 void pipe_linear_fill_info(struct pipe_tile_info *t,
-			   struct pipe_format_block *block,
+			   const struct pipe_format_block *block,
 			   unsigned tile_width, unsigned tile_height,
 			   unsigned tiles_x, unsigned tiles_y);
 
-static INLINE boolean pipe_linear_check_tile(struct pipe_tile_info *t)
+static INLINE boolean pipe_linear_check_tile(const struct pipe_tile_info *t)
 {
    if (t->tile.size != t->block.size * t->cols * t->rows)
       return FALSE;