/*
 * This file was generated automatically by ExtUtils::ParseXS version 3.34 from the
 * contents of pogl_gl_Prog_Clam.xs. Do not edit this file, edit pogl_gl_Prog_Clam.xs instead.
 *
 *    ANY CHANGES MADE HERE WILL BE LOST!
 *
 */

#line 1 "pogl_gl_Prog_Clam.xs"
/*  Last saved: Sun 06 Sep 2009 02:10:05 PM */

/*  Copyright (c) 1998 Kenneth Albanowski. All rights reserved.
 *  Copyright (c) 2007 Bob Free. All rights reserved.
 *  Copyright (c) 2009 Chris Marshall. All rights reserved.
 *  This program is free software; you can redistribute it and/or
 *  modify it under the same terms as Perl itself.
 */

/* OpenGL GLX bindings */
#define IN_POGL_GLX_XS

#include <stdio.h>

#include "pgopogl.h"

#ifdef HAVE_GL
#include "gl_util.h"

/* Note: this is caching procs once for all contexts */
/* !!! This should instead cache per context */
#if defined(_WIN32) || (defined(__CYGWIN__) && defined(HAVE_W32API))
#define loadProc(proc,name) \
{ \
  if (!proc) \
  { \
    proc = (void *)wglGetProcAddress(name); \
    if (!proc) croak(name " is not supported by this renderer"); \
  } \
}
#define testProc(proc,name) ((proc) ? 1 : !!(proc = (void *)wglGetProcAddress(name)))
#else /* not using WGL */
#define loadProc(proc,name)
#define testProc(proc,name) 1
#endif /* not defined _WIN32, __CYGWIN__, and HAVE_W32API */
#endif /* defined HAVE_GL */

#ifdef HAVE_GLX
#include "glx_util.h"
#endif /* defined HAVE_GLX */

#ifdef HAVE_GLU
#include "glu_util.h"
#endif /* defined HAVE_GLU */





#line 60 "pogl_gl_Prog_Clam.c"
#ifndef PERL_UNUSED_VAR
#  define PERL_UNUSED_VAR(var) if (0) var = var
#endif

#ifndef dVAR
#  define dVAR		dNOOP
#endif


/* This stuff is not part of the API! You have been warned. */
#ifndef PERL_VERSION_DECIMAL
#  define PERL_VERSION_DECIMAL(r,v,s) (r*1000000 + v*1000 + s)
#endif
#ifndef PERL_DECIMAL_VERSION
#  define PERL_DECIMAL_VERSION \
	  PERL_VERSION_DECIMAL(PERL_REVISION,PERL_VERSION,PERL_SUBVERSION)
#endif
#ifndef PERL_VERSION_GE
#  define PERL_VERSION_GE(r,v,s) \
	  (PERL_DECIMAL_VERSION >= PERL_VERSION_DECIMAL(r,v,s))
#endif
#ifndef PERL_VERSION_LE
#  define PERL_VERSION_LE(r,v,s) \
	  (PERL_DECIMAL_VERSION <= PERL_VERSION_DECIMAL(r,v,s))
#endif

/* XS_INTERNAL is the explicit static-linkage variant of the default
 * XS macro.
 *
 * XS_EXTERNAL is the same as XS_INTERNAL except it does not include
 * "STATIC", ie. it exports XSUB symbols. You probably don't want that
 * for anything but the BOOT XSUB.
 *
 * See XSUB.h in core!
 */


/* TODO: This might be compatible further back than 5.10.0. */
#if PERL_VERSION_GE(5, 10, 0) && PERL_VERSION_LE(5, 15, 1)
#  undef XS_EXTERNAL
#  undef XS_INTERNAL
#  if defined(__CYGWIN__) && defined(USE_DYNAMIC_LOADING)
#    define XS_EXTERNAL(name) __declspec(dllexport) XSPROTO(name)
#    define XS_INTERNAL(name) STATIC XSPROTO(name)
#  endif
#  if defined(__SYMBIAN32__)
#    define XS_EXTERNAL(name) EXPORT_C XSPROTO(name)
#    define XS_INTERNAL(name) EXPORT_C STATIC XSPROTO(name)
#  endif
#  ifndef XS_EXTERNAL
#    if defined(HASATTRIBUTE_UNUSED) && !defined(__cplusplus)
#      define XS_EXTERNAL(name) void name(pTHX_ CV* cv __attribute__unused__)
#      define XS_INTERNAL(name) STATIC void name(pTHX_ CV* cv __attribute__unused__)
#    else
#      ifdef __cplusplus
#        define XS_EXTERNAL(name) extern "C" XSPROTO(name)
#        define XS_INTERNAL(name) static XSPROTO(name)
#      else
#        define XS_EXTERNAL(name) XSPROTO(name)
#        define XS_INTERNAL(name) STATIC XSPROTO(name)
#      endif
#    endif
#  endif
#endif

/* perl >= 5.10.0 && perl <= 5.15.1 */


/* The XS_EXTERNAL macro is used for functions that must not be static
 * like the boot XSUB of a module. If perl didn't have an XS_EXTERNAL
 * macro defined, the best we can do is assume XS is the same.
 * Dito for XS_INTERNAL.
 */
#ifndef XS_EXTERNAL
#  define XS_EXTERNAL(name) XS(name)
#endif
#ifndef XS_INTERNAL
#  define XS_INTERNAL(name) XS(name)
#endif

/* Now, finally, after all this mess, we want an ExtUtils::ParseXS
 * internal macro that we're free to redefine for varying linkage due
 * to the EXPORT_XSUB_SYMBOLS XS keyword. This is internal, use
 * XS_EXTERNAL(name) or XS_INTERNAL(name) in your code if you need to!
 */

#undef XS_EUPXS
#if defined(PERL_EUPXS_ALWAYS_EXPORT)
#  define XS_EUPXS(name) XS_EXTERNAL(name)
#else
   /* default to internal */
#  define XS_EUPXS(name) XS_INTERNAL(name)
#endif

#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE
#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params)

/* prototype to pass -Wmissing-prototypes */
STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params);

STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params)
{
    const GV *const gv = CvGV(cv);

    PERL_ARGS_ASSERT_CROAK_XS_USAGE;

    if (gv) {
        const char *const gvname = GvNAME(gv);
        const HV *const stash = GvSTASH(gv);
        const char *const hvname = stash ? HvNAME(stash) : NULL;

        if (hvname)
	    Perl_croak_nocontext("Usage: %s::%s(%s)", hvname, gvname, params);
        else
	    Perl_croak_nocontext("Usage: %s(%s)", gvname, params);
    } else {
        /* Pants. I don't think that it should be possible to get here. */
	Perl_croak_nocontext("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params);
    }
}
#undef  PERL_ARGS_ASSERT_CROAK_XS_USAGE

#define croak_xs_usage        S_croak_xs_usage

#endif

/* NOTE: the prototype of newXSproto() is different in versions of perls,
 * so we define a portable version of newXSproto()
 */
#ifdef newXS_flags
#define newXSproto_portable(name, c_impl, file, proto) newXS_flags(name, c_impl, file, proto, 0)
#else
#define newXSproto_portable(name, c_impl, file, proto) (PL_Sv=(SV*)newXS(name, c_impl, file), sv_setpv(PL_Sv, proto), (CV*)PL_Sv)
#endif /* !defined(newXS_flags) */

#if PERL_VERSION_LE(5, 21, 5)
#  define newXS_deffile(a,b) Perl_newXS(aTHX_ a,b,file)
#else
#  define newXS_deffile(a,b) Perl_newXS_deffile(aTHX_ a,b)
#endif

#line 204 "pogl_gl_Prog_Clam.c"
#ifdef HAVE_GL
#ifdef GL_ARB_vertex_program
#define XSubPPtmpAAAA 1


XS_EUPXS(XS_OpenGL_glProgramLocalParameter4dARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramLocalParameter4dARB)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "target, index, x, y, z, w");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLuint	index = (unsigned int)SvUV(ST(1))
;
	GLdouble	x = (double)SvNV(ST(2))
;
	GLdouble	y = (double)SvNV(ST(3))
;
	GLdouble	z = (double)SvNV(ST(4))
;
	GLdouble	w = (double)SvNV(ST(5))
;
#line 72 "pogl_gl_Prog_Clam.xs"
		loadProc(glProgramLocalParameter4dARB,"glProgramLocalParameter4dARB");
#line 231 "pogl_gl_Prog_Clam.c"

	glProgramLocalParameter4dARB(target, index, x, y, z, w);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glProgramLocalParameter4dvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramLocalParameter4dvARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, index, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLuint	index = (unsigned int)SvUV(ST(1))
;
	void *	v = INT2PTR(void *,SvIV(ST(2)))
;
#line 81 "pogl_gl_Prog_Clam.xs"
		loadProc(glProgramLocalParameter4dvARB,"glProgramLocalParameter4dvARB");
#line 254 "pogl_gl_Prog_Clam.c"
#line 83 "pogl_gl_Prog_Clam.xs"
		glProgramLocalParameter4dvARB(target,index,(GLdouble*)v);
#line 257 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glProgramLocalParameter4dvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramLocalParameter4dvARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, index, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLuint	index = (unsigned int)SvUV(ST(1))
;
	SV *	v = ST(2)
;
#line 92 "pogl_gl_Prog_Clam.xs"
		loadProc(glProgramLocalParameter4dvARB,"glProgramLocalParameter4dvARB");
#line 278 "pogl_gl_Prog_Clam.c"
#line 94 "pogl_gl_Prog_Clam.xs"
	{
		GLdouble * v_s = EL(v, sizeof(GLdouble)*4);
		glProgramLocalParameter4dvARB(target,index,v_s);
	}
#line 284 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glProgramLocalParameter4dvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramLocalParameter4dvARB_p)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "target, index, x, y, z, w");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLuint	index = (unsigned int)SvUV(ST(1))
;
	GLdouble	x = (double)SvNV(ST(2))
;
	GLdouble	y = (double)SvNV(ST(3))
;
	GLdouble	z = (double)SvNV(ST(4))
;
	GLdouble	w = (double)SvNV(ST(5))
;
#line 110 "pogl_gl_Prog_Clam.xs"
		loadProc(glProgramLocalParameter4dvARB,"glProgramLocalParameter4dvARB");
#line 311 "pogl_gl_Prog_Clam.c"
#line 112 "pogl_gl_Prog_Clam.xs"
	{
		GLdouble param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glProgramLocalParameter4dvARB(target,index,param);
	}
#line 321 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glProgramLocalParameter4fARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramLocalParameter4fARB)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "target, index, x, y, z, w");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLuint	index = (unsigned int)SvUV(ST(1))
;
	GLfloat	x = (float)SvNV(ST(2))
;
	GLfloat	y = (float)SvNV(ST(3))
;
	GLfloat	z = (float)SvNV(ST(4))
;
	GLfloat	w = (float)SvNV(ST(5))
;
#line 131 "pogl_gl_Prog_Clam.xs"
		loadProc(glProgramLocalParameter4fARB,"glProgramLocalParameter4fARB");
#line 348 "pogl_gl_Prog_Clam.c"

	glProgramLocalParameter4fARB(target, index, x, y, z, w);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glProgramLocalParameter4fvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramLocalParameter4fvARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, index, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLuint	index = (unsigned int)SvUV(ST(1))
;
	void *	v = INT2PTR(void *,SvIV(ST(2)))
;
#line 140 "pogl_gl_Prog_Clam.xs"
		loadProc(glProgramLocalParameter4fvARB,"glProgramLocalParameter4fvARB");
#line 371 "pogl_gl_Prog_Clam.c"
#line 142 "pogl_gl_Prog_Clam.xs"
		glProgramLocalParameter4fvARB(target,index,(GLfloat*)v);
#line 374 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glProgramLocalParameter4fvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramLocalParameter4fvARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, index, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLuint	index = (unsigned int)SvUV(ST(1))
;
	SV *	v = ST(2)
;
#line 151 "pogl_gl_Prog_Clam.xs"
		loadProc(glProgramLocalParameter4fvARB,"glProgramLocalParameter4fvARB");
#line 395 "pogl_gl_Prog_Clam.c"
#line 153 "pogl_gl_Prog_Clam.xs"
	{
		GLfloat * v_s = EL(v, sizeof(GLfloat)*4);
		glProgramLocalParameter4fvARB(target,index,v_s);
	}
#line 401 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glProgramLocalParameter4fvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramLocalParameter4fvARB_p)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "target, index, x, y, z, w");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLuint	index = (unsigned int)SvUV(ST(1))
;
	GLfloat	x = (float)SvNV(ST(2))
;
	GLfloat	y = (float)SvNV(ST(3))
;
	GLfloat	z = (float)SvNV(ST(4))
;
	GLfloat	w = (float)SvNV(ST(5))
;
#line 169 "pogl_gl_Prog_Clam.xs"
		loadProc(glProgramLocalParameter4fvARB,"glProgramLocalParameter4fvARB");
#line 428 "pogl_gl_Prog_Clam.c"
#line 171 "pogl_gl_Prog_Clam.xs"
	{
		GLfloat param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glProgramLocalParameter4fvARB(target,index,param);
	}
#line 438 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetProgramEnvParameterdvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramEnvParameterdvARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, index, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	index = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 187 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramEnvParameterdvARB,"glGetProgramEnvParameterdvARB");
#line 459 "pogl_gl_Prog_Clam.c"
#line 189 "pogl_gl_Prog_Clam.xs"
		glGetProgramEnvParameterdvARB(target,index,(GLdouble*)params);
#line 462 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetProgramEnvParameterdvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramEnvParameterdvARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, index, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	index = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 198 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramEnvParameterdvARB,"glGetProgramEnvParameterdvARB");
#line 483 "pogl_gl_Prog_Clam.c"
#line 200 "pogl_gl_Prog_Clam.xs"
	{
		GLdouble * params_s = EL(params, sizeof(GLdouble) * 4);
		glGetProgramEnvParameterdvARB(target,index,params_s);
	}
#line 489 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetProgramEnvParameterdvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramEnvParameterdvARB_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, index");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	index = (int)SvIV(ST(1))
;
#line 211 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramEnvParameterdvARB,"glGetProgramEnvParameterdvARB");
#line 510 "pogl_gl_Prog_Clam.c"
#line 213 "pogl_gl_Prog_Clam.xs"
	{
		GLdouble params[4];
		glGetProgramEnvParameterdvARB(target,index,params);

		EXTEND(sp, 4);
		PUSHs(sv_2mortal(newSVnv(params[0])));
		PUSHs(sv_2mortal(newSVnv(params[1])));
		PUSHs(sv_2mortal(newSVnv(params[2])));
		PUSHs(sv_2mortal(newSVnv(params[3])));
	}
#line 522 "pogl_gl_Prog_Clam.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glGetProgramEnvParameterfvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramEnvParameterfvARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, index, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	index = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 231 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramEnvParameterfvARB,"glGetProgramEnvParameterfvARB");
#line 544 "pogl_gl_Prog_Clam.c"
#line 233 "pogl_gl_Prog_Clam.xs"
		glGetProgramEnvParameterfvARB(target,index,(GLfloat*)params);
#line 547 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetProgramEnvParameterfvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramEnvParameterfvARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, index, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	index = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 242 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramEnvParameterfvARB,"glGetProgramEnvParameterfvARB");
#line 568 "pogl_gl_Prog_Clam.c"
#line 244 "pogl_gl_Prog_Clam.xs"
	{
		GLfloat * params_s = EL(params, sizeof(GLfloat) * 4);
		glGetProgramEnvParameterfvARB(target,index,params_s);
	}
#line 574 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetProgramEnvParameterfvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramEnvParameterfvARB_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, index");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	index = (int)SvIV(ST(1))
;
#line 255 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramEnvParameterfvARB,"glGetProgramEnvParameterfvARB");
#line 595 "pogl_gl_Prog_Clam.c"
#line 257 "pogl_gl_Prog_Clam.xs"
	{
		GLfloat params[4];
		glGetProgramEnvParameterfvARB(target,index,params);

		EXTEND(sp, 4);
		PUSHs(sv_2mortal(newSVnv(params[0])));
		PUSHs(sv_2mortal(newSVnv(params[1])));
		PUSHs(sv_2mortal(newSVnv(params[2])));
		PUSHs(sv_2mortal(newSVnv(params[3])));
	}
#line 607 "pogl_gl_Prog_Clam.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glGetProgramLocalParameterdvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramLocalParameterdvARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, index, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	index = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 275 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramLocalParameterdvARB,"glGetProgramLocalParameterdvARB");
#line 629 "pogl_gl_Prog_Clam.c"
#line 277 "pogl_gl_Prog_Clam.xs"
		glGetProgramLocalParameterdvARB(target,index,(GLdouble*)params);
#line 632 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetProgramLocalParameterdvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramLocalParameterdvARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, index, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	index = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 286 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramLocalParameterdvARB,"glGetProgramLocalParameterdvARB");
#line 653 "pogl_gl_Prog_Clam.c"
#line 288 "pogl_gl_Prog_Clam.xs"
	{
		GLdouble * params_s = EL(params, sizeof(GLdouble) * 4);
		glGetProgramLocalParameterdvARB(target,index,params_s);
	}
#line 659 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetProgramLocalParameterdvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramLocalParameterdvARB_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, index");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	index = (int)SvIV(ST(1))
;
#line 299 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramLocalParameterdvARB,"glGetProgramLocalParameterdvARB");
#line 680 "pogl_gl_Prog_Clam.c"
#line 301 "pogl_gl_Prog_Clam.xs"
	{
		GLdouble params[4];
		glGetProgramLocalParameterdvARB(target,index,params);

		EXTEND(sp, 4);
		PUSHs(sv_2mortal(newSVnv(params[0])));
		PUSHs(sv_2mortal(newSVnv(params[1])));
		PUSHs(sv_2mortal(newSVnv(params[2])));
		PUSHs(sv_2mortal(newSVnv(params[3])));
	}
#line 692 "pogl_gl_Prog_Clam.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glGetProgramLocalParameterfvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramLocalParameterfvARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, index, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	index = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 319 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramLocalParameterfvARB,"glGetProgramLocalParameterfvARB");
#line 714 "pogl_gl_Prog_Clam.c"
#line 321 "pogl_gl_Prog_Clam.xs"
		glGetProgramLocalParameterfvARB(target,index,(GLfloat*)params);
#line 717 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetProgramLocalParameterfvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramLocalParameterfvARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, index, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	index = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 330 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramLocalParameterfvARB,"glGetProgramLocalParameterfvARB");
#line 738 "pogl_gl_Prog_Clam.c"
#line 332 "pogl_gl_Prog_Clam.xs"
	{
		GLfloat * params_s = EL(params, sizeof(GLfloat) * 4);
		glGetProgramLocalParameterfvARB(target,index,params_s);
	}
#line 744 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetProgramLocalParameterfvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramLocalParameterfvARB_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, index");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	index = (int)SvIV(ST(1))
;
#line 343 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramLocalParameterfvARB,"glGetProgramLocalParameterfvARB");
#line 765 "pogl_gl_Prog_Clam.c"
#line 345 "pogl_gl_Prog_Clam.xs"
	{
		GLfloat params[4];
		glGetProgramLocalParameterfvARB(target,index,params);

		EXTEND(sp, 4);
		PUSHs(sv_2mortal(newSVnv(params[0])));
		PUSHs(sv_2mortal(newSVnv(params[1])));
		PUSHs(sv_2mortal(newSVnv(params[2])));
		PUSHs(sv_2mortal(newSVnv(params[3])));
	}
#line 777 "pogl_gl_Prog_Clam.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glGetProgramivARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramivARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, pname, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 363 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramivARB,"glGetProgramivARB");
#line 799 "pogl_gl_Prog_Clam.c"
#line 365 "pogl_gl_Prog_Clam.xs"
		glGetProgramivARB(target,pname,params);
#line 802 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetProgramivARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramivARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, pname, params");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 374 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramivARB,"glGetProgramivARB");
#line 823 "pogl_gl_Prog_Clam.c"
#line 376 "pogl_gl_Prog_Clam.xs"
	{
		GLint * params_s = EL(params, sizeof(GLint)*gl_get_count(pname));
		glGetProgramivARB(target,pname,params_s);
	}
#line 829 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetProgramivARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramivARB_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, pname");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	GLuint	RETVAL;
	dXSTARG;
#line 387 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramivARB,"glGetProgramivARB");
#line 850 "pogl_gl_Prog_Clam.c"
#line 389 "pogl_gl_Prog_Clam.xs"
	{
		GLuint param;
		glGetProgramivARB(target,pname,(void *)&param);
		RETVAL = param;
	}
#line 857 "pogl_gl_Prog_Clam.c"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_OpenGL_glGetProgramStringARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramStringARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, pname, string");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	string = INT2PTR(void *,SvIV(ST(2)))
;
#line 404 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramStringARB,"glGetProgramStringARB");
#line 879 "pogl_gl_Prog_Clam.c"
#line 406 "pogl_gl_Prog_Clam.xs"
		glGetProgramStringARB(target,pname,string);
#line 882 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetProgramStringARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramStringARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "target, pname, string");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	string = ST(2)
;
#line 415 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramivARB,"glGetProgramivARB");
		loadProc(glGetProgramStringARB,"glGetProgramStringARB");
#line 904 "pogl_gl_Prog_Clam.c"
#line 418 "pogl_gl_Prog_Clam.xs"
	{
		GLint len;
		glGetProgramivARB(target,GL_PROGRAM_LENGTH_ARB,(GLvoid *)&len);
		if (len)
		{
			GLubyte * string_s = EL(string, sizeof(GLubyte)*len);
			glGetProgramStringARB(target,pname,string_s);
		}
	}
#line 915 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetProgramStringARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetProgramStringARB_p)
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "target, pname=GL_PROGRAM_STRING_ARB");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	pname;
	SV *	RETVAL;

	if (items < 2)
	    pname = GL_PROGRAM_STRING_ARB;
	else {
	    pname = (int)SvIV(ST(1))
;
	}
#line 435 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetProgramivARB,"glGetProgramivARB");
		loadProc(glGetProgramStringARB,"glGetProgramStringARB");
#line 942 "pogl_gl_Prog_Clam.c"
#line 438 "pogl_gl_Prog_Clam.xs"
	{
		GLint len;
		glGetProgramivARB(target,GL_PROGRAM_LENGTH_ARB,(GLvoid *)&len);
		if (len)
		{
			char * string = malloc(len+1);
			glGetProgramStringARB(target,pname,(GLubyte*)string);
			string[len] = 0;
			if (*string)
				RETVAL = newSVpv(string, 0);
			else
				RETVAL = newSVsv(&PL_sv_undef);

			free(string);
		}
		else
		{
			RETVAL = newSVsv(&PL_sv_undef);
		}
	}
#line 964 "pogl_gl_Prog_Clam.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_OpenGL_glIsProgramARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glIsProgramARB)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "program");
    {
	GLuint	program = (unsigned int)SvUV(ST(0))
;
	GLboolean	RETVAL;
#line 466 "pogl_gl_Prog_Clam.xs"
		loadProc(glIsProgramARB,"glIsProgramARB");
#line 984 "pogl_gl_Prog_Clam.c"
#line 468 "pogl_gl_Prog_Clam.xs"
	{
		RETVAL = glIsProgramARB(program);
	}
#line 989 "pogl_gl_Prog_Clam.c"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}

#endif
#if defined(GL_ARB_vertex_program) || defined(GL_ARB_vertex_shader)
#define XSubPPtmpAAAB 1


XS_EUPXS(XS_OpenGL_glVertexAttrib1dARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib1dARB)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, x");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLdouble	x = (double)SvNV(ST(1))
;
#line 485 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib1dARB,"glVertexAttrib1dARB");
#line 1013 "pogl_gl_Prog_Clam.c"

	glVertexAttrib1dARB(index, x);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib1dvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib1dvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 493 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib1dvARB,"glVertexAttrib1dvARB");
#line 1034 "pogl_gl_Prog_Clam.c"
#line 495 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib1dvARB(index,(GLdouble*)v);
#line 1037 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib1dvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib1dvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 503 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib1dvARB,"glVertexAttrib1dvARB");
#line 1056 "pogl_gl_Prog_Clam.c"
#line 505 "pogl_gl_Prog_Clam.xs"
	{
		GLdouble * v_s = EL(v, sizeof(GLdouble)*1);
		glVertexAttrib1dvARB(index,v_s);
	}
#line 1062 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib1dvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib1dvARB_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, x");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLdouble	x = (double)SvNV(ST(1))
;
#line 517 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib1dvARB,"glVertexAttrib1dvARB");
#line 1081 "pogl_gl_Prog_Clam.c"
#line 519 "pogl_gl_Prog_Clam.xs"
	{
		GLdouble param[1];
		param[0] = x;
		glVertexAttrib1dvARB(index,param);
	}
#line 1088 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib1fARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib1fARB)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, x");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLfloat	x = (float)SvNV(ST(1))
;
#line 531 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib1fARB,"glVertexAttrib1fARB");
#line 1107 "pogl_gl_Prog_Clam.c"

	glVertexAttrib1fARB(index, x);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib1sARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib1sARB)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, x");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLshort	x = (short)SvIV(ST(1))
;
#line 539 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib1sARB,"glVertexAttrib1sARB");
#line 1128 "pogl_gl_Prog_Clam.c"

	glVertexAttrib1sARB(index, x);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib1svARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib1svARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 547 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib1svARB,"glVertexAttrib1svARB");
#line 1149 "pogl_gl_Prog_Clam.c"
#line 549 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib1svARB(index,(GLshort*)v);
#line 1152 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib1svARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib1svARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 557 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib1svARB,"glVertexAttrib1svARB");
#line 1171 "pogl_gl_Prog_Clam.c"
#line 559 "pogl_gl_Prog_Clam.xs"
	{
		GLshort * v_s = EL(v, sizeof(GLshort)*1);
		glVertexAttrib1svARB(index,v_s);
	}
#line 1177 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib1svARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib1svARB_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, x");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLshort	x = (short)SvIV(ST(1))
;
#line 571 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib1svARB,"glVertexAttrib1svARB");
#line 1196 "pogl_gl_Prog_Clam.c"
#line 573 "pogl_gl_Prog_Clam.xs"
	{
		GLshort param[1];
		param[0] = x;
		glVertexAttrib1svARB(index,param);
	}
#line 1203 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib2dARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib2dARB)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "index, x, y");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLdouble	x = (double)SvNV(ST(1))
;
	GLdouble	y = (double)SvNV(ST(2))
;
#line 586 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib2dARB,"glVertexAttrib2dARB");
#line 1224 "pogl_gl_Prog_Clam.c"

	glVertexAttrib2dARB(index, x, y);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib2dvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib2dvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 594 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib2dvARB,"glVertexAttrib2dvARB");
#line 1245 "pogl_gl_Prog_Clam.c"
#line 596 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib2dvARB(index,(GLdouble*)v);
#line 1248 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib2dvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib2dvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 604 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib2dvARB,"glVertexAttrib2dvARB");
#line 1267 "pogl_gl_Prog_Clam.c"
#line 606 "pogl_gl_Prog_Clam.xs"
	{
		GLdouble * v_s = EL(v, sizeof(GLdouble)*2);
		glVertexAttrib2dvARB(index,v_s);
	}
#line 1273 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib2dvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib2dvARB_p)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "index, x, y");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLdouble	x = (double)SvNV(ST(1))
;
	GLdouble	y = (double)SvNV(ST(2))
;
#line 619 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib2dvARB,"glVertexAttrib2dvARB");
#line 1294 "pogl_gl_Prog_Clam.c"
#line 621 "pogl_gl_Prog_Clam.xs"
	{
		GLdouble param[2];
		param[0] = x;
		param[1] = y;
		glVertexAttrib2dvARB(index,param);
	}
#line 1302 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib2fARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib2fARB)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "index, x, y");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLfloat	x = (float)SvNV(ST(1))
;
	GLfloat	y = (float)SvNV(ST(2))
;
#line 635 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib2fARB,"glVertexAttrib2fARB");
#line 1323 "pogl_gl_Prog_Clam.c"

	glVertexAttrib2fARB(index, x, y);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib2sARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib2sARB)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "index, x, y");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLshort	x = (short)SvIV(ST(1))
;
	GLshort	y = (short)SvIV(ST(2))
;
#line 644 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib2sARB,"glVertexAttrib2sARB");
#line 1346 "pogl_gl_Prog_Clam.c"

	glVertexAttrib2sARB(index, x, y);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib2svARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib2svARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 652 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib2svARB,"glVertexAttrib2svARB");
#line 1367 "pogl_gl_Prog_Clam.c"
#line 654 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib2svARB(index,(GLshort*)v);
#line 1370 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib2svARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib2svARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 662 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib2svARB,"glVertexAttrib2svARB");
#line 1389 "pogl_gl_Prog_Clam.c"
#line 664 "pogl_gl_Prog_Clam.xs"
	{
		GLshort * v_s = EL(v, sizeof(GLshort)*2);
		glVertexAttrib2svARB(index,v_s);
	}
#line 1395 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib2svARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib2svARB_p)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "index, x, y");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLshort	x = (short)SvIV(ST(1))
;
	GLshort	y = (short)SvIV(ST(2))
;
#line 677 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib2svARB,"glVertexAttrib2svARB");
#line 1416 "pogl_gl_Prog_Clam.c"
#line 679 "pogl_gl_Prog_Clam.xs"
	{
		GLshort param[2];
		param[0] = x;
		param[1] = y;
		glVertexAttrib2svARB(index,param);
	}
#line 1424 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib3dARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib3dARB)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "index, x, y, z");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLdouble	x = (double)SvNV(ST(1))
;
	GLdouble	y = (double)SvNV(ST(2))
;
	GLdouble	z = (double)SvNV(ST(3))
;
#line 694 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib3dARB,"glVertexAttrib3dARB");
#line 1447 "pogl_gl_Prog_Clam.c"

	glVertexAttrib3dARB(index, x, y, z);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib3dvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib3dvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 702 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib3dvARB,"glVertexAttrib3dvARB");
#line 1468 "pogl_gl_Prog_Clam.c"
#line 704 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib3dvARB(index,(GLdouble*)v);
#line 1471 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib3dvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib3dvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 712 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib3dvARB,"glVertexAttrib3dvARB");
#line 1490 "pogl_gl_Prog_Clam.c"
#line 714 "pogl_gl_Prog_Clam.xs"
	{
		GLdouble * v_s = EL(v, sizeof(GLdouble)*3);
		glVertexAttrib3dvARB(index,v_s);
	}
#line 1496 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib3dvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib3dvARB_p)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "index, x, y, z");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLdouble	x = (double)SvNV(ST(1))
;
	GLdouble	y = (double)SvNV(ST(2))
;
	GLdouble	z = (double)SvNV(ST(3))
;
#line 728 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib3dvARB,"glVertexAttrib3dvARB");
#line 1519 "pogl_gl_Prog_Clam.c"
#line 730 "pogl_gl_Prog_Clam.xs"
	{
		GLdouble param[3];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		glVertexAttrib3dvARB(index,param);
	}
#line 1528 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib3fARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib3fARB)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "index, x, y, z");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLfloat	x = (float)SvNV(ST(1))
;
	GLfloat	y = (float)SvNV(ST(2))
;
	GLfloat	z = (float)SvNV(ST(3))
;
#line 746 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib3fARB,"glVertexAttrib3fARB");
#line 1551 "pogl_gl_Prog_Clam.c"

	glVertexAttrib3fARB(index, x, y, z);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib3fvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib3fvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 754 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib3fvARB,"glVertexAttrib3fvARB");
#line 1572 "pogl_gl_Prog_Clam.c"
#line 756 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib3fvARB(index,(GLfloat*)v);
#line 1575 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib3fvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib3fvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 764 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib3fvARB,"glVertexAttrib3fvARB");
#line 1594 "pogl_gl_Prog_Clam.c"
#line 766 "pogl_gl_Prog_Clam.xs"
	{
		GLfloat * v_s = EL(v, sizeof(GLfloat)*3);
		glVertexAttrib3fvARB(index,v_s);
	}
#line 1600 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib3fvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib3fvARB_p)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "index, x, y, z");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLfloat	x = (float)SvNV(ST(1))
;
	GLfloat	y = (float)SvNV(ST(2))
;
	GLfloat	z = (float)SvNV(ST(3))
;
#line 780 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib3fvARB,"glVertexAttrib3fvARB");
#line 1623 "pogl_gl_Prog_Clam.c"
#line 782 "pogl_gl_Prog_Clam.xs"
	{
		GLfloat param[3];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		glVertexAttrib3fvARB(index,param);
	}
#line 1632 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib3sARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib3sARB)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "index, x, y, z");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLshort	x = (short)SvIV(ST(1))
;
	GLshort	y = (short)SvIV(ST(2))
;
	GLshort	z = (short)SvIV(ST(3))
;
#line 798 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib3sARB,"glVertexAttrib3sARB");
#line 1655 "pogl_gl_Prog_Clam.c"

	glVertexAttrib3sARB(index, x, y, z);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib3svARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib3svARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 806 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib3svARB,"glVertexAttrib3svARB");
#line 1676 "pogl_gl_Prog_Clam.c"
#line 808 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib3svARB(index,(GLshort*)v);
#line 1679 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib3svARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib3svARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 816 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib3svARB,"glVertexAttrib3svARB");
#line 1698 "pogl_gl_Prog_Clam.c"
#line 818 "pogl_gl_Prog_Clam.xs"
	{
		GLshort * v_s = EL(v, sizeof(GLshort)*3);
		glVertexAttrib3svARB(index,v_s);
	}
#line 1704 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib3svARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib3svARB_p)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "index, x, y, z");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLshort	x = (short)SvIV(ST(1))
;
	GLshort	y = (short)SvIV(ST(2))
;
	GLshort	z = (short)SvIV(ST(3))
;
#line 832 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib3svARB,"glVertexAttrib3svARB");
#line 1727 "pogl_gl_Prog_Clam.c"
#line 834 "pogl_gl_Prog_Clam.xs"
	{
		GLshort param[3];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		glVertexAttrib3svARB(index,param);
	}
#line 1736 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NbvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NbvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 848 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NbvARB,"glVertexAttrib4NbvARB");
#line 1755 "pogl_gl_Prog_Clam.c"
#line 850 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib4NbvARB(index,(GLbyte*)v);
#line 1758 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NbvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NbvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 858 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NbvARB,"glVertexAttrib4NbvARB");
#line 1777 "pogl_gl_Prog_Clam.c"
#line 860 "pogl_gl_Prog_Clam.xs"
	{
		GLbyte * v_s = EL(v, sizeof(GLbyte)*4);
		glVertexAttrib4NbvARB(index,v_s);
	}
#line 1783 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NbvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NbvARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLbyte	x = (int)SvIV(ST(1))
;
	GLbyte	y = (int)SvIV(ST(2))
;
	GLbyte	z = (int)SvIV(ST(3))
;
	GLbyte	w = (int)SvIV(ST(4))
;
#line 874 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NbvARB,"glVertexAttrib4NbvARB");
#line 1808 "pogl_gl_Prog_Clam.c"
#line 876 "pogl_gl_Prog_Clam.xs"
	{
		GLbyte param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glVertexAttrib4NbvARB(index,param);
	}
#line 1818 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NivARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NivARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 891 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NivARB,"glVertexAttrib4NivARB");
#line 1837 "pogl_gl_Prog_Clam.c"
#line 893 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib4NivARB(index,(GLint*)v);
#line 1840 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NivARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NivARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 901 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NivARB,"glVertexAttrib4NivARB");
#line 1859 "pogl_gl_Prog_Clam.c"
#line 903 "pogl_gl_Prog_Clam.xs"
	{
		GLint * v_s = EL(v, sizeof(GLint)*4);
		glVertexAttrib4NivARB(index,v_s);
	}
#line 1865 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NivARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NivARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLint	x = (int)SvIV(ST(1))
;
	GLint	y = (int)SvIV(ST(2))
;
	GLint	z = (int)SvIV(ST(3))
;
	GLint	w = (int)SvIV(ST(4))
;
#line 917 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NivARB,"glVertexAttrib4NivARB");
#line 1890 "pogl_gl_Prog_Clam.c"
#line 919 "pogl_gl_Prog_Clam.xs"
	{
		GLint param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glVertexAttrib4NivARB(index,param);
	}
#line 1900 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NsvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NsvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 934 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NsvARB,"glVertexAttrib4NsvARB");
#line 1919 "pogl_gl_Prog_Clam.c"
#line 936 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib4NsvARB(index,(GLshort*)v);
#line 1922 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NsvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NsvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 944 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NsvARB,"glVertexAttrib4NsvARB");
#line 1941 "pogl_gl_Prog_Clam.c"
#line 946 "pogl_gl_Prog_Clam.xs"
	{
		GLshort * v_s = EL(v, sizeof(GLshort)*4);
		glVertexAttrib4NsvARB(index,v_s);
	}
#line 1947 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NsvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NsvARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLshort	x = (short)SvIV(ST(1))
;
	GLshort	y = (short)SvIV(ST(2))
;
	GLshort	z = (short)SvIV(ST(3))
;
	GLshort	w = (short)SvIV(ST(4))
;
#line 960 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NsvARB,"glVertexAttrib4NsvARB");
#line 1972 "pogl_gl_Prog_Clam.c"
#line 962 "pogl_gl_Prog_Clam.xs"
	{
		GLshort param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glVertexAttrib4NsvARB(index,param);
	}
#line 1982 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NubARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NubARB)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLubyte	x = (unsigned int)SvUV(ST(1))
;
	GLubyte	y = (unsigned int)SvUV(ST(2))
;
	GLubyte	z = (unsigned int)SvUV(ST(3))
;
	GLubyte	w = (unsigned int)SvUV(ST(4))
;
#line 980 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NubARB,"glVertexAttrib4NubARB");
#line 2007 "pogl_gl_Prog_Clam.c"

	glVertexAttrib4NubARB(index, x, y, z, w);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NubvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NubvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 988 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NubvARB,"glVertexAttrib4NubvARB");
#line 2028 "pogl_gl_Prog_Clam.c"
#line 990 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib4NubvARB(index,(GLubyte*)v);
#line 2031 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NubvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NubvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 998 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NubvARB,"glVertexAttrib4NubvARB");
#line 2050 "pogl_gl_Prog_Clam.c"
#line 1000 "pogl_gl_Prog_Clam.xs"
	{
		GLubyte * v_s = EL(v, sizeof(GLubyte)*4);
		glVertexAttrib4NubvARB(index,v_s);
	}
#line 2056 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NubvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NubvARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLubyte	x = (unsigned int)SvUV(ST(1))
;
	GLubyte	y = (unsigned int)SvUV(ST(2))
;
	GLubyte	z = (unsigned int)SvUV(ST(3))
;
	GLubyte	w = (unsigned int)SvUV(ST(4))
;
#line 1014 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NubvARB,"glVertexAttrib4NubvARB");
#line 2081 "pogl_gl_Prog_Clam.c"
#line 1016 "pogl_gl_Prog_Clam.xs"
	{
		GLubyte param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glVertexAttrib4NubvARB(index,param);
	}
#line 2091 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NuivARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NuivARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 1031 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NuivARB,"glVertexAttrib4NuivARB");
#line 2110 "pogl_gl_Prog_Clam.c"
#line 1033 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib4NuivARB(index,(GLuint*)v);
#line 2113 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NuivARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NuivARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 1041 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NuivARB,"glVertexAttrib4NuivARB");
#line 2132 "pogl_gl_Prog_Clam.c"
#line 1043 "pogl_gl_Prog_Clam.xs"
	{
		GLuint * v_s = EL(v, sizeof(GLuint)*4);
		glVertexAttrib4NuivARB(index,v_s);
	}
#line 2138 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NuivARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NuivARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLuint	x = (unsigned int)SvUV(ST(1))
;
	GLuint	y = (unsigned int)SvUV(ST(2))
;
	GLuint	z = (unsigned int)SvUV(ST(3))
;
	GLuint	w = (unsigned int)SvUV(ST(4))
;
#line 1057 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NuivARB,"glVertexAttrib4NuivARB");
#line 2163 "pogl_gl_Prog_Clam.c"
#line 1059 "pogl_gl_Prog_Clam.xs"
	{
		GLuint param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glVertexAttrib4NuivARB(index,param);
	}
#line 2173 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NusvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NusvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 1074 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NusvARB,"glVertexAttrib4NusvARB");
#line 2192 "pogl_gl_Prog_Clam.c"
#line 1076 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib4NusvARB(index,(GLushort*)v);
#line 2195 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NusvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NusvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 1084 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NusvARB,"glVertexAttrib4NusvARB");
#line 2214 "pogl_gl_Prog_Clam.c"
#line 1086 "pogl_gl_Prog_Clam.xs"
	{
		GLushort * v_s = EL(v, sizeof(GLushort)*4);
		glVertexAttrib4NusvARB(index,v_s);
	}
#line 2220 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4NusvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4NusvARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLushort	x = (unsigned short)SvUV(ST(1))
;
	GLushort	y = (unsigned short)SvUV(ST(2))
;
	GLushort	z = (unsigned short)SvUV(ST(3))
;
	GLushort	w = (unsigned short)SvUV(ST(4))
;
#line 1100 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4NusvARB,"glVertexAttrib4NusvARB");
#line 2245 "pogl_gl_Prog_Clam.c"
#line 1102 "pogl_gl_Prog_Clam.xs"
	{
		GLushort param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glVertexAttrib4NusvARB(index,param);
	}
#line 2255 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4bvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4bvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 1117 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4bvARB,"glVertexAttrib4bvARB");
#line 2274 "pogl_gl_Prog_Clam.c"
#line 1119 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib4bvARB(index,(GLbyte*)v);
#line 2277 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4bvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4bvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 1127 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4bvARB,"glVertexAttrib4bvARB");
#line 2296 "pogl_gl_Prog_Clam.c"
#line 1129 "pogl_gl_Prog_Clam.xs"
	{
		GLbyte * v_s = EL(v, sizeof(GLbyte)*4);
		glVertexAttrib4bvARB(index,v_s);
	}
#line 2302 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4bvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4bvARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLbyte	x = (int)SvIV(ST(1))
;
	GLbyte	y = (int)SvIV(ST(2))
;
	GLbyte	z = (int)SvIV(ST(3))
;
	GLbyte	w = (int)SvIV(ST(4))
;
#line 1143 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4bvARB,"glVertexAttrib4bvARB");
#line 2327 "pogl_gl_Prog_Clam.c"
#line 1145 "pogl_gl_Prog_Clam.xs"
	{
		GLbyte param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glVertexAttrib4bvARB(index,param);
	}
#line 2337 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4dARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4dARB)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLdouble	x = (double)SvNV(ST(1))
;
	GLdouble	y = (double)SvNV(ST(2))
;
	GLdouble	z = (double)SvNV(ST(3))
;
	GLdouble	w = (double)SvNV(ST(4))
;
#line 1163 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4dARB,"glVertexAttrib4dARB");
#line 2362 "pogl_gl_Prog_Clam.c"

	glVertexAttrib4dARB(index, x, y, z, w);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4dvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4dvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 1171 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4dvARB,"glVertexAttrib4dvARB");
#line 2383 "pogl_gl_Prog_Clam.c"
#line 1173 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib4dvARB(index,(GLdouble*)v);
#line 2386 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4dvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4dvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 1181 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4dvARB,"glVertexAttrib4dvARB");
#line 2405 "pogl_gl_Prog_Clam.c"
#line 1183 "pogl_gl_Prog_Clam.xs"
	{
		GLdouble * v_s = EL(v, sizeof(GLdouble)*4);
		glVertexAttrib4dvARB(index,v_s);
	}
#line 2411 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4dvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4dvARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLdouble	x = (double)SvNV(ST(1))
;
	GLdouble	y = (double)SvNV(ST(2))
;
	GLdouble	z = (double)SvNV(ST(3))
;
	GLdouble	w = (double)SvNV(ST(4))
;
#line 1198 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4dvARB,"glVertexAttrib4dvARB");
#line 2436 "pogl_gl_Prog_Clam.c"
#line 1200 "pogl_gl_Prog_Clam.xs"
	{
		GLdouble param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glVertexAttrib4dvARB(index,param);
	}
#line 2446 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4fARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4fARB)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLfloat	x = (float)SvNV(ST(1))
;
	GLfloat	y = (float)SvNV(ST(2))
;
	GLfloat	z = (float)SvNV(ST(3))
;
	GLfloat	w = (float)SvNV(ST(4))
;
#line 1218 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4fARB,"glVertexAttrib4fARB");
#line 2471 "pogl_gl_Prog_Clam.c"

	glVertexAttrib4fARB(index, x, y, z, w);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4fvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4fvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 1226 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4fvARB,"glVertexAttrib4fvARB");
#line 2492 "pogl_gl_Prog_Clam.c"
#line 1228 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib4fvARB(index,(GLfloat*)v);
#line 2495 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4fvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4fvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 1236 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4fvARB,"glVertexAttrib4fvARB");
#line 2514 "pogl_gl_Prog_Clam.c"
#line 1238 "pogl_gl_Prog_Clam.xs"
	{
		GLfloat * v_s = EL(v, sizeof(GLfloat)*4);
		glVertexAttrib4fvARB(index,v_s);
	}
#line 2520 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4fvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4fvARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLfloat	x = (float)SvNV(ST(1))
;
	GLfloat	y = (float)SvNV(ST(2))
;
	GLfloat	z = (float)SvNV(ST(3))
;
	GLfloat	w = (float)SvNV(ST(4))
;
#line 1253 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4fvARB,"glVertexAttrib4fvARB");
#line 2545 "pogl_gl_Prog_Clam.c"
#line 1255 "pogl_gl_Prog_Clam.xs"
	{
		GLfloat param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glVertexAttrib4fvARB(index,param);
	}
#line 2555 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4ivARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4ivARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 1270 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4ivARB,"glVertexAttrib4ivARB");
#line 2574 "pogl_gl_Prog_Clam.c"
#line 1272 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib4ivARB(index,(GLint*)v);
#line 2577 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4ivARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4ivARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 1280 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4ivARB,"glVertexAttrib4ivARB");
#line 2596 "pogl_gl_Prog_Clam.c"
#line 1282 "pogl_gl_Prog_Clam.xs"
	{
		GLint * v_s = EL(v, sizeof(GLint)*4);
		glVertexAttrib4ivARB(index,v_s);
	}
#line 2602 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4ivARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4ivARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLint	x = (int)SvIV(ST(1))
;
	GLint	y = (int)SvIV(ST(2))
;
	GLint	z = (int)SvIV(ST(3))
;
	GLint	w = (int)SvIV(ST(4))
;
#line 1296 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4ivARB,"glVertexAttrib4ivARB");
#line 2627 "pogl_gl_Prog_Clam.c"
#line 1298 "pogl_gl_Prog_Clam.xs"
	{
		GLint param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glVertexAttrib4ivARB(index,param);
	}
#line 2637 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4sARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4sARB)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLshort	x = (short)SvIV(ST(1))
;
	GLshort	y = (short)SvIV(ST(2))
;
	GLshort	z = (short)SvIV(ST(3))
;
	GLshort	w = (short)SvIV(ST(4))
;
#line 1316 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4sARB,"glVertexAttrib4sARB");
#line 2662 "pogl_gl_Prog_Clam.c"

	glVertexAttrib4sARB(index, x, y, z, w);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4svARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4svARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 1324 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4svARB,"glVertexAttrib4svARB");
#line 2683 "pogl_gl_Prog_Clam.c"
#line 1326 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib4svARB(index,(GLshort*)v);
#line 2686 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4svARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4svARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 1334 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4svARB,"glVertexAttrib4svARB");
#line 2705 "pogl_gl_Prog_Clam.c"
#line 1336 "pogl_gl_Prog_Clam.xs"
	{
		GLshort * v_s = EL(v, sizeof(GLshort)*4);
		glVertexAttrib4svARB(index,v_s);
	}
#line 2711 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4svARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4svARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLshort	x = (short)SvIV(ST(1))
;
	GLshort	y = (short)SvIV(ST(2))
;
	GLshort	z = (short)SvIV(ST(3))
;
	GLshort	w = (short)SvIV(ST(4))
;
#line 1351 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4svARB,"glVertexAttrib4svARB");
#line 2736 "pogl_gl_Prog_Clam.c"
#line 1353 "pogl_gl_Prog_Clam.xs"
	{
		GLshort param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glVertexAttrib4svARB(index,param);
	}
#line 2746 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4ubvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4ubvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 1368 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4ubvARB,"glVertexAttrib4ubvARB");
#line 2765 "pogl_gl_Prog_Clam.c"
#line 1370 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib4ubvARB(index,(GLubyte*)v);
#line 2768 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4ubvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4ubvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 1378 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4ubvARB,"glVertexAttrib4ubvARB");
#line 2787 "pogl_gl_Prog_Clam.c"
#line 1380 "pogl_gl_Prog_Clam.xs"
	{
		GLubyte * v_s = EL(v, sizeof(GLubyte)*4);
		glVertexAttrib4ubvARB(index,v_s);
	}
#line 2793 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4ubvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4ubvARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLubyte	x = (unsigned int)SvUV(ST(1))
;
	GLubyte	y = (unsigned int)SvUV(ST(2))
;
	GLubyte	z = (unsigned int)SvUV(ST(3))
;
	GLubyte	w = (unsigned int)SvUV(ST(4))
;
#line 1394 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4ubvARB,"glVertexAttrib4ubvARB");
#line 2818 "pogl_gl_Prog_Clam.c"
#line 1396 "pogl_gl_Prog_Clam.xs"
	{
		GLubyte param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glVertexAttrib4ubvARB(index,param);
	}
#line 2828 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4uivARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4uivARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 1411 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4uivARB,"glVertexAttrib4uivARB");
#line 2847 "pogl_gl_Prog_Clam.c"
#line 1413 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib4uivARB(index,(GLuint*)v);
#line 2850 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4uivARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4uivARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 1421 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4uivARB,"glVertexAttrib4uivARB");
#line 2869 "pogl_gl_Prog_Clam.c"
#line 1423 "pogl_gl_Prog_Clam.xs"
	{
		GLuint * v_s = EL(v, sizeof(GLuint)*4);
		glVertexAttrib4uivARB(index,v_s);
	}
#line 2875 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4uivARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4uivARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLuint	x = (unsigned int)SvUV(ST(1))
;
	GLuint	y = (unsigned int)SvUV(ST(2))
;
	GLuint	z = (unsigned int)SvUV(ST(3))
;
	GLuint	w = (unsigned int)SvUV(ST(4))
;
#line 1437 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4uivARB,"glVertexAttrib4uivARB");
#line 2900 "pogl_gl_Prog_Clam.c"
#line 1439 "pogl_gl_Prog_Clam.xs"
	{
		GLuint param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glVertexAttrib4uivARB(index,param);
	}
#line 2910 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4usvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4usvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 1454 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4usvARB,"glVertexAttrib4usvARB");
#line 2929 "pogl_gl_Prog_Clam.c"
#line 1456 "pogl_gl_Prog_Clam.xs"
		glVertexAttrib4usvARB(index,(GLushort*)v);
#line 2932 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4usvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4usvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, v");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	SV *	v = ST(1)
;
#line 1464 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4usvARB,"glVertexAttrib4usvARB");
#line 2951 "pogl_gl_Prog_Clam.c"
#line 1466 "pogl_gl_Prog_Clam.xs"
	{
		GLushort * v_s = EL(v, sizeof(GLushort)*4);
		glVertexAttrib4usvARB(index,v_s);
	}
#line 2957 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttrib4usvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttrib4usvARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "index, x, y, z, w");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLushort	x = (unsigned short)SvUV(ST(1))
;
	GLushort	y = (unsigned short)SvUV(ST(2))
;
	GLushort	z = (unsigned short)SvUV(ST(3))
;
	GLushort	w = (unsigned short)SvUV(ST(4))
;
#line 1480 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttrib4usvARB,"glVertexAttrib4usvARB");
#line 2982 "pogl_gl_Prog_Clam.c"
#line 1482 "pogl_gl_Prog_Clam.xs"
	{
		GLushort param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glVertexAttrib4usvARB(index,param);
	}
#line 2992 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttribPointerARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttribPointerARB_c)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "index, size, type, normalized, stride, pointer");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLint	size = (int)SvIV(ST(1))
;
	GLenum	type = (int)SvIV(ST(2))
;
	GLboolean	normalized = (bool)SvTRUE(ST(3))
;
	GLsizei	stride = (int)SvIV(ST(4))
;
	void *	pointer = INT2PTR(void *,SvIV(ST(5)))
;
#line 1501 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttribPointerARB,"glVertexAttribPointerARB");
#line 3019 "pogl_gl_Prog_Clam.c"
#line 1503 "pogl_gl_Prog_Clam.xs"
		glVertexAttribPointerARB(index,size,type,
			normalized,stride,pointer);
#line 3023 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glVertexAttribPointerARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glVertexAttribPointerARB_p)
{
    dVAR; dXSARGS;
    if (items < 4)
       croak_xs_usage(cv,  "index, type, normalized, stride, ...");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLenum	type = (int)SvIV(ST(1))
;
	GLboolean	normalized = (bool)SvTRUE(ST(2))
;
	GLsizei	stride = (int)SvIV(ST(3))
;
#line 1514 "pogl_gl_Prog_Clam.xs"
		loadProc(glVertexAttribPointerARB,"glVertexAttribPointerARB");
#line 3046 "pogl_gl_Prog_Clam.c"
#line 1516 "pogl_gl_Prog_Clam.xs"
	{
		GLuint count = items - 4;
		GLuint size = gl_type_size(type);
		void * pointer = malloc(count * size);

		SvItems(type,4,count,pointer);

		glVertexAttribPointerARB(index,count,type,
			normalized,stride,pointer);

		free(pointer);
	}
#line 3060 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glEnableVertexAttribArrayARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glEnableVertexAttribArrayARB)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "index");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
#line 1534 "pogl_gl_Prog_Clam.xs"
		loadProc(glEnableVertexAttribArrayARB,"glEnableVertexAttribArrayARB");
#line 3077 "pogl_gl_Prog_Clam.c"

	glEnableVertexAttribArrayARB(index);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glDisableVertexAttribArrayARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glDisableVertexAttribArrayARB)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "index");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
#line 1541 "pogl_gl_Prog_Clam.xs"
		loadProc(glDisableVertexAttribArrayARB,"glDisableVertexAttribArrayARB");
#line 3096 "pogl_gl_Prog_Clam.c"

	glDisableVertexAttribArrayARB(index);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetVertexAttribdvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetVertexAttribdvARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "index, pname, params");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 1550 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetVertexAttribdvARB,"glGetVertexAttribdvARB");
#line 3119 "pogl_gl_Prog_Clam.c"
#line 1552 "pogl_gl_Prog_Clam.xs"
		glGetVertexAttribdvARB(index,pname,(GLdouble*)params);
#line 3122 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetVertexAttribdvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetVertexAttribdvARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "index, pname, params");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 1561 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetVertexAttribdvARB,"glGetVertexAttribdvARB");
#line 3143 "pogl_gl_Prog_Clam.c"
#line 1563 "pogl_gl_Prog_Clam.xs"
	{
		GLdouble * params_s = EL(params, sizeof(GLdouble) * 4);
		glGetVertexAttribdvARB(index,pname,params_s);
	}
#line 3149 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetVertexAttribdvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetVertexAttribdvARB_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, pname");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	GLdouble	RETVAL;
	dXSTARG;
#line 1574 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetVertexAttribdvARB,"glGetVertexAttribdvARB");
#line 3170 "pogl_gl_Prog_Clam.c"
#line 1576 "pogl_gl_Prog_Clam.xs"
	{
		GLdouble param;
		glGetVertexAttribdvARB(index,pname,(void *)&param);
		RETVAL = param;
	}
#line 3177 "pogl_gl_Prog_Clam.c"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_OpenGL_glGetVertexAttribfvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetVertexAttribfvARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "index, pname, params");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 1591 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetVertexAttribfvARB,"glGetVertexAttribfvARB");
#line 3199 "pogl_gl_Prog_Clam.c"
#line 1593 "pogl_gl_Prog_Clam.xs"
		glGetVertexAttribfvARB(index,pname,(GLfloat*)params);
#line 3202 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetVertexAttribfvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetVertexAttribfvARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "index, pname, params");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 1602 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetVertexAttribfvARB,"glGetVertexAttribfvARB");
#line 3223 "pogl_gl_Prog_Clam.c"
#line 1604 "pogl_gl_Prog_Clam.xs"
	{
		GLfloat * params_s = EL(params, sizeof(GLfloat) * 4);
		glGetVertexAttribfvARB(index,pname,params_s);
	}
#line 3229 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetVertexAttribfvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetVertexAttribfvARB_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, pname");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	GLfloat	RETVAL;
	dXSTARG;
#line 1615 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetVertexAttribfvARB,"glGetVertexAttribfvARB");
#line 3250 "pogl_gl_Prog_Clam.c"
#line 1617 "pogl_gl_Prog_Clam.xs"
	{
		GLfloat param;
		glGetVertexAttribfvARB(index,pname,(void *)&param);
		RETVAL = param;
	}
#line 3257 "pogl_gl_Prog_Clam.c"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_OpenGL_glGetVertexAttribivARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetVertexAttribivARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "index, pname, params");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 1632 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetVertexAttribivARB,"glGetVertexAttribivARB");
#line 3279 "pogl_gl_Prog_Clam.c"
#line 1634 "pogl_gl_Prog_Clam.xs"
		glGetVertexAttribivARB(index,pname,(GLint*)params);
#line 3282 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetVertexAttribivARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetVertexAttribivARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "index, pname, params");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 1643 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetVertexAttribivARB,"glGetVertexAttribivARB");
#line 3303 "pogl_gl_Prog_Clam.c"
#line 1645 "pogl_gl_Prog_Clam.xs"
	{
		GLint * params_s = EL(params, sizeof(GLint) * 4);
		glGetVertexAttribivARB(index,pname,params_s);
	}
#line 3309 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetVertexAttribivARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetVertexAttribivARB_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, pname");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	GLuint	RETVAL;
	dXSTARG;
#line 1656 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetVertexAttribivARB,"glGetVertexAttribivARB");
#line 3330 "pogl_gl_Prog_Clam.c"
#line 1658 "pogl_gl_Prog_Clam.xs"
	{
		GLuint param;
		glGetVertexAttribivARB(index,pname,(void *)&param);
		RETVAL = param;
	}
#line 3337 "pogl_gl_Prog_Clam.c"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_OpenGL_glGetVertexAttribPointervARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetVertexAttribPointervARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "index, pname, pointer");
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	pointer = INT2PTR(void *,SvIV(ST(2)))
;
#line 1673 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetVertexAttribPointervARB,"glGetVertexAttribPointervARB");
#line 3359 "pogl_gl_Prog_Clam.c"
#line 1675 "pogl_gl_Prog_Clam.xs"
		glGetVertexAttribPointervARB(index,pname,pointer);
#line 3362 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetVertexAttribPointervARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetVertexAttribPointervARB_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "index, pname");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLuint	index = (unsigned int)SvUV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
#line 1683 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetVertexAttribPointervARB,"glGetVertexAttribPointervARB");
		loadProc(glGetVertexAttribivARB,"glGetVertexAttribivARB");
#line 3384 "pogl_gl_Prog_Clam.c"
#line 1686 "pogl_gl_Prog_Clam.xs"
	{
		void * pointer;
		GLuint i,count,type;

		glGetVertexAttribPointervARB(index,pname,&pointer);

		glGetVertexAttribivARB(index,GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB,(void *)&count);
		glGetVertexAttribivARB(index,GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB,(void *)&type);

		EXTEND(sp, count);

		switch (type)
		{
#ifdef GL_VERSION_1_2
			case GL_UNSIGNED_BYTE_3_3_2:
			case GL_UNSIGNED_BYTE_2_3_3_REV:
				for (i=0;i<count;i++)
				{
				  PUSHs(sv_2mortal(newSViv(((GLubyte*)pointer)[i])));
				}
				break;
			case GL_UNSIGNED_SHORT_5_6_5:
			case GL_UNSIGNED_SHORT_5_6_5_REV:
			case GL_UNSIGNED_SHORT_4_4_4_4:
			case GL_UNSIGNED_SHORT_4_4_4_4_REV:
			case GL_UNSIGNED_SHORT_5_5_5_1:
			case GL_UNSIGNED_SHORT_1_5_5_5_REV:
				for (i=0;i<count;i++)
				{
				  PUSHs(sv_2mortal(newSViv(((GLushort*)pointer)[i])));
				}
				break;
			case GL_UNSIGNED_INT_8_8_8_8:
			case GL_UNSIGNED_INT_8_8_8_8_REV:
			case GL_UNSIGNED_INT_10_10_10_2:
			case GL_UNSIGNED_INT_2_10_10_10_REV:
				for (i=0;i<count;i++)
				{
				  PUSHs(sv_2mortal(newSViv(((GLuint*)pointer)[i])));
				}
				break;
#endif
			case GL_UNSIGNED_BYTE:
			case GL_BITMAP:
				for (i=0;i<count;i++)
				{
				  PUSHs(sv_2mortal(newSViv(((GLubyte*)pointer)[i])));
				}
				break;
			case GL_BYTE:
				for (i=0;i<count;i++)
				{
				  PUSHs(sv_2mortal(newSViv(((GLbyte*)pointer)[i])));
				}
				break;
			case GL_UNSIGNED_SHORT:
				for (i=0;i<count;i++)
				{
				  PUSHs(sv_2mortal(newSViv(((GLushort*)pointer)[i])));
				}
				break;
			case GL_SHORT:
				for (i=0;i<count;i++)
				{
				  PUSHs(sv_2mortal(newSViv(((GLushort*)pointer)[i])));
				}
				break;
			case GL_UNSIGNED_INT:
				for (i=0;i<count;i++)
				{
				  PUSHs(sv_2mortal(newSViv(((GLuint*)pointer)[i])));
				}
				break;
			case GL_INT:
				for (i=0;i<count;i++)
				{
				  PUSHs(sv_2mortal(newSViv(((GLint*)pointer)[i])));
				}
				break;
			case GL_FLOAT: 
				for (i=0;i<count;i++)
				{
				  PUSHs(sv_2mortal(newSVnv(((GLfloat*)pointer)[i])));
				}
				break;
			case GL_DOUBLE: 
				for (i=0;i<count;i++)
				{
				  PUSHs(sv_2mortal(newSVnv(((GLdouble*)pointer)[i])));
				}
				break;
			default:
				croak("unknown type");
		}
	}
#line 3481 "pogl_gl_Prog_Clam.c"
	PUTBACK;
	return;
    }
}

#endif
#ifdef GL_ARB_vertex_shader
#define XSubPPtmpAAAC 1


XS_EUPXS(XS_OpenGL_glBindAttribLocationARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glBindAttribLocationARB)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "programObj, index, name");
    {
	GLhandleARB	programObj = (unsigned int)SvUV(ST(0))
;
	GLuint	index = (unsigned int)SvUV(ST(1))
;
	void *	name = INT2PTR(void *,SvIV(ST(2)))
;
#line 1794 "pogl_gl_Prog_Clam.xs"
		loadProc(glBindAttribLocationARB,"glBindAttribLocationARB");
#line 3507 "pogl_gl_Prog_Clam.c"
#line 1796 "pogl_gl_Prog_Clam.xs"
		glBindAttribLocationARB(programObj,index,name);
#line 3510 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetActiveAttribARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetActiveAttribARB_c)
{
    dVAR; dXSARGS;
    if (items != 7)
       croak_xs_usage(cv,  "programObj, index, maxLength, length, size, type, name");
    {
	GLhandleARB	programObj = (unsigned int)SvUV(ST(0))
;
	GLuint	index = (unsigned int)SvUV(ST(1))
;
	GLsizei	maxLength = (int)SvIV(ST(2))
;
	void *	length = INT2PTR(void *,SvIV(ST(3)))
;
	void *	size = INT2PTR(void *,SvIV(ST(4)))
;
	void *	type = INT2PTR(void *,SvIV(ST(5)))
;
	void *	name = INT2PTR(void *,SvIV(ST(6)))
;
#line 1809 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetActiveAttribARB,"glGetActiveAttribARB");
#line 3539 "pogl_gl_Prog_Clam.c"
#line 1811 "pogl_gl_Prog_Clam.xs"
		glGetActiveAttribARB(programObj,index,maxLength,length,size,type,name);
#line 3542 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetActiveAttribARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetActiveAttribARB_s)
{
    dVAR; dXSARGS;
    if (items != 7)
       croak_xs_usage(cv,  "programObj, index, maxLength, length, size, type, name");
    {
	GLhandleARB	programObj = (unsigned int)SvUV(ST(0))
;
	GLuint	index = (unsigned int)SvUV(ST(1))
;
	GLsizei	maxLength = (int)SvIV(ST(2))
;
	SV *	length = ST(3)
;
	SV *	size = ST(4)
;
	SV *	type = ST(5)
;
	SV *	name = ST(6)
;
#line 1824 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetActiveAttribARB,"glGetActiveAttribARB");
#line 3571 "pogl_gl_Prog_Clam.c"
#line 1826 "pogl_gl_Prog_Clam.xs"
	{
		GLsizei	  *length_s = EL(length, sizeof(GLsizei));
		GLint	  *size_s = EL(size, sizeof(GLint));
		GLenum	  *type_s = EL(type, sizeof(GLenum));
		GLcharARB *name_s = EL(name, sizeof(GLcharARB));
		glGetActiveAttribARB(programObj,index,maxLength,length_s,size_s,type_s,name_s);
	}
#line 3580 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetActiveAttribARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetActiveAttribARB_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "programObj, index");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLhandleARB	programObj = (unsigned int)SvUV(ST(0))
;
	GLuint	index = (unsigned int)SvUV(ST(1))
;
#line 1840 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetObjectParameterivARB,"glGetObjectParameterivARB");
		loadProc(glGetActiveAttribARB,"glGetActiveAttribARB");
#line 3602 "pogl_gl_Prog_Clam.c"
#line 1843 "pogl_gl_Prog_Clam.xs"
	{
		GLsizei maxLength;
		glGetObjectParameterivARB(programObj,GL_OBJECT_ACTIVE_ATTRIBUTES_ARB,
			(GLvoid *)&maxLength);
		if (maxLength)
		{
			GLsizei length;
			GLint size;
			GLenum type;
			GLcharARB *name;

			name = malloc(maxLength+1);
			glGetActiveAttribARB(programObj,index,maxLength,
				&length,&size,&type,name);
			name[length] = 0;

			if (*name)
			{
				EXTEND(sp,3);
				PUSHs(sv_2mortal(newSVpv(name,0)));
				PUSHs(sv_2mortal(newSViv(type)));
				PUSHs(sv_2mortal(newSViv(size)));
			}
			else
			{
				EXTEND(sp,1);
				PUSHs(sv_2mortal(newSVsv(&PL_sv_undef)));
			}

			free(name);
		}
		else
		{
			EXTEND(sp,1);
			PUSHs(sv_2mortal(newSVsv(&PL_sv_undef)));
		}
	}
#line 3641 "pogl_gl_Prog_Clam.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glGetAttribLocationARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetAttribLocationARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "programObj, name");
    {
	GLhandleARB	programObj = (unsigned int)SvUV(ST(0))
;
	void *	name = INT2PTR(void *,SvIV(ST(1)))
;
	GLint	RETVAL;
	dXSTARG;
#line 1887 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetAttribLocationARB,"glGetAttribLocationARB");
#line 3663 "pogl_gl_Prog_Clam.c"
#line 1889 "pogl_gl_Prog_Clam.xs"
		RETVAL = glGetAttribLocationARB(programObj, name);
#line 3666 "pogl_gl_Prog_Clam.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_OpenGL_glGetAttribLocationARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetAttribLocationARB_p)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "programObj, ...");
    {
	GLhandleARB	programObj = (unsigned int)SvUV(ST(0))
;
	GLint	RETVAL;
	dXSTARG;
#line 1899 "pogl_gl_Prog_Clam.xs"
		loadProc(glGetAttribLocationARB,"glGetAttribLocationARB");
#line 3686 "pogl_gl_Prog_Clam.c"
#line 1901 "pogl_gl_Prog_Clam.xs"
	{
		GLcharARB *name = (GLcharARB *)SvPV(ST(1),PL_na);
		RETVAL = glGetAttribLocationARB(programObj, name);
	}
#line 3692 "pogl_gl_Prog_Clam.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

#endif
#ifdef GL_ARB_point_parameters
#define XSubPPtmpAAAD 1


XS_EUPXS(XS_OpenGL_glPointParameterfARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glPointParameterfARB)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "pname, param");
    {
	GLenum	pname = (int)SvIV(ST(0))
;
	GLfloat	param = (float)SvNV(ST(1))
;
#line 1919 "pogl_gl_Prog_Clam.xs"
		loadProc(glPointParameterfARB,"glPointParameterfARB");
#line 3716 "pogl_gl_Prog_Clam.c"
#line 1921 "pogl_gl_Prog_Clam.xs"
	{
		glPointParameterfARB(pname,param);
	}
#line 3721 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glPointParameterfvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glPointParameterfvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "pname, params");
    {
	GLenum	pname = (int)SvIV(ST(0))
;
	void *	params = INT2PTR(void *,SvIV(ST(1)))
;
#line 1931 "pogl_gl_Prog_Clam.xs"
		loadProc(glPointParameterfvARB,"glPointParameterfvARB");
#line 3740 "pogl_gl_Prog_Clam.c"
#line 1933 "pogl_gl_Prog_Clam.xs"
		glPointParameterfvARB(pname,(GLfloat*)params);
#line 3743 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glPointParameterfvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glPointParameterfvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "pname, params");
    {
	GLenum	pname = (int)SvIV(ST(0))
;
	SV *	params = ST(1)
;
#line 1941 "pogl_gl_Prog_Clam.xs"
		loadProc(glPointParameterfvARB,"glPointParameterfvARB");
#line 3762 "pogl_gl_Prog_Clam.c"
#line 1943 "pogl_gl_Prog_Clam.xs"
	{
		int count = gl_get_count(pname);
		GLfloat * params_s = EL(params, sizeof(GLfloat)*count);
		glPointParameterfvARB(pname,params_s);
	}
#line 3769 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glPointParameterfvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glPointParameterfvARB_p)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "pname, ...");
    {
	GLenum	pname = (int)SvIV(ST(0))
;
#line 1955 "pogl_gl_Prog_Clam.xs"
		loadProc(glPointParameterfvARB,"glPointParameterfvARB");
#line 3786 "pogl_gl_Prog_Clam.c"
#line 1957 "pogl_gl_Prog_Clam.xs"
	{
		GLfloat params[4];
		int i;
		if ((items-1) != gl_get_count(pname))
			croak("Incorrect number of arguments");
		for(i=1;i<items;i++)
			params[i-1] = (GLfloat)SvNV(ST(i));
		glPointParameterfvARB(pname,params);
	}
#line 3797 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}

#endif
#ifdef GL_ARB_multisample
#define XSubPPtmpAAAE 1


XS_EUPXS(XS_OpenGL_glSampleCoverageARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glSampleCoverageARB)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "value, invert");
    {
	GLclampf	value = (float)SvNV(ST(0))
;
	GLboolean	invert = (bool)SvTRUE(ST(1))
;
#line 1978 "pogl_gl_Prog_Clam.xs"
		loadProc(glSampleCoverageARB,"glSampleCoverageARB");
#line 3820 "pogl_gl_Prog_Clam.c"
#line 1980 "pogl_gl_Prog_Clam.xs"
	{
		glSampleCoverageARB(value,invert);
	}
#line 3825 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}

#endif
#ifdef GL_ARB_color_buffer_float
#define XSubPPtmpAAAF 1


XS_EUPXS(XS_OpenGL_glClampColorARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glClampColorARB)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, clamp");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	clamp = (int)SvIV(ST(1))
;
#line 1995 "pogl_gl_Prog_Clam.xs"
		loadProc(glClampColorARB,"glClampColorARB");
#line 3848 "pogl_gl_Prog_Clam.c"
#line 1997 "pogl_gl_Prog_Clam.xs"
	{
		glClampColorARB(target,clamp);
	}
#line 3853 "pogl_gl_Prog_Clam.c"
    }
    XSRETURN_EMPTY;
}

#endif
#endif /* HAVE_GL */
#ifdef __cplusplus
extern "C"
#endif
XS_EXTERNAL(boot_OpenGL__GL__ProgClam); /* prototype to pass -Wmissing-prototypes */
XS_EXTERNAL(boot_OpenGL__GL__ProgClam)
{
#if PERL_VERSION_LE(5, 21, 5)
    dVAR; dXSARGS;
#else
    dVAR; dXSBOOTARGSXSAPIVERCHK;
#endif
#if (PERL_REVISION == 5 && PERL_VERSION < 9)
    char* file = __FILE__;
#else
    const char* file = __FILE__;
#endif

    PERL_UNUSED_VAR(file);

    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
#if PERL_VERSION_LE(5, 21, 5)
    XS_VERSION_BOOTCHECK;
#  ifdef XS_APIVERSION_BOOTCHECK
    XS_APIVERSION_BOOTCHECK;
#  endif
#endif

#if XSubPPtmpAAAA
        newXS_deffile("OpenGL::glProgramLocalParameter4dARB", XS_OpenGL_glProgramLocalParameter4dARB);
        newXS_deffile("OpenGL::glProgramLocalParameter4dvARB_c", XS_OpenGL_glProgramLocalParameter4dvARB_c);
        newXS_deffile("OpenGL::glProgramLocalParameter4dvARB_s", XS_OpenGL_glProgramLocalParameter4dvARB_s);
        newXS_deffile("OpenGL::glProgramLocalParameter4dvARB_p", XS_OpenGL_glProgramLocalParameter4dvARB_p);
        newXS_deffile("OpenGL::glProgramLocalParameter4fARB", XS_OpenGL_glProgramLocalParameter4fARB);
        newXS_deffile("OpenGL::glProgramLocalParameter4fvARB_c", XS_OpenGL_glProgramLocalParameter4fvARB_c);
        newXS_deffile("OpenGL::glProgramLocalParameter4fvARB_s", XS_OpenGL_glProgramLocalParameter4fvARB_s);
        newXS_deffile("OpenGL::glProgramLocalParameter4fvARB_p", XS_OpenGL_glProgramLocalParameter4fvARB_p);
        newXS_deffile("OpenGL::glGetProgramEnvParameterdvARB_c", XS_OpenGL_glGetProgramEnvParameterdvARB_c);
        newXS_deffile("OpenGL::glGetProgramEnvParameterdvARB_s", XS_OpenGL_glGetProgramEnvParameterdvARB_s);
        newXS_deffile("OpenGL::glGetProgramEnvParameterdvARB_p", XS_OpenGL_glGetProgramEnvParameterdvARB_p);
        newXS_deffile("OpenGL::glGetProgramEnvParameterfvARB_c", XS_OpenGL_glGetProgramEnvParameterfvARB_c);
        newXS_deffile("OpenGL::glGetProgramEnvParameterfvARB_s", XS_OpenGL_glGetProgramEnvParameterfvARB_s);
        newXS_deffile("OpenGL::glGetProgramEnvParameterfvARB_p", XS_OpenGL_glGetProgramEnvParameterfvARB_p);
        newXS_deffile("OpenGL::glGetProgramLocalParameterdvARB_c", XS_OpenGL_glGetProgramLocalParameterdvARB_c);
        newXS_deffile("OpenGL::glGetProgramLocalParameterdvARB_s", XS_OpenGL_glGetProgramLocalParameterdvARB_s);
        newXS_deffile("OpenGL::glGetProgramLocalParameterdvARB_p", XS_OpenGL_glGetProgramLocalParameterdvARB_p);
        newXS_deffile("OpenGL::glGetProgramLocalParameterfvARB_c", XS_OpenGL_glGetProgramLocalParameterfvARB_c);
        newXS_deffile("OpenGL::glGetProgramLocalParameterfvARB_s", XS_OpenGL_glGetProgramLocalParameterfvARB_s);
        newXS_deffile("OpenGL::glGetProgramLocalParameterfvARB_p", XS_OpenGL_glGetProgramLocalParameterfvARB_p);
        newXS_deffile("OpenGL::glGetProgramivARB_c", XS_OpenGL_glGetProgramivARB_c);
        newXS_deffile("OpenGL::glGetProgramivARB_s", XS_OpenGL_glGetProgramivARB_s);
        newXS_deffile("OpenGL::glGetProgramivARB_p", XS_OpenGL_glGetProgramivARB_p);
        newXS_deffile("OpenGL::glGetProgramStringARB_c", XS_OpenGL_glGetProgramStringARB_c);
        newXS_deffile("OpenGL::glGetProgramStringARB_s", XS_OpenGL_glGetProgramStringARB_s);
        newXS_deffile("OpenGL::glGetProgramStringARB_p", XS_OpenGL_glGetProgramStringARB_p);
        newXS_deffile("OpenGL::glIsProgramARB", XS_OpenGL_glIsProgramARB);
#endif
#if XSubPPtmpAAAB
        newXS_deffile("OpenGL::glVertexAttrib1dARB", XS_OpenGL_glVertexAttrib1dARB);
        newXS_deffile("OpenGL::glVertexAttrib1dvARB_c", XS_OpenGL_glVertexAttrib1dvARB_c);
        newXS_deffile("OpenGL::glVertexAttrib1dvARB_s", XS_OpenGL_glVertexAttrib1dvARB_s);
        newXS_deffile("OpenGL::glVertexAttrib1dvARB_p", XS_OpenGL_glVertexAttrib1dvARB_p);
        newXS_deffile("OpenGL::glVertexAttrib1fARB", XS_OpenGL_glVertexAttrib1fARB);
        newXS_deffile("OpenGL::glVertexAttrib1sARB", XS_OpenGL_glVertexAttrib1sARB);
        newXS_deffile("OpenGL::glVertexAttrib1svARB_c", XS_OpenGL_glVertexAttrib1svARB_c);
        newXS_deffile("OpenGL::glVertexAttrib1svARB_s", XS_OpenGL_glVertexAttrib1svARB_s);
        newXS_deffile("OpenGL::glVertexAttrib1svARB_p", XS_OpenGL_glVertexAttrib1svARB_p);
        newXS_deffile("OpenGL::glVertexAttrib2dARB", XS_OpenGL_glVertexAttrib2dARB);
        newXS_deffile("OpenGL::glVertexAttrib2dvARB_c", XS_OpenGL_glVertexAttrib2dvARB_c);
        newXS_deffile("OpenGL::glVertexAttrib2dvARB_s", XS_OpenGL_glVertexAttrib2dvARB_s);
        newXS_deffile("OpenGL::glVertexAttrib2dvARB_p", XS_OpenGL_glVertexAttrib2dvARB_p);
        newXS_deffile("OpenGL::glVertexAttrib2fARB", XS_OpenGL_glVertexAttrib2fARB);
        newXS_deffile("OpenGL::glVertexAttrib2sARB", XS_OpenGL_glVertexAttrib2sARB);
        newXS_deffile("OpenGL::glVertexAttrib2svARB_c", XS_OpenGL_glVertexAttrib2svARB_c);
        newXS_deffile("OpenGL::glVertexAttrib2svARB_s", XS_OpenGL_glVertexAttrib2svARB_s);
        newXS_deffile("OpenGL::glVertexAttrib2svARB_p", XS_OpenGL_glVertexAttrib2svARB_p);
        newXS_deffile("OpenGL::glVertexAttrib3dARB", XS_OpenGL_glVertexAttrib3dARB);
        newXS_deffile("OpenGL::glVertexAttrib3dvARB_c", XS_OpenGL_glVertexAttrib3dvARB_c);
        newXS_deffile("OpenGL::glVertexAttrib3dvARB_s", XS_OpenGL_glVertexAttrib3dvARB_s);
        newXS_deffile("OpenGL::glVertexAttrib3dvARB_p", XS_OpenGL_glVertexAttrib3dvARB_p);
        newXS_deffile("OpenGL::glVertexAttrib3fARB", XS_OpenGL_glVertexAttrib3fARB);
        newXS_deffile("OpenGL::glVertexAttrib3fvARB_c", XS_OpenGL_glVertexAttrib3fvARB_c);
        newXS_deffile("OpenGL::glVertexAttrib3fvARB_s", XS_OpenGL_glVertexAttrib3fvARB_s);
        newXS_deffile("OpenGL::glVertexAttrib3fvARB_p", XS_OpenGL_glVertexAttrib3fvARB_p);
        newXS_deffile("OpenGL::glVertexAttrib3sARB", XS_OpenGL_glVertexAttrib3sARB);
        newXS_deffile("OpenGL::glVertexAttrib3svARB_c", XS_OpenGL_glVertexAttrib3svARB_c);
        newXS_deffile("OpenGL::glVertexAttrib3svARB_s", XS_OpenGL_glVertexAttrib3svARB_s);
        newXS_deffile("OpenGL::glVertexAttrib3svARB_p", XS_OpenGL_glVertexAttrib3svARB_p);
        newXS_deffile("OpenGL::glVertexAttrib4NbvARB_c", XS_OpenGL_glVertexAttrib4NbvARB_c);
        newXS_deffile("OpenGL::glVertexAttrib4NbvARB_s", XS_OpenGL_glVertexAttrib4NbvARB_s);
        newXS_deffile("OpenGL::glVertexAttrib4NbvARB_p", XS_OpenGL_glVertexAttrib4NbvARB_p);
        newXS_deffile("OpenGL::glVertexAttrib4NivARB_c", XS_OpenGL_glVertexAttrib4NivARB_c);
        newXS_deffile("OpenGL::glVertexAttrib4NivARB_s", XS_OpenGL_glVertexAttrib4NivARB_s);
        newXS_deffile("OpenGL::glVertexAttrib4NivARB_p", XS_OpenGL_glVertexAttrib4NivARB_p);
        newXS_deffile("OpenGL::glVertexAttrib4NsvARB_c", XS_OpenGL_glVertexAttrib4NsvARB_c);
        newXS_deffile("OpenGL::glVertexAttrib4NsvARB_s", XS_OpenGL_glVertexAttrib4NsvARB_s);
        newXS_deffile("OpenGL::glVertexAttrib4NsvARB_p", XS_OpenGL_glVertexAttrib4NsvARB_p);
        newXS_deffile("OpenGL::glVertexAttrib4NubARB", XS_OpenGL_glVertexAttrib4NubARB);
        newXS_deffile("OpenGL::glVertexAttrib4NubvARB_c", XS_OpenGL_glVertexAttrib4NubvARB_c);
        newXS_deffile("OpenGL::glVertexAttrib4NubvARB_s", XS_OpenGL_glVertexAttrib4NubvARB_s);
        newXS_deffile("OpenGL::glVertexAttrib4NubvARB_p", XS_OpenGL_glVertexAttrib4NubvARB_p);
        newXS_deffile("OpenGL::glVertexAttrib4NuivARB_c", XS_OpenGL_glVertexAttrib4NuivARB_c);
        newXS_deffile("OpenGL::glVertexAttrib4NuivARB_s", XS_OpenGL_glVertexAttrib4NuivARB_s);
        newXS_deffile("OpenGL::glVertexAttrib4NuivARB_p", XS_OpenGL_glVertexAttrib4NuivARB_p);
        newXS_deffile("OpenGL::glVertexAttrib4NusvARB_c", XS_OpenGL_glVertexAttrib4NusvARB_c);
        newXS_deffile("OpenGL::glVertexAttrib4NusvARB_s", XS_OpenGL_glVertexAttrib4NusvARB_s);
        newXS_deffile("OpenGL::glVertexAttrib4NusvARB_p", XS_OpenGL_glVertexAttrib4NusvARB_p);
        newXS_deffile("OpenGL::glVertexAttrib4bvARB_c", XS_OpenGL_glVertexAttrib4bvARB_c);
        newXS_deffile("OpenGL::glVertexAttrib4bvARB_s", XS_OpenGL_glVertexAttrib4bvARB_s);
        newXS_deffile("OpenGL::glVertexAttrib4bvARB_p", XS_OpenGL_glVertexAttrib4bvARB_p);
        newXS_deffile("OpenGL::glVertexAttrib4dARB", XS_OpenGL_glVertexAttrib4dARB);
        newXS_deffile("OpenGL::glVertexAttrib4dvARB_c", XS_OpenGL_glVertexAttrib4dvARB_c);
        newXS_deffile("OpenGL::glVertexAttrib4dvARB_s", XS_OpenGL_glVertexAttrib4dvARB_s);
        newXS_deffile("OpenGL::glVertexAttrib4dvARB_p", XS_OpenGL_glVertexAttrib4dvARB_p);
        newXS_deffile("OpenGL::glVertexAttrib4fARB", XS_OpenGL_glVertexAttrib4fARB);
        newXS_deffile("OpenGL::glVertexAttrib4fvARB_c", XS_OpenGL_glVertexAttrib4fvARB_c);
        newXS_deffile("OpenGL::glVertexAttrib4fvARB_s", XS_OpenGL_glVertexAttrib4fvARB_s);
        newXS_deffile("OpenGL::glVertexAttrib4fvARB_p", XS_OpenGL_glVertexAttrib4fvARB_p);
        newXS_deffile("OpenGL::glVertexAttrib4ivARB_c", XS_OpenGL_glVertexAttrib4ivARB_c);
        newXS_deffile("OpenGL::glVertexAttrib4ivARB_s", XS_OpenGL_glVertexAttrib4ivARB_s);
        newXS_deffile("OpenGL::glVertexAttrib4ivARB_p", XS_OpenGL_glVertexAttrib4ivARB_p);
        newXS_deffile("OpenGL::glVertexAttrib4sARB", XS_OpenGL_glVertexAttrib4sARB);
        newXS_deffile("OpenGL::glVertexAttrib4svARB_c", XS_OpenGL_glVertexAttrib4svARB_c);
        newXS_deffile("OpenGL::glVertexAttrib4svARB_s", XS_OpenGL_glVertexAttrib4svARB_s);
        newXS_deffile("OpenGL::glVertexAttrib4svARB_p", XS_OpenGL_glVertexAttrib4svARB_p);
        newXS_deffile("OpenGL::glVertexAttrib4ubvARB_c", XS_OpenGL_glVertexAttrib4ubvARB_c);
        newXS_deffile("OpenGL::glVertexAttrib4ubvARB_s", XS_OpenGL_glVertexAttrib4ubvARB_s);
        newXS_deffile("OpenGL::glVertexAttrib4ubvARB_p", XS_OpenGL_glVertexAttrib4ubvARB_p);
        newXS_deffile("OpenGL::glVertexAttrib4uivARB_c", XS_OpenGL_glVertexAttrib4uivARB_c);
        newXS_deffile("OpenGL::glVertexAttrib4uivARB_s", XS_OpenGL_glVertexAttrib4uivARB_s);
        newXS_deffile("OpenGL::glVertexAttrib4uivARB_p", XS_OpenGL_glVertexAttrib4uivARB_p);
        newXS_deffile("OpenGL::glVertexAttrib4usvARB_c", XS_OpenGL_glVertexAttrib4usvARB_c);
        newXS_deffile("OpenGL::glVertexAttrib4usvARB_s", XS_OpenGL_glVertexAttrib4usvARB_s);
        newXS_deffile("OpenGL::glVertexAttrib4usvARB_p", XS_OpenGL_glVertexAttrib4usvARB_p);
        newXS_deffile("OpenGL::glVertexAttribPointerARB_c", XS_OpenGL_glVertexAttribPointerARB_c);
        newXS_deffile("OpenGL::glVertexAttribPointerARB_p", XS_OpenGL_glVertexAttribPointerARB_p);
        newXS_deffile("OpenGL::glEnableVertexAttribArrayARB", XS_OpenGL_glEnableVertexAttribArrayARB);
        newXS_deffile("OpenGL::glDisableVertexAttribArrayARB", XS_OpenGL_glDisableVertexAttribArrayARB);
        newXS_deffile("OpenGL::glGetVertexAttribdvARB_c", XS_OpenGL_glGetVertexAttribdvARB_c);
        newXS_deffile("OpenGL::glGetVertexAttribdvARB_s", XS_OpenGL_glGetVertexAttribdvARB_s);
        newXS_deffile("OpenGL::glGetVertexAttribdvARB_p", XS_OpenGL_glGetVertexAttribdvARB_p);
        newXS_deffile("OpenGL::glGetVertexAttribfvARB_c", XS_OpenGL_glGetVertexAttribfvARB_c);
        newXS_deffile("OpenGL::glGetVertexAttribfvARB_s", XS_OpenGL_glGetVertexAttribfvARB_s);
        newXS_deffile("OpenGL::glGetVertexAttribfvARB_p", XS_OpenGL_glGetVertexAttribfvARB_p);
        newXS_deffile("OpenGL::glGetVertexAttribivARB_c", XS_OpenGL_glGetVertexAttribivARB_c);
        newXS_deffile("OpenGL::glGetVertexAttribivARB_s", XS_OpenGL_glGetVertexAttribivARB_s);
        newXS_deffile("OpenGL::glGetVertexAttribivARB_p", XS_OpenGL_glGetVertexAttribivARB_p);
        newXS_deffile("OpenGL::glGetVertexAttribPointervARB_c", XS_OpenGL_glGetVertexAttribPointervARB_c);
        newXS_deffile("OpenGL::glGetVertexAttribPointervARB_p", XS_OpenGL_glGetVertexAttribPointervARB_p);
#endif
#if XSubPPtmpAAAC
        newXS_deffile("OpenGL::glBindAttribLocationARB", XS_OpenGL_glBindAttribLocationARB);
        newXS_deffile("OpenGL::glGetActiveAttribARB_c", XS_OpenGL_glGetActiveAttribARB_c);
        newXS_deffile("OpenGL::glGetActiveAttribARB_s", XS_OpenGL_glGetActiveAttribARB_s);
        newXS_deffile("OpenGL::glGetActiveAttribARB_p", XS_OpenGL_glGetActiveAttribARB_p);
        newXS_deffile("OpenGL::glGetAttribLocationARB_c", XS_OpenGL_glGetAttribLocationARB_c);
        newXS_deffile("OpenGL::glGetAttribLocationARB_p", XS_OpenGL_glGetAttribLocationARB_p);
#endif
#if XSubPPtmpAAAD
        newXS_deffile("OpenGL::glPointParameterfARB", XS_OpenGL_glPointParameterfARB);
        newXS_deffile("OpenGL::glPointParameterfvARB_c", XS_OpenGL_glPointParameterfvARB_c);
        newXS_deffile("OpenGL::glPointParameterfvARB_s", XS_OpenGL_glPointParameterfvARB_s);
        newXS_deffile("OpenGL::glPointParameterfvARB_p", XS_OpenGL_glPointParameterfvARB_p);
#endif
#if XSubPPtmpAAAE
        newXS_deffile("OpenGL::glSampleCoverageARB", XS_OpenGL_glSampleCoverageARB);
#endif
#if XSubPPtmpAAAF
        newXS_deffile("OpenGL::glClampColorARB", XS_OpenGL_glClampColorARB);
#endif

    /* Initialisation Section */

#if XSubPPtmpAAAA
#endif
#if XSubPPtmpAAAB
#endif
#if XSubPPtmpAAAC
#endif
#if XSubPPtmpAAAD
#endif
#if XSubPPtmpAAAE
#endif
#if XSubPPtmpAAAF
#endif
#line 4045 "pogl_gl_Prog_Clam.c"

    /* End of Initialisation Section */

#if PERL_VERSION_LE(5, 21, 5)
#  if PERL_VERSION_GE(5, 9, 0)
    if (PL_unitcheckav)
        call_list(PL_scopestack_ix, PL_unitcheckav);
#  endif
    XSRETURN_YES;
#else
    Perl_xs_boot_epilog(aTHX_ ax);
#endif
}

