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

#line 1 "pogl_gl_Mult_Prog.xs"
/*  Last saved: Sun 06 Sep 2009 02:09:59 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_Mult_Prog.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(pTHX_ const CV *const cv, const char *const params);

STATIC void
S_croak_xs_usage(pTHX_ 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(aTHX_ "Usage: %s::%s(%s)", hvname, gvname, params);
        else
            Perl_croak(aTHX_ "Usage: %s(%s)", gvname, params);
    } else {
        /* Pants. I don't think that it should be possible to get here. */
        Perl_croak(aTHX_ "Usage: CODE(0x%"UVxf")(%s)", PTR2UV(cv), params);
    }
}
#undef  PERL_ARGS_ASSERT_CROAK_XS_USAGE

#ifdef PERL_IMPLICIT_CONTEXT
#define croak_xs_usage(a,b)    S_croak_xs_usage(aTHX_ a,b)
#else
#define croak_xs_usage        S_croak_xs_usage
#endif

#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) */

#line 202 "pogl_gl_Mult_Prog.c"
#ifdef HAVE_GL
#ifdef GL_ARB_multitexture
#define XSubPPtmpAAAA 1


XS_EUPXS(XS_OpenGL_glMultiTexCoord3dARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord3dARB)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "target, s, t, r");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLdouble	s = (double)SvNV(ST(1))
;
	GLdouble	t = (double)SvNV(ST(2))
;
	GLdouble	r = (double)SvNV(ST(3))
;
#line 70 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord3dARB,"glMultiTexCoord3dARB");
#line 225 "pogl_gl_Mult_Prog.c"
#line 72 "pogl_gl_Mult_Prog.xs"
		glMultiTexCoord3dARB(target,s,t,r);
#line 228 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord3dvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord3dvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 80 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord3dvARB,"glMultiTexCoord3dvARB");
#line 247 "pogl_gl_Mult_Prog.c"
#line 82 "pogl_gl_Mult_Prog.xs"
		glMultiTexCoord3dvARB(target,v);
#line 250 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord3dvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord3dvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 90 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord3dvARB,"glMultiTexCoord3dvARB");
#line 269 "pogl_gl_Mult_Prog.c"
#line 92 "pogl_gl_Mult_Prog.xs"
	{
		GLdouble * v_s = EL(v, sizeof(GLdouble));
		glMultiTexCoord3dvARB(target,v_s);
	}
#line 275 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord3dvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord3dvARB_p)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "target, s, t, r");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLdouble	s = (double)SvNV(ST(1))
;
	GLdouble	t = (double)SvNV(ST(2))
;
	GLdouble	r = (double)SvNV(ST(3))
;
#line 106 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord3dvARB,"glMultiTexCoord3dvARB");
#line 298 "pogl_gl_Mult_Prog.c"
#line 108 "pogl_gl_Mult_Prog.xs"
	{
		GLdouble param[3];
		param[0] = s;
		param[1] = t;
		param[2] = r;
		glMultiTexCoord3dvARB(target,param);
	}
#line 307 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord3fARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord3fARB)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "target, s, t, r");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLfloat	s = (float)SvNV(ST(1))
;
	GLfloat	t = (float)SvNV(ST(2))
;
	GLfloat	r = (float)SvNV(ST(3))
;
#line 124 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord3fARB,"glMultiTexCoord3fARB");
#line 330 "pogl_gl_Mult_Prog.c"
#line 126 "pogl_gl_Mult_Prog.xs"
		glMultiTexCoord3fARB(target,s,t,r);
#line 333 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord3fvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord3fvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 134 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord3fvARB,"glMultiTexCoord3fvARB");
#line 352 "pogl_gl_Mult_Prog.c"
#line 136 "pogl_gl_Mult_Prog.xs"
		glMultiTexCoord3fvARB(target,v);
#line 355 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord3fvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord3fvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 144 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord3fvARB,"glMultiTexCoord3fvARB");
#line 374 "pogl_gl_Mult_Prog.c"
#line 146 "pogl_gl_Mult_Prog.xs"
	{
		GLfloat * v_s = EL(v, sizeof(GLfloat));
		glMultiTexCoord3fvARB(target,v_s);
	}
#line 380 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord3fvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord3fvARB_p)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "target, s, t, r");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLfloat	s = (float)SvNV(ST(1))
;
	GLfloat	t = (float)SvNV(ST(2))
;
	GLfloat	r = (float)SvNV(ST(3))
;
#line 160 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord3fvARB,"glMultiTexCoord3fvARB");
#line 403 "pogl_gl_Mult_Prog.c"
#line 162 "pogl_gl_Mult_Prog.xs"
	{
		GLfloat param[3];
		param[0] = s;
		param[1] = t;
		param[2] = r;
		glMultiTexCoord3fvARB(target,param);
	}
#line 412 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord3iARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord3iARB)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "target, s, t, r");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	s = (int)SvIV(ST(1))
;
	GLint	t = (int)SvIV(ST(2))
;
	GLint	r = (int)SvIV(ST(3))
;
#line 178 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord3iARB,"glMultiTexCoord3iARB");
#line 435 "pogl_gl_Mult_Prog.c"
#line 180 "pogl_gl_Mult_Prog.xs"
		glMultiTexCoord3iARB(target,s,t,r);
#line 438 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord3ivARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord3ivARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 188 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord3ivARB,"glMultiTexCoord3ivARB");
#line 457 "pogl_gl_Mult_Prog.c"
#line 190 "pogl_gl_Mult_Prog.xs"
		glMultiTexCoord3ivARB(target,v);
#line 460 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord3ivARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord3ivARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 198 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord3ivARB,"glMultiTexCoord3ivARB");
#line 479 "pogl_gl_Mult_Prog.c"
#line 200 "pogl_gl_Mult_Prog.xs"
	{
		GLint * v_s = EL(v, sizeof(GLint));
		glMultiTexCoord3ivARB(target,v_s);
	}
#line 485 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord3ivARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord3ivARB_p)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "target, s, t, r");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	s = (int)SvIV(ST(1))
;
	GLint	t = (int)SvIV(ST(2))
;
	GLint	r = (int)SvIV(ST(3))
;
#line 214 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord3ivARB,"glMultiTexCoord3ivARB");
#line 508 "pogl_gl_Mult_Prog.c"
#line 216 "pogl_gl_Mult_Prog.xs"
	{
		GLint param[3];
		param[0] = s;
		param[1] = t;
		param[2] = r;
		glMultiTexCoord3ivARB(target,param);
	}
#line 517 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord3sARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord3sARB)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "target, s, t, r");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLshort	s = (short)SvIV(ST(1))
;
	GLshort	t = (short)SvIV(ST(2))
;
	GLshort	r = (short)SvIV(ST(3))
;
#line 232 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord3sARB,"glMultiTexCoord3sARB");
#line 540 "pogl_gl_Mult_Prog.c"
#line 234 "pogl_gl_Mult_Prog.xs"
		glMultiTexCoord3sARB(target,s,t,r);
#line 543 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord3svARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord3svARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 242 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord3svARB,"glMultiTexCoord3svARB");
#line 562 "pogl_gl_Mult_Prog.c"
#line 244 "pogl_gl_Mult_Prog.xs"
		glMultiTexCoord3svARB(target,v);
#line 565 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord3svARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord3svARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 252 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord3svARB,"glMultiTexCoord3svARB");
#line 584 "pogl_gl_Mult_Prog.c"
#line 254 "pogl_gl_Mult_Prog.xs"
	{
		GLshort * v_s = EL(v, sizeof(GLshort));
		glMultiTexCoord3svARB(target,v_s);
	}
#line 590 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord3svARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord3svARB_p)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "target, s, t, r");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLshort	s = (short)SvIV(ST(1))
;
	GLshort	t = (short)SvIV(ST(2))
;
	GLshort	r = (short)SvIV(ST(3))
;
#line 268 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord3svARB,"glMultiTexCoord3svARB");
#line 613 "pogl_gl_Mult_Prog.c"
#line 270 "pogl_gl_Mult_Prog.xs"
	{
		GLshort param[3];
		param[0] = s;
		param[1] = t;
		param[2] = r;
		glMultiTexCoord3svARB(target,param);
	}
#line 622 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord4dARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord4dARB)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "target, s, t, r, q");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLdouble	s = (double)SvNV(ST(1))
;
	GLdouble	t = (double)SvNV(ST(2))
;
	GLdouble	r = (double)SvNV(ST(3))
;
	GLdouble	q = (double)SvNV(ST(4))
;
#line 287 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord4dARB,"glMultiTexCoord4dARB");
#line 647 "pogl_gl_Mult_Prog.c"
#line 289 "pogl_gl_Mult_Prog.xs"
		glMultiTexCoord4dARB(target,s,t,r,q);
#line 650 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord4dvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord4dvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 297 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord4dvARB,"glMultiTexCoord4dvARB");
#line 669 "pogl_gl_Mult_Prog.c"
#line 299 "pogl_gl_Mult_Prog.xs"
		glMultiTexCoord4dvARB(target,v);
#line 672 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord4dvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord4dvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 307 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord4dvARB,"glMultiTexCoord4dvARB");
#line 691 "pogl_gl_Mult_Prog.c"
#line 309 "pogl_gl_Mult_Prog.xs"
	{
		GLdouble * v_s = EL(v, sizeof(GLdouble));
		glMultiTexCoord4dvARB(target,v_s);
	}
#line 697 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord4dvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord4dvARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "target, s, t, r, q");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLdouble	s = (double)SvNV(ST(1))
;
	GLdouble	t = (double)SvNV(ST(2))
;
	GLdouble	r = (double)SvNV(ST(3))
;
	GLdouble	q = (double)SvNV(ST(4))
;
#line 324 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord4dvARB,"glMultiTexCoord4dvARB");
#line 722 "pogl_gl_Mult_Prog.c"
#line 326 "pogl_gl_Mult_Prog.xs"
	{
		GLdouble param[4];
		param[0] = s;
		param[1] = t;
		param[2] = r;
		param[3] = q;
		glMultiTexCoord4dvARB(target,param);
	}
#line 732 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord4fARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord4fARB)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "target, s, t, r, q");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLfloat	s = (float)SvNV(ST(1))
;
	GLfloat	t = (float)SvNV(ST(2))
;
	GLfloat	r = (float)SvNV(ST(3))
;
	GLfloat	q = (float)SvNV(ST(4))
;
#line 344 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord4fARB,"glMultiTexCoord4fARB");
#line 757 "pogl_gl_Mult_Prog.c"
#line 346 "pogl_gl_Mult_Prog.xs"
		glMultiTexCoord4fARB(target,s,t,r,q);
#line 760 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord4fvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord4fvARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 354 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord4fvARB,"glMultiTexCoord4fvARB");
#line 779 "pogl_gl_Mult_Prog.c"
#line 356 "pogl_gl_Mult_Prog.xs"
		glMultiTexCoord4fvARB(target,v);
#line 782 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord4fvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord4fvARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 364 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord4fvARB,"glMultiTexCoord4fvARB");
#line 801 "pogl_gl_Mult_Prog.c"
#line 366 "pogl_gl_Mult_Prog.xs"
	{
		GLfloat * v_s = EL(v, sizeof(GLfloat));
		glMultiTexCoord4fvARB(target,v_s);
	}
#line 807 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord4fvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord4fvARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "target, s, t, r, q");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLfloat	s = (float)SvNV(ST(1))
;
	GLfloat	t = (float)SvNV(ST(2))
;
	GLfloat	r = (float)SvNV(ST(3))
;
	GLfloat	q = (float)SvNV(ST(4))
;
#line 381 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord4fvARB,"glMultiTexCoord4fvARB");
#line 832 "pogl_gl_Mult_Prog.c"
#line 383 "pogl_gl_Mult_Prog.xs"
	{
		GLfloat param[4];
		param[0] = s;
		param[1] = t;
		param[2] = r;
		param[3] = q;
		glMultiTexCoord4fvARB(target,param);
	}
#line 842 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord4iARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord4iARB)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "target, s, t, r, q");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	s = (int)SvIV(ST(1))
;
	GLint	t = (int)SvIV(ST(2))
;
	GLint	r = (int)SvIV(ST(3))
;
	GLint	q = (int)SvIV(ST(4))
;
#line 401 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord4iARB,"glMultiTexCoord4iARB");
#line 867 "pogl_gl_Mult_Prog.c"
#line 403 "pogl_gl_Mult_Prog.xs"
		glMultiTexCoord4iARB(target,s,t,r,q);
#line 870 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord4ivARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord4ivARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 411 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord4ivARB,"glMultiTexCoord4ivARB");
#line 889 "pogl_gl_Mult_Prog.c"
#line 413 "pogl_gl_Mult_Prog.xs"
		glMultiTexCoord4ivARB(target,v);
#line 892 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord4ivARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord4ivARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 421 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord4ivARB,"glMultiTexCoord4ivARB");
#line 911 "pogl_gl_Mult_Prog.c"
#line 423 "pogl_gl_Mult_Prog.xs"
	{
		GLint * v_s = EL(v, sizeof(GLint));
		glMultiTexCoord4ivARB(target,v_s);
	}
#line 917 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord4ivARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord4ivARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "target, s, t, r, q");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLint	s = (int)SvIV(ST(1))
;
	GLint	t = (int)SvIV(ST(2))
;
	GLint	r = (int)SvIV(ST(3))
;
	GLint	q = (int)SvIV(ST(4))
;
#line 438 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord4ivARB,"glMultiTexCoord4ivARB");
#line 942 "pogl_gl_Mult_Prog.c"
#line 440 "pogl_gl_Mult_Prog.xs"
	{
		GLint param[4];
		param[0] = s;
		param[1] = t;
		param[2] = r;
		param[3] = q;
		glMultiTexCoord4ivARB(target,param);
	}
#line 952 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord4sARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord4sARB)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "target, s, t, r, q");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLshort	s = (short)SvIV(ST(1))
;
	GLshort	t = (short)SvIV(ST(2))
;
	GLshort	r = (short)SvIV(ST(3))
;
	GLshort	q = (short)SvIV(ST(4))
;
#line 458 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord4sARB,"glMultiTexCoord4sARB");
#line 977 "pogl_gl_Mult_Prog.c"
#line 460 "pogl_gl_Mult_Prog.xs"
		glMultiTexCoord4sARB(target,s,t,r,q);
#line 980 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord4svARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord4svARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 468 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord4svARB,"glMultiTexCoord4svARB");
#line 999 "pogl_gl_Mult_Prog.c"
#line 470 "pogl_gl_Mult_Prog.xs"
		glMultiTexCoord4svARB(target,v);
#line 1002 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord4svARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord4svARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, v");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	void *	v = INT2PTR(void *,SvIV(ST(1)))
;
#line 478 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord4svARB,"glMultiTexCoord4svARB");
#line 1021 "pogl_gl_Mult_Prog.c"
#line 480 "pogl_gl_Mult_Prog.xs"
	{
		GLshort * v_s = EL(v, sizeof(GLshort));
		glMultiTexCoord4svARB(target,v_s);
	}
#line 1027 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glMultiTexCoord4svARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glMultiTexCoord4svARB_p)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "target, s, t, r, q");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLshort	s = (short)SvIV(ST(1))
;
	GLshort	t = (short)SvIV(ST(2))
;
	GLshort	r = (short)SvIV(ST(3))
;
	GLshort	q = (short)SvIV(ST(4))
;
#line 495 "pogl_gl_Mult_Prog.xs"
		loadProc(glMultiTexCoord4svARB,"glMultiTexCoord4svARB");
#line 1052 "pogl_gl_Mult_Prog.c"
#line 497 "pogl_gl_Mult_Prog.xs"
	{
		GLshort param[4];
		param[0] = s;
		param[1] = t;
		param[2] = r;
		param[3] = q;
		glMultiTexCoord4svARB(target,param);
	}
#line 1062 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}

#endif
#ifdef GL_ARB_shader_objects
#define XSubPPtmpAAAB 1


XS_EUPXS(XS_OpenGL_glDeleteObjectARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glDeleteObjectARB)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "obj");
    {
	GLhandleARB	obj = (unsigned int)SvUV(ST(0))
;
#line 517 "pogl_gl_Mult_Prog.xs"
		loadProc(glDeleteObjectARB,"glDeleteObjectARB");
#line 1083 "pogl_gl_Mult_Prog.c"
#line 519 "pogl_gl_Mult_Prog.xs"
	{
		glDeleteObjectARB(obj);
	}
#line 1088 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetHandleARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetHandleARB)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "pname");
    {
	GLenum	pname = (int)SvIV(ST(0))
;
	GLhandleARB	RETVAL;
	dXSTARG;
#line 528 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetHandleARB,"glGetHandleARB");
#line 1107 "pogl_gl_Mult_Prog.c"
#line 530 "pogl_gl_Mult_Prog.xs"
	{
		RETVAL = glGetHandleARB(pname);
	}
#line 1112 "pogl_gl_Mult_Prog.c"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_OpenGL_glDetachObjectARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glDetachObjectARB)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "containerObj, attachedObj");
    {
	GLhandleARB	containerObj = (unsigned int)SvUV(ST(0))
;
	GLhandleARB	attachedObj = (unsigned int)SvUV(ST(1))
;
#line 542 "pogl_gl_Mult_Prog.xs"
		loadProc(glDetachObjectARB,"glDetachObjectARB");
#line 1132 "pogl_gl_Mult_Prog.c"
#line 544 "pogl_gl_Mult_Prog.xs"
	{
		glDetachObjectARB(containerObj, attachedObj);
	}
#line 1137 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glCreateShaderObjectARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glCreateShaderObjectARB)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "shaderType");
    {
	GLenum	shaderType = (int)SvIV(ST(0))
;
	GLhandleARB	RETVAL;
	dXSTARG;
#line 553 "pogl_gl_Mult_Prog.xs"
		loadProc(glCreateShaderObjectARB,"glCreateShaderObjectARB");
#line 1156 "pogl_gl_Mult_Prog.c"
#line 555 "pogl_gl_Mult_Prog.xs"
	{
		RETVAL = glCreateShaderObjectARB(shaderType);
	}
#line 1161 "pogl_gl_Mult_Prog.c"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_OpenGL_glShaderSourceARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glShaderSourceARB_c)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "shaderObj, count, string, length");
    {
	GLhandleARB	shaderObj = (unsigned int)SvUV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	void *	string = INT2PTR(void *,SvIV(ST(2)))
;
	void *	length = INT2PTR(void *,SvIV(ST(3)))
;
#line 569 "pogl_gl_Mult_Prog.xs"
		loadProc(glShaderSourceARB,"glShaderSourceARB");
#line 1185 "pogl_gl_Mult_Prog.c"
#line 571 "pogl_gl_Mult_Prog.xs"
	{
		glShaderSourceARB(shaderObj, count, string, length);
	}
#line 1190 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glShaderSourceARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glShaderSourceARB_p)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "shaderObj, ...");
    {
	GLhandleARB	shaderObj = (unsigned int)SvUV(ST(0))
;
#line 580 "pogl_gl_Mult_Prog.xs"
		loadProc(glShaderSourceARB,"glShaderSourceARB");
#line 1207 "pogl_gl_Mult_Prog.c"
#line 582 "pogl_gl_Mult_Prog.xs"
	{
		int i;
		int count = items - 1;
		GLcharARB **string = malloc(sizeof(GLcharARB *) * count);
		GLint *length = malloc(sizeof(GLint) * count);

		for(i=0;i<count;i++) {
			string[i] = (GLcharARB *)SvPV(ST(i+1),PL_na);
			length[i] = strlen(string[i]);
		}

		glShaderSourceARB(shaderObj, count, (const GLcharARB**)string,
			(const GLint *)length);

		free(length);
                free(string);
	}
#line 1226 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glCompileShaderARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glCompileShaderARB)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "shaderObj");
    {
	GLhandleARB	shaderObj = (unsigned int)SvUV(ST(0))
;
#line 605 "pogl_gl_Mult_Prog.xs"
		loadProc(glCompileShaderARB,"glCompileShaderARB");
#line 1243 "pogl_gl_Mult_Prog.c"
#line 607 "pogl_gl_Mult_Prog.xs"
	{
		glCompileShaderARB(shaderObj);
	}
#line 1248 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glCreateProgramObjectARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glCreateProgramObjectARB)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	GLhandleARB	RETVAL;
	dXSTARG;
#line 615 "pogl_gl_Mult_Prog.xs"
		loadProc(glCreateProgramObjectARB,"glCreateProgramObjectARB");
#line 1265 "pogl_gl_Mult_Prog.c"
#line 617 "pogl_gl_Mult_Prog.xs"
	{
		RETVAL = glCreateProgramObjectARB();
	}
#line 1270 "pogl_gl_Mult_Prog.c"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_OpenGL_glAttachObjectARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glAttachObjectARB)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "containerObj, obj");
    {
	GLhandleARB	containerObj = (unsigned int)SvUV(ST(0))
;
	GLhandleARB	obj = (unsigned int)SvUV(ST(1))
;
#line 629 "pogl_gl_Mult_Prog.xs"
		loadProc(glAttachObjectARB,"glAttachObjectARB");
#line 1290 "pogl_gl_Mult_Prog.c"
#line 631 "pogl_gl_Mult_Prog.xs"
	{
		glAttachObjectARB(containerObj, obj);
	}
#line 1295 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glLinkProgramARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glLinkProgramARB)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "programObj");
    {
	GLhandleARB	programObj = (unsigned int)SvUV(ST(0))
;
#line 640 "pogl_gl_Mult_Prog.xs"
		loadProc(glLinkProgramARB,"glLinkProgramARB");
#line 1312 "pogl_gl_Mult_Prog.c"
#line 642 "pogl_gl_Mult_Prog.xs"
	{
		glLinkProgramARB(programObj);
	}
#line 1317 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUseProgramObjectARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUseProgramObjectARB)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "programObj");
    {
	GLhandleARB	programObj = (unsigned int)SvUV(ST(0))
;
#line 651 "pogl_gl_Mult_Prog.xs"
		loadProc(glUseProgramObjectARB,"glUseProgramObjectARB");
#line 1334 "pogl_gl_Mult_Prog.c"
#line 653 "pogl_gl_Mult_Prog.xs"
	{
		glUseProgramObjectARB(programObj);
	}
#line 1339 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glValidateProgramARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glValidateProgramARB)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "programObj");
    {
	GLhandleARB	programObj = (unsigned int)SvUV(ST(0))
;
#line 662 "pogl_gl_Mult_Prog.xs"
		loadProc(glValidateProgramARB,"glValidateProgramARB");
#line 1356 "pogl_gl_Mult_Prog.c"
#line 664 "pogl_gl_Mult_Prog.xs"
	{
		glValidateProgramARB(programObj);
	}
#line 1361 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform1fARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform1fARB)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "location, v0");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLfloat	v0 = (float)SvNV(ST(1))
;
#line 674 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform1fARB,"glUniform1fARB");
#line 1380 "pogl_gl_Mult_Prog.c"
#line 676 "pogl_gl_Mult_Prog.xs"
	{
		glUniform1fARB(location, v0);
	}
#line 1385 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform2fARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform2fARB)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, v0, v1");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLfloat	v0 = (float)SvNV(ST(1))
;
	GLfloat	v1 = (float)SvNV(ST(2))
;
#line 687 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform2fARB,"glUniform2fARB");
#line 1406 "pogl_gl_Mult_Prog.c"
#line 689 "pogl_gl_Mult_Prog.xs"
	{
		glUniform2fARB(location, v0, v1);
	}
#line 1411 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform3fARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform3fARB)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "location, v0, v1, v2");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLfloat	v0 = (float)SvNV(ST(1))
;
	GLfloat	v1 = (float)SvNV(ST(2))
;
	GLfloat	v2 = (float)SvNV(ST(3))
;
#line 701 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform3fARB,"glUniform3fARB");
#line 1434 "pogl_gl_Mult_Prog.c"
#line 703 "pogl_gl_Mult_Prog.xs"
	{
		glUniform3fARB(location, v0, v1, v2);
	}
#line 1439 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform4fARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform4fARB)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "location, v0, v1, v2, v3");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLfloat	v0 = (float)SvNV(ST(1))
;
	GLfloat	v1 = (float)SvNV(ST(2))
;
	GLfloat	v2 = (float)SvNV(ST(3))
;
	GLfloat	v3 = (float)SvNV(ST(4))
;
#line 716 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform4fARB,"glUniform4fARB");
#line 1464 "pogl_gl_Mult_Prog.c"
#line 718 "pogl_gl_Mult_Prog.xs"
	{
		glUniform4fARB(location, v0, v1, v2, v3);
	}
#line 1469 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform1iARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform1iARB)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "location, v0");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLint	v0 = (int)SvIV(ST(1))
;
#line 728 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform1iARB,"glUniform1iARB");
#line 1488 "pogl_gl_Mult_Prog.c"
#line 730 "pogl_gl_Mult_Prog.xs"
	{
		glUniform1iARB(location, v0);
	}
#line 1493 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform2iARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform2iARB)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, v0, v1");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLint	v0 = (int)SvIV(ST(1))
;
	GLint	v1 = (int)SvIV(ST(2))
;
#line 741 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform2iARB,"glUniform2iARB");
#line 1514 "pogl_gl_Mult_Prog.c"
#line 743 "pogl_gl_Mult_Prog.xs"
	{
		glUniform2iARB(location, v0, v1);
	}
#line 1519 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform3iARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform3iARB)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "location, v0, v1, v2");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLint	v0 = (int)SvIV(ST(1))
;
	GLint	v1 = (int)SvIV(ST(2))
;
	GLint	v2 = (int)SvIV(ST(3))
;
#line 755 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform3iARB,"glUniform3iARB");
#line 1542 "pogl_gl_Mult_Prog.c"
#line 757 "pogl_gl_Mult_Prog.xs"
	{
		glUniform3iARB(location, v0, v1, v2);
	}
#line 1547 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform4iARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform4iARB)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "location, v0, v1, v2, v3");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLint	v0 = (int)SvIV(ST(1))
;
	GLint	v1 = (int)SvIV(ST(2))
;
	GLint	v2 = (int)SvIV(ST(3))
;
	GLint	v3 = (int)SvIV(ST(4))
;
#line 770 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform4iARB,"glUniform4iARB");
#line 1572 "pogl_gl_Mult_Prog.c"
#line 772 "pogl_gl_Mult_Prog.xs"
	{
		glUniform4iARB(location, v0, v1, v2, v3);
	}
#line 1577 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform1fvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform1fvARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, count, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	void *	value = INT2PTR(void *,SvIV(ST(2)))
;
#line 783 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform1fvARB,"glUniform1fvARB");
#line 1598 "pogl_gl_Mult_Prog.c"
#line 785 "pogl_gl_Mult_Prog.xs"
		glUniform1fvARB(location, count, value);
#line 1601 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform1fvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform1fvARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, count, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	SV *	value = ST(2)
;
#line 794 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform1fvARB,"glUniform1fvARB");
#line 1622 "pogl_gl_Mult_Prog.c"
#line 796 "pogl_gl_Mult_Prog.xs"
	{
		GLfloat * value_s = EL(value, sizeof(GLfloat));
		glUniform1fvARB(location, count, value_s);
	}
#line 1628 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform1fvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform1fvARB_p)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "location, ...");
    {
	GLint	location = (int)SvIV(ST(0))
;
#line 806 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform1fvARB,"glUniform1fvARB");
#line 1645 "pogl_gl_Mult_Prog.c"
#line 808 "pogl_gl_Mult_Prog.xs"
	{
		int i;
		GLsizei count = items - 1;
		GLfloat *value = malloc(sizeof(GLfloat) * count);

		for(i=0;i<count;i++) {
			value[i] = (GLfloat)SvNV(ST(i+1));
		}

		glUniform1fvARB(location, count, value);

		free(value);
	}
#line 1660 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform2fvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform2fvARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, count, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	void *	value = INT2PTR(void *,SvIV(ST(2)))
;
#line 829 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform2fvARB,"glUniform2fvARB");
#line 1681 "pogl_gl_Mult_Prog.c"
#line 831 "pogl_gl_Mult_Prog.xs"
		glUniform2fvARB(location, count, value);
#line 1684 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform2fvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform2fvARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, count, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	SV *	value = ST(2)
;
#line 840 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform2fvARB,"glUniform2fvARB");
#line 1705 "pogl_gl_Mult_Prog.c"
#line 842 "pogl_gl_Mult_Prog.xs"
	{
		GLfloat * value_s = EL(value, sizeof(GLfloat));
		glUniform2fvARB(location, count, value_s);
	}
#line 1711 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform2fvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform2fvARB_p)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "location, ...");
    {
	GLint	location = (int)SvIV(ST(0))
;
#line 852 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform2fvARB,"glUniform2fvARB");
#line 1728 "pogl_gl_Mult_Prog.c"
#line 854 "pogl_gl_Mult_Prog.xs"
	{
		int i;
		GLsizei elements = items - 1;
		GLsizei count = elements >> 1;
		GLfloat *value = malloc(sizeof(GLfloat) * elements);

		for(i=0;i<elements;i++) {
			value[i] = (GLfloat)SvNV(ST(i+1));
		}

		glUniform2fvARB(location, count, value);

		free(value);
	}
#line 1744 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform3fvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform3fvARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, count, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	void *	value = INT2PTR(void *,SvIV(ST(2)))
;
#line 876 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform3fvARB,"glUniform3fvARB");
#line 1765 "pogl_gl_Mult_Prog.c"
#line 878 "pogl_gl_Mult_Prog.xs"
		glUniform3fvARB(location, count, value);
#line 1768 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform3fvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform3fvARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, count, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	SV *	value = ST(2)
;
#line 887 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform3fvARB,"glUniform3fvARB");
#line 1789 "pogl_gl_Mult_Prog.c"
#line 889 "pogl_gl_Mult_Prog.xs"
	{
		GLfloat * value_s = EL(value, sizeof(GLfloat));
		glUniform3fvARB(location, count, value_s);
	}
#line 1795 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform3fvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform3fvARB_p)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "location, ...");
    {
	GLint	location = (int)SvIV(ST(0))
;
#line 899 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform3fvARB,"glUniform3fvARB");
#line 1812 "pogl_gl_Mult_Prog.c"
#line 901 "pogl_gl_Mult_Prog.xs"
	{
		int i;
		GLsizei elements = items - 1;
		GLsizei count = elements / 3;
		GLfloat *value = malloc(sizeof(GLfloat) * elements);

		for(i=0;i<elements;i++) {
			value[i] = (GLfloat)SvNV(ST(i+1));
		}

		glUniform3fvARB(location, count, value);

		free(value);
	}
#line 1828 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform4fvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform4fvARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, count, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	void *	value = INT2PTR(void *,SvIV(ST(2)))
;
#line 923 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform4fvARB,"glUniform4fvARB");
#line 1849 "pogl_gl_Mult_Prog.c"
#line 925 "pogl_gl_Mult_Prog.xs"
		glUniform4fvARB(location, count, value);
#line 1852 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform4fvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform4fvARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, count, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	SV *	value = ST(2)
;
#line 934 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform4fvARB,"glUniform4fvARB");
#line 1873 "pogl_gl_Mult_Prog.c"
#line 936 "pogl_gl_Mult_Prog.xs"
	{
		GLfloat * value_s = EL(value, sizeof(GLfloat));
		glUniform4fvARB(location, count, value_s);
	}
#line 1879 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform4fvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform4fvARB_p)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "location, ...");
    {
	GLint	location = (int)SvIV(ST(0))
;
#line 946 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform4fvARB,"glUniform4fvARB");
#line 1896 "pogl_gl_Mult_Prog.c"
#line 948 "pogl_gl_Mult_Prog.xs"
	{
		int i;
		GLsizei elements = items - 1;
		GLsizei count = elements >> 2;
		GLfloat *value = malloc(sizeof(GLfloat) * elements);

		for(i=0;i<elements;i++) {
			value[i] = (GLfloat)SvNV(ST(i+1));
		}

		glUniform4fvARB(location, count, value);

		free(value);
	}
#line 1912 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform1ivARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform1ivARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, count, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	void *	value = INT2PTR(void *,SvIV(ST(2)))
;
#line 970 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform1ivARB,"glUniform1ivARB");
#line 1933 "pogl_gl_Mult_Prog.c"
#line 972 "pogl_gl_Mult_Prog.xs"
		glUniform1ivARB(location, count, value);
#line 1936 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform1ivARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform1ivARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, count, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	SV *	value = ST(2)
;
#line 981 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform1ivARB,"glUniform1ivARB");
#line 1957 "pogl_gl_Mult_Prog.c"
#line 983 "pogl_gl_Mult_Prog.xs"
	{
		GLint * value_s = EL(value, sizeof(GLint));
		glUniform1ivARB(location, count, value_s);
	}
#line 1963 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform1ivARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform1ivARB_p)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "location, ...");
    {
	GLint	location = (int)SvIV(ST(0))
;
#line 993 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform1ivARB,"glUniform1ivARB");
#line 1980 "pogl_gl_Mult_Prog.c"
#line 995 "pogl_gl_Mult_Prog.xs"
	{
		int i;
		GLsizei count = items - 1;
		GLint *value = malloc(sizeof(GLint) * count);

		for(i=0;i<count;i++) {
			value[i] = SvIV(ST(i+1));
		}

		glUniform1ivARB(location, count, value);

		free(value);
	}
#line 1995 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform2ivARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform2ivARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, count, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	void *	value = INT2PTR(void *,SvIV(ST(2)))
;
#line 1016 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform2ivARB,"glUniform2ivARB");
#line 2016 "pogl_gl_Mult_Prog.c"
#line 1018 "pogl_gl_Mult_Prog.xs"
		glUniform2ivARB(location, count, value);
#line 2019 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform2ivARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform2ivARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, count, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	SV *	value = ST(2)
;
#line 1027 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform2ivARB,"glUniform2ivARB");
#line 2040 "pogl_gl_Mult_Prog.c"
#line 1029 "pogl_gl_Mult_Prog.xs"
	{
		GLint * value_s = EL(value, sizeof(GLint));
		glUniform2ivARB(location, count, value_s);
	}
#line 2046 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform2ivARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform2ivARB_p)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "location, ...");
    {
	GLint	location = (int)SvIV(ST(0))
;
#line 1039 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform2ivARB,"glUniform2ivARB");
#line 2063 "pogl_gl_Mult_Prog.c"
#line 1041 "pogl_gl_Mult_Prog.xs"
	{
		int i;
		GLsizei elements = items - 1;
		GLsizei count = elements >> 1;
		GLint *value = malloc(sizeof(GLint) * elements);

		for(i=0;i<elements;i++) {
			value[i] = SvIV(ST(i+1));
		}

		glUniform2ivARB(location, count, value);

		free(value);
	}
#line 2079 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform3ivARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform3ivARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, count, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	void *	value = INT2PTR(void *,SvIV(ST(2)))
;
#line 1063 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform3ivARB,"glUniform3ivARB");
#line 2100 "pogl_gl_Mult_Prog.c"
#line 1065 "pogl_gl_Mult_Prog.xs"
		glUniform3ivARB(location, count, value);
#line 2103 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform3ivARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform3ivARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, count, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	SV *	value = ST(2)
;
#line 1074 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform3ivARB,"glUniform3ivARB");
#line 2124 "pogl_gl_Mult_Prog.c"
#line 1076 "pogl_gl_Mult_Prog.xs"
	{
		GLint * value_s = EL(value, sizeof(GLint));
		glUniform3ivARB(location, count, value_s);
	}
#line 2130 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform3ivARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform3ivARB_p)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "location, ...");
    {
	GLint	location = (int)SvIV(ST(0))
;
#line 1086 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform3ivARB,"glUniform3ivARB");
#line 2147 "pogl_gl_Mult_Prog.c"
#line 1088 "pogl_gl_Mult_Prog.xs"
	{
		int i;
		GLsizei elements = items - 1;
		GLsizei count = elements / 3;
		GLint *value = malloc(sizeof(GLint) * elements);

		for(i=0;i<elements;i++) {
			value[i] = SvIV(ST(i+1));
		}

		glUniform3ivARB(location, count, value);

		free(value);
	}
#line 2163 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform4ivARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform4ivARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, count, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	void *	value = INT2PTR(void *,SvIV(ST(2)))
;
#line 1110 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform4ivARB,"glUniform4ivARB");
#line 2184 "pogl_gl_Mult_Prog.c"
#line 1112 "pogl_gl_Mult_Prog.xs"
		glUniform4ivARB(location, count, value);
#line 2187 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform4ivARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform4ivARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "location, count, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	SV *	value = ST(2)
;
#line 1121 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform4ivARB,"glUniformifvARB");
#line 2208 "pogl_gl_Mult_Prog.c"
#line 1123 "pogl_gl_Mult_Prog.xs"
	{
		GLint * value_s = EL(value, sizeof(GLint));
		glUniform4ivARB(location, count, value_s);
	}
#line 2214 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniform4ivARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniform4ivARB_p)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "location, ...");
    {
	GLint	location = (int)SvIV(ST(0))
;
#line 1133 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniform4ivARB,"glUniform4ivARB");
#line 2231 "pogl_gl_Mult_Prog.c"
#line 1135 "pogl_gl_Mult_Prog.xs"
	{
		int i;
		GLsizei elements = items - 1;
		GLsizei count = elements >> 2;
		GLint *value = malloc(sizeof(GLint) * elements);

		for(i=0;i<elements;i++) {
			value[i] = SvIV(ST(i+1));
		}

		glUniform4ivARB(location, count, value);

		free(value);
	}
#line 2247 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniformMatrix2fvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniformMatrix2fvARB_c)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "location, count, transpose, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	GLboolean	transpose = (bool)SvTRUE(ST(2))
;
	void *	value = INT2PTR(void *,SvIV(ST(3)))
;
#line 1158 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniformMatrix2fvARB,"glUniformMatrix2fvARB");
#line 2270 "pogl_gl_Mult_Prog.c"
#line 1160 "pogl_gl_Mult_Prog.xs"
		glUniformMatrix2fvARB(location, count, transpose, value);
#line 2273 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniformMatrix2fvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniformMatrix2fvARB_s)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "location, count, transpose, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	GLboolean	transpose = (bool)SvTRUE(ST(2))
;
	SV *	value = ST(3)
;
#line 1170 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniformMatrix2fvARB,"glUniformMatrix2fvARB");
#line 2296 "pogl_gl_Mult_Prog.c"
#line 1172 "pogl_gl_Mult_Prog.xs"
	{
		GLfloat * value_s = EL(value, sizeof(GLfloat));
		glUniformMatrix2fvARB(location, count, transpose, value_s);
	}
#line 2302 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniformMatrix2fvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniformMatrix2fvARB_p)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "location, transpose, ...");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLboolean	transpose = (bool)SvTRUE(ST(1))
;
#line 1183 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniformMatrix2fvARB,"glUniformMatrix2fvARB");
#line 2321 "pogl_gl_Mult_Prog.c"
#line 1185 "pogl_gl_Mult_Prog.xs"
	{
		int i;
		GLsizei elements = items - 2;
		GLsizei count = elements / 4;
		GLfloat *value = malloc(sizeof(GLfloat) * elements);

		for(i=0;i<elements;i++) {
			value[i] = (GLfloat)SvNV(ST(i+2));
		}

		glUniformMatrix2fvARB(location, count, transpose, value);

		free(value);
	}
#line 2337 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniformMatrix3fvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniformMatrix3fvARB_c)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "location, count, transpose, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	GLboolean	transpose = (bool)SvTRUE(ST(2))
;
	void *	value = INT2PTR(void *,SvIV(ST(3)))
;
#line 1208 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniformMatrix3fvARB,"glUniformMatrix2fvARB");
#line 2360 "pogl_gl_Mult_Prog.c"
#line 1210 "pogl_gl_Mult_Prog.xs"
		glUniformMatrix3fvARB(location, count, transpose, value);
#line 2363 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniformMatrix3fvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniformMatrix3fvARB_s)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "location, count, transpose, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	GLboolean	transpose = (bool)SvTRUE(ST(2))
;
	SV *	value = ST(3)
;
#line 1220 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniformMatrix3fvARB,"glUniformMatrix3fvARB");
#line 2386 "pogl_gl_Mult_Prog.c"
#line 1222 "pogl_gl_Mult_Prog.xs"
	{
		GLfloat * value_s = EL(value, sizeof(GLfloat));
		glUniformMatrix3fvARB(location, count, transpose, value_s);
	}
#line 2392 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniformMatrix3fvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniformMatrix3fvARB_p)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "location, transpose, ...");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLboolean	transpose = (bool)SvTRUE(ST(1))
;
#line 1233 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniformMatrix3fvARB,"glUniformMatrix3fvARB");
#line 2411 "pogl_gl_Mult_Prog.c"
#line 1235 "pogl_gl_Mult_Prog.xs"
	{
		int i;
		GLsizei elements = items - 2;
		GLsizei count = elements / 9;
		GLfloat *value = malloc(sizeof(GLfloat) * elements);

		for(i=0;i<elements;i++) {
			value[i] = (GLfloat)SvNV(ST(i+2));
		}

		glUniformMatrix3fvARB(location, count, transpose, value);

		free(value);
	}
#line 2427 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniformMatrix4fvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniformMatrix4fvARB_c)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "location, count, transpose, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	GLboolean	transpose = (bool)SvTRUE(ST(2))
;
	void *	value = INT2PTR(void *,SvIV(ST(3)))
;
#line 1258 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniformMatrix4fvARB,"glUniformMatrix4fvARB");
#line 2450 "pogl_gl_Mult_Prog.c"
#line 1260 "pogl_gl_Mult_Prog.xs"
		glUniformMatrix4fvARB(location, count, transpose, value);
#line 2453 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniformMatrix4fvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniformMatrix4fvARB_s)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "location, count, transpose, value");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLsizei	count = (int)SvIV(ST(1))
;
	GLboolean	transpose = (bool)SvTRUE(ST(2))
;
	SV *	value = ST(3)
;
#line 1270 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniformMatrix4fvARB,"glUniformMatrix4fvARB");
#line 2476 "pogl_gl_Mult_Prog.c"
#line 1272 "pogl_gl_Mult_Prog.xs"
	{
		GLfloat * value_s = EL(value, sizeof(GLfloat));
		glUniformMatrix4fvARB(location, count, transpose, value_s);
	}
#line 2482 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glUniformMatrix4fvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glUniformMatrix4fvARB_p)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "location, transpose, ...");
    {
	GLint	location = (int)SvIV(ST(0))
;
	GLboolean	transpose = (bool)SvTRUE(ST(1))
;
#line 1283 "pogl_gl_Mult_Prog.xs"
		loadProc(glUniformMatrix4fvARB,"glUniformMatrix4fvARB");
#line 2501 "pogl_gl_Mult_Prog.c"
#line 1285 "pogl_gl_Mult_Prog.xs"
	{
		int i;
		GLsizei elements = items - 2;
		GLsizei count = elements / 16;
		GLfloat *value = malloc(sizeof(GLfloat) * elements);

		for(i=0;i<elements;i++) {
			value[i] = (GLfloat)SvNV(ST(i+2));
		}

		glUniformMatrix4fvARB(location, count, transpose, value);

		free(value);
	}
#line 2517 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetObjectParameterfvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetObjectParameterfvARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "obj, pname, params");
    {
	GLhandleARB	obj = (unsigned int)SvUV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 1307 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetObjectParameterfvARB,"glGetObjectParameterfvARB");
#line 2538 "pogl_gl_Mult_Prog.c"
#line 1309 "pogl_gl_Mult_Prog.xs"
		glGetObjectParameterfvARB(obj,pname,params);
#line 2541 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetObjectParameterfvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetObjectParameterfvARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "obj, pname, params");
    {
	GLhandleARB	obj = (unsigned int)SvUV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 1318 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetObjectParameterfvARB,"glGetObjectParameterfvARB");
#line 2562 "pogl_gl_Mult_Prog.c"
#line 1320 "pogl_gl_Mult_Prog.xs"
	{
		GLfloat * params_s = EL(params, sizeof(GLfloat));
		glGetObjectParameterfvARB(obj,pname,params_s);
	}
#line 2568 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetObjectParameterfvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetObjectParameterfvARB_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "obj, pname");
    {
	GLhandleARB	obj = (unsigned int)SvUV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	GLfloat	RETVAL;
	dXSTARG;
#line 1331 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetObjectParameterfvARB,"glGetObjectParameterfvARB");
#line 2589 "pogl_gl_Mult_Prog.c"
#line 1333 "pogl_gl_Mult_Prog.xs"
	{
		GLfloat	ret;
		glGetObjectParameterfvARB(obj,pname,&ret);
		RETVAL = ret;
	}
#line 2596 "pogl_gl_Mult_Prog.c"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_OpenGL_glGetObjectParameterivARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetObjectParameterivARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "obj, pname, params");
    {
	GLhandleARB	obj = (unsigned int)SvUV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 1348 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetObjectParameterivARB,"glGetObjectParameterivARB");
#line 2618 "pogl_gl_Mult_Prog.c"
#line 1350 "pogl_gl_Mult_Prog.xs"
		glGetObjectParameterivARB(obj,pname,params);
#line 2621 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetObjectParameterivARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetObjectParameterivARB_s)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "obj, pname, params");
    {
	GLhandleARB	obj = (unsigned int)SvUV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	SV *	params = ST(2)
;
#line 1359 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetObjectParameterivARB,"glGetObjectParameterivARB");
#line 2642 "pogl_gl_Mult_Prog.c"
#line 1361 "pogl_gl_Mult_Prog.xs"
	{
		GLint * params_s = EL(params, sizeof(GLint));
		glGetObjectParameterivARB(obj,pname,params_s);
	}
#line 2648 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetObjectParameterivARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetObjectParameterivARB_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "obj, pname");
    {
	GLhandleARB	obj = (unsigned int)SvUV(ST(0))
;
	GLenum	pname = (int)SvIV(ST(1))
;
	GLint	RETVAL;
	dXSTARG;
#line 1372 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetObjectParameterivARB,"glGetObjectParameterivARB");
#line 2669 "pogl_gl_Mult_Prog.c"
#line 1374 "pogl_gl_Mult_Prog.xs"
	{
		GLint	ret;
		glGetObjectParameterivARB(obj,pname,&ret);
		RETVAL = ret;
	}
#line 2676 "pogl_gl_Mult_Prog.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_OpenGL_glGetInfoLogARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetInfoLogARB_c)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "obj, maxLength, length, infoLog");
    {
	GLhandleARB	obj = (unsigned int)SvUV(ST(0))
;
	GLsizei	maxLength = (int)SvIV(ST(1))
;
	void *	length = INT2PTR(void *,SvIV(ST(2)))
;
	void *	infoLog = INT2PTR(void *,SvIV(ST(3)))
;
#line 1390 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetInfoLogARB,"glGetInfoLogARB");
#line 2700 "pogl_gl_Mult_Prog.c"
#line 1392 "pogl_gl_Mult_Prog.xs"
		glGetInfoLogARB(obj, maxLength, length, infoLog);
#line 2703 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetInfoLogARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetInfoLogARB_p)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "obj");
    {
	GLhandleARB	obj = (unsigned int)SvUV(ST(0))
;
	SV *	RETVAL;
#line 1399 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetObjectParameterivARB,"glGetObjectParameterivARB");
		loadProc(glGetInfoLogARB,"glGetInfoLogARB");
#line 2722 "pogl_gl_Mult_Prog.c"
#line 1402 "pogl_gl_Mult_Prog.xs"
	{
		GLint maxLength;
		glGetObjectParameterivARB(obj,GL_OBJECT_INFO_LOG_LENGTH_ARB,(GLvoid *)&maxLength);
		if (maxLength)
		{
			GLint length;
			GLcharARB * infoLog = malloc(maxLength+1);
			glGetInfoLogARB(obj,maxLength,&length,infoLog);
			infoLog[length] = 0;
			if (*infoLog)
				RETVAL = newSVpv(infoLog, 0);
			else
				RETVAL = newSVsv(&PL_sv_undef);

			free(infoLog);
		}
		else
		{
			RETVAL = newSVsv(&PL_sv_undef);
		}
	}
#line 2745 "pogl_gl_Mult_Prog.c"
	ST(0) = RETVAL;
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}


XS_EUPXS(XS_OpenGL_glGetAttachedObjectsARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetAttachedObjectsARB_c)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "containerObj, maxCount, count, obj");
    {
	GLhandleARB	containerObj = (unsigned int)SvUV(ST(0))
;
	GLsizei	maxCount = (int)SvIV(ST(1))
;
	void *	count = INT2PTR(void *,SvIV(ST(2)))
;
	void *	obj = INT2PTR(void *,SvIV(ST(3)))
;
#line 1434 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetAttachedObjectsARB,"glGetAttachedObjectsARB");
#line 2770 "pogl_gl_Mult_Prog.c"
#line 1436 "pogl_gl_Mult_Prog.xs"
		glGetAttachedObjectsARB(containerObj, maxCount, count, obj);
#line 2773 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetAttachedObjectsARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetAttachedObjectsARB_s)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "containerObj, maxCount, count, obj");
    {
	GLhandleARB	containerObj = (unsigned int)SvUV(ST(0))
;
	GLsizei	maxCount = (int)SvIV(ST(1))
;
	void *	count = INT2PTR(void *,SvIV(ST(2)))
;
	SV *	obj = ST(3)
;
#line 1446 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetObjectParameterivARB,"glGetObjectParameterivARB");
		loadProc(glGetAttachedObjectsARB,"glGetAttachedObjectsARB");
#line 2797 "pogl_gl_Mult_Prog.c"
#line 1449 "pogl_gl_Mult_Prog.xs"
	{
		GLint len;
		glGetObjectParameterivARB(containerObj,GL_OBJECT_ATTACHED_OBJECTS_ARB,
			(GLvoid *)&len);
		if (len)
		{
			GLsizei * count_s = EL(count, sizeof(GLsizei));
			GLhandleARB * obj_s = EL(obj, sizeof(GLhandleARB)*len);
			glGetAttachedObjectsARB(containerObj, maxCount, count_s, obj_s);
		}
	}
#line 2810 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetAttachedObjectsARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetAttachedObjectsARB_p)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "containerObj");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLhandleARB	containerObj = (unsigned int)SvUV(ST(0))
;
#line 1466 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetObjectParameterivARB,"glGetObjectParameterivARB");
		loadProc(glGetAttachedObjectsARB,"glGetAttachedObjectsARB");
#line 2830 "pogl_gl_Mult_Prog.c"
#line 1469 "pogl_gl_Mult_Prog.xs"
	{
		GLsizei maxCount;
		GLsizei count;
		GLhandleARB *obj;
		int i;

		glGetObjectParameterivARB(containerObj,GL_OBJECT_ATTACHED_OBJECTS_ARB,
			(GLvoid *)&maxCount);
		obj = malloc(sizeof(GLhandleARB)*maxCount);

		glGetAttachedObjectsARB(containerObj, maxCount, &count, obj);

		EXTEND(sp, count);
		for(i=0;i<count;i++)
			PUSHs(sv_2mortal(newSViv(obj[i])));

		free(obj);
	}
#line 2850 "pogl_gl_Mult_Prog.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glGetUniformLocationARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetUniformLocationARB_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 1494 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetUniformLocationARB,"glGetUniformLocationARB");
#line 2872 "pogl_gl_Mult_Prog.c"
#line 1496 "pogl_gl_Mult_Prog.xs"
		RETVAL = glGetUniformLocationARB(programObj, name);
#line 2875 "pogl_gl_Mult_Prog.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_OpenGL_glGetUniformLocationARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetUniformLocationARB_p)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "programObj, ...");
    {
	GLhandleARB	programObj = (unsigned int)SvUV(ST(0))
;
	GLint	RETVAL;
	dXSTARG;
#line 1505 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetUniformLocationARB,"glGetUniformLocationARB");
#line 2895 "pogl_gl_Mult_Prog.c"
#line 1507 "pogl_gl_Mult_Prog.xs"
	{
		GLcharARB *name = (GLcharARB *)SvPV(ST(1),PL_na);
		RETVAL = glGetUniformLocationARB(programObj, name);
	}
#line 2901 "pogl_gl_Mult_Prog.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_OpenGL_glGetActiveUniformARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetActiveUniformARB_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 1525 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetActiveUniformARB,"glGetActiveUniformARB");
#line 2931 "pogl_gl_Mult_Prog.c"
#line 1527 "pogl_gl_Mult_Prog.xs"
		glGetActiveUniformARB(programObj,index,maxLength,length,size,type,name);
#line 2934 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetActiveUniformARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetActiveUniformARB_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 1540 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetActiveUniformARB,"glGetActiveUniformARB");
#line 2963 "pogl_gl_Mult_Prog.c"
#line 1542 "pogl_gl_Mult_Prog.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));
		glGetActiveUniformARB(programObj,index,maxLength,length_s,size_s,type_s,name_s);
	}
#line 2972 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetActiveUniformARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetActiveUniformARB_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 1556 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetObjectParameterivARB,"glGetObjectParameterivARB");
		loadProc(glGetActiveUniformARB,"glGetActiveUniformARB");
#line 2994 "pogl_gl_Mult_Prog.c"
#line 1559 "pogl_gl_Mult_Prog.xs"
	{
		GLsizei maxLength;
		glGetObjectParameterivARB(programObj,GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB,
			(GLvoid *)&maxLength);
		if (maxLength)
		{
			GLsizei length;
			GLint size;
			GLenum type;
			GLcharARB *name;

			name = malloc(maxLength+1);
			glGetActiveUniformARB(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 3033 "pogl_gl_Mult_Prog.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glGetUniformfvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetUniformfvARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "programObj, location, params");
    {
	GLhandleARB	programObj = (unsigned int)SvUV(ST(0))
;
	GLint	location = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 1604 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetUniformfvARB,"glGetUniformfvARB");
#line 3055 "pogl_gl_Mult_Prog.c"
#line 1606 "pogl_gl_Mult_Prog.xs"
		glGetUniformfvARB(programObj, location, params);
#line 3058 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetUniformfvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetUniformfvARB_p)
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "programObj, location, count=1");
    {
	GLhandleARB	programObj = (unsigned int)SvUV(ST(0))
;
	GLint	location = (int)SvIV(ST(1))
;
	int	count;

	if (items < 3)
	    count = 1;
	else {
	    count = (int)SvIV(ST(2))
;
	}
#line 1615 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetUniformfvARB,"glGetUniformfvARB");
#line 3085 "pogl_gl_Mult_Prog.c"
#line 1617 "pogl_gl_Mult_Prog.xs"
	{
		int i;
		GLfloat	*ret = malloc(sizeof(GLfloat)*count);
		glGetUniformfvARB(programObj, location, ret);

		for(i=0;i<count;i++)
			PUSHs(sv_2mortal(newSVnv(ret[i])));
	}
#line 3095 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetUniformivARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetUniformivARB_c)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "programObj, location, params");
    {
	GLhandleARB	programObj = (unsigned int)SvUV(ST(0))
;
	GLint	location = (int)SvIV(ST(1))
;
	void *	params = INT2PTR(void *,SvIV(ST(2)))
;
#line 1633 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetUniformivARB,"glGetUniformivARB");
#line 3116 "pogl_gl_Mult_Prog.c"
#line 1635 "pogl_gl_Mult_Prog.xs"
		glGetUniformivARB(programObj, location, params);
#line 3119 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetUniformivARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetUniformivARB_p)
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "programObj, location, count=1");
    {
	GLhandleARB	programObj = (unsigned int)SvUV(ST(0))
;
	GLint	location = (int)SvIV(ST(1))
;
	int	count;

	if (items < 3)
	    count = 1;
	else {
	    count = (int)SvIV(ST(2))
;
	}
#line 1644 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetUniformivARB,"glGetUniformivARB");
#line 3146 "pogl_gl_Mult_Prog.c"
#line 1646 "pogl_gl_Mult_Prog.xs"
	{
		int i;
		GLint	*ret = malloc(sizeof(GLint)*count);
		glGetUniformivARB(programObj, location, ret);

		for(i=0;i<count;i++)
			PUSHs(sv_2mortal(newSViv(ret[i])));
	}
#line 3156 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetShaderSourceARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetShaderSourceARB_c)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "obj, maxLength, length, source");
    {
	GLhandleARB	obj = (unsigned int)SvUV(ST(0))
;
	GLsizei	maxLength = (int)SvIV(ST(1))
;
	void *	length = INT2PTR(void *,SvIV(ST(2)))
;
	void *	source = INT2PTR(void *,SvIV(ST(3)))
;
#line 1663 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetShaderSourceARB,"glGetShaderSourceARB");
#line 3179 "pogl_gl_Mult_Prog.c"
#line 1665 "pogl_gl_Mult_Prog.xs"
		glGetShaderSourceARB(obj, maxLength, length, source);
#line 3182 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGetShaderSourceARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGetShaderSourceARB_p)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "obj");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLhandleARB	obj = (unsigned int)SvUV(ST(0))
;
#line 1672 "pogl_gl_Mult_Prog.xs"
		loadProc(glGetObjectParameterivARB,"glGetObjectParameterivARB");
		loadProc(glGetShaderSourceARB,"glGetShaderSourceARB");
#line 3202 "pogl_gl_Mult_Prog.c"
#line 1675 "pogl_gl_Mult_Prog.xs"
	{
		GLsizei maxLength;
		glGetObjectParameterivARB(obj,GL_OBJECT_SHADER_SOURCE_LENGTH_ARB,
			(GLvoid *)&maxLength);

		EXTEND(sp,1);

		if (maxLength)
		{
			GLsizei length;
			GLcharARB *source;

			source = malloc(maxLength+1);
			glGetShaderSourceARB(obj,maxLength,&length,source);
			source[length] = 0;

			if (*source)
			{
				PUSHs(sv_2mortal(newSVpv(source,0)));
			}
			else
			{
				PUSHs(sv_2mortal(newSVsv(&PL_sv_undef)));
			}

			free(source);
		}
		else
		{
			PUSHs(sv_2mortal(newSVsv(&PL_sv_undef)));
		}
	}
#line 3236 "pogl_gl_Mult_Prog.c"
	PUTBACK;
	return;
    }
}

#endif
#ifdef GL_ARB_vertex_program
#define XSubPPtmpAAAC 1


XS_EUPXS(XS_OpenGL_glProgramStringARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramStringARB_c)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "target, format, len, string");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	format = (int)SvIV(ST(1))
;
	GLsizei	len = (int)SvIV(ST(2))
;
	void *	string = INT2PTR(void *,SvIV(ST(3)))
;
#line 1721 "pogl_gl_Mult_Prog.xs"
		loadProc(glProgramStringARB,"glProgramStringARB");
#line 3264 "pogl_gl_Mult_Prog.c"
#line 1723 "pogl_gl_Mult_Prog.xs"
		glProgramStringARB(target,format,len,string);
#line 3267 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glProgramStringARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramStringARB_s)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "target, format, len, string");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLenum	format = (int)SvIV(ST(1))
;
	GLsizei	len = (int)SvIV(ST(2))
;
	SV *	string = ST(3)
;
#line 1733 "pogl_gl_Mult_Prog.xs"
		loadProc(glProgramStringARB,"glProgramStringARB");
#line 3290 "pogl_gl_Mult_Prog.c"
#line 1735 "pogl_gl_Mult_Prog.xs"
	{
		GLvoid * string_s = EL(string, len);
		glProgramStringARB(target,format,len,string_s);
	}
#line 3296 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glProgramStringARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramStringARB_p)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, string");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	char *	string = (char *)SvPV_nolen(ST(1))
;
#line 1747 "pogl_gl_Mult_Prog.xs"
		loadProc(glProgramStringARB,"glProgramStringARB");
#line 3315 "pogl_gl_Mult_Prog.c"
#line 1749 "pogl_gl_Mult_Prog.xs"
	{
		int len = strlen(string);
		glProgramStringARB(target,GL_PROGRAM_FORMAT_ASCII_ARB,len,string);
	}
#line 3321 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glBindProgramARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glBindProgramARB)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "target, program");
    {
	GLenum	target = (int)SvIV(ST(0))
;
	GLuint	program = (unsigned int)SvUV(ST(1))
;
#line 1760 "pogl_gl_Mult_Prog.xs"
		loadProc(glBindProgramARB,"glBindProgramARB");
#line 3340 "pogl_gl_Mult_Prog.c"

	glBindProgramARB(target, program);
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glDeleteProgramsARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glDeleteProgramsARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "n, programs");
    {
	GLsizei	n = (int)SvIV(ST(0))
;
	void *	programs = INT2PTR(void *,SvIV(ST(1)))
;
#line 1768 "pogl_gl_Mult_Prog.xs"
		loadProc(glDeleteProgramsARB,"glDeleteProgramsARB");
#line 3361 "pogl_gl_Mult_Prog.c"
#line 1770 "pogl_gl_Mult_Prog.xs"
	{
		glDeleteProgramsARB(n,(GLuint*)programs);
	}
#line 3366 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glDeleteProgramsARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glDeleteProgramsARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "n, programs");
    {
	GLsizei	n = (int)SvIV(ST(0))
;
	SV *	programs = ST(1)
;
#line 1780 "pogl_gl_Mult_Prog.xs"
		loadProc(glDeleteProgramsARB,"glDeleteProgramsARB");
#line 3385 "pogl_gl_Mult_Prog.c"
#line 1782 "pogl_gl_Mult_Prog.xs"
	{
		GLuint * programs_s = EL(programs, sizeof(GLuint)*n);
		glDeleteProgramsARB(n,programs_s);
	}
#line 3391 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glDeleteProgramsARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glDeleteProgramsARB_p)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
#line 1791 "pogl_gl_Mult_Prog.xs"
		loadProc(glDeleteProgramsARB,"glDeleteProgramsARB");
#line 3405 "pogl_gl_Mult_Prog.c"
#line 1793 "pogl_gl_Mult_Prog.xs"
	{
		if (items) {
			GLuint * list = malloc(sizeof(GLuint) * items);
			int i;

			for (i=0;i<items;i++)
				list[i] = SvIV(ST(i));

			glDeleteProgramsARB(items, list);
			free(list);
		}
	}
#line 3419 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGenProgramsARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGenProgramsARB_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "n, programs");
    {
	GLsizei	n = (int)SvIV(ST(0))
;
	void *	programs = INT2PTR(void *,SvIV(ST(1)))
;
#line 1812 "pogl_gl_Mult_Prog.xs"
		loadProc(glGenProgramsARB,"glGenProgramsARB");
#line 3438 "pogl_gl_Mult_Prog.c"
#line 1814 "pogl_gl_Mult_Prog.xs"
	{
		glGenProgramsARB(n,(GLuint*)programs);
	}
#line 3443 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGenProgramsARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGenProgramsARB_s)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "n, programs");
    {
	GLsizei	n = (int)SvIV(ST(0))
;
	SV *	programs = ST(1)
;
#line 1824 "pogl_gl_Mult_Prog.xs"
		loadProc(glGenProgramsARB,"glGenProgramsARB");
#line 3462 "pogl_gl_Mult_Prog.c"
#line 1826 "pogl_gl_Mult_Prog.xs"
	{
		GLuint * programs_s = EL(programs, sizeof(GLuint)*n);
		glGenProgramsARB(n, programs_s);
	}
#line 3468 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glGenProgramsARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glGenProgramsARB_p)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "n");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GLsizei	n = (int)SvIV(ST(0))
;
#line 1836 "pogl_gl_Mult_Prog.xs"
		loadProc(glGenProgramsARB,"glGenProgramsARB");
#line 3487 "pogl_gl_Mult_Prog.c"
#line 1838 "pogl_gl_Mult_Prog.xs"
	if (n)
	{
		GLuint * programs = malloc(sizeof(GLuint) * n);
		int i;

		glGenProgramsARB(n, programs);

		EXTEND(sp, n);
		for(i=0;i<n;i++)
			PUSHs(sv_2mortal(newSViv(programs[i])));

		free(programs);
	} 
#line 3502 "pogl_gl_Mult_Prog.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_OpenGL_glProgramEnvParameter4dARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramEnvParameter4dARB)
{
    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 1862 "pogl_gl_Mult_Prog.xs"
		loadProc(glProgramEnvParameter4dARB,"glProgramEnvParameter4dARB");
#line 3530 "pogl_gl_Mult_Prog.c"

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


XS_EUPXS(XS_OpenGL_glProgramEnvParameter4dvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramEnvParameter4dvARB_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 1871 "pogl_gl_Mult_Prog.xs"
		loadProc(glProgramEnvParameter4dvARB,"glProgramEnvParameter4dvARB");
#line 3553 "pogl_gl_Mult_Prog.c"
#line 1873 "pogl_gl_Mult_Prog.xs"
		glProgramEnvParameter4dvARB(target,index,(GLdouble*)v);
#line 3556 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glProgramEnvParameter4dvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramEnvParameter4dvARB_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 1882 "pogl_gl_Mult_Prog.xs"
		loadProc(glProgramEnvParameter4dvARB,"glProgramEnvParameter4dvARB");
#line 3577 "pogl_gl_Mult_Prog.c"
#line 1884 "pogl_gl_Mult_Prog.xs"
	{
		GLdouble * v_s = EL(v, sizeof(GLdouble)*4);
		glProgramEnvParameter4dvARB(target,index,v_s);
	}
#line 3583 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glProgramEnvParameter4dvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramEnvParameter4dvARB_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 1900 "pogl_gl_Mult_Prog.xs"
		loadProc(glProgramEnvParameter4dvARB,"glProgramEnvParameter4dvARB");
#line 3610 "pogl_gl_Mult_Prog.c"
#line 1902 "pogl_gl_Mult_Prog.xs"
	{
		GLdouble param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glProgramEnvParameter4dvARB(target,index,param);
	}
#line 3620 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glProgramEnvParameter4fARB); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramEnvParameter4fARB)
{
    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 1921 "pogl_gl_Mult_Prog.xs"
		loadProc(glProgramEnvParameter4fARB,"glProgramEnvParameter4fARB");
#line 3647 "pogl_gl_Mult_Prog.c"

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


XS_EUPXS(XS_OpenGL_glProgramEnvParameter4fvARB_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramEnvParameter4fvARB_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 1930 "pogl_gl_Mult_Prog.xs"
		loadProc(glProgramEnvParameter4fvARB,"glProgramEnvParameter4fvARB");
#line 3670 "pogl_gl_Mult_Prog.c"
#line 1932 "pogl_gl_Mult_Prog.xs"
		glProgramEnvParameter4fvARB(target,index,(GLfloat*)v);
#line 3673 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glProgramEnvParameter4fvARB_s); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramEnvParameter4fvARB_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 1941 "pogl_gl_Mult_Prog.xs"
		loadProc(glProgramEnvParameter4fvARB,"glProgramEnvParameter4fvARB");
#line 3694 "pogl_gl_Mult_Prog.c"
#line 1943 "pogl_gl_Mult_Prog.xs"
	{
		GLfloat * v_s = EL(v, sizeof(GLfloat)*4);
		glProgramEnvParameter4fvARB(target,index,v_s);
	}
#line 3700 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_OpenGL_glProgramEnvParameter4fvARB_p); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_OpenGL_glProgramEnvParameter4fvARB_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 1959 "pogl_gl_Mult_Prog.xs"
		loadProc(glProgramEnvParameter4fvARB,"glProgramEnvParameter4fvARB");
#line 3727 "pogl_gl_Mult_Prog.c"
#line 1961 "pogl_gl_Mult_Prog.xs"
	{
		GLfloat param[4];
		param[0] = x;
		param[1] = y;
		param[2] = z;
		param[3] = w;
		glProgramEnvParameter4fvARB(target,index,param);
	}
#line 3737 "pogl_gl_Mult_Prog.c"
    }
    XSRETURN_EMPTY;
}

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

    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
#ifdef XS_APIVERSION_BOOTCHECK
    XS_APIVERSION_BOOTCHECK;
#endif
    XS_VERSION_BOOTCHECK;

#if XSubPPtmpAAAA
        newXS("OpenGL::glMultiTexCoord3dARB", XS_OpenGL_glMultiTexCoord3dARB, file);
        newXS("OpenGL::glMultiTexCoord3dvARB_c", XS_OpenGL_glMultiTexCoord3dvARB_c, file);
        newXS("OpenGL::glMultiTexCoord3dvARB_s", XS_OpenGL_glMultiTexCoord3dvARB_s, file);
        newXS("OpenGL::glMultiTexCoord3dvARB_p", XS_OpenGL_glMultiTexCoord3dvARB_p, file);
        newXS("OpenGL::glMultiTexCoord3fARB", XS_OpenGL_glMultiTexCoord3fARB, file);
        newXS("OpenGL::glMultiTexCoord3fvARB_c", XS_OpenGL_glMultiTexCoord3fvARB_c, file);
        newXS("OpenGL::glMultiTexCoord3fvARB_s", XS_OpenGL_glMultiTexCoord3fvARB_s, file);
        newXS("OpenGL::glMultiTexCoord3fvARB_p", XS_OpenGL_glMultiTexCoord3fvARB_p, file);
        newXS("OpenGL::glMultiTexCoord3iARB", XS_OpenGL_glMultiTexCoord3iARB, file);
        newXS("OpenGL::glMultiTexCoord3ivARB_c", XS_OpenGL_glMultiTexCoord3ivARB_c, file);
        newXS("OpenGL::glMultiTexCoord3ivARB_s", XS_OpenGL_glMultiTexCoord3ivARB_s, file);
        newXS("OpenGL::glMultiTexCoord3ivARB_p", XS_OpenGL_glMultiTexCoord3ivARB_p, file);
        newXS("OpenGL::glMultiTexCoord3sARB", XS_OpenGL_glMultiTexCoord3sARB, file);
        newXS("OpenGL::glMultiTexCoord3svARB_c", XS_OpenGL_glMultiTexCoord3svARB_c, file);
        newXS("OpenGL::glMultiTexCoord3svARB_s", XS_OpenGL_glMultiTexCoord3svARB_s, file);
        newXS("OpenGL::glMultiTexCoord3svARB_p", XS_OpenGL_glMultiTexCoord3svARB_p, file);
        newXS("OpenGL::glMultiTexCoord4dARB", XS_OpenGL_glMultiTexCoord4dARB, file);
        newXS("OpenGL::glMultiTexCoord4dvARB_c", XS_OpenGL_glMultiTexCoord4dvARB_c, file);
        newXS("OpenGL::glMultiTexCoord4dvARB_s", XS_OpenGL_glMultiTexCoord4dvARB_s, file);
        newXS("OpenGL::glMultiTexCoord4dvARB_p", XS_OpenGL_glMultiTexCoord4dvARB_p, file);
        newXS("OpenGL::glMultiTexCoord4fARB", XS_OpenGL_glMultiTexCoord4fARB, file);
        newXS("OpenGL::glMultiTexCoord4fvARB_c", XS_OpenGL_glMultiTexCoord4fvARB_c, file);
        newXS("OpenGL::glMultiTexCoord4fvARB_s", XS_OpenGL_glMultiTexCoord4fvARB_s, file);
        newXS("OpenGL::glMultiTexCoord4fvARB_p", XS_OpenGL_glMultiTexCoord4fvARB_p, file);
        newXS("OpenGL::glMultiTexCoord4iARB", XS_OpenGL_glMultiTexCoord4iARB, file);
        newXS("OpenGL::glMultiTexCoord4ivARB_c", XS_OpenGL_glMultiTexCoord4ivARB_c, file);
        newXS("OpenGL::glMultiTexCoord4ivARB_s", XS_OpenGL_glMultiTexCoord4ivARB_s, file);
        newXS("OpenGL::glMultiTexCoord4ivARB_p", XS_OpenGL_glMultiTexCoord4ivARB_p, file);
        newXS("OpenGL::glMultiTexCoord4sARB", XS_OpenGL_glMultiTexCoord4sARB, file);
        newXS("OpenGL::glMultiTexCoord4svARB_c", XS_OpenGL_glMultiTexCoord4svARB_c, file);
        newXS("OpenGL::glMultiTexCoord4svARB_s", XS_OpenGL_glMultiTexCoord4svARB_s, file);
        newXS("OpenGL::glMultiTexCoord4svARB_p", XS_OpenGL_glMultiTexCoord4svARB_p, file);
#endif
#if XSubPPtmpAAAB
        newXS("OpenGL::glDeleteObjectARB", XS_OpenGL_glDeleteObjectARB, file);
        newXS("OpenGL::glGetHandleARB", XS_OpenGL_glGetHandleARB, file);
        newXS("OpenGL::glDetachObjectARB", XS_OpenGL_glDetachObjectARB, file);
        newXS("OpenGL::glCreateShaderObjectARB", XS_OpenGL_glCreateShaderObjectARB, file);
        newXS("OpenGL::glShaderSourceARB_c", XS_OpenGL_glShaderSourceARB_c, file);
        newXS("OpenGL::glShaderSourceARB_p", XS_OpenGL_glShaderSourceARB_p, file);
        newXS("OpenGL::glCompileShaderARB", XS_OpenGL_glCompileShaderARB, file);
        newXS("OpenGL::glCreateProgramObjectARB", XS_OpenGL_glCreateProgramObjectARB, file);
        newXS("OpenGL::glAttachObjectARB", XS_OpenGL_glAttachObjectARB, file);
        newXS("OpenGL::glLinkProgramARB", XS_OpenGL_glLinkProgramARB, file);
        newXS("OpenGL::glUseProgramObjectARB", XS_OpenGL_glUseProgramObjectARB, file);
        newXS("OpenGL::glValidateProgramARB", XS_OpenGL_glValidateProgramARB, file);
        newXS("OpenGL::glUniform1fARB", XS_OpenGL_glUniform1fARB, file);
        newXS("OpenGL::glUniform2fARB", XS_OpenGL_glUniform2fARB, file);
        newXS("OpenGL::glUniform3fARB", XS_OpenGL_glUniform3fARB, file);
        newXS("OpenGL::glUniform4fARB", XS_OpenGL_glUniform4fARB, file);
        newXS("OpenGL::glUniform1iARB", XS_OpenGL_glUniform1iARB, file);
        newXS("OpenGL::glUniform2iARB", XS_OpenGL_glUniform2iARB, file);
        newXS("OpenGL::glUniform3iARB", XS_OpenGL_glUniform3iARB, file);
        newXS("OpenGL::glUniform4iARB", XS_OpenGL_glUniform4iARB, file);
        newXS("OpenGL::glUniform1fvARB_c", XS_OpenGL_glUniform1fvARB_c, file);
        newXS("OpenGL::glUniform1fvARB_s", XS_OpenGL_glUniform1fvARB_s, file);
        newXS("OpenGL::glUniform1fvARB_p", XS_OpenGL_glUniform1fvARB_p, file);
        newXS("OpenGL::glUniform2fvARB_c", XS_OpenGL_glUniform2fvARB_c, file);
        newXS("OpenGL::glUniform2fvARB_s", XS_OpenGL_glUniform2fvARB_s, file);
        newXS("OpenGL::glUniform2fvARB_p", XS_OpenGL_glUniform2fvARB_p, file);
        newXS("OpenGL::glUniform3fvARB_c", XS_OpenGL_glUniform3fvARB_c, file);
        newXS("OpenGL::glUniform3fvARB_s", XS_OpenGL_glUniform3fvARB_s, file);
        newXS("OpenGL::glUniform3fvARB_p", XS_OpenGL_glUniform3fvARB_p, file);
        newXS("OpenGL::glUniform4fvARB_c", XS_OpenGL_glUniform4fvARB_c, file);
        newXS("OpenGL::glUniform4fvARB_s", XS_OpenGL_glUniform4fvARB_s, file);
        newXS("OpenGL::glUniform4fvARB_p", XS_OpenGL_glUniform4fvARB_p, file);
        newXS("OpenGL::glUniform1ivARB_c", XS_OpenGL_glUniform1ivARB_c, file);
        newXS("OpenGL::glUniform1ivARB_s", XS_OpenGL_glUniform1ivARB_s, file);
        newXS("OpenGL::glUniform1ivARB_p", XS_OpenGL_glUniform1ivARB_p, file);
        newXS("OpenGL::glUniform2ivARB_c", XS_OpenGL_glUniform2ivARB_c, file);
        newXS("OpenGL::glUniform2ivARB_s", XS_OpenGL_glUniform2ivARB_s, file);
        newXS("OpenGL::glUniform2ivARB_p", XS_OpenGL_glUniform2ivARB_p, file);
        newXS("OpenGL::glUniform3ivARB_c", XS_OpenGL_glUniform3ivARB_c, file);
        newXS("OpenGL::glUniform3ivARB_s", XS_OpenGL_glUniform3ivARB_s, file);
        newXS("OpenGL::glUniform3ivARB_p", XS_OpenGL_glUniform3ivARB_p, file);
        newXS("OpenGL::glUniform4ivARB_c", XS_OpenGL_glUniform4ivARB_c, file);
        newXS("OpenGL::glUniform4ivARB_s", XS_OpenGL_glUniform4ivARB_s, file);
        newXS("OpenGL::glUniform4ivARB_p", XS_OpenGL_glUniform4ivARB_p, file);
        newXS("OpenGL::glUniformMatrix2fvARB_c", XS_OpenGL_glUniformMatrix2fvARB_c, file);
        newXS("OpenGL::glUniformMatrix2fvARB_s", XS_OpenGL_glUniformMatrix2fvARB_s, file);
        newXS("OpenGL::glUniformMatrix2fvARB_p", XS_OpenGL_glUniformMatrix2fvARB_p, file);
        newXS("OpenGL::glUniformMatrix3fvARB_c", XS_OpenGL_glUniformMatrix3fvARB_c, file);
        newXS("OpenGL::glUniformMatrix3fvARB_s", XS_OpenGL_glUniformMatrix3fvARB_s, file);
        newXS("OpenGL::glUniformMatrix3fvARB_p", XS_OpenGL_glUniformMatrix3fvARB_p, file);
        newXS("OpenGL::glUniformMatrix4fvARB_c", XS_OpenGL_glUniformMatrix4fvARB_c, file);
        newXS("OpenGL::glUniformMatrix4fvARB_s", XS_OpenGL_glUniformMatrix4fvARB_s, file);
        newXS("OpenGL::glUniformMatrix4fvARB_p", XS_OpenGL_glUniformMatrix4fvARB_p, file);
        newXS("OpenGL::glGetObjectParameterfvARB_c", XS_OpenGL_glGetObjectParameterfvARB_c, file);
        newXS("OpenGL::glGetObjectParameterfvARB_s", XS_OpenGL_glGetObjectParameterfvARB_s, file);
        newXS("OpenGL::glGetObjectParameterfvARB_p", XS_OpenGL_glGetObjectParameterfvARB_p, file);
        newXS("OpenGL::glGetObjectParameterivARB_c", XS_OpenGL_glGetObjectParameterivARB_c, file);
        newXS("OpenGL::glGetObjectParameterivARB_s", XS_OpenGL_glGetObjectParameterivARB_s, file);
        newXS("OpenGL::glGetObjectParameterivARB_p", XS_OpenGL_glGetObjectParameterivARB_p, file);
        newXS("OpenGL::glGetInfoLogARB_c", XS_OpenGL_glGetInfoLogARB_c, file);
        newXS("OpenGL::glGetInfoLogARB_p", XS_OpenGL_glGetInfoLogARB_p, file);
        newXS("OpenGL::glGetAttachedObjectsARB_c", XS_OpenGL_glGetAttachedObjectsARB_c, file);
        newXS("OpenGL::glGetAttachedObjectsARB_s", XS_OpenGL_glGetAttachedObjectsARB_s, file);
        newXS("OpenGL::glGetAttachedObjectsARB_p", XS_OpenGL_glGetAttachedObjectsARB_p, file);
        newXS("OpenGL::glGetUniformLocationARB_c", XS_OpenGL_glGetUniformLocationARB_c, file);
        newXS("OpenGL::glGetUniformLocationARB_p", XS_OpenGL_glGetUniformLocationARB_p, file);
        newXS("OpenGL::glGetActiveUniformARB_c", XS_OpenGL_glGetActiveUniformARB_c, file);
        newXS("OpenGL::glGetActiveUniformARB_s", XS_OpenGL_glGetActiveUniformARB_s, file);
        newXS("OpenGL::glGetActiveUniformARB_p", XS_OpenGL_glGetActiveUniformARB_p, file);
        newXS("OpenGL::glGetUniformfvARB_c", XS_OpenGL_glGetUniformfvARB_c, file);
        newXS("OpenGL::glGetUniformfvARB_p", XS_OpenGL_glGetUniformfvARB_p, file);
        newXS("OpenGL::glGetUniformivARB_c", XS_OpenGL_glGetUniformivARB_c, file);
        newXS("OpenGL::glGetUniformivARB_p", XS_OpenGL_glGetUniformivARB_p, file);
        newXS("OpenGL::glGetShaderSourceARB_c", XS_OpenGL_glGetShaderSourceARB_c, file);
        newXS("OpenGL::glGetShaderSourceARB_p", XS_OpenGL_glGetShaderSourceARB_p, file);
#endif
#if XSubPPtmpAAAC
        newXS("OpenGL::glProgramStringARB_c", XS_OpenGL_glProgramStringARB_c, file);
        newXS("OpenGL::glProgramStringARB_s", XS_OpenGL_glProgramStringARB_s, file);
        newXS("OpenGL::glProgramStringARB_p", XS_OpenGL_glProgramStringARB_p, file);
        newXS("OpenGL::glBindProgramARB", XS_OpenGL_glBindProgramARB, file);
        newXS("OpenGL::glDeleteProgramsARB_c", XS_OpenGL_glDeleteProgramsARB_c, file);
        newXS("OpenGL::glDeleteProgramsARB_s", XS_OpenGL_glDeleteProgramsARB_s, file);
        newXS("OpenGL::glDeleteProgramsARB_p", XS_OpenGL_glDeleteProgramsARB_p, file);
        newXS("OpenGL::glGenProgramsARB_c", XS_OpenGL_glGenProgramsARB_c, file);
        newXS("OpenGL::glGenProgramsARB_s", XS_OpenGL_glGenProgramsARB_s, file);
        newXS("OpenGL::glGenProgramsARB_p", XS_OpenGL_glGenProgramsARB_p, file);
        newXS("OpenGL::glProgramEnvParameter4dARB", XS_OpenGL_glProgramEnvParameter4dARB, file);
        newXS("OpenGL::glProgramEnvParameter4dvARB_c", XS_OpenGL_glProgramEnvParameter4dvARB_c, file);
        newXS("OpenGL::glProgramEnvParameter4dvARB_s", XS_OpenGL_glProgramEnvParameter4dvARB_s, file);
        newXS("OpenGL::glProgramEnvParameter4dvARB_p", XS_OpenGL_glProgramEnvParameter4dvARB_p, file);
        newXS("OpenGL::glProgramEnvParameter4fARB", XS_OpenGL_glProgramEnvParameter4fARB, file);
        newXS("OpenGL::glProgramEnvParameter4fvARB_c", XS_OpenGL_glProgramEnvParameter4fvARB_c, file);
        newXS("OpenGL::glProgramEnvParameter4fvARB_s", XS_OpenGL_glProgramEnvParameter4fvARB_s, file);
        newXS("OpenGL::glProgramEnvParameter4fvARB_p", XS_OpenGL_glProgramEnvParameter4fvARB_p, file);
#endif

    /* Initialisation Section */

#if XSubPPtmpAAAA
#endif
#if XSubPPtmpAAAB
#endif
#if XSubPPtmpAAAC
#endif
#line 3904 "pogl_gl_Mult_Prog.c"

    /* End of Initialisation Section */

#if (PERL_REVISION == 5 && PERL_VERSION >= 9)
  if (PL_unitcheckav)
       call_list(PL_scopestack_ix, PL_unitcheckav);
#endif
    XSRETURN_YES;
}

