#ifndef INLINE_MESA_H
#define INLINE_MESA_H

/*
    *** Automatically generated from '/home/aros/ABIv0/Build/20110803/AROS/workbench/libs/mesa/src/aros/arosmesa/arosmesa.conf'. Edits will be lost. ***
    Copyright © 1995-2011, The AROS Development Team. All rights reserved.
*/

/*
    Desc: Inline function for mesa
*/

#include <aros/libcall.h>
#include <exec/types.h>
#include <aros/preprocessor/variadic/cast2iptr.hpp>


static inline void __inline_Mesa_AROSMesaDestroyContext(AROSMesaContext __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, AROSMesaDestroyContext,
        AROS_LCA(AROSMesaContext,(__arg1),A0),
        struct Library *, (__MesaBase), 7, Mesa    );
}

#define AROSMesaDestroyContext(arg1) \
    __inline_Mesa_AROSMesaDestroyContext((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_AROSMesaMakeCurrent(AROSMesaContext __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, AROSMesaMakeCurrent,
        AROS_LCA(AROSMesaContext,(__arg1),A0),
        struct Library *, (__MesaBase), 8, Mesa    );
}

#define AROSMesaMakeCurrent(arg1) \
    __inline_Mesa_AROSMesaMakeCurrent((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_AROSMesaSwapBuffers(AROSMesaContext __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, AROSMesaSwapBuffers,
        AROS_LCA(AROSMesaContext,(__arg1),A0),
        struct Library *, (__MesaBase), 9, Mesa    );
}

#define AROSMesaSwapBuffers(arg1) \
    __inline_Mesa_AROSMesaSwapBuffers((arg1), (APTR)MesaBase)

static inline AROSMesaContext __inline_Mesa_AROSMesaGetCurrentContext(APTR __MesaBase)
{
    return AROS_LC0(AROSMesaContext, AROSMesaGetCurrentContext,
        struct Library *, (__MesaBase), 10, Mesa    );
}

#define AROSMesaGetCurrentContext() \
    __inline_Mesa_AROSMesaGetCurrentContext((APTR)MesaBase)

static inline APTR __inline_Mesa_AROSMesaGetOpenGLStateTrackerApi(APTR __MesaBase)
{
    return AROS_LC0(APTR, AROSMesaGetOpenGLStateTrackerApi,
        struct Library *, (__MesaBase), 11, Mesa    );
}

#define AROSMesaGetOpenGLStateTrackerApi() \
    __inline_Mesa_AROSMesaGetOpenGLStateTrackerApi((APTR)MesaBase)

static inline void __inline_Mesa_AROSMesaSetRast(AROSMesaContext __arg1, struct TagItem * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, AROSMesaSetRast,
        AROS_LCA(AROSMesaContext,(__arg1),A0),
        AROS_LCA(struct TagItem *,(__arg2),A1),
        struct Library *, (__MesaBase), 12, Mesa    );
}

#define AROSMesaSetRast(arg1, arg2) \
    __inline_Mesa_AROSMesaSetRast((arg1), (arg2), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define AROSMesaSetRastTags(arg1, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    AROSMesaSetRast((arg1), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_AROSMesaGetConfig(AROSMesaContext __arg1, GLenum __arg2, GLint* __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, AROSMesaGetConfig,
        AROS_LCA(AROSMesaContext,(__arg1),A0),
        AROS_LCA(GLenum,(__arg2),D0),
        AROS_LCA(GLint*,(__arg3),A1),
        struct Library *, (__MesaBase), 13, Mesa    );
}

#define AROSMesaGetConfig(arg1, arg2, arg3) \
    __inline_Mesa_AROSMesaGetConfig((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glClearIndex(GLfloat __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glClearIndex,
        AROS_LCA(GLfloat,(__arg1),D0),
        struct Library *, (__MesaBase), 35, Mesa    );
}

#define glClearIndex(arg1) \
    __inline_Mesa_glClearIndex((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glClearColor(GLclampf __arg1, GLclampf __arg2, GLclampf __arg3, GLclampf __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glClearColor,
        AROS_LCA(GLclampf,(__arg1),D0),
        AROS_LCA(GLclampf,(__arg2),D1),
        AROS_LCA(GLclampf,(__arg3),D2),
        AROS_LCA(GLclampf,(__arg4),D3),
        struct Library *, (__MesaBase), 36, Mesa    );
}

#define glClearColor(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glClearColor((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glClear(GLbitfield __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glClear,
        AROS_LCA(GLbitfield,(__arg1),D0),
        struct Library *, (__MesaBase), 37, Mesa    );
}

#define glClear(arg1) \
    __inline_Mesa_glClear((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glIndexMask(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glIndexMask,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 38, Mesa    );
}

#define glIndexMask(arg1) \
    __inline_Mesa_glIndexMask((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColorMask(GLboolean __arg1, GLboolean __arg2, GLboolean __arg3, GLboolean __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glColorMask,
        AROS_LCA(GLboolean,(__arg1),D0),
        AROS_LCA(GLboolean,(__arg2),D1),
        AROS_LCA(GLboolean,(__arg3),D2),
        AROS_LCA(GLboolean,(__arg4),D3),
        struct Library *, (__MesaBase), 39, Mesa    );
}

#define glColorMask(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glColorMask((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glAlphaFunc(GLenum __arg1, GLclampf __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glAlphaFunc,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLclampf,(__arg2),D1),
        struct Library *, (__MesaBase), 40, Mesa    );
}

#define glAlphaFunc(arg1, arg2) \
    __inline_Mesa_glAlphaFunc((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glBlendFunc(GLenum __arg1, GLenum __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBlendFunc,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        struct Library *, (__MesaBase), 41, Mesa    );
}

#define glBlendFunc(arg1, arg2) \
    __inline_Mesa_glBlendFunc((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glLogicOp(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glLogicOp,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 42, Mesa    );
}

#define glLogicOp(arg1) \
    __inline_Mesa_glLogicOp((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glCullFace(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glCullFace,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 43, Mesa    );
}

#define glCullFace(arg1) \
    __inline_Mesa_glCullFace((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glFrontFace(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glFrontFace,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 44, Mesa    );
}

#define glFrontFace(arg1) \
    __inline_Mesa_glFrontFace((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glPointSize(GLfloat __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glPointSize,
        AROS_LCA(GLfloat,(__arg1),D0),
        struct Library *, (__MesaBase), 45, Mesa    );
}

#define glPointSize(arg1) \
    __inline_Mesa_glPointSize((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glLineWidth(GLfloat __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glLineWidth,
        AROS_LCA(GLfloat,(__arg1),D0),
        struct Library *, (__MesaBase), 46, Mesa    );
}

#define glLineWidth(arg1) \
    __inline_Mesa_glLineWidth((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glLineStipple(GLint __arg1, GLushort __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glLineStipple,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLushort,(__arg2),D1),
        struct Library *, (__MesaBase), 47, Mesa    );
}

#define glLineStipple(arg1, arg2) \
    __inline_Mesa_glLineStipple((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPolygonMode(GLenum __arg1, GLenum __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPolygonMode,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        struct Library *, (__MesaBase), 48, Mesa    );
}

#define glPolygonMode(arg1, arg2) \
    __inline_Mesa_glPolygonMode((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPolygonOffset(GLfloat __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPolygonOffset,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 49, Mesa    );
}

#define glPolygonOffset(arg1, arg2) \
    __inline_Mesa_glPolygonOffset((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPolygonStipple(const GLubyte * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glPolygonStipple,
        AROS_LCA(const GLubyte *,(__arg1),A0),
        struct Library *, (__MesaBase), 50, Mesa    );
}

#define glPolygonStipple(arg1) \
    __inline_Mesa_glPolygonStipple((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glGetPolygonStipple(GLubyte * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glGetPolygonStipple,
        AROS_LCA(GLubyte *,(__arg1),A0),
        struct Library *, (__MesaBase), 51, Mesa    );
}

#define glGetPolygonStipple(arg1) \
    __inline_Mesa_glGetPolygonStipple((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glEdgeFlag(GLboolean __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glEdgeFlag,
        AROS_LCA(GLboolean,(__arg1),D0),
        struct Library *, (__MesaBase), 52, Mesa    );
}

#define glEdgeFlag(arg1) \
    __inline_Mesa_glEdgeFlag((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glEdgeFlagv(const GLboolean * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glEdgeFlagv,
        AROS_LCA(const GLboolean *,(__arg1),A0),
        struct Library *, (__MesaBase), 53, Mesa    );
}

#define glEdgeFlagv(arg1) \
    __inline_Mesa_glEdgeFlagv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glScissor(GLint __arg1, GLint __arg2, GLsizei __arg3, GLsizei __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glScissor,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        struct Library *, (__MesaBase), 54, Mesa    );
}

#define glScissor(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glScissor((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glClipPlane(GLenum __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glClipPlane,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 55, Mesa    );
}

#define glClipPlane(arg1, arg2) \
    __inline_Mesa_glClipPlane((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetClipPlane(GLenum __arg1, GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGetClipPlane,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 56, Mesa    );
}

#define glGetClipPlane(arg1, arg2) \
    __inline_Mesa_glGetClipPlane((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDrawBuffer(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glDrawBuffer,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 57, Mesa    );
}

#define glDrawBuffer(arg1) \
    __inline_Mesa_glDrawBuffer((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glReadBuffer(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glReadBuffer,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 58, Mesa    );
}

#define glReadBuffer(arg1) \
    __inline_Mesa_glReadBuffer((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glEnable(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glEnable,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 59, Mesa    );
}

#define glEnable(arg1) \
    __inline_Mesa_glEnable((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDisable(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glDisable,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 60, Mesa    );
}

#define glDisable(arg1) \
    __inline_Mesa_glDisable((arg1), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsEnabled(GLenum __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsEnabled,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 61, Mesa    );
}

#define glIsEnabled(arg1) \
    __inline_Mesa_glIsEnabled((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glEnableClientState(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glEnableClientState,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 62, Mesa    );
}

#define glEnableClientState(arg1) \
    __inline_Mesa_glEnableClientState((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDisableClientState(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glDisableClientState,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 63, Mesa    );
}

#define glDisableClientState(arg1) \
    __inline_Mesa_glDisableClientState((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glGetBooleanv(GLenum __arg1, GLboolean * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGetBooleanv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLboolean *,(__arg2),A0),
        struct Library *, (__MesaBase), 64, Mesa    );
}

#define glGetBooleanv(arg1, arg2) \
    __inline_Mesa_glGetBooleanv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetDoublev(GLenum __arg1, GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGetDoublev,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 65, Mesa    );
}

#define glGetDoublev(arg1, arg2) \
    __inline_Mesa_glGetDoublev((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetFloatv(GLenum __arg1, GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGetFloatv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 66, Mesa    );
}

#define glGetFloatv(arg1, arg2) \
    __inline_Mesa_glGetFloatv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetIntegerv(GLenum __arg1, GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGetIntegerv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 67, Mesa    );
}

#define glGetIntegerv(arg1, arg2) \
    __inline_Mesa_glGetIntegerv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPushAttrib(GLbitfield __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glPushAttrib,
        AROS_LCA(GLbitfield,(__arg1),D0),
        struct Library *, (__MesaBase), 68, Mesa    );
}

#define glPushAttrib(arg1) \
    __inline_Mesa_glPushAttrib((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glPopAttrib(APTR __MesaBase)
{
    AROS_LC0NR(void, glPopAttrib,
        struct Library *, (__MesaBase), 69, Mesa    );
}

#define glPopAttrib() \
    __inline_Mesa_glPopAttrib((APTR)MesaBase)

static inline void __inline_Mesa_glPushClientAttrib(GLbitfield __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glPushClientAttrib,
        AROS_LCA(GLbitfield,(__arg1),D0),
        struct Library *, (__MesaBase), 70, Mesa    );
}

#define glPushClientAttrib(arg1) \
    __inline_Mesa_glPushClientAttrib((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glPopClientAttrib(APTR __MesaBase)
{
    AROS_LC0NR(void, glPopClientAttrib,
        struct Library *, (__MesaBase), 71, Mesa    );
}

#define glPopClientAttrib() \
    __inline_Mesa_glPopClientAttrib((APTR)MesaBase)

static inline GLint __inline_Mesa_glRenderMode(GLenum __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLint, glRenderMode,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 72, Mesa    );
}

#define glRenderMode(arg1) \
    __inline_Mesa_glRenderMode((arg1), (APTR)MesaBase)

static inline GLenum __inline_Mesa_glGetError(APTR __MesaBase)
{
    return AROS_LC0(GLenum, glGetError,
        struct Library *, (__MesaBase), 73, Mesa    );
}

#define glGetError() \
    __inline_Mesa_glGetError((APTR)MesaBase)

static inline const GLubyte * __inline_Mesa_glGetString(GLenum __arg1, APTR __MesaBase)
{
    return AROS_LC1(const GLubyte *, glGetString,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 74, Mesa    );
}

#define glGetString(arg1) \
    __inline_Mesa_glGetString((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glFinish(APTR __MesaBase)
{
    AROS_LC0NR(void, glFinish,
        struct Library *, (__MesaBase), 75, Mesa    );
}

#define glFinish() \
    __inline_Mesa_glFinish((APTR)MesaBase)

static inline void __inline_Mesa_glFlush(APTR __MesaBase)
{
    AROS_LC0NR(void, glFlush,
        struct Library *, (__MesaBase), 76, Mesa    );
}

#define glFlush() \
    __inline_Mesa_glFlush((APTR)MesaBase)

static inline void __inline_Mesa_glHint(GLenum __arg1, GLenum __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glHint,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        struct Library *, (__MesaBase), 77, Mesa    );
}

#define glHint(arg1, arg2) \
    __inline_Mesa_glHint((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glClearDepth(GLclampd __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glClearDepth,
        AROS_LCA(GLclampd,(__arg1),D0),
        struct Library *, (__MesaBase), 78, Mesa    );
}

#define glClearDepth(arg1) \
    __inline_Mesa_glClearDepth((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDepthFunc(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glDepthFunc,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 79, Mesa    );
}

#define glDepthFunc(arg1) \
    __inline_Mesa_glDepthFunc((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDepthMask(GLboolean __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glDepthMask,
        AROS_LCA(GLboolean,(__arg1),D0),
        struct Library *, (__MesaBase), 80, Mesa    );
}

#define glDepthMask(arg1) \
    __inline_Mesa_glDepthMask((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDepthRange(GLclampd __arg1, GLclampd __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDepthRange,
        AROS_LCA(GLclampd,(__arg1),D0),
        AROS_LCA(GLclampd,(__arg2),D1),
        struct Library *, (__MesaBase), 81, Mesa    );
}

#define glDepthRange(arg1, arg2) \
    __inline_Mesa_glDepthRange((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glClearAccum(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glClearAccum,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        struct Library *, (__MesaBase), 82, Mesa    );
}

#define glClearAccum(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glClearAccum((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glAccum(GLenum __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glAccum,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 83, Mesa    );
}

#define glAccum(arg1, arg2) \
    __inline_Mesa_glAccum((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMatrixMode(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glMatrixMode,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 84, Mesa    );
}

#define glMatrixMode(arg1) \
    __inline_Mesa_glMatrixMode((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glOrtho(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, GLdouble __arg5, GLdouble __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glOrtho,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        AROS_LCA(GLdouble,(__arg5),D4),
        AROS_LCA(GLdouble,(__arg6),D5),
        struct Library *, (__MesaBase), 85, Mesa    );
}

#define glOrtho(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glOrtho((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glFrustum(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, GLdouble __arg5, GLdouble __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glFrustum,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        AROS_LCA(GLdouble,(__arg5),D4),
        AROS_LCA(GLdouble,(__arg6),D5),
        struct Library *, (__MesaBase), 86, Mesa    );
}

#define glFrustum(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glFrustum((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glViewport(GLint __arg1, GLint __arg2, GLsizei __arg3, GLsizei __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glViewport,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        struct Library *, (__MesaBase), 87, Mesa    );
}

#define glViewport(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glViewport((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glPushMatrix(APTR __MesaBase)
{
    AROS_LC0NR(void, glPushMatrix,
        struct Library *, (__MesaBase), 88, Mesa    );
}

#define glPushMatrix() \
    __inline_Mesa_glPushMatrix((APTR)MesaBase)

static inline void __inline_Mesa_glPopMatrix(APTR __MesaBase)
{
    AROS_LC0NR(void, glPopMatrix,
        struct Library *, (__MesaBase), 89, Mesa    );
}

#define glPopMatrix() \
    __inline_Mesa_glPopMatrix((APTR)MesaBase)

static inline void __inline_Mesa_glLoadIdentity(APTR __MesaBase)
{
    AROS_LC0NR(void, glLoadIdentity,
        struct Library *, (__MesaBase), 90, Mesa    );
}

#define glLoadIdentity() \
    __inline_Mesa_glLoadIdentity((APTR)MesaBase)

static inline void __inline_Mesa_glLoadMatrixd(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glLoadMatrixd,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 91, Mesa    );
}

#define glLoadMatrixd(arg1) \
    __inline_Mesa_glLoadMatrixd((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glLoadMatrixf(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glLoadMatrixf,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 92, Mesa    );
}

#define glLoadMatrixf(arg1) \
    __inline_Mesa_glLoadMatrixf((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glMultMatrixd(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glMultMatrixd,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 93, Mesa    );
}

#define glMultMatrixd(arg1) \
    __inline_Mesa_glMultMatrixd((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glMultMatrixf(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glMultMatrixf,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 94, Mesa    );
}

#define glMultMatrixf(arg1) \
    __inline_Mesa_glMultMatrixf((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glRotated(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glRotated,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        struct Library *, (__MesaBase), 95, Mesa    );
}

#define glRotated(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glRotated((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glRotatef(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glRotatef,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        struct Library *, (__MesaBase), 96, Mesa    );
}

#define glRotatef(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glRotatef((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glScaled(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glScaled,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 97, Mesa    );
}

#define glScaled(arg1, arg2, arg3) \
    __inline_Mesa_glScaled((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glScalef(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glScalef,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 98, Mesa    );
}

#define glScalef(arg1, arg2, arg3) \
    __inline_Mesa_glScalef((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTranslated(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTranslated,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 99, Mesa    );
}

#define glTranslated(arg1, arg2, arg3) \
    __inline_Mesa_glTranslated((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTranslatef(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTranslatef,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 100, Mesa    );
}

#define glTranslatef(arg1, arg2, arg3) \
    __inline_Mesa_glTranslatef((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsList(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsList,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 101, Mesa    );
}

#define glIsList(arg1) \
    __inline_Mesa_glIsList((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteLists(GLuint __arg1, GLsizei __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDeleteLists,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        struct Library *, (__MesaBase), 102, Mesa    );
}

#define glDeleteLists(arg1, arg2) \
    __inline_Mesa_glDeleteLists((arg1), (arg2), (APTR)MesaBase)

static inline GLuint __inline_Mesa_glGenLists(GLsizei __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLuint, glGenLists,
        AROS_LCA(GLsizei,(__arg1),D0),
        struct Library *, (__MesaBase), 103, Mesa    );
}

#define glGenLists(arg1) \
    __inline_Mesa_glGenLists((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glNewList(GLuint __arg1, GLenum __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glNewList,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        struct Library *, (__MesaBase), 104, Mesa    );
}

#define glNewList(arg1, arg2) \
    __inline_Mesa_glNewList((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glEndList(APTR __MesaBase)
{
    AROS_LC0NR(void, glEndList,
        struct Library *, (__MesaBase), 105, Mesa    );
}

#define glEndList() \
    __inline_Mesa_glEndList((APTR)MesaBase)

static inline void __inline_Mesa_glCallList(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glCallList,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 106, Mesa    );
}

#define glCallList(arg1) \
    __inline_Mesa_glCallList((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glCallLists(GLsizei __arg1, GLenum __arg2, const GLvoid * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glCallLists,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLvoid *,(__arg3),A0),
        struct Library *, (__MesaBase), 107, Mesa    );
}

#define glCallLists(arg1, arg2, arg3) \
    __inline_Mesa_glCallLists((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glListBase(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glListBase,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 108, Mesa    );
}

#define glListBase(arg1) \
    __inline_Mesa_glListBase((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glBegin(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glBegin,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 109, Mesa    );
}

#define glBegin(arg1) \
    __inline_Mesa_glBegin((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glEnd(APTR __MesaBase)
{
    AROS_LC0NR(void, glEnd,
        struct Library *, (__MesaBase), 110, Mesa    );
}

#define glEnd() \
    __inline_Mesa_glEnd((APTR)MesaBase)

static inline void __inline_Mesa_glVertex2d(GLdouble __arg1, GLdouble __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertex2d,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        struct Library *, (__MesaBase), 111, Mesa    );
}

#define glVertex2d(arg1, arg2) \
    __inline_Mesa_glVertex2d((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex2f(GLfloat __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertex2f,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 112, Mesa    );
}

#define glVertex2f(arg1, arg2) \
    __inline_Mesa_glVertex2f((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex2i(GLint __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertex2i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 113, Mesa    );
}

#define glVertex2i(arg1, arg2) \
    __inline_Mesa_glVertex2i((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex2s(GLshort __arg1, GLshort __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertex2s,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        struct Library *, (__MesaBase), 114, Mesa    );
}

#define glVertex2s(arg1, arg2) \
    __inline_Mesa_glVertex2s((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex3d(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertex3d,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 115, Mesa    );
}

#define glVertex3d(arg1, arg2, arg3) \
    __inline_Mesa_glVertex3d((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex3f(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertex3f,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 116, Mesa    );
}

#define glVertex3f(arg1, arg2, arg3) \
    __inline_Mesa_glVertex3f((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex3i(GLint __arg1, GLint __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertex3i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 117, Mesa    );
}

#define glVertex3i(arg1, arg2, arg3) \
    __inline_Mesa_glVertex3i((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex3s(GLshort __arg1, GLshort __arg2, GLshort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertex3s,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        struct Library *, (__MesaBase), 118, Mesa    );
}

#define glVertex3s(arg1, arg2, arg3) \
    __inline_Mesa_glVertex3s((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex4d(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertex4d,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        struct Library *, (__MesaBase), 119, Mesa    );
}

#define glVertex4d(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertex4d((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex4f(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertex4f,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        struct Library *, (__MesaBase), 120, Mesa    );
}

#define glVertex4f(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertex4f((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex4i(GLint __arg1, GLint __arg2, GLint __arg3, GLint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertex4i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        struct Library *, (__MesaBase), 121, Mesa    );
}

#define glVertex4i(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertex4i((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex4s(GLshort __arg1, GLshort __arg2, GLshort __arg3, GLshort __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertex4s,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        AROS_LCA(GLshort,(__arg4),D3),
        struct Library *, (__MesaBase), 122, Mesa    );
}

#define glVertex4s(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertex4s((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex2dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glVertex2dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 123, Mesa    );
}

#define glVertex2dv(arg1) \
    __inline_Mesa_glVertex2dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex2fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glVertex2fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 124, Mesa    );
}

#define glVertex2fv(arg1) \
    __inline_Mesa_glVertex2fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex2iv(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glVertex2iv,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 125, Mesa    );
}

#define glVertex2iv(arg1) \
    __inline_Mesa_glVertex2iv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex2sv(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glVertex2sv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 126, Mesa    );
}

#define glVertex2sv(arg1) \
    __inline_Mesa_glVertex2sv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex3dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glVertex3dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 127, Mesa    );
}

#define glVertex3dv(arg1) \
    __inline_Mesa_glVertex3dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex3fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glVertex3fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 128, Mesa    );
}

#define glVertex3fv(arg1) \
    __inline_Mesa_glVertex3fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex3iv(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glVertex3iv,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 129, Mesa    );
}

#define glVertex3iv(arg1) \
    __inline_Mesa_glVertex3iv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex3sv(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glVertex3sv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 130, Mesa    );
}

#define glVertex3sv(arg1) \
    __inline_Mesa_glVertex3sv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex4dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glVertex4dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 131, Mesa    );
}

#define glVertex4dv(arg1) \
    __inline_Mesa_glVertex4dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex4fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glVertex4fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 132, Mesa    );
}

#define glVertex4fv(arg1) \
    __inline_Mesa_glVertex4fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex4iv(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glVertex4iv,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 133, Mesa    );
}

#define glVertex4iv(arg1) \
    __inline_Mesa_glVertex4iv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glVertex4sv(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glVertex4sv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 134, Mesa    );
}

#define glVertex4sv(arg1) \
    __inline_Mesa_glVertex4sv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glNormal3b(GLbyte __arg1, GLbyte __arg2, GLbyte __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glNormal3b,
        AROS_LCA(GLbyte,(__arg1),D0),
        AROS_LCA(GLbyte,(__arg2),D1),
        AROS_LCA(GLbyte,(__arg3),D2),
        struct Library *, (__MesaBase), 135, Mesa    );
}

#define glNormal3b(arg1, arg2, arg3) \
    __inline_Mesa_glNormal3b((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glNormal3d(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glNormal3d,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 136, Mesa    );
}

#define glNormal3d(arg1, arg2, arg3) \
    __inline_Mesa_glNormal3d((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glNormal3f(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glNormal3f,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 137, Mesa    );
}

#define glNormal3f(arg1, arg2, arg3) \
    __inline_Mesa_glNormal3f((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glNormal3i(GLint __arg1, GLint __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glNormal3i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 138, Mesa    );
}

#define glNormal3i(arg1, arg2, arg3) \
    __inline_Mesa_glNormal3i((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glNormal3s(GLshort __arg1, GLshort __arg2, GLshort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glNormal3s,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        struct Library *, (__MesaBase), 139, Mesa    );
}

#define glNormal3s(arg1, arg2, arg3) \
    __inline_Mesa_glNormal3s((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glNormal3bv(const GLbyte * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glNormal3bv,
        AROS_LCA(const GLbyte *,(__arg1),A0),
        struct Library *, (__MesaBase), 140, Mesa    );
}

#define glNormal3bv(arg1) \
    __inline_Mesa_glNormal3bv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glNormal3dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glNormal3dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 141, Mesa    );
}

#define glNormal3dv(arg1) \
    __inline_Mesa_glNormal3dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glNormal3fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glNormal3fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 142, Mesa    );
}

#define glNormal3fv(arg1) \
    __inline_Mesa_glNormal3fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glNormal3iv(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glNormal3iv,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 143, Mesa    );
}

#define glNormal3iv(arg1) \
    __inline_Mesa_glNormal3iv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glNormal3sv(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glNormal3sv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 144, Mesa    );
}

#define glNormal3sv(arg1) \
    __inline_Mesa_glNormal3sv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glIndexd(GLdouble __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glIndexd,
        AROS_LCA(GLdouble,(__arg1),D0),
        struct Library *, (__MesaBase), 145, Mesa    );
}

#define glIndexd(arg1) \
    __inline_Mesa_glIndexd((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glIndexf(GLfloat __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glIndexf,
        AROS_LCA(GLfloat,(__arg1),D0),
        struct Library *, (__MesaBase), 146, Mesa    );
}

#define glIndexf(arg1) \
    __inline_Mesa_glIndexf((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glIndexi(GLint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glIndexi,
        AROS_LCA(GLint,(__arg1),D0),
        struct Library *, (__MesaBase), 147, Mesa    );
}

#define glIndexi(arg1) \
    __inline_Mesa_glIndexi((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glIndexs(GLshort __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glIndexs,
        AROS_LCA(GLshort,(__arg1),D0),
        struct Library *, (__MesaBase), 148, Mesa    );
}

#define glIndexs(arg1) \
    __inline_Mesa_glIndexs((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glIndexub(GLubyte __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glIndexub,
        AROS_LCA(GLubyte,(__arg1),D0),
        struct Library *, (__MesaBase), 149, Mesa    );
}

#define glIndexub(arg1) \
    __inline_Mesa_glIndexub((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glIndexdv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glIndexdv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 150, Mesa    );
}

#define glIndexdv(arg1) \
    __inline_Mesa_glIndexdv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glIndexfv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glIndexfv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 151, Mesa    );
}

#define glIndexfv(arg1) \
    __inline_Mesa_glIndexfv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glIndexiv(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glIndexiv,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 152, Mesa    );
}

#define glIndexiv(arg1) \
    __inline_Mesa_glIndexiv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glIndexsv(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glIndexsv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 153, Mesa    );
}

#define glIndexsv(arg1) \
    __inline_Mesa_glIndexsv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glIndexubv(const GLubyte * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glIndexubv,
        AROS_LCA(const GLubyte *,(__arg1),A0),
        struct Library *, (__MesaBase), 154, Mesa    );
}

#define glIndexubv(arg1) \
    __inline_Mesa_glIndexubv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColor3b(GLbyte __arg1, GLbyte __arg2, GLbyte __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glColor3b,
        AROS_LCA(GLbyte,(__arg1),D0),
        AROS_LCA(GLbyte,(__arg2),D1),
        AROS_LCA(GLbyte,(__arg3),D2),
        struct Library *, (__MesaBase), 155, Mesa    );
}

#define glColor3b(arg1, arg2, arg3) \
    __inline_Mesa_glColor3b((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glColor3d(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glColor3d,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 156, Mesa    );
}

#define glColor3d(arg1, arg2, arg3) \
    __inline_Mesa_glColor3d((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glColor3f(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glColor3f,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 157, Mesa    );
}

#define glColor3f(arg1, arg2, arg3) \
    __inline_Mesa_glColor3f((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glColor3i(GLint __arg1, GLint __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glColor3i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 158, Mesa    );
}

#define glColor3i(arg1, arg2, arg3) \
    __inline_Mesa_glColor3i((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glColor3s(GLshort __arg1, GLshort __arg2, GLshort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glColor3s,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        struct Library *, (__MesaBase), 159, Mesa    );
}

#define glColor3s(arg1, arg2, arg3) \
    __inline_Mesa_glColor3s((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glColor3ub(GLubyte __arg1, GLubyte __arg2, GLubyte __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glColor3ub,
        AROS_LCA(GLubyte,(__arg1),D0),
        AROS_LCA(GLubyte,(__arg2),D1),
        AROS_LCA(GLubyte,(__arg3),D2),
        struct Library *, (__MesaBase), 160, Mesa    );
}

#define glColor3ub(arg1, arg2, arg3) \
    __inline_Mesa_glColor3ub((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glColor3ui(GLuint __arg1, GLuint __arg2, GLuint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glColor3ui,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        struct Library *, (__MesaBase), 161, Mesa    );
}

#define glColor3ui(arg1, arg2, arg3) \
    __inline_Mesa_glColor3ui((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glColor3us(GLushort __arg1, GLushort __arg2, GLushort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glColor3us,
        AROS_LCA(GLushort,(__arg1),D0),
        AROS_LCA(GLushort,(__arg2),D1),
        AROS_LCA(GLushort,(__arg3),D2),
        struct Library *, (__MesaBase), 162, Mesa    );
}

#define glColor3us(arg1, arg2, arg3) \
    __inline_Mesa_glColor3us((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glColor4b(GLbyte __arg1, GLbyte __arg2, GLbyte __arg3, GLbyte __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glColor4b,
        AROS_LCA(GLbyte,(__arg1),D0),
        AROS_LCA(GLbyte,(__arg2),D1),
        AROS_LCA(GLbyte,(__arg3),D2),
        AROS_LCA(GLbyte,(__arg4),D3),
        struct Library *, (__MesaBase), 163, Mesa    );
}

#define glColor4b(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glColor4b((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glColor4d(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glColor4d,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        struct Library *, (__MesaBase), 164, Mesa    );
}

#define glColor4d(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glColor4d((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glColor4f(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glColor4f,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        struct Library *, (__MesaBase), 165, Mesa    );
}

#define glColor4f(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glColor4f((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glColor4i(GLint __arg1, GLint __arg2, GLint __arg3, GLint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glColor4i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        struct Library *, (__MesaBase), 166, Mesa    );
}

#define glColor4i(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glColor4i((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glColor4s(GLshort __arg1, GLshort __arg2, GLshort __arg3, GLshort __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glColor4s,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        AROS_LCA(GLshort,(__arg4),D3),
        struct Library *, (__MesaBase), 167, Mesa    );
}

#define glColor4s(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glColor4s((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glColor4ub(GLubyte __arg1, GLubyte __arg2, GLubyte __arg3, GLubyte __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glColor4ub,
        AROS_LCA(GLubyte,(__arg1),D0),
        AROS_LCA(GLubyte,(__arg2),D1),
        AROS_LCA(GLubyte,(__arg3),D2),
        AROS_LCA(GLubyte,(__arg4),D3),
        struct Library *, (__MesaBase), 168, Mesa    );
}

#define glColor4ub(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glColor4ub((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glColor4ui(GLuint __arg1, GLuint __arg2, GLuint __arg3, GLuint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glColor4ui,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        struct Library *, (__MesaBase), 169, Mesa    );
}

#define glColor4ui(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glColor4ui((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glColor4us(GLushort __arg1, GLushort __arg2, GLushort __arg3, GLushort __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glColor4us,
        AROS_LCA(GLushort,(__arg1),D0),
        AROS_LCA(GLushort,(__arg2),D1),
        AROS_LCA(GLushort,(__arg3),D2),
        AROS_LCA(GLushort,(__arg4),D3),
        struct Library *, (__MesaBase), 170, Mesa    );
}

#define glColor4us(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glColor4us((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glColor3bv(const GLbyte * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glColor3bv,
        AROS_LCA(const GLbyte *,(__arg1),A0),
        struct Library *, (__MesaBase), 171, Mesa    );
}

#define glColor3bv(arg1) \
    __inline_Mesa_glColor3bv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColor3dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glColor3dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 172, Mesa    );
}

#define glColor3dv(arg1) \
    __inline_Mesa_glColor3dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColor3fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glColor3fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 173, Mesa    );
}

#define glColor3fv(arg1) \
    __inline_Mesa_glColor3fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColor3iv(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glColor3iv,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 174, Mesa    );
}

#define glColor3iv(arg1) \
    __inline_Mesa_glColor3iv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColor3sv(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glColor3sv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 175, Mesa    );
}

#define glColor3sv(arg1) \
    __inline_Mesa_glColor3sv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColor3ubv(const GLubyte * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glColor3ubv,
        AROS_LCA(const GLubyte *,(__arg1),A0),
        struct Library *, (__MesaBase), 176, Mesa    );
}

#define glColor3ubv(arg1) \
    __inline_Mesa_glColor3ubv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColor3uiv(const GLuint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glColor3uiv,
        AROS_LCA(const GLuint *,(__arg1),A0),
        struct Library *, (__MesaBase), 177, Mesa    );
}

#define glColor3uiv(arg1) \
    __inline_Mesa_glColor3uiv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColor3usv(const GLushort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glColor3usv,
        AROS_LCA(const GLushort *,(__arg1),A0),
        struct Library *, (__MesaBase), 178, Mesa    );
}

#define glColor3usv(arg1) \
    __inline_Mesa_glColor3usv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColor4bv(const GLbyte * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glColor4bv,
        AROS_LCA(const GLbyte *,(__arg1),A0),
        struct Library *, (__MesaBase), 179, Mesa    );
}

#define glColor4bv(arg1) \
    __inline_Mesa_glColor4bv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColor4dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glColor4dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 180, Mesa    );
}

#define glColor4dv(arg1) \
    __inline_Mesa_glColor4dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColor4fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glColor4fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 181, Mesa    );
}

#define glColor4fv(arg1) \
    __inline_Mesa_glColor4fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColor4iv(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glColor4iv,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 182, Mesa    );
}

#define glColor4iv(arg1) \
    __inline_Mesa_glColor4iv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColor4sv(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glColor4sv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 183, Mesa    );
}

#define glColor4sv(arg1) \
    __inline_Mesa_glColor4sv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColor4ubv(const GLubyte * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glColor4ubv,
        AROS_LCA(const GLubyte *,(__arg1),A0),
        struct Library *, (__MesaBase), 184, Mesa    );
}

#define glColor4ubv(arg1) \
    __inline_Mesa_glColor4ubv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColor4uiv(const GLuint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glColor4uiv,
        AROS_LCA(const GLuint *,(__arg1),A0),
        struct Library *, (__MesaBase), 185, Mesa    );
}

#define glColor4uiv(arg1) \
    __inline_Mesa_glColor4uiv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColor4usv(const GLushort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glColor4usv,
        AROS_LCA(const GLushort *,(__arg1),A0),
        struct Library *, (__MesaBase), 186, Mesa    );
}

#define glColor4usv(arg1) \
    __inline_Mesa_glColor4usv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord1d(GLdouble __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord1d,
        AROS_LCA(GLdouble,(__arg1),D0),
        struct Library *, (__MesaBase), 187, Mesa    );
}

#define glTexCoord1d(arg1) \
    __inline_Mesa_glTexCoord1d((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord1f(GLfloat __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord1f,
        AROS_LCA(GLfloat,(__arg1),D0),
        struct Library *, (__MesaBase), 188, Mesa    );
}

#define glTexCoord1f(arg1) \
    __inline_Mesa_glTexCoord1f((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord1i(GLint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord1i,
        AROS_LCA(GLint,(__arg1),D0),
        struct Library *, (__MesaBase), 189, Mesa    );
}

#define glTexCoord1i(arg1) \
    __inline_Mesa_glTexCoord1i((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord1s(GLshort __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord1s,
        AROS_LCA(GLshort,(__arg1),D0),
        struct Library *, (__MesaBase), 190, Mesa    );
}

#define glTexCoord1s(arg1) \
    __inline_Mesa_glTexCoord1s((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord2d(GLdouble __arg1, GLdouble __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glTexCoord2d,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        struct Library *, (__MesaBase), 191, Mesa    );
}

#define glTexCoord2d(arg1, arg2) \
    __inline_Mesa_glTexCoord2d((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord2f(GLfloat __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glTexCoord2f,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 192, Mesa    );
}

#define glTexCoord2f(arg1, arg2) \
    __inline_Mesa_glTexCoord2f((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord2i(GLint __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glTexCoord2i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 193, Mesa    );
}

#define glTexCoord2i(arg1, arg2) \
    __inline_Mesa_glTexCoord2i((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord2s(GLshort __arg1, GLshort __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glTexCoord2s,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        struct Library *, (__MesaBase), 194, Mesa    );
}

#define glTexCoord2s(arg1, arg2) \
    __inline_Mesa_glTexCoord2s((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord3d(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexCoord3d,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 195, Mesa    );
}

#define glTexCoord3d(arg1, arg2, arg3) \
    __inline_Mesa_glTexCoord3d((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord3f(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexCoord3f,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 196, Mesa    );
}

#define glTexCoord3f(arg1, arg2, arg3) \
    __inline_Mesa_glTexCoord3f((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord3i(GLint __arg1, GLint __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexCoord3i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 197, Mesa    );
}

#define glTexCoord3i(arg1, arg2, arg3) \
    __inline_Mesa_glTexCoord3i((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord3s(GLshort __arg1, GLshort __arg2, GLshort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexCoord3s,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        struct Library *, (__MesaBase), 198, Mesa    );
}

#define glTexCoord3s(arg1, arg2, arg3) \
    __inline_Mesa_glTexCoord3s((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord4d(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glTexCoord4d,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        struct Library *, (__MesaBase), 199, Mesa    );
}

#define glTexCoord4d(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glTexCoord4d((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord4f(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glTexCoord4f,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        struct Library *, (__MesaBase), 200, Mesa    );
}

#define glTexCoord4f(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glTexCoord4f((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord4i(GLint __arg1, GLint __arg2, GLint __arg3, GLint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glTexCoord4i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        struct Library *, (__MesaBase), 201, Mesa    );
}

#define glTexCoord4i(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glTexCoord4i((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord4s(GLshort __arg1, GLshort __arg2, GLshort __arg3, GLshort __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glTexCoord4s,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        AROS_LCA(GLshort,(__arg4),D3),
        struct Library *, (__MesaBase), 202, Mesa    );
}

#define glTexCoord4s(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glTexCoord4s((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord1dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord1dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 203, Mesa    );
}

#define glTexCoord1dv(arg1) \
    __inline_Mesa_glTexCoord1dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord1fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord1fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 204, Mesa    );
}

#define glTexCoord1fv(arg1) \
    __inline_Mesa_glTexCoord1fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord1iv(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord1iv,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 205, Mesa    );
}

#define glTexCoord1iv(arg1) \
    __inline_Mesa_glTexCoord1iv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord1sv(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord1sv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 206, Mesa    );
}

#define glTexCoord1sv(arg1) \
    __inline_Mesa_glTexCoord1sv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord2dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord2dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 207, Mesa    );
}

#define glTexCoord2dv(arg1) \
    __inline_Mesa_glTexCoord2dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord2fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord2fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 208, Mesa    );
}

#define glTexCoord2fv(arg1) \
    __inline_Mesa_glTexCoord2fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord2iv(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord2iv,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 209, Mesa    );
}

#define glTexCoord2iv(arg1) \
    __inline_Mesa_glTexCoord2iv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord2sv(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord2sv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 210, Mesa    );
}

#define glTexCoord2sv(arg1) \
    __inline_Mesa_glTexCoord2sv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord3dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord3dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 211, Mesa    );
}

#define glTexCoord3dv(arg1) \
    __inline_Mesa_glTexCoord3dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord3fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord3fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 212, Mesa    );
}

#define glTexCoord3fv(arg1) \
    __inline_Mesa_glTexCoord3fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord3iv(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord3iv,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 213, Mesa    );
}

#define glTexCoord3iv(arg1) \
    __inline_Mesa_glTexCoord3iv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord3sv(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord3sv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 214, Mesa    );
}

#define glTexCoord3sv(arg1) \
    __inline_Mesa_glTexCoord3sv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord4dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord4dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 215, Mesa    );
}

#define glTexCoord4dv(arg1) \
    __inline_Mesa_glTexCoord4dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord4fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord4fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 216, Mesa    );
}

#define glTexCoord4fv(arg1) \
    __inline_Mesa_glTexCoord4fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord4iv(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord4iv,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 217, Mesa    );
}

#define glTexCoord4iv(arg1) \
    __inline_Mesa_glTexCoord4iv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoord4sv(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glTexCoord4sv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 218, Mesa    );
}

#define glTexCoord4sv(arg1) \
    __inline_Mesa_glTexCoord4sv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos2d(GLdouble __arg1, GLdouble __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glRasterPos2d,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        struct Library *, (__MesaBase), 219, Mesa    );
}

#define glRasterPos2d(arg1, arg2) \
    __inline_Mesa_glRasterPos2d((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos2f(GLfloat __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glRasterPos2f,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 220, Mesa    );
}

#define glRasterPos2f(arg1, arg2) \
    __inline_Mesa_glRasterPos2f((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos2i(GLint __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glRasterPos2i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 221, Mesa    );
}

#define glRasterPos2i(arg1, arg2) \
    __inline_Mesa_glRasterPos2i((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos2s(GLshort __arg1, GLshort __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glRasterPos2s,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        struct Library *, (__MesaBase), 222, Mesa    );
}

#define glRasterPos2s(arg1, arg2) \
    __inline_Mesa_glRasterPos2s((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos3d(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glRasterPos3d,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 223, Mesa    );
}

#define glRasterPos3d(arg1, arg2, arg3) \
    __inline_Mesa_glRasterPos3d((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos3f(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glRasterPos3f,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 224, Mesa    );
}

#define glRasterPos3f(arg1, arg2, arg3) \
    __inline_Mesa_glRasterPos3f((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos3i(GLint __arg1, GLint __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glRasterPos3i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 225, Mesa    );
}

#define glRasterPos3i(arg1, arg2, arg3) \
    __inline_Mesa_glRasterPos3i((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos3s(GLshort __arg1, GLshort __arg2, GLshort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glRasterPos3s,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        struct Library *, (__MesaBase), 226, Mesa    );
}

#define glRasterPos3s(arg1, arg2, arg3) \
    __inline_Mesa_glRasterPos3s((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos4d(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glRasterPos4d,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        struct Library *, (__MesaBase), 227, Mesa    );
}

#define glRasterPos4d(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glRasterPos4d((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos4f(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glRasterPos4f,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        struct Library *, (__MesaBase), 228, Mesa    );
}

#define glRasterPos4f(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glRasterPos4f((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos4i(GLint __arg1, GLint __arg2, GLint __arg3, GLint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glRasterPos4i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        struct Library *, (__MesaBase), 229, Mesa    );
}

#define glRasterPos4i(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glRasterPos4i((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos4s(GLshort __arg1, GLshort __arg2, GLshort __arg3, GLshort __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glRasterPos4s,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        AROS_LCA(GLshort,(__arg4),D3),
        struct Library *, (__MesaBase), 230, Mesa    );
}

#define glRasterPos4s(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glRasterPos4s((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos2dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glRasterPos2dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 231, Mesa    );
}

#define glRasterPos2dv(arg1) \
    __inline_Mesa_glRasterPos2dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos2fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glRasterPos2fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 232, Mesa    );
}

#define glRasterPos2fv(arg1) \
    __inline_Mesa_glRasterPos2fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos2iv(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glRasterPos2iv,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 233, Mesa    );
}

#define glRasterPos2iv(arg1) \
    __inline_Mesa_glRasterPos2iv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos2sv(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glRasterPos2sv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 234, Mesa    );
}

#define glRasterPos2sv(arg1) \
    __inline_Mesa_glRasterPos2sv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos3dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glRasterPos3dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 235, Mesa    );
}

#define glRasterPos3dv(arg1) \
    __inline_Mesa_glRasterPos3dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos3fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glRasterPos3fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 236, Mesa    );
}

#define glRasterPos3fv(arg1) \
    __inline_Mesa_glRasterPos3fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos3iv(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glRasterPos3iv,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 237, Mesa    );
}

#define glRasterPos3iv(arg1) \
    __inline_Mesa_glRasterPos3iv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos3sv(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glRasterPos3sv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 238, Mesa    );
}

#define glRasterPos3sv(arg1) \
    __inline_Mesa_glRasterPos3sv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos4dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glRasterPos4dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 239, Mesa    );
}

#define glRasterPos4dv(arg1) \
    __inline_Mesa_glRasterPos4dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos4fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glRasterPos4fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 240, Mesa    );
}

#define glRasterPos4fv(arg1) \
    __inline_Mesa_glRasterPos4fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos4iv(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glRasterPos4iv,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 241, Mesa    );
}

#define glRasterPos4iv(arg1) \
    __inline_Mesa_glRasterPos4iv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glRasterPos4sv(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glRasterPos4sv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 242, Mesa    );
}

#define glRasterPos4sv(arg1) \
    __inline_Mesa_glRasterPos4sv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glRectd(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glRectd,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        struct Library *, (__MesaBase), 243, Mesa    );
}

#define glRectd(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glRectd((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glRectf(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glRectf,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        struct Library *, (__MesaBase), 244, Mesa    );
}

#define glRectf(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glRectf((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glRecti(GLint __arg1, GLint __arg2, GLint __arg3, GLint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glRecti,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        struct Library *, (__MesaBase), 245, Mesa    );
}

#define glRecti(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glRecti((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glRects(GLshort __arg1, GLshort __arg2, GLshort __arg3, GLshort __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glRects,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        AROS_LCA(GLshort,(__arg4),D3),
        struct Library *, (__MesaBase), 246, Mesa    );
}

#define glRects(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glRects((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glRectdv(const GLdouble * __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glRectdv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        AROS_LCA(const GLdouble *,(__arg2),A1),
        struct Library *, (__MesaBase), 247, Mesa    );
}

#define glRectdv(arg1, arg2) \
    __inline_Mesa_glRectdv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glRectfv(const GLfloat * __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glRectfv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        AROS_LCA(const GLfloat *,(__arg2),A1),
        struct Library *, (__MesaBase), 248, Mesa    );
}

#define glRectfv(arg1, arg2) \
    __inline_Mesa_glRectfv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glRectiv(const GLint * __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glRectiv,
        AROS_LCA(const GLint *,(__arg1),A0),
        AROS_LCA(const GLint *,(__arg2),A1),
        struct Library *, (__MesaBase), 249, Mesa    );
}

#define glRectiv(arg1, arg2) \
    __inline_Mesa_glRectiv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glRectsv(const GLshort * __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glRectsv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        AROS_LCA(const GLshort *,(__arg2),A1),
        struct Library *, (__MesaBase), 250, Mesa    );
}

#define glRectsv(arg1, arg2) \
    __inline_Mesa_glRectsv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexPointer(GLint __arg1, GLenum __arg2, GLsizei __arg3, const GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertexPointer,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(const GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 251, Mesa    );
}

#define glVertexPointer(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertexPointer((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glNormalPointer(GLenum __arg1, GLsizei __arg2, const GLvoid * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glNormalPointer,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLvoid *,(__arg3),A0),
        struct Library *, (__MesaBase), 252, Mesa    );
}

#define glNormalPointer(arg1, arg2, arg3) \
    __inline_Mesa_glNormalPointer((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glColorPointer(GLint __arg1, GLenum __arg2, GLsizei __arg3, const GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glColorPointer,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(const GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 253, Mesa    );
}

#define glColorPointer(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glColorPointer((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glIndexPointer(GLenum __arg1, GLsizei __arg2, const GLvoid * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glIndexPointer,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLvoid *,(__arg3),A0),
        struct Library *, (__MesaBase), 254, Mesa    );
}

#define glIndexPointer(arg1, arg2, arg3) \
    __inline_Mesa_glIndexPointer((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoordPointer(GLint __arg1, GLenum __arg2, GLsizei __arg3, const GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glTexCoordPointer,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(const GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 255, Mesa    );
}

#define glTexCoordPointer(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glTexCoordPointer((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glEdgeFlagPointer(GLsizei __arg1, const GLvoid * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glEdgeFlagPointer,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLvoid *,(__arg2),A0),
        struct Library *, (__MesaBase), 256, Mesa    );
}

#define glEdgeFlagPointer(arg1, arg2) \
    __inline_Mesa_glEdgeFlagPointer((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetPointerv(GLenum __arg1, GLvoid * * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGetPointerv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLvoid * *,(__arg2),A0),
        struct Library *, (__MesaBase), 257, Mesa    );
}

#define glGetPointerv(arg1, arg2) \
    __inline_Mesa_glGetPointerv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glArrayElement(GLint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glArrayElement,
        AROS_LCA(GLint,(__arg1),D0),
        struct Library *, (__MesaBase), 258, Mesa    );
}

#define glArrayElement(arg1) \
    __inline_Mesa_glArrayElement((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDrawArrays(GLenum __arg1, GLint __arg2, GLsizei __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glDrawArrays,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        struct Library *, (__MesaBase), 259, Mesa    );
}

#define glDrawArrays(arg1, arg2, arg3) \
    __inline_Mesa_glDrawArrays((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glDrawElements(GLenum __arg1, GLsizei __arg2, GLenum __arg3, const GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glDrawElements,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(const GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 260, Mesa    );
}

#define glDrawElements(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glDrawElements((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glInterleavedArrays(GLenum __arg1, GLsizei __arg2, const GLvoid * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glInterleavedArrays,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLvoid *,(__arg3),A0),
        struct Library *, (__MesaBase), 261, Mesa    );
}

#define glInterleavedArrays(arg1, arg2, arg3) \
    __inline_Mesa_glInterleavedArrays((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glShadeModel(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glShadeModel,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 262, Mesa    );
}

#define glShadeModel(arg1) \
    __inline_Mesa_glShadeModel((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glLightf(GLenum __arg1, GLenum __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glLightf,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 263, Mesa    );
}

#define glLightf(arg1, arg2, arg3) \
    __inline_Mesa_glLightf((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glLighti(GLenum __arg1, GLenum __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glLighti,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 264, Mesa    );
}

#define glLighti(arg1, arg2, arg3) \
    __inline_Mesa_glLighti((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glLightfv(GLenum __arg1, GLenum __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glLightfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 265, Mesa    );
}

#define glLightfv(arg1, arg2, arg3) \
    __inline_Mesa_glLightfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glLightiv(GLenum __arg1, GLenum __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glLightiv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 266, Mesa    );
}

#define glLightiv(arg1, arg2, arg3) \
    __inline_Mesa_glLightiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetLightfv(GLenum __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetLightfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 267, Mesa    );
}

#define glGetLightfv(arg1, arg2, arg3) \
    __inline_Mesa_glGetLightfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetLightiv(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetLightiv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 268, Mesa    );
}

#define glGetLightiv(arg1, arg2, arg3) \
    __inline_Mesa_glGetLightiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glLightModelf(GLenum __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glLightModelf,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 269, Mesa    );
}

#define glLightModelf(arg1, arg2) \
    __inline_Mesa_glLightModelf((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glLightModeli(GLenum __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glLightModeli,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 270, Mesa    );
}

#define glLightModeli(arg1, arg2) \
    __inline_Mesa_glLightModeli((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glLightModelfv(GLenum __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glLightModelfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 271, Mesa    );
}

#define glLightModelfv(arg1, arg2) \
    __inline_Mesa_glLightModelfv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glLightModeliv(GLenum __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glLightModeliv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 272, Mesa    );
}

#define glLightModeliv(arg1, arg2) \
    __inline_Mesa_glLightModeliv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMaterialf(GLenum __arg1, GLenum __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glMaterialf,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 273, Mesa    );
}

#define glMaterialf(arg1, arg2, arg3) \
    __inline_Mesa_glMaterialf((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glMateriali(GLenum __arg1, GLenum __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glMateriali,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 274, Mesa    );
}

#define glMateriali(arg1, arg2, arg3) \
    __inline_Mesa_glMateriali((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glMaterialfv(GLenum __arg1, GLenum __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glMaterialfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 275, Mesa    );
}

#define glMaterialfv(arg1, arg2, arg3) \
    __inline_Mesa_glMaterialfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glMaterialiv(GLenum __arg1, GLenum __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glMaterialiv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 276, Mesa    );
}

#define glMaterialiv(arg1, arg2, arg3) \
    __inline_Mesa_glMaterialiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetMaterialfv(GLenum __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetMaterialfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 277, Mesa    );
}

#define glGetMaterialfv(arg1, arg2, arg3) \
    __inline_Mesa_glGetMaterialfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetMaterialiv(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetMaterialiv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 278, Mesa    );
}

#define glGetMaterialiv(arg1, arg2, arg3) \
    __inline_Mesa_glGetMaterialiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glColorMaterial(GLenum __arg1, GLenum __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glColorMaterial,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        struct Library *, (__MesaBase), 279, Mesa    );
}

#define glColorMaterial(arg1, arg2) \
    __inline_Mesa_glColorMaterial((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPixelZoom(GLfloat __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPixelZoom,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 280, Mesa    );
}

#define glPixelZoom(arg1, arg2) \
    __inline_Mesa_glPixelZoom((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPixelStoref(GLenum __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPixelStoref,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 281, Mesa    );
}

#define glPixelStoref(arg1, arg2) \
    __inline_Mesa_glPixelStoref((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPixelStorei(GLenum __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPixelStorei,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 282, Mesa    );
}

#define glPixelStorei(arg1, arg2) \
    __inline_Mesa_glPixelStorei((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPixelTransferf(GLenum __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPixelTransferf,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 283, Mesa    );
}

#define glPixelTransferf(arg1, arg2) \
    __inline_Mesa_glPixelTransferf((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPixelTransferi(GLenum __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPixelTransferi,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 284, Mesa    );
}

#define glPixelTransferi(arg1, arg2) \
    __inline_Mesa_glPixelTransferi((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPixelMapfv(GLenum __arg1, GLsizei __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glPixelMapfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 285, Mesa    );
}

#define glPixelMapfv(arg1, arg2, arg3) \
    __inline_Mesa_glPixelMapfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glPixelMapuiv(GLenum __arg1, GLsizei __arg2, const GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glPixelMapuiv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 286, Mesa    );
}

#define glPixelMapuiv(arg1, arg2, arg3) \
    __inline_Mesa_glPixelMapuiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glPixelMapusv(GLenum __arg1, GLsizei __arg2, const GLushort * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glPixelMapusv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLushort *,(__arg3),A0),
        struct Library *, (__MesaBase), 287, Mesa    );
}

#define glPixelMapusv(arg1, arg2, arg3) \
    __inline_Mesa_glPixelMapusv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetPixelMapfv(GLenum __arg1, GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGetPixelMapfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 288, Mesa    );
}

#define glGetPixelMapfv(arg1, arg2) \
    __inline_Mesa_glGetPixelMapfv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetPixelMapuiv(GLenum __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGetPixelMapuiv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 289, Mesa    );
}

#define glGetPixelMapuiv(arg1, arg2) \
    __inline_Mesa_glGetPixelMapuiv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetPixelMapusv(GLenum __arg1, GLushort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGetPixelMapusv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLushort *,(__arg2),A0),
        struct Library *, (__MesaBase), 290, Mesa    );
}

#define glGetPixelMapusv(arg1, arg2) \
    __inline_Mesa_glGetPixelMapusv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glBitmap(GLsizei __arg1, GLsizei __arg2, GLfloat __arg3, GLfloat __arg4, GLfloat __arg5, GLfloat __arg6, const GLubyte * __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glBitmap,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        AROS_LCA(GLfloat,(__arg5),D4),
        AROS_LCA(GLfloat,(__arg6),D5),
        AROS_LCA(const GLubyte *,(__arg7),A0),
        struct Library *, (__MesaBase), 291, Mesa    );
}

#define glBitmap(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glBitmap((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glReadPixels(GLint __arg1, GLint __arg2, GLsizei __arg3, GLsizei __arg4, GLenum __arg5, GLenum __arg6, GLvoid * __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glReadPixels,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(GLenum,(__arg6),D5),
        AROS_LCA(GLvoid *,(__arg7),A0),
        struct Library *, (__MesaBase), 292, Mesa    );
}

#define glReadPixels(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glReadPixels((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glDrawPixels(GLsizei __arg1, GLsizei __arg2, GLenum __arg3, GLenum __arg4, const GLvoid * __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glDrawPixels,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(const GLvoid *,(__arg5),A0),
        struct Library *, (__MesaBase), 293, Mesa    );
}

#define glDrawPixels(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glDrawPixels((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyPixels(GLint __arg1, GLint __arg2, GLsizei __arg3, GLsizei __arg4, GLenum __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glCopyPixels,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        struct Library *, (__MesaBase), 294, Mesa    );
}

#define glCopyPixels(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glCopyPixels((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glStencilFunc(GLenum __arg1, GLint __arg2, GLuint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glStencilFunc,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        struct Library *, (__MesaBase), 295, Mesa    );
}

#define glStencilFunc(arg1, arg2, arg3) \
    __inline_Mesa_glStencilFunc((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glStencilMask(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glStencilMask,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 296, Mesa    );
}

#define glStencilMask(arg1) \
    __inline_Mesa_glStencilMask((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glStencilOp(GLenum __arg1, GLenum __arg2, GLenum __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glStencilOp,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        struct Library *, (__MesaBase), 297, Mesa    );
}

#define glStencilOp(arg1, arg2, arg3) \
    __inline_Mesa_glStencilOp((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glClearStencil(GLint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glClearStencil,
        AROS_LCA(GLint,(__arg1),D0),
        struct Library *, (__MesaBase), 298, Mesa    );
}

#define glClearStencil(arg1) \
    __inline_Mesa_glClearStencil((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexGend(GLenum __arg1, GLenum __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexGend,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 299, Mesa    );
}

#define glTexGend(arg1, arg2, arg3) \
    __inline_Mesa_glTexGend((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexGenf(GLenum __arg1, GLenum __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexGenf,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 300, Mesa    );
}

#define glTexGenf(arg1, arg2, arg3) \
    __inline_Mesa_glTexGenf((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexGeni(GLenum __arg1, GLenum __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexGeni,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 301, Mesa    );
}

#define glTexGeni(arg1, arg2, arg3) \
    __inline_Mesa_glTexGeni((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexGendv(GLenum __arg1, GLenum __arg2, const GLdouble * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexGendv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLdouble *,(__arg3),A0),
        struct Library *, (__MesaBase), 302, Mesa    );
}

#define glTexGendv(arg1, arg2, arg3) \
    __inline_Mesa_glTexGendv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexGenfv(GLenum __arg1, GLenum __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexGenfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 303, Mesa    );
}

#define glTexGenfv(arg1, arg2, arg3) \
    __inline_Mesa_glTexGenfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexGeniv(GLenum __arg1, GLenum __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexGeniv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 304, Mesa    );
}

#define glTexGeniv(arg1, arg2, arg3) \
    __inline_Mesa_glTexGeniv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTexGendv(GLenum __arg1, GLenum __arg2, GLdouble * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetTexGendv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLdouble *,(__arg3),A0),
        struct Library *, (__MesaBase), 305, Mesa    );
}

#define glGetTexGendv(arg1, arg2, arg3) \
    __inline_Mesa_glGetTexGendv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTexGenfv(GLenum __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetTexGenfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 306, Mesa    );
}

#define glGetTexGenfv(arg1, arg2, arg3) \
    __inline_Mesa_glGetTexGenfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTexGeniv(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetTexGeniv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 307, Mesa    );
}

#define glGetTexGeniv(arg1, arg2, arg3) \
    __inline_Mesa_glGetTexGeniv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexEnvf(GLenum __arg1, GLenum __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexEnvf,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 308, Mesa    );
}

#define glTexEnvf(arg1, arg2, arg3) \
    __inline_Mesa_glTexEnvf((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexEnvi(GLenum __arg1, GLenum __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexEnvi,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 309, Mesa    );
}

#define glTexEnvi(arg1, arg2, arg3) \
    __inline_Mesa_glTexEnvi((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexEnvfv(GLenum __arg1, GLenum __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexEnvfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 310, Mesa    );
}

#define glTexEnvfv(arg1, arg2, arg3) \
    __inline_Mesa_glTexEnvfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexEnviv(GLenum __arg1, GLenum __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexEnviv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 311, Mesa    );
}

#define glTexEnviv(arg1, arg2, arg3) \
    __inline_Mesa_glTexEnviv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTexEnvfv(GLenum __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetTexEnvfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 312, Mesa    );
}

#define glGetTexEnvfv(arg1, arg2, arg3) \
    __inline_Mesa_glGetTexEnvfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTexEnviv(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetTexEnviv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 313, Mesa    );
}

#define glGetTexEnviv(arg1, arg2, arg3) \
    __inline_Mesa_glGetTexEnviv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexParameterf(GLenum __arg1, GLenum __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexParameterf,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 314, Mesa    );
}

#define glTexParameterf(arg1, arg2, arg3) \
    __inline_Mesa_glTexParameterf((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexParameteri(GLenum __arg1, GLenum __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexParameteri,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 315, Mesa    );
}

#define glTexParameteri(arg1, arg2, arg3) \
    __inline_Mesa_glTexParameteri((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexParameterfv(GLenum __arg1, GLenum __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexParameterfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 316, Mesa    );
}

#define glTexParameterfv(arg1, arg2, arg3) \
    __inline_Mesa_glTexParameterfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexParameteriv(GLenum __arg1, GLenum __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexParameteriv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 317, Mesa    );
}

#define glTexParameteriv(arg1, arg2, arg3) \
    __inline_Mesa_glTexParameteriv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTexParameterfv(GLenum __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetTexParameterfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 318, Mesa    );
}

#define glGetTexParameterfv(arg1, arg2, arg3) \
    __inline_Mesa_glGetTexParameterfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTexParameteriv(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetTexParameteriv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 319, Mesa    );
}

#define glGetTexParameteriv(arg1, arg2, arg3) \
    __inline_Mesa_glGetTexParameteriv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTexLevelParameterfv(GLenum __arg1, GLint __arg2, GLenum __arg3, GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetTexLevelParameterfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 320, Mesa    );
}

#define glGetTexLevelParameterfv(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetTexLevelParameterfv((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTexLevelParameteriv(GLenum __arg1, GLint __arg2, GLenum __arg3, GLint * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetTexLevelParameteriv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLint *,(__arg4),A0),
        struct Library *, (__MesaBase), 321, Mesa    );
}

#define glGetTexLevelParameteriv(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetTexLevelParameteriv((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glTexImage1D(GLenum __arg1, GLint __arg2, GLint __arg3, GLsizei __arg4, GLint __arg5, GLenum __arg6, GLenum __arg7, const GLvoid * __arg8, APTR __MesaBase)
{
    AROS_LC8NR(void, glTexImage1D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLenum,(__arg6),D5),
        AROS_LCA(GLenum,(__arg7),D6),
        AROS_LCA(const GLvoid *,(__arg8),A0),
        struct Library *, (__MesaBase), 322, Mesa    );
}

#define glTexImage1D(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
    __inline_Mesa_glTexImage1D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (APTR)MesaBase)

static inline void __inline_Mesa_glTexImage2D(GLenum __arg1, GLint __arg2, GLint __arg3, GLsizei __arg4, GLsizei __arg5, GLint __arg6, GLenum __arg7, GLenum __arg8, const GLvoid * __arg9, APTR __MesaBase)
{
    AROS_LC9NR(void, glTexImage2D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        AROS_LCA(GLint,(__arg6),D5),
        AROS_LCA(GLenum,(__arg7),D6),
        AROS_LCA(GLenum,(__arg8),D7),
        AROS_LCA(const GLvoid *,(__arg9),A0),
        struct Library *, (__MesaBase), 323, Mesa    );
}

#define glTexImage2D(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Mesa_glTexImage2D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTexImage(GLenum __arg1, GLint __arg2, GLenum __arg3, GLenum __arg4, GLvoid * __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glGetTexImage,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLvoid *,(__arg5),A0),
        struct Library *, (__MesaBase), 324, Mesa    );
}

#define glGetTexImage(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glGetTexImage((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glGenTextures(GLsizei __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGenTextures,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 325, Mesa    );
}

#define glGenTextures(arg1, arg2) \
    __inline_Mesa_glGenTextures((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteTextures(GLsizei __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDeleteTextures,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 326, Mesa    );
}

#define glDeleteTextures(arg1, arg2) \
    __inline_Mesa_glDeleteTextures((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glBindTexture(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBindTexture,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 327, Mesa    );
}

#define glBindTexture(arg1, arg2) \
    __inline_Mesa_glBindTexture((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPrioritizeTextures(GLsizei __arg1, const GLuint * __arg2, const GLclampf * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glPrioritizeTextures,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        AROS_LCA(const GLclampf *,(__arg3),A1),
        struct Library *, (__MesaBase), 328, Mesa    );
}

#define glPrioritizeTextures(arg1, arg2, arg3) \
    __inline_Mesa_glPrioritizeTextures((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glAreTexturesResident(GLsizei __arg1, const GLuint * __arg2, GLboolean * __arg3, APTR __MesaBase)
{
    return AROS_LC3(GLboolean, glAreTexturesResident,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        AROS_LCA(GLboolean *,(__arg3),A1),
        struct Library *, (__MesaBase), 329, Mesa    );
}

#define glAreTexturesResident(arg1, arg2, arg3) \
    __inline_Mesa_glAreTexturesResident((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsTexture(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsTexture,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 330, Mesa    );
}

#define glIsTexture(arg1) \
    __inline_Mesa_glIsTexture((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glTexSubImage1D(GLenum __arg1, GLint __arg2, GLint __arg3, GLsizei __arg4, GLenum __arg5, GLenum __arg6, const GLvoid * __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glTexSubImage1D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(GLenum,(__arg6),D5),
        AROS_LCA(const GLvoid *,(__arg7),A0),
        struct Library *, (__MesaBase), 331, Mesa    );
}

#define glTexSubImage1D(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glTexSubImage1D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glTexSubImage2D(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLsizei __arg5, GLsizei __arg6, GLenum __arg7, GLenum __arg8, const GLvoid * __arg9, APTR __MesaBase)
{
    AROS_LC9NR(void, glTexSubImage2D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(GLenum,(__arg7),D6),
        AROS_LCA(GLenum,(__arg8),D7),
        AROS_LCA(const GLvoid *,(__arg9),A0),
        struct Library *, (__MesaBase), 332, Mesa    );
}

#define glTexSubImage2D(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Mesa_glTexSubImage2D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyTexImage1D(GLenum __arg1, GLint __arg2, GLenum __arg3, GLint __arg4, GLint __arg5, GLsizei __arg6, GLint __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glCopyTexImage1D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(GLint,(__arg7),D6),
        struct Library *, (__MesaBase), 333, Mesa    );
}

#define glCopyTexImage1D(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glCopyTexImage1D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyTexImage2D(GLenum __arg1, GLint __arg2, GLenum __arg3, GLint __arg4, GLint __arg5, GLsizei __arg6, GLsizei __arg7, GLint __arg8, APTR __MesaBase)
{
    AROS_LC8NR(void, glCopyTexImage2D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(GLsizei,(__arg7),D6),
        AROS_LCA(GLint,(__arg8),D7),
        struct Library *, (__MesaBase), 334, Mesa    );
}

#define glCopyTexImage2D(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
    __inline_Mesa_glCopyTexImage2D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyTexSubImage1D(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, GLsizei __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glCopyTexSubImage1D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        struct Library *, (__MesaBase), 335, Mesa    );
}

#define glCopyTexSubImage1D(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glCopyTexSubImage1D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyTexSubImage2D(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, GLint __arg6, GLsizei __arg7, GLsizei __arg8, APTR __MesaBase)
{
    AROS_LC8NR(void, glCopyTexSubImage2D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLint,(__arg6),D5),
        AROS_LCA(GLsizei,(__arg7),D6),
        AROS_LCA(GLsizei,(__arg8),D7),
        struct Library *, (__MesaBase), 336, Mesa    );
}

#define glCopyTexSubImage2D(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
    __inline_Mesa_glCopyTexSubImage2D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (APTR)MesaBase)

static inline void __inline_Mesa_glMap1d(GLenum __arg1, GLdouble __arg2, GLdouble __arg3, GLint __arg4, GLint __arg5, const GLdouble * __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glMap1d,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(const GLdouble *,(__arg6),A0),
        struct Library *, (__MesaBase), 337, Mesa    );
}

#define glMap1d(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glMap1d((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glMap1f(GLenum __arg1, GLfloat __arg2, GLfloat __arg3, GLint __arg4, GLint __arg5, const GLfloat * __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glMap1f,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(const GLfloat *,(__arg6),A0),
        struct Library *, (__MesaBase), 338, Mesa    );
}

#define glMap1f(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glMap1f((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glMap2d(GLenum __arg1, GLdouble __arg2, GLdouble __arg3, GLint __arg4, GLint __arg5, GLdouble __arg6, GLdouble __arg7, GLint __arg8, GLint __arg9, const GLdouble * __arg10, APTR __MesaBase)
{
    AROS_LC10NR(void, glMap2d,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLdouble,(__arg6),D5),
        AROS_LCA(GLdouble,(__arg7),D6),
        AROS_LCA(GLint,(__arg8),D7),
        AROS_LCA(GLint,(__arg9),A0),
        AROS_LCA(const GLdouble *,(__arg10),A1),
        struct Library *, (__MesaBase), 339, Mesa    );
}

#define glMap2d(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) \
    __inline_Mesa_glMap2d((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (APTR)MesaBase)

static inline void __inline_Mesa_glMap2f(GLenum __arg1, GLfloat __arg2, GLfloat __arg3, GLint __arg4, GLint __arg5, GLfloat __arg6, GLfloat __arg7, GLint __arg8, GLint __arg9, const GLfloat * __arg10, APTR __MesaBase)
{
    AROS_LC10NR(void, glMap2f,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLfloat,(__arg6),D5),
        AROS_LCA(GLfloat,(__arg7),D6),
        AROS_LCA(GLint,(__arg8),D7),
        AROS_LCA(GLint,(__arg9),A0),
        AROS_LCA(const GLfloat *,(__arg10),A1),
        struct Library *, (__MesaBase), 340, Mesa    );
}

#define glMap2f(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) \
    __inline_Mesa_glMap2f((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (APTR)MesaBase)

static inline void __inline_Mesa_glGetMapdv(GLenum __arg1, GLenum __arg2, GLdouble * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetMapdv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLdouble *,(__arg3),A0),
        struct Library *, (__MesaBase), 341, Mesa    );
}

#define glGetMapdv(arg1, arg2, arg3) \
    __inline_Mesa_glGetMapdv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetMapfv(GLenum __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetMapfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 342, Mesa    );
}

#define glGetMapfv(arg1, arg2, arg3) \
    __inline_Mesa_glGetMapfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetMapiv(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetMapiv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 343, Mesa    );
}

#define glGetMapiv(arg1, arg2, arg3) \
    __inline_Mesa_glGetMapiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glEvalCoord1d(GLdouble __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glEvalCoord1d,
        AROS_LCA(GLdouble,(__arg1),D0),
        struct Library *, (__MesaBase), 344, Mesa    );
}

#define glEvalCoord1d(arg1) \
    __inline_Mesa_glEvalCoord1d((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glEvalCoord1f(GLfloat __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glEvalCoord1f,
        AROS_LCA(GLfloat,(__arg1),D0),
        struct Library *, (__MesaBase), 345, Mesa    );
}

#define glEvalCoord1f(arg1) \
    __inline_Mesa_glEvalCoord1f((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glEvalCoord1dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glEvalCoord1dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 346, Mesa    );
}

#define glEvalCoord1dv(arg1) \
    __inline_Mesa_glEvalCoord1dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glEvalCoord1fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glEvalCoord1fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 347, Mesa    );
}

#define glEvalCoord1fv(arg1) \
    __inline_Mesa_glEvalCoord1fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glEvalCoord2d(GLdouble __arg1, GLdouble __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glEvalCoord2d,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        struct Library *, (__MesaBase), 348, Mesa    );
}

#define glEvalCoord2d(arg1, arg2) \
    __inline_Mesa_glEvalCoord2d((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glEvalCoord2f(GLfloat __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glEvalCoord2f,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 349, Mesa    );
}

#define glEvalCoord2f(arg1, arg2) \
    __inline_Mesa_glEvalCoord2f((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glEvalCoord2dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glEvalCoord2dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 350, Mesa    );
}

#define glEvalCoord2dv(arg1) \
    __inline_Mesa_glEvalCoord2dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glEvalCoord2fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glEvalCoord2fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 351, Mesa    );
}

#define glEvalCoord2fv(arg1) \
    __inline_Mesa_glEvalCoord2fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glMapGrid1d(GLint __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glMapGrid1d,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 352, Mesa    );
}

#define glMapGrid1d(arg1, arg2, arg3) \
    __inline_Mesa_glMapGrid1d((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glMapGrid1f(GLint __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glMapGrid1f,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 353, Mesa    );
}

#define glMapGrid1f(arg1, arg2, arg3) \
    __inline_Mesa_glMapGrid1f((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glMapGrid2d(GLint __arg1, GLdouble __arg2, GLdouble __arg3, GLint __arg4, GLdouble __arg5, GLdouble __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glMapGrid2d,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLdouble,(__arg5),D4),
        AROS_LCA(GLdouble,(__arg6),D5),
        struct Library *, (__MesaBase), 354, Mesa    );
}

#define glMapGrid2d(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glMapGrid2d((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glMapGrid2f(GLint __arg1, GLfloat __arg2, GLfloat __arg3, GLint __arg4, GLfloat __arg5, GLfloat __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glMapGrid2f,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLfloat,(__arg5),D4),
        AROS_LCA(GLfloat,(__arg6),D5),
        struct Library *, (__MesaBase), 355, Mesa    );
}

#define glMapGrid2f(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glMapGrid2f((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glEvalPoint1(GLint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glEvalPoint1,
        AROS_LCA(GLint,(__arg1),D0),
        struct Library *, (__MesaBase), 356, Mesa    );
}

#define glEvalPoint1(arg1) \
    __inline_Mesa_glEvalPoint1((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glEvalPoint2(GLint __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glEvalPoint2,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 357, Mesa    );
}

#define glEvalPoint2(arg1, arg2) \
    __inline_Mesa_glEvalPoint2((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glEvalMesh1(GLenum __arg1, GLint __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glEvalMesh1,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 358, Mesa    );
}

#define glEvalMesh1(arg1, arg2, arg3) \
    __inline_Mesa_glEvalMesh1((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glEvalMesh2(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glEvalMesh2,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        struct Library *, (__MesaBase), 359, Mesa    );
}

#define glEvalMesh2(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glEvalMesh2((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glFogf(GLenum __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glFogf,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 360, Mesa    );
}

#define glFogf(arg1, arg2) \
    __inline_Mesa_glFogf((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glFogi(GLenum __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glFogi,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 361, Mesa    );
}

#define glFogi(arg1, arg2) \
    __inline_Mesa_glFogi((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glFogfv(GLenum __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glFogfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 362, Mesa    );
}

#define glFogfv(arg1, arg2) \
    __inline_Mesa_glFogfv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glFogiv(GLenum __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glFogiv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 363, Mesa    );
}

#define glFogiv(arg1, arg2) \
    __inline_Mesa_glFogiv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glFeedbackBuffer(GLsizei __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glFeedbackBuffer,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 364, Mesa    );
}

#define glFeedbackBuffer(arg1, arg2, arg3) \
    __inline_Mesa_glFeedbackBuffer((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glPassThrough(GLfloat __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glPassThrough,
        AROS_LCA(GLfloat,(__arg1),D0),
        struct Library *, (__MesaBase), 365, Mesa    );
}

#define glPassThrough(arg1) \
    __inline_Mesa_glPassThrough((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSelectBuffer(GLsizei __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glSelectBuffer,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 366, Mesa    );
}

#define glSelectBuffer(arg1, arg2) \
    __inline_Mesa_glSelectBuffer((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glInitNames(APTR __MesaBase)
{
    AROS_LC0NR(void, glInitNames,
        struct Library *, (__MesaBase), 367, Mesa    );
}

#define glInitNames() \
    __inline_Mesa_glInitNames((APTR)MesaBase)

static inline void __inline_Mesa_glLoadName(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glLoadName,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 368, Mesa    );
}

#define glLoadName(arg1) \
    __inline_Mesa_glLoadName((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glPushName(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glPushName,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 369, Mesa    );
}

#define glPushName(arg1) \
    __inline_Mesa_glPushName((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glPopName(APTR __MesaBase)
{
    AROS_LC0NR(void, glPopName,
        struct Library *, (__MesaBase), 370, Mesa    );
}

#define glPopName() \
    __inline_Mesa_glPopName((APTR)MesaBase)

static inline void __inline_Mesa_glDrawRangeElements(GLenum __arg1, GLuint __arg2, GLuint __arg3, GLsizei __arg4, GLenum __arg5, const GLvoid * __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glDrawRangeElements,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(const GLvoid *,(__arg6),A0),
        struct Library *, (__MesaBase), 371, Mesa    );
}

#define glDrawRangeElements(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glDrawRangeElements((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glTexImage3D(GLenum __arg1, GLint __arg2, GLint __arg3, GLsizei __arg4, GLsizei __arg5, GLsizei __arg6, GLint __arg7, GLenum __arg8, GLenum __arg9, const GLvoid * __arg10, APTR __MesaBase)
{
    AROS_LC10NR(void, glTexImage3D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(GLint,(__arg7),D6),
        AROS_LCA(GLenum,(__arg8),D7),
        AROS_LCA(GLenum,(__arg9),A0),
        AROS_LCA(const GLvoid *,(__arg10),A1),
        struct Library *, (__MesaBase), 372, Mesa    );
}

#define glTexImage3D(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) \
    __inline_Mesa_glTexImage3D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (APTR)MesaBase)

static inline void __inline_Mesa_glTexSubImage3D(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, GLsizei __arg6, GLsizei __arg7, GLsizei __arg8, GLenum __arg9, GLenum __arg10, const GLvoid * __arg11, APTR __MesaBase)
{
    AROS_LC11NR(void, glTexSubImage3D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(GLsizei,(__arg7),D6),
        AROS_LCA(GLsizei,(__arg8),D7),
        AROS_LCA(GLenum,(__arg9),A0),
        AROS_LCA(GLenum,(__arg10),A1),
        AROS_LCA(const GLvoid *,(__arg11),A2),
        struct Library *, (__MesaBase), 373, Mesa    );
}

#define glTexSubImage3D(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) \
    __inline_Mesa_glTexSubImage3D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (arg11), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyTexSubImage3D(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, GLint __arg6, GLint __arg7, GLsizei __arg8, GLsizei __arg9, APTR __MesaBase)
{
    AROS_LC9NR(void, glCopyTexSubImage3D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLint,(__arg6),D5),
        AROS_LCA(GLint,(__arg7),D6),
        AROS_LCA(GLsizei,(__arg8),D7),
        AROS_LCA(GLsizei,(__arg9),A0),
        struct Library *, (__MesaBase), 374, Mesa    );
}

#define glCopyTexSubImage3D(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Mesa_glCopyTexSubImage3D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)MesaBase)

static inline void __inline_Mesa_glColorTable(GLenum __arg1, GLenum __arg2, GLsizei __arg3, GLenum __arg4, GLenum __arg5, const GLvoid * __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glColorTable,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(const GLvoid *,(__arg6),A0),
        struct Library *, (__MesaBase), 375, Mesa    );
}

#define glColorTable(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glColorTable((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glColorSubTable(GLenum __arg1, GLsizei __arg2, GLsizei __arg3, GLenum __arg4, GLenum __arg5, const GLvoid * __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glColorSubTable,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(const GLvoid *,(__arg6),A0),
        struct Library *, (__MesaBase), 376, Mesa    );
}

#define glColorSubTable(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glColorSubTable((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glColorTableParameteriv(GLenum __arg1, GLenum __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glColorTableParameteriv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 377, Mesa    );
}

#define glColorTableParameteriv(arg1, arg2, arg3) \
    __inline_Mesa_glColorTableParameteriv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glColorTableParameterfv(GLenum __arg1, GLenum __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glColorTableParameterfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 378, Mesa    );
}

#define glColorTableParameterfv(arg1, arg2, arg3) \
    __inline_Mesa_glColorTableParameterfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyColorSubTable(GLenum __arg1, GLsizei __arg2, GLint __arg3, GLint __arg4, GLsizei __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glCopyColorSubTable,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        struct Library *, (__MesaBase), 379, Mesa    );
}

#define glCopyColorSubTable(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glCopyColorSubTable((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyColorTable(GLenum __arg1, GLenum __arg2, GLint __arg3, GLint __arg4, GLsizei __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glCopyColorTable,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        struct Library *, (__MesaBase), 380, Mesa    );
}

#define glCopyColorTable(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glCopyColorTable((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glGetColorTable(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetColorTable,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 381, Mesa    );
}

#define glGetColorTable(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetColorTable((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetColorTableParameterfv(GLenum __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetColorTableParameterfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 382, Mesa    );
}

#define glGetColorTableParameterfv(arg1, arg2, arg3) \
    __inline_Mesa_glGetColorTableParameterfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetColorTableParameteriv(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetColorTableParameteriv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 383, Mesa    );
}

#define glGetColorTableParameteriv(arg1, arg2, arg3) \
    __inline_Mesa_glGetColorTableParameteriv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glBlendEquation(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glBlendEquation,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 384, Mesa    );
}

#define glBlendEquation(arg1) \
    __inline_Mesa_glBlendEquation((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glBlendColor(GLclampf __arg1, GLclampf __arg2, GLclampf __arg3, GLclampf __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glBlendColor,
        AROS_LCA(GLclampf,(__arg1),D0),
        AROS_LCA(GLclampf,(__arg2),D1),
        AROS_LCA(GLclampf,(__arg3),D2),
        AROS_LCA(GLclampf,(__arg4),D3),
        struct Library *, (__MesaBase), 385, Mesa    );
}

#define glBlendColor(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glBlendColor((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glHistogram(GLenum __arg1, GLsizei __arg2, GLenum __arg3, GLboolean __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glHistogram,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLboolean,(__arg4),D3),
        struct Library *, (__MesaBase), 386, Mesa    );
}

#define glHistogram(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glHistogram((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glResetHistogram(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glResetHistogram,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 387, Mesa    );
}

#define glResetHistogram(arg1) \
    __inline_Mesa_glResetHistogram((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glGetHistogram(GLenum __arg1, GLboolean __arg2, GLenum __arg3, GLenum __arg4, GLvoid * __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glGetHistogram,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLboolean,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLvoid *,(__arg5),A0),
        struct Library *, (__MesaBase), 388, Mesa    );
}

#define glGetHistogram(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glGetHistogram((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glGetHistogramParameterfv(GLenum __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetHistogramParameterfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 389, Mesa    );
}

#define glGetHistogramParameterfv(arg1, arg2, arg3) \
    __inline_Mesa_glGetHistogramParameterfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetHistogramParameteriv(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetHistogramParameteriv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 390, Mesa    );
}

#define glGetHistogramParameteriv(arg1, arg2, arg3) \
    __inline_Mesa_glGetHistogramParameteriv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glMinmax(GLenum __arg1, GLenum __arg2, GLboolean __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glMinmax,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLboolean,(__arg3),D2),
        struct Library *, (__MesaBase), 391, Mesa    );
}

#define glMinmax(arg1, arg2, arg3) \
    __inline_Mesa_glMinmax((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glResetMinmax(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glResetMinmax,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 392, Mesa    );
}

#define glResetMinmax(arg1) \
    __inline_Mesa_glResetMinmax((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glGetMinmax(GLenum __arg1, GLboolean __arg2, GLenum __arg3, GLenum __arg4, GLvoid * __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glGetMinmax,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLboolean,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLvoid *,(__arg5),A0),
        struct Library *, (__MesaBase), 393, Mesa    );
}

#define glGetMinmax(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glGetMinmax((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glGetMinmaxParameterfv(GLenum __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetMinmaxParameterfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 394, Mesa    );
}

#define glGetMinmaxParameterfv(arg1, arg2, arg3) \
    __inline_Mesa_glGetMinmaxParameterfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetMinmaxParameteriv(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetMinmaxParameteriv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 395, Mesa    );
}

#define glGetMinmaxParameteriv(arg1, arg2, arg3) \
    __inline_Mesa_glGetMinmaxParameteriv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glConvolutionFilter1D(GLenum __arg1, GLenum __arg2, GLsizei __arg3, GLenum __arg4, GLenum __arg5, const GLvoid * __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glConvolutionFilter1D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(const GLvoid *,(__arg6),A0),
        struct Library *, (__MesaBase), 396, Mesa    );
}

#define glConvolutionFilter1D(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glConvolutionFilter1D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glConvolutionFilter2D(GLenum __arg1, GLenum __arg2, GLsizei __arg3, GLsizei __arg4, GLenum __arg5, GLenum __arg6, const GLvoid * __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glConvolutionFilter2D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(GLenum,(__arg6),D5),
        AROS_LCA(const GLvoid *,(__arg7),A0),
        struct Library *, (__MesaBase), 397, Mesa    );
}

#define glConvolutionFilter2D(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glConvolutionFilter2D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glConvolutionParameterf(GLenum __arg1, GLenum __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glConvolutionParameterf,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 398, Mesa    );
}

#define glConvolutionParameterf(arg1, arg2, arg3) \
    __inline_Mesa_glConvolutionParameterf((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glConvolutionParameterfv(GLenum __arg1, GLenum __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glConvolutionParameterfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 399, Mesa    );
}

#define glConvolutionParameterfv(arg1, arg2, arg3) \
    __inline_Mesa_glConvolutionParameterfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glConvolutionParameteri(GLenum __arg1, GLenum __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glConvolutionParameteri,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 400, Mesa    );
}

#define glConvolutionParameteri(arg1, arg2, arg3) \
    __inline_Mesa_glConvolutionParameteri((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glConvolutionParameteriv(GLenum __arg1, GLenum __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glConvolutionParameteriv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 401, Mesa    );
}

#define glConvolutionParameteriv(arg1, arg2, arg3) \
    __inline_Mesa_glConvolutionParameteriv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyConvolutionFilter1D(GLenum __arg1, GLenum __arg2, GLint __arg3, GLint __arg4, GLsizei __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glCopyConvolutionFilter1D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        struct Library *, (__MesaBase), 402, Mesa    );
}

#define glCopyConvolutionFilter1D(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glCopyConvolutionFilter1D((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyConvolutionFilter2D(GLenum __arg1, GLenum __arg2, GLint __arg3, GLint __arg4, GLsizei __arg5, GLsizei __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glCopyConvolutionFilter2D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        struct Library *, (__MesaBase), 403, Mesa    );
}

#define glCopyConvolutionFilter2D(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glCopyConvolutionFilter2D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glGetConvolutionFilter(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetConvolutionFilter,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 404, Mesa    );
}

#define glGetConvolutionFilter(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetConvolutionFilter((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetConvolutionParameterfv(GLenum __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetConvolutionParameterfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 405, Mesa    );
}

#define glGetConvolutionParameterfv(arg1, arg2, arg3) \
    __inline_Mesa_glGetConvolutionParameterfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetConvolutionParameteriv(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetConvolutionParameteriv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 406, Mesa    );
}

#define glGetConvolutionParameteriv(arg1, arg2, arg3) \
    __inline_Mesa_glGetConvolutionParameteriv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSeparableFilter2D(GLenum __arg1, GLenum __arg2, GLsizei __arg3, GLsizei __arg4, GLenum __arg5, GLenum __arg6, const GLvoid * __arg7, const GLvoid * __arg8, APTR __MesaBase)
{
    AROS_LC8NR(void, glSeparableFilter2D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(GLenum,(__arg6),D5),
        AROS_LCA(const GLvoid *,(__arg7),A0),
        AROS_LCA(const GLvoid *,(__arg8),A1),
        struct Library *, (__MesaBase), 407, Mesa    );
}

#define glSeparableFilter2D(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
    __inline_Mesa_glSeparableFilter2D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (APTR)MesaBase)

static inline void __inline_Mesa_glGetSeparableFilter(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLvoid * __arg4, GLvoid * __arg5, GLvoid * __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glGetSeparableFilter,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLvoid *,(__arg4),A0),
        AROS_LCA(GLvoid *,(__arg5),A1),
        AROS_LCA(GLvoid *,(__arg6),A2),
        struct Library *, (__MesaBase), 408, Mesa    );
}

#define glGetSeparableFilter(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glGetSeparableFilter((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glActiveTexture(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glActiveTexture,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 409, Mesa    );
}

#define glActiveTexture(arg1) \
    __inline_Mesa_glActiveTexture((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glClientActiveTexture(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glClientActiveTexture,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 410, Mesa    );
}

#define glClientActiveTexture(arg1) \
    __inline_Mesa_glClientActiveTexture((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glCompressedTexImage1D(GLenum __arg1, GLint __arg2, GLenum __arg3, GLsizei __arg4, GLint __arg5, GLsizei __arg6, const GLvoid * __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glCompressedTexImage1D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(const GLvoid *,(__arg7),A0),
        struct Library *, (__MesaBase), 411, Mesa    );
}

#define glCompressedTexImage1D(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glCompressedTexImage1D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glCompressedTexImage2D(GLenum __arg1, GLint __arg2, GLenum __arg3, GLsizei __arg4, GLsizei __arg5, GLint __arg6, GLsizei __arg7, const GLvoid * __arg8, APTR __MesaBase)
{
    AROS_LC8NR(void, glCompressedTexImage2D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        AROS_LCA(GLint,(__arg6),D5),
        AROS_LCA(GLsizei,(__arg7),D6),
        AROS_LCA(const GLvoid *,(__arg8),A0),
        struct Library *, (__MesaBase), 412, Mesa    );
}

#define glCompressedTexImage2D(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
    __inline_Mesa_glCompressedTexImage2D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (APTR)MesaBase)

static inline void __inline_Mesa_glCompressedTexImage3D(GLenum __arg1, GLint __arg2, GLenum __arg3, GLsizei __arg4, GLsizei __arg5, GLsizei __arg6, GLint __arg7, GLsizei __arg8, const GLvoid * __arg9, APTR __MesaBase)
{
    AROS_LC9NR(void, glCompressedTexImage3D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(GLint,(__arg7),D6),
        AROS_LCA(GLsizei,(__arg8),D7),
        AROS_LCA(const GLvoid *,(__arg9),A0),
        struct Library *, (__MesaBase), 413, Mesa    );
}

#define glCompressedTexImage3D(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Mesa_glCompressedTexImage3D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)MesaBase)

static inline void __inline_Mesa_glCompressedTexSubImage1D(GLenum __arg1, GLint __arg2, GLint __arg3, GLsizei __arg4, GLenum __arg5, GLsizei __arg6, const GLvoid * __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glCompressedTexSubImage1D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(const GLvoid *,(__arg7),A0),
        struct Library *, (__MesaBase), 414, Mesa    );
}

#define glCompressedTexSubImage1D(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glCompressedTexSubImage1D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glCompressedTexSubImage2D(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLsizei __arg5, GLsizei __arg6, GLenum __arg7, GLsizei __arg8, const GLvoid * __arg9, APTR __MesaBase)
{
    AROS_LC9NR(void, glCompressedTexSubImage2D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(GLenum,(__arg7),D6),
        AROS_LCA(GLsizei,(__arg8),D7),
        AROS_LCA(const GLvoid *,(__arg9),A0),
        struct Library *, (__MesaBase), 415, Mesa    );
}

#define glCompressedTexSubImage2D(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Mesa_glCompressedTexSubImage2D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)MesaBase)

static inline void __inline_Mesa_glCompressedTexSubImage3D(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, GLsizei __arg6, GLsizei __arg7, GLsizei __arg8, GLenum __arg9, GLsizei __arg10, const GLvoid * __arg11, APTR __MesaBase)
{
    AROS_LC11NR(void, glCompressedTexSubImage3D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(GLsizei,(__arg7),D6),
        AROS_LCA(GLsizei,(__arg8),D7),
        AROS_LCA(GLenum,(__arg9),A0),
        AROS_LCA(GLsizei,(__arg10),A1),
        AROS_LCA(const GLvoid *,(__arg11),A2),
        struct Library *, (__MesaBase), 416, Mesa    );
}

#define glCompressedTexSubImage3D(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) \
    __inline_Mesa_glCompressedTexSubImage3D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (arg11), (APTR)MesaBase)

static inline void __inline_Mesa_glGetCompressedTexImage(GLenum __arg1, GLint __arg2, GLvoid * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetCompressedTexImage,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLvoid *,(__arg3),A0),
        struct Library *, (__MesaBase), 417, Mesa    );
}

#define glGetCompressedTexImage(arg1, arg2, arg3) \
    __inline_Mesa_glGetCompressedTexImage((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord1d(GLenum __arg1, GLdouble __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord1d,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        struct Library *, (__MesaBase), 418, Mesa    );
}

#define glMultiTexCoord1d(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord1d((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord1dv(GLenum __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord1dv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 419, Mesa    );
}

#define glMultiTexCoord1dv(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord1dv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord1f(GLenum __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord1f,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 420, Mesa    );
}

#define glMultiTexCoord1f(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord1f((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord1fv(GLenum __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord1fv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 421, Mesa    );
}

#define glMultiTexCoord1fv(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord1fv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord1i(GLenum __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord1i,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 422, Mesa    );
}

#define glMultiTexCoord1i(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord1i((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord1iv(GLenum __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord1iv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 423, Mesa    );
}

#define glMultiTexCoord1iv(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord1iv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord1s(GLenum __arg1, GLshort __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord1s,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        struct Library *, (__MesaBase), 424, Mesa    );
}

#define glMultiTexCoord1s(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord1s((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord1sv(GLenum __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord1sv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 425, Mesa    );
}

#define glMultiTexCoord1sv(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord1sv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord2d(GLenum __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glMultiTexCoord2d,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 426, Mesa    );
}

#define glMultiTexCoord2d(arg1, arg2, arg3) \
    __inline_Mesa_glMultiTexCoord2d((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord2dv(GLenum __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord2dv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 427, Mesa    );
}

#define glMultiTexCoord2dv(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord2dv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord2f(GLenum __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glMultiTexCoord2f,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 428, Mesa    );
}

#define glMultiTexCoord2f(arg1, arg2, arg3) \
    __inline_Mesa_glMultiTexCoord2f((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord2fv(GLenum __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord2fv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 429, Mesa    );
}

#define glMultiTexCoord2fv(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord2fv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord2i(GLenum __arg1, GLint __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glMultiTexCoord2i,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 430, Mesa    );
}

#define glMultiTexCoord2i(arg1, arg2, arg3) \
    __inline_Mesa_glMultiTexCoord2i((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord2iv(GLenum __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord2iv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 431, Mesa    );
}

#define glMultiTexCoord2iv(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord2iv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord2s(GLenum __arg1, GLshort __arg2, GLshort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glMultiTexCoord2s,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        struct Library *, (__MesaBase), 432, Mesa    );
}

#define glMultiTexCoord2s(arg1, arg2, arg3) \
    __inline_Mesa_glMultiTexCoord2s((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord2sv(GLenum __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord2sv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 433, Mesa    );
}

#define glMultiTexCoord2sv(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord2sv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord3d(GLenum __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glMultiTexCoord3d,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        struct Library *, (__MesaBase), 434, Mesa    );
}

#define glMultiTexCoord3d(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glMultiTexCoord3d((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord3dv(GLenum __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord3dv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 435, Mesa    );
}

#define glMultiTexCoord3dv(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord3dv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord3f(GLenum __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glMultiTexCoord3f,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        struct Library *, (__MesaBase), 436, Mesa    );
}

#define glMultiTexCoord3f(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glMultiTexCoord3f((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord3fv(GLenum __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord3fv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 437, Mesa    );
}

#define glMultiTexCoord3fv(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord3fv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord3i(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glMultiTexCoord3i,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        struct Library *, (__MesaBase), 438, Mesa    );
}

#define glMultiTexCoord3i(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glMultiTexCoord3i((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord3iv(GLenum __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord3iv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 439, Mesa    );
}

#define glMultiTexCoord3iv(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord3iv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord3s(GLenum __arg1, GLshort __arg2, GLshort __arg3, GLshort __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glMultiTexCoord3s,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        AROS_LCA(GLshort,(__arg4),D3),
        struct Library *, (__MesaBase), 440, Mesa    );
}

#define glMultiTexCoord3s(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glMultiTexCoord3s((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord3sv(GLenum __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord3sv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 441, Mesa    );
}

#define glMultiTexCoord3sv(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord3sv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord4d(GLenum __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, GLdouble __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glMultiTexCoord4d,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        AROS_LCA(GLdouble,(__arg5),D4),
        struct Library *, (__MesaBase), 442, Mesa    );
}

#define glMultiTexCoord4d(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glMultiTexCoord4d((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord4dv(GLenum __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord4dv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 443, Mesa    );
}

#define glMultiTexCoord4dv(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord4dv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord4f(GLenum __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, GLfloat __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glMultiTexCoord4f,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        AROS_LCA(GLfloat,(__arg5),D4),
        struct Library *, (__MesaBase), 444, Mesa    );
}

#define glMultiTexCoord4f(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glMultiTexCoord4f((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord4fv(GLenum __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord4fv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 445, Mesa    );
}

#define glMultiTexCoord4fv(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord4fv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord4i(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glMultiTexCoord4i,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        struct Library *, (__MesaBase), 446, Mesa    );
}

#define glMultiTexCoord4i(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glMultiTexCoord4i((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord4iv(GLenum __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord4iv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 447, Mesa    );
}

#define glMultiTexCoord4iv(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord4iv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord4s(GLenum __arg1, GLshort __arg2, GLshort __arg3, GLshort __arg4, GLshort __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glMultiTexCoord4s,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        AROS_LCA(GLshort,(__arg4),D3),
        AROS_LCA(GLshort,(__arg5),D4),
        struct Library *, (__MesaBase), 448, Mesa    );
}

#define glMultiTexCoord4s(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glMultiTexCoord4s((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord4sv(GLenum __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord4sv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 449, Mesa    );
}

#define glMultiTexCoord4sv(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord4sv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glLoadTransposeMatrixd(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glLoadTransposeMatrixd,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 450, Mesa    );
}

#define glLoadTransposeMatrixd(arg1) \
    __inline_Mesa_glLoadTransposeMatrixd((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glLoadTransposeMatrixf(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glLoadTransposeMatrixf,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 451, Mesa    );
}

#define glLoadTransposeMatrixf(arg1) \
    __inline_Mesa_glLoadTransposeMatrixf((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glMultTransposeMatrixd(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glMultTransposeMatrixd,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 452, Mesa    );
}

#define glMultTransposeMatrixd(arg1) \
    __inline_Mesa_glMultTransposeMatrixd((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glMultTransposeMatrixf(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glMultTransposeMatrixf,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 453, Mesa    );
}

#define glMultTransposeMatrixf(arg1) \
    __inline_Mesa_glMultTransposeMatrixf((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSampleCoverage(GLclampf __arg1, GLboolean __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glSampleCoverage,
        AROS_LCA(GLclampf,(__arg1),D0),
        AROS_LCA(GLboolean,(__arg2),D1),
        struct Library *, (__MesaBase), 454, Mesa    );
}

#define glSampleCoverage(arg1, arg2) \
    __inline_Mesa_glSampleCoverage((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glActiveTextureARB(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glActiveTextureARB,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 455, Mesa    );
}

#define glActiveTextureARB(arg1) \
    __inline_Mesa_glActiveTextureARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glClientActiveTextureARB(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glClientActiveTextureARB,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 456, Mesa    );
}

#define glClientActiveTextureARB(arg1) \
    __inline_Mesa_glClientActiveTextureARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord1dARB(GLenum __arg1, GLdouble __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord1dARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        struct Library *, (__MesaBase), 457, Mesa    );
}

#define glMultiTexCoord1dARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord1dARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord1dvARB(GLenum __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord1dvARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 458, Mesa    );
}

#define glMultiTexCoord1dvARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord1dvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord1fARB(GLenum __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord1fARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 459, Mesa    );
}

#define glMultiTexCoord1fARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord1fARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord1fvARB(GLenum __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord1fvARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 460, Mesa    );
}

#define glMultiTexCoord1fvARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord1fvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord1iARB(GLenum __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord1iARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 461, Mesa    );
}

#define glMultiTexCoord1iARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord1iARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord1ivARB(GLenum __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord1ivARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 462, Mesa    );
}

#define glMultiTexCoord1ivARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord1ivARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord1sARB(GLenum __arg1, GLshort __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord1sARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        struct Library *, (__MesaBase), 463, Mesa    );
}

#define glMultiTexCoord1sARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord1sARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord1svARB(GLenum __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord1svARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 464, Mesa    );
}

#define glMultiTexCoord1svARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord1svARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord2dARB(GLenum __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glMultiTexCoord2dARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 465, Mesa    );
}

#define glMultiTexCoord2dARB(arg1, arg2, arg3) \
    __inline_Mesa_glMultiTexCoord2dARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord2dvARB(GLenum __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord2dvARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 466, Mesa    );
}

#define glMultiTexCoord2dvARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord2dvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord2fARB(GLenum __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glMultiTexCoord2fARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 467, Mesa    );
}

#define glMultiTexCoord2fARB(arg1, arg2, arg3) \
    __inline_Mesa_glMultiTexCoord2fARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord2fvARB(GLenum __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord2fvARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 468, Mesa    );
}

#define glMultiTexCoord2fvARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord2fvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord2iARB(GLenum __arg1, GLint __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glMultiTexCoord2iARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 469, Mesa    );
}

#define glMultiTexCoord2iARB(arg1, arg2, arg3) \
    __inline_Mesa_glMultiTexCoord2iARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord2ivARB(GLenum __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord2ivARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 470, Mesa    );
}

#define glMultiTexCoord2ivARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord2ivARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord2sARB(GLenum __arg1, GLshort __arg2, GLshort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glMultiTexCoord2sARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        struct Library *, (__MesaBase), 471, Mesa    );
}

#define glMultiTexCoord2sARB(arg1, arg2, arg3) \
    __inline_Mesa_glMultiTexCoord2sARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord2svARB(GLenum __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord2svARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 472, Mesa    );
}

#define glMultiTexCoord2svARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord2svARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord3dARB(GLenum __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glMultiTexCoord3dARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        struct Library *, (__MesaBase), 473, Mesa    );
}

#define glMultiTexCoord3dARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glMultiTexCoord3dARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord3dvARB(GLenum __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord3dvARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 474, Mesa    );
}

#define glMultiTexCoord3dvARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord3dvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord3fARB(GLenum __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glMultiTexCoord3fARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        struct Library *, (__MesaBase), 475, Mesa    );
}

#define glMultiTexCoord3fARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glMultiTexCoord3fARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord3fvARB(GLenum __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord3fvARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 476, Mesa    );
}

#define glMultiTexCoord3fvARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord3fvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord3iARB(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glMultiTexCoord3iARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        struct Library *, (__MesaBase), 477, Mesa    );
}

#define glMultiTexCoord3iARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glMultiTexCoord3iARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord3ivARB(GLenum __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord3ivARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 478, Mesa    );
}

#define glMultiTexCoord3ivARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord3ivARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord3sARB(GLenum __arg1, GLshort __arg2, GLshort __arg3, GLshort __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glMultiTexCoord3sARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        AROS_LCA(GLshort,(__arg4),D3),
        struct Library *, (__MesaBase), 479, Mesa    );
}

#define glMultiTexCoord3sARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glMultiTexCoord3sARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord3svARB(GLenum __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord3svARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 480, Mesa    );
}

#define glMultiTexCoord3svARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord3svARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord4dARB(GLenum __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, GLdouble __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glMultiTexCoord4dARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        AROS_LCA(GLdouble,(__arg5),D4),
        struct Library *, (__MesaBase), 481, Mesa    );
}

#define glMultiTexCoord4dARB(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glMultiTexCoord4dARB((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord4dvARB(GLenum __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord4dvARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 482, Mesa    );
}

#define glMultiTexCoord4dvARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord4dvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord4fARB(GLenum __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, GLfloat __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glMultiTexCoord4fARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        AROS_LCA(GLfloat,(__arg5),D4),
        struct Library *, (__MesaBase), 483, Mesa    );
}

#define glMultiTexCoord4fARB(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glMultiTexCoord4fARB((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord4fvARB(GLenum __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord4fvARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 484, Mesa    );
}

#define glMultiTexCoord4fvARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord4fvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord4iARB(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glMultiTexCoord4iARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        struct Library *, (__MesaBase), 485, Mesa    );
}

#define glMultiTexCoord4iARB(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glMultiTexCoord4iARB((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord4ivARB(GLenum __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord4ivARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 486, Mesa    );
}

#define glMultiTexCoord4ivARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord4ivARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord4sARB(GLenum __arg1, GLshort __arg2, GLshort __arg3, GLshort __arg4, GLshort __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glMultiTexCoord4sARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        AROS_LCA(GLshort,(__arg4),D3),
        AROS_LCA(GLshort,(__arg5),D4),
        struct Library *, (__MesaBase), 487, Mesa    );
}

#define glMultiTexCoord4sARB(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glMultiTexCoord4sARB((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiTexCoord4svARB(GLenum __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glMultiTexCoord4svARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 488, Mesa    );
}

#define glMultiTexCoord4svARB(arg1, arg2) \
    __inline_Mesa_glMultiTexCoord4svARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glBlendFuncSeparate(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLenum __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glBlendFuncSeparate,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        struct Library *, (__MesaBase), 489, Mesa    );
}

#define glBlendFuncSeparate(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glBlendFuncSeparate((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glFogCoordf(GLfloat __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glFogCoordf,
        AROS_LCA(GLfloat,(__arg1),D0),
        struct Library *, (__MesaBase), 490, Mesa    );
}

#define glFogCoordf(arg1) \
    __inline_Mesa_glFogCoordf((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glFogCoordfv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glFogCoordfv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 491, Mesa    );
}

#define glFogCoordfv(arg1) \
    __inline_Mesa_glFogCoordfv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glFogCoordd(GLdouble __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glFogCoordd,
        AROS_LCA(GLdouble,(__arg1),D0),
        struct Library *, (__MesaBase), 492, Mesa    );
}

#define glFogCoordd(arg1) \
    __inline_Mesa_glFogCoordd((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glFogCoorddv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glFogCoorddv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 493, Mesa    );
}

#define glFogCoorddv(arg1) \
    __inline_Mesa_glFogCoorddv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glFogCoordPointer(GLenum __arg1, GLsizei __arg2, const GLvoid * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glFogCoordPointer,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLvoid *,(__arg3),A0),
        struct Library *, (__MesaBase), 494, Mesa    );
}

#define glFogCoordPointer(arg1, arg2, arg3) \
    __inline_Mesa_glFogCoordPointer((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiDrawArrays(GLenum __arg1, const GLint * __arg2, const GLsizei * __arg3, GLsizei __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glMultiDrawArrays,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        AROS_LCA(const GLsizei *,(__arg3),A1),
        AROS_LCA(GLsizei,(__arg4),D1),
        struct Library *, (__MesaBase), 495, Mesa    );
}

#define glMultiDrawArrays(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glMultiDrawArrays((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiDrawElements(GLenum __arg1, const GLsizei * __arg2, GLenum __arg3, const GLvoid *  * __arg4, GLsizei __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glMultiDrawElements,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLsizei *,(__arg2),A0),
        AROS_LCA(GLenum,(__arg3),D1),
        AROS_LCA(const GLvoid *  *,(__arg4),A1),
        AROS_LCA(GLsizei,(__arg5),D2),
        struct Library *, (__MesaBase), 496, Mesa    );
}

#define glMultiDrawElements(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glMultiDrawElements((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glPointParameterf(GLenum __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPointParameterf,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 497, Mesa    );
}

#define glPointParameterf(arg1, arg2) \
    __inline_Mesa_glPointParameterf((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPointParameterfv(GLenum __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPointParameterfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 498, Mesa    );
}

#define glPointParameterfv(arg1, arg2) \
    __inline_Mesa_glPointParameterfv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPointParameteri(GLenum __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPointParameteri,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 499, Mesa    );
}

#define glPointParameteri(arg1, arg2) \
    __inline_Mesa_glPointParameteri((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPointParameteriv(GLenum __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPointParameteriv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 500, Mesa    );
}

#define glPointParameteriv(arg1, arg2) \
    __inline_Mesa_glPointParameteriv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3b(GLbyte __arg1, GLbyte __arg2, GLbyte __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glSecondaryColor3b,
        AROS_LCA(GLbyte,(__arg1),D0),
        AROS_LCA(GLbyte,(__arg2),D1),
        AROS_LCA(GLbyte,(__arg3),D2),
        struct Library *, (__MesaBase), 501, Mesa    );
}

#define glSecondaryColor3b(arg1, arg2, arg3) \
    __inline_Mesa_glSecondaryColor3b((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3bv(const GLbyte * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSecondaryColor3bv,
        AROS_LCA(const GLbyte *,(__arg1),A0),
        struct Library *, (__MesaBase), 502, Mesa    );
}

#define glSecondaryColor3bv(arg1) \
    __inline_Mesa_glSecondaryColor3bv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3d(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glSecondaryColor3d,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 503, Mesa    );
}

#define glSecondaryColor3d(arg1, arg2, arg3) \
    __inline_Mesa_glSecondaryColor3d((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSecondaryColor3dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 504, Mesa    );
}

#define glSecondaryColor3dv(arg1) \
    __inline_Mesa_glSecondaryColor3dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3f(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glSecondaryColor3f,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 505, Mesa    );
}

#define glSecondaryColor3f(arg1, arg2, arg3) \
    __inline_Mesa_glSecondaryColor3f((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSecondaryColor3fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 506, Mesa    );
}

#define glSecondaryColor3fv(arg1) \
    __inline_Mesa_glSecondaryColor3fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3i(GLint __arg1, GLint __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glSecondaryColor3i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 507, Mesa    );
}

#define glSecondaryColor3i(arg1, arg2, arg3) \
    __inline_Mesa_glSecondaryColor3i((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3iv(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSecondaryColor3iv,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 508, Mesa    );
}

#define glSecondaryColor3iv(arg1) \
    __inline_Mesa_glSecondaryColor3iv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3s(GLshort __arg1, GLshort __arg2, GLshort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glSecondaryColor3s,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        struct Library *, (__MesaBase), 509, Mesa    );
}

#define glSecondaryColor3s(arg1, arg2, arg3) \
    __inline_Mesa_glSecondaryColor3s((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3sv(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSecondaryColor3sv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 510, Mesa    );
}

#define glSecondaryColor3sv(arg1) \
    __inline_Mesa_glSecondaryColor3sv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3ub(GLubyte __arg1, GLubyte __arg2, GLubyte __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glSecondaryColor3ub,
        AROS_LCA(GLubyte,(__arg1),D0),
        AROS_LCA(GLubyte,(__arg2),D1),
        AROS_LCA(GLubyte,(__arg3),D2),
        struct Library *, (__MesaBase), 511, Mesa    );
}

#define glSecondaryColor3ub(arg1, arg2, arg3) \
    __inline_Mesa_glSecondaryColor3ub((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3ubv(const GLubyte * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSecondaryColor3ubv,
        AROS_LCA(const GLubyte *,(__arg1),A0),
        struct Library *, (__MesaBase), 512, Mesa    );
}

#define glSecondaryColor3ubv(arg1) \
    __inline_Mesa_glSecondaryColor3ubv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3ui(GLuint __arg1, GLuint __arg2, GLuint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glSecondaryColor3ui,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        struct Library *, (__MesaBase), 513, Mesa    );
}

#define glSecondaryColor3ui(arg1, arg2, arg3) \
    __inline_Mesa_glSecondaryColor3ui((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3uiv(const GLuint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSecondaryColor3uiv,
        AROS_LCA(const GLuint *,(__arg1),A0),
        struct Library *, (__MesaBase), 514, Mesa    );
}

#define glSecondaryColor3uiv(arg1) \
    __inline_Mesa_glSecondaryColor3uiv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3us(GLushort __arg1, GLushort __arg2, GLushort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glSecondaryColor3us,
        AROS_LCA(GLushort,(__arg1),D0),
        AROS_LCA(GLushort,(__arg2),D1),
        AROS_LCA(GLushort,(__arg3),D2),
        struct Library *, (__MesaBase), 515, Mesa    );
}

#define glSecondaryColor3us(arg1, arg2, arg3) \
    __inline_Mesa_glSecondaryColor3us((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3usv(const GLushort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSecondaryColor3usv,
        AROS_LCA(const GLushort *,(__arg1),A0),
        struct Library *, (__MesaBase), 516, Mesa    );
}

#define glSecondaryColor3usv(arg1) \
    __inline_Mesa_glSecondaryColor3usv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColorPointer(GLint __arg1, GLenum __arg2, GLsizei __arg3, const GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glSecondaryColorPointer,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(const GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 517, Mesa    );
}

#define glSecondaryColorPointer(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glSecondaryColorPointer((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos2d(GLdouble __arg1, GLdouble __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glWindowPos2d,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        struct Library *, (__MesaBase), 518, Mesa    );
}

#define glWindowPos2d(arg1, arg2) \
    __inline_Mesa_glWindowPos2d((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos2dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos2dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 519, Mesa    );
}

#define glWindowPos2dv(arg1) \
    __inline_Mesa_glWindowPos2dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos2f(GLfloat __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glWindowPos2f,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 520, Mesa    );
}

#define glWindowPos2f(arg1, arg2) \
    __inline_Mesa_glWindowPos2f((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos2fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos2fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 521, Mesa    );
}

#define glWindowPos2fv(arg1) \
    __inline_Mesa_glWindowPos2fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos2i(GLint __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glWindowPos2i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 522, Mesa    );
}

#define glWindowPos2i(arg1, arg2) \
    __inline_Mesa_glWindowPos2i((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos2iv(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos2iv,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 523, Mesa    );
}

#define glWindowPos2iv(arg1) \
    __inline_Mesa_glWindowPos2iv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos2s(GLshort __arg1, GLshort __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glWindowPos2s,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        struct Library *, (__MesaBase), 524, Mesa    );
}

#define glWindowPos2s(arg1, arg2) \
    __inline_Mesa_glWindowPos2s((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos2sv(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos2sv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 525, Mesa    );
}

#define glWindowPos2sv(arg1) \
    __inline_Mesa_glWindowPos2sv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos3d(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glWindowPos3d,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 526, Mesa    );
}

#define glWindowPos3d(arg1, arg2, arg3) \
    __inline_Mesa_glWindowPos3d((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos3dv(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos3dv,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 527, Mesa    );
}

#define glWindowPos3dv(arg1) \
    __inline_Mesa_glWindowPos3dv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos3f(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glWindowPos3f,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 528, Mesa    );
}

#define glWindowPos3f(arg1, arg2, arg3) \
    __inline_Mesa_glWindowPos3f((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos3fv(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos3fv,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 529, Mesa    );
}

#define glWindowPos3fv(arg1) \
    __inline_Mesa_glWindowPos3fv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos3i(GLint __arg1, GLint __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glWindowPos3i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 530, Mesa    );
}

#define glWindowPos3i(arg1, arg2, arg3) \
    __inline_Mesa_glWindowPos3i((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos3iv(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos3iv,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 531, Mesa    );
}

#define glWindowPos3iv(arg1) \
    __inline_Mesa_glWindowPos3iv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos3s(GLshort __arg1, GLshort __arg2, GLshort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glWindowPos3s,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        struct Library *, (__MesaBase), 532, Mesa    );
}

#define glWindowPos3s(arg1, arg2, arg3) \
    __inline_Mesa_glWindowPos3s((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos3sv(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos3sv,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 533, Mesa    );
}

#define glWindowPos3sv(arg1) \
    __inline_Mesa_glWindowPos3sv((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glGenQueries(GLsizei __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGenQueries,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 534, Mesa    );
}

#define glGenQueries(arg1, arg2) \
    __inline_Mesa_glGenQueries((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteQueries(GLsizei __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDeleteQueries,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 535, Mesa    );
}

#define glDeleteQueries(arg1, arg2) \
    __inline_Mesa_glDeleteQueries((arg1), (arg2), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsQuery(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsQuery,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 536, Mesa    );
}

#define glIsQuery(arg1) \
    __inline_Mesa_glIsQuery((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glBeginQuery(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBeginQuery,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 537, Mesa    );
}

#define glBeginQuery(arg1, arg2) \
    __inline_Mesa_glBeginQuery((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glEndQuery(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glEndQuery,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 538, Mesa    );
}

#define glEndQuery(arg1) \
    __inline_Mesa_glEndQuery((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glGetQueryiv(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetQueryiv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 539, Mesa    );
}

#define glGetQueryiv(arg1, arg2, arg3) \
    __inline_Mesa_glGetQueryiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetQueryObjectiv(GLuint __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetQueryObjectiv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 540, Mesa    );
}

#define glGetQueryObjectiv(arg1, arg2, arg3) \
    __inline_Mesa_glGetQueryObjectiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetQueryObjectuiv(GLuint __arg1, GLenum __arg2, GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetQueryObjectuiv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 541, Mesa    );
}

#define glGetQueryObjectuiv(arg1, arg2, arg3) \
    __inline_Mesa_glGetQueryObjectuiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glBindBuffer(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBindBuffer,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 542, Mesa    );
}

#define glBindBuffer(arg1, arg2) \
    __inline_Mesa_glBindBuffer((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteBuffers(GLsizei __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDeleteBuffers,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 543, Mesa    );
}

#define glDeleteBuffers(arg1, arg2) \
    __inline_Mesa_glDeleteBuffers((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGenBuffers(GLsizei __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGenBuffers,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 544, Mesa    );
}

#define glGenBuffers(arg1, arg2) \
    __inline_Mesa_glGenBuffers((arg1), (arg2), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsBuffer(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsBuffer,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 545, Mesa    );
}

#define glIsBuffer(arg1) \
    __inline_Mesa_glIsBuffer((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glBufferData(GLenum __arg1, GLsizeiptr __arg2, const GLvoid * __arg3, GLenum __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glBufferData,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizeiptr,(__arg2),D1),
        AROS_LCA(const GLvoid *,(__arg3),A0),
        AROS_LCA(GLenum,(__arg4),D2),
        struct Library *, (__MesaBase), 546, Mesa    );
}

#define glBufferData(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glBufferData((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glBufferSubData(GLenum __arg1, GLintptr __arg2, GLsizeiptr __arg3, const GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glBufferSubData,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLintptr,(__arg2),D1),
        AROS_LCA(GLsizeiptr,(__arg3),D2),
        AROS_LCA(const GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 547, Mesa    );
}

#define glBufferSubData(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glBufferSubData((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetBufferSubData(GLenum __arg1, GLintptr __arg2, GLsizeiptr __arg3, GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetBufferSubData,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLintptr,(__arg2),D1),
        AROS_LCA(GLsizeiptr,(__arg3),D2),
        AROS_LCA(GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 548, Mesa    );
}

#define glGetBufferSubData(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetBufferSubData((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline GLvoid* __inline_Mesa_glMapBuffer(GLenum __arg1, GLenum __arg2, APTR __MesaBase)
{
    return AROS_LC2(GLvoid*, glMapBuffer,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        struct Library *, (__MesaBase), 549, Mesa    );
}

#define glMapBuffer(arg1, arg2) \
    __inline_Mesa_glMapBuffer((arg1), (arg2), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glUnmapBuffer(GLenum __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glUnmapBuffer,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 550, Mesa    );
}

#define glUnmapBuffer(arg1) \
    __inline_Mesa_glUnmapBuffer((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glGetBufferParameteriv(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetBufferParameteriv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 551, Mesa    );
}

#define glGetBufferParameteriv(arg1, arg2, arg3) \
    __inline_Mesa_glGetBufferParameteriv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetBufferPointerv(GLenum __arg1, GLenum __arg2, GLvoid *  * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetBufferPointerv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLvoid *  *,(__arg3),A0),
        struct Library *, (__MesaBase), 552, Mesa    );
}

#define glGetBufferPointerv(arg1, arg2, arg3) \
    __inline_Mesa_glGetBufferPointerv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glBlendEquationSeparate(GLenum __arg1, GLenum __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBlendEquationSeparate,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        struct Library *, (__MesaBase), 553, Mesa    );
}

#define glBlendEquationSeparate(arg1, arg2) \
    __inline_Mesa_glBlendEquationSeparate((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDrawBuffers(GLsizei __arg1, const GLenum * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDrawBuffers,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLenum *,(__arg2),A0),
        struct Library *, (__MesaBase), 554, Mesa    );
}

#define glDrawBuffers(arg1, arg2) \
    __inline_Mesa_glDrawBuffers((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glStencilOpSeparate(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLenum __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glStencilOpSeparate,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        struct Library *, (__MesaBase), 555, Mesa    );
}

#define glStencilOpSeparate(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glStencilOpSeparate((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glStencilFuncSeparate(GLenum __arg1, GLenum __arg2, GLint __arg3, GLuint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glStencilFuncSeparate,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        struct Library *, (__MesaBase), 556, Mesa    );
}

#define glStencilFuncSeparate(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glStencilFuncSeparate((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glStencilMaskSeparate(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glStencilMaskSeparate,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 557, Mesa    );
}

#define glStencilMaskSeparate(arg1, arg2) \
    __inline_Mesa_glStencilMaskSeparate((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glAttachShader(GLuint __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glAttachShader,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 558, Mesa    );
}

#define glAttachShader(arg1, arg2) \
    __inline_Mesa_glAttachShader((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glBindAttribLocation(GLuint __arg1, GLuint __arg2, const GLchar * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glBindAttribLocation,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(const GLchar *,(__arg3),A0),
        struct Library *, (__MesaBase), 559, Mesa    );
}

#define glBindAttribLocation(arg1, arg2, arg3) \
    __inline_Mesa_glBindAttribLocation((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glCompileShader(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glCompileShader,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 560, Mesa    );
}

#define glCompileShader(arg1) \
    __inline_Mesa_glCompileShader((arg1), (APTR)MesaBase)

static inline GLuint __inline_Mesa_glCreateProgram(APTR __MesaBase)
{
    return AROS_LC0(GLuint, glCreateProgram,
        struct Library *, (__MesaBase), 561, Mesa    );
}

#define glCreateProgram() \
    __inline_Mesa_glCreateProgram((APTR)MesaBase)

static inline GLuint __inline_Mesa_glCreateShader(GLenum __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLuint, glCreateShader,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 562, Mesa    );
}

#define glCreateShader(arg1) \
    __inline_Mesa_glCreateShader((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteProgram(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glDeleteProgram,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 563, Mesa    );
}

#define glDeleteProgram(arg1) \
    __inline_Mesa_glDeleteProgram((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteShader(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glDeleteShader,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 564, Mesa    );
}

#define glDeleteShader(arg1) \
    __inline_Mesa_glDeleteShader((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDetachShader(GLuint __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDetachShader,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 565, Mesa    );
}

#define glDetachShader(arg1, arg2) \
    __inline_Mesa_glDetachShader((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDisableVertexAttribArray(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glDisableVertexAttribArray,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 566, Mesa    );
}

#define glDisableVertexAttribArray(arg1) \
    __inline_Mesa_glDisableVertexAttribArray((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glEnableVertexAttribArray(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glEnableVertexAttribArray,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 567, Mesa    );
}

#define glEnableVertexAttribArray(arg1) \
    __inline_Mesa_glEnableVertexAttribArray((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glGetActiveAttrib(GLuint __arg1, GLuint __arg2, GLsizei __arg3, GLsizei * __arg4, GLint * __arg5, GLenum * __arg6, GLchar * __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glGetActiveAttrib,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei *,(__arg4),A0),
        AROS_LCA(GLint *,(__arg5),A1),
        AROS_LCA(GLenum *,(__arg6),A2),
        AROS_LCA(GLchar *,(__arg7),A3),
        struct Library *, (__MesaBase), 568, Mesa    );
}

#define glGetActiveAttrib(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glGetActiveAttrib((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glGetActiveUniform(GLuint __arg1, GLuint __arg2, GLsizei __arg3, GLsizei * __arg4, GLint * __arg5, GLenum * __arg6, GLchar * __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glGetActiveUniform,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei *,(__arg4),A0),
        AROS_LCA(GLint *,(__arg5),A1),
        AROS_LCA(GLenum *,(__arg6),A2),
        AROS_LCA(GLchar *,(__arg7),A3),
        struct Library *, (__MesaBase), 569, Mesa    );
}

#define glGetActiveUniform(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glGetActiveUniform((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glGetAttachedShaders(GLuint __arg1, GLsizei __arg2, GLsizei * __arg3, GLuint * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetAttachedShaders,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLsizei *,(__arg3),A0),
        AROS_LCA(GLuint *,(__arg4),A1),
        struct Library *, (__MesaBase), 570, Mesa    );
}

#define glGetAttachedShaders(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetAttachedShaders((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline GLint __inline_Mesa_glGetAttribLocation(GLuint __arg1, const GLchar * __arg2, APTR __MesaBase)
{
    return AROS_LC2(GLint, glGetAttribLocation,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLchar *,(__arg2),A0),
        struct Library *, (__MesaBase), 571, Mesa    );
}

#define glGetAttribLocation(arg1, arg2) \
    __inline_Mesa_glGetAttribLocation((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetProgramiv(GLuint __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetProgramiv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 572, Mesa    );
}

#define glGetProgramiv(arg1, arg2, arg3) \
    __inline_Mesa_glGetProgramiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetProgramInfoLog(GLuint __arg1, GLsizei __arg2, GLsizei * __arg3, GLchar * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetProgramInfoLog,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLsizei *,(__arg3),A0),
        AROS_LCA(GLchar *,(__arg4),A1),
        struct Library *, (__MesaBase), 573, Mesa    );
}

#define glGetProgramInfoLog(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetProgramInfoLog((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetShaderiv(GLuint __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetShaderiv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 574, Mesa    );
}

#define glGetShaderiv(arg1, arg2, arg3) \
    __inline_Mesa_glGetShaderiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetShaderInfoLog(GLuint __arg1, GLsizei __arg2, GLsizei * __arg3, GLchar * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetShaderInfoLog,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLsizei *,(__arg3),A0),
        AROS_LCA(GLchar *,(__arg4),A1),
        struct Library *, (__MesaBase), 575, Mesa    );
}

#define glGetShaderInfoLog(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetShaderInfoLog((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetShaderSource(GLuint __arg1, GLsizei __arg2, GLsizei * __arg3, GLchar * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetShaderSource,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLsizei *,(__arg3),A0),
        AROS_LCA(GLchar *,(__arg4),A1),
        struct Library *, (__MesaBase), 576, Mesa    );
}

#define glGetShaderSource(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetShaderSource((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline GLint __inline_Mesa_glGetUniformLocation(GLuint __arg1, const GLchar * __arg2, APTR __MesaBase)
{
    return AROS_LC2(GLint, glGetUniformLocation,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLchar *,(__arg2),A0),
        struct Library *, (__MesaBase), 577, Mesa    );
}

#define glGetUniformLocation(arg1, arg2) \
    __inline_Mesa_glGetUniformLocation((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetUniformfv(GLuint __arg1, GLint __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetUniformfv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 578, Mesa    );
}

#define glGetUniformfv(arg1, arg2, arg3) \
    __inline_Mesa_glGetUniformfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetUniformiv(GLuint __arg1, GLint __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetUniformiv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 579, Mesa    );
}

#define glGetUniformiv(arg1, arg2, arg3) \
    __inline_Mesa_glGetUniformiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetVertexAttribdv(GLuint __arg1, GLenum __arg2, GLdouble * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetVertexAttribdv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLdouble *,(__arg3),A0),
        struct Library *, (__MesaBase), 580, Mesa    );
}

#define glGetVertexAttribdv(arg1, arg2, arg3) \
    __inline_Mesa_glGetVertexAttribdv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetVertexAttribfv(GLuint __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetVertexAttribfv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 581, Mesa    );
}

#define glGetVertexAttribfv(arg1, arg2, arg3) \
    __inline_Mesa_glGetVertexAttribfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetVertexAttribiv(GLuint __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetVertexAttribiv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 582, Mesa    );
}

#define glGetVertexAttribiv(arg1, arg2, arg3) \
    __inline_Mesa_glGetVertexAttribiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetVertexAttribPointerv(GLuint __arg1, GLenum __arg2, GLvoid *  * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetVertexAttribPointerv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLvoid *  *,(__arg3),A0),
        struct Library *, (__MesaBase), 583, Mesa    );
}

#define glGetVertexAttribPointerv(arg1, arg2, arg3) \
    __inline_Mesa_glGetVertexAttribPointerv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsProgram(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsProgram,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 584, Mesa    );
}

#define glIsProgram(arg1) \
    __inline_Mesa_glIsProgram((arg1), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsShader(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsShader,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 585, Mesa    );
}

#define glIsShader(arg1) \
    __inline_Mesa_glIsShader((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glLinkProgram(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glLinkProgram,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 586, Mesa    );
}

#define glLinkProgram(arg1) \
    __inline_Mesa_glLinkProgram((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glShaderSource(GLuint __arg1, GLsizei __arg2, const GLchar *  * __arg3, const GLint * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glShaderSource,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLchar *  *,(__arg3),A0),
        AROS_LCA(const GLint *,(__arg4),A1),
        struct Library *, (__MesaBase), 587, Mesa    );
}

#define glShaderSource(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glShaderSource((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glUseProgram(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glUseProgram,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 588, Mesa    );
}

#define glUseProgram(arg1) \
    __inline_Mesa_glUseProgram((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform1f(GLint __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glUniform1f,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 589, Mesa    );
}

#define glUniform1f(arg1, arg2) \
    __inline_Mesa_glUniform1f((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform2f(GLint __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform2f,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 590, Mesa    );
}

#define glUniform2f(arg1, arg2, arg3) \
    __inline_Mesa_glUniform2f((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform3f(GLint __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniform3f,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        struct Library *, (__MesaBase), 591, Mesa    );
}

#define glUniform3f(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniform3f((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform4f(GLint __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, GLfloat __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glUniform4f,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        AROS_LCA(GLfloat,(__arg5),D4),
        struct Library *, (__MesaBase), 592, Mesa    );
}

#define glUniform4f(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glUniform4f((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform1i(GLint __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glUniform1i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 593, Mesa    );
}

#define glUniform1i(arg1, arg2) \
    __inline_Mesa_glUniform1i((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform2i(GLint __arg1, GLint __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform2i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 594, Mesa    );
}

#define glUniform2i(arg1, arg2, arg3) \
    __inline_Mesa_glUniform2i((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform3i(GLint __arg1, GLint __arg2, GLint __arg3, GLint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniform3i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        struct Library *, (__MesaBase), 595, Mesa    );
}

#define glUniform3i(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniform3i((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform4i(GLint __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glUniform4i,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        struct Library *, (__MesaBase), 596, Mesa    );
}

#define glUniform4i(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glUniform4i((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform1fv(GLint __arg1, GLsizei __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform1fv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 597, Mesa    );
}

#define glUniform1fv(arg1, arg2, arg3) \
    __inline_Mesa_glUniform1fv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform2fv(GLint __arg1, GLsizei __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform2fv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 598, Mesa    );
}

#define glUniform2fv(arg1, arg2, arg3) \
    __inline_Mesa_glUniform2fv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform3fv(GLint __arg1, GLsizei __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform3fv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 599, Mesa    );
}

#define glUniform3fv(arg1, arg2, arg3) \
    __inline_Mesa_glUniform3fv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform4fv(GLint __arg1, GLsizei __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform4fv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 600, Mesa    );
}

#define glUniform4fv(arg1, arg2, arg3) \
    __inline_Mesa_glUniform4fv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform1iv(GLint __arg1, GLsizei __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform1iv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 601, Mesa    );
}

#define glUniform1iv(arg1, arg2, arg3) \
    __inline_Mesa_glUniform1iv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform2iv(GLint __arg1, GLsizei __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform2iv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 602, Mesa    );
}

#define glUniform2iv(arg1, arg2, arg3) \
    __inline_Mesa_glUniform2iv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform3iv(GLint __arg1, GLsizei __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform3iv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 603, Mesa    );
}

#define glUniform3iv(arg1, arg2, arg3) \
    __inline_Mesa_glUniform3iv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform4iv(GLint __arg1, GLsizei __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform4iv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 604, Mesa    );
}

#define glUniform4iv(arg1, arg2, arg3) \
    __inline_Mesa_glUniform4iv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniformMatrix2fv(GLint __arg1, GLsizei __arg2, GLboolean __arg3, const GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniformMatrix2fv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLboolean,(__arg3),D2),
        AROS_LCA(const GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 605, Mesa    );
}

#define glUniformMatrix2fv(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniformMatrix2fv((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glUniformMatrix3fv(GLint __arg1, GLsizei __arg2, GLboolean __arg3, const GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniformMatrix3fv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLboolean,(__arg3),D2),
        AROS_LCA(const GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 606, Mesa    );
}

#define glUniformMatrix3fv(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniformMatrix3fv((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glUniformMatrix4fv(GLint __arg1, GLsizei __arg2, GLboolean __arg3, const GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniformMatrix4fv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLboolean,(__arg3),D2),
        AROS_LCA(const GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 607, Mesa    );
}

#define glUniformMatrix4fv(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniformMatrix4fv((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glValidateProgram(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glValidateProgram,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 608, Mesa    );
}

#define glValidateProgram(arg1) \
    __inline_Mesa_glValidateProgram((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1d(GLuint __arg1, GLdouble __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1d,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        struct Library *, (__MesaBase), 609, Mesa    );
}

#define glVertexAttrib1d(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1d((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1dv(GLuint __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1dv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 610, Mesa    );
}

#define glVertexAttrib1dv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1dv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1f(GLuint __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1f,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 611, Mesa    );
}

#define glVertexAttrib1f(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1f((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1fv(GLuint __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1fv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 612, Mesa    );
}

#define glVertexAttrib1fv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1fv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1s(GLuint __arg1, GLshort __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1s,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        struct Library *, (__MesaBase), 613, Mesa    );
}

#define glVertexAttrib1s(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1s((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1sv(GLuint __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1sv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 614, Mesa    );
}

#define glVertexAttrib1sv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1sv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2d(GLuint __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttrib2d,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 615, Mesa    );
}

#define glVertexAttrib2d(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttrib2d((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2dv(GLuint __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib2dv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 616, Mesa    );
}

#define glVertexAttrib2dv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib2dv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2f(GLuint __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttrib2f,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 617, Mesa    );
}

#define glVertexAttrib2f(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttrib2f((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2fv(GLuint __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib2fv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 618, Mesa    );
}

#define glVertexAttrib2fv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib2fv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2s(GLuint __arg1, GLshort __arg2, GLshort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttrib2s,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        struct Library *, (__MesaBase), 619, Mesa    );
}

#define glVertexAttrib2s(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttrib2s((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2sv(GLuint __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib2sv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 620, Mesa    );
}

#define glVertexAttrib2sv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib2sv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3d(GLuint __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertexAttrib3d,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        struct Library *, (__MesaBase), 621, Mesa    );
}

#define glVertexAttrib3d(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertexAttrib3d((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3dv(GLuint __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib3dv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 622, Mesa    );
}

#define glVertexAttrib3dv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib3dv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3f(GLuint __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertexAttrib3f,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        struct Library *, (__MesaBase), 623, Mesa    );
}

#define glVertexAttrib3f(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertexAttrib3f((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3fv(GLuint __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib3fv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 624, Mesa    );
}

#define glVertexAttrib3fv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib3fv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3s(GLuint __arg1, GLshort __arg2, GLshort __arg3, GLshort __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertexAttrib3s,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        AROS_LCA(GLshort,(__arg4),D3),
        struct Library *, (__MesaBase), 625, Mesa    );
}

#define glVertexAttrib3s(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertexAttrib3s((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3sv(GLuint __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib3sv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 626, Mesa    );
}

#define glVertexAttrib3sv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib3sv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4Nbv(GLuint __arg1, const GLbyte * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4Nbv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLbyte *,(__arg2),A0),
        struct Library *, (__MesaBase), 627, Mesa    );
}

#define glVertexAttrib4Nbv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4Nbv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4Niv(GLuint __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4Niv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 628, Mesa    );
}

#define glVertexAttrib4Niv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4Niv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4Nsv(GLuint __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4Nsv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 629, Mesa    );
}

#define glVertexAttrib4Nsv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4Nsv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4Nub(GLuint __arg1, GLubyte __arg2, GLubyte __arg3, GLubyte __arg4, GLubyte __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttrib4Nub,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLubyte,(__arg2),D1),
        AROS_LCA(GLubyte,(__arg3),D2),
        AROS_LCA(GLubyte,(__arg4),D3),
        AROS_LCA(GLubyte,(__arg5),D4),
        struct Library *, (__MesaBase), 630, Mesa    );
}

#define glVertexAttrib4Nub(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttrib4Nub((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4Nubv(GLuint __arg1, const GLubyte * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4Nubv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLubyte *,(__arg2),A0),
        struct Library *, (__MesaBase), 631, Mesa    );
}

#define glVertexAttrib4Nubv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4Nubv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4Nuiv(GLuint __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4Nuiv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 632, Mesa    );
}

#define glVertexAttrib4Nuiv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4Nuiv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4Nusv(GLuint __arg1, const GLushort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4Nusv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLushort *,(__arg2),A0),
        struct Library *, (__MesaBase), 633, Mesa    );
}

#define glVertexAttrib4Nusv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4Nusv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4bv(GLuint __arg1, const GLbyte * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4bv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLbyte *,(__arg2),A0),
        struct Library *, (__MesaBase), 634, Mesa    );
}

#define glVertexAttrib4bv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4bv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4d(GLuint __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, GLdouble __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttrib4d,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        AROS_LCA(GLdouble,(__arg5),D4),
        struct Library *, (__MesaBase), 635, Mesa    );
}

#define glVertexAttrib4d(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttrib4d((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4dv(GLuint __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4dv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 636, Mesa    );
}

#define glVertexAttrib4dv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4dv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4f(GLuint __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, GLfloat __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttrib4f,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        AROS_LCA(GLfloat,(__arg5),D4),
        struct Library *, (__MesaBase), 637, Mesa    );
}

#define glVertexAttrib4f(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttrib4f((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4fv(GLuint __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4fv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 638, Mesa    );
}

#define glVertexAttrib4fv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4fv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4iv(GLuint __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4iv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 639, Mesa    );
}

#define glVertexAttrib4iv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4iv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4s(GLuint __arg1, GLshort __arg2, GLshort __arg3, GLshort __arg4, GLshort __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttrib4s,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        AROS_LCA(GLshort,(__arg4),D3),
        AROS_LCA(GLshort,(__arg5),D4),
        struct Library *, (__MesaBase), 640, Mesa    );
}

#define glVertexAttrib4s(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttrib4s((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4sv(GLuint __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4sv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 641, Mesa    );
}

#define glVertexAttrib4sv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4sv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4ubv(GLuint __arg1, const GLubyte * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4ubv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLubyte *,(__arg2),A0),
        struct Library *, (__MesaBase), 642, Mesa    );
}

#define glVertexAttrib4ubv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4ubv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4uiv(GLuint __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4uiv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 643, Mesa    );
}

#define glVertexAttrib4uiv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4uiv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4usv(GLuint __arg1, const GLushort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4usv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLushort *,(__arg2),A0),
        struct Library *, (__MesaBase), 644, Mesa    );
}

#define glVertexAttrib4usv(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4usv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribPointer(GLuint __arg1, GLint __arg2, GLenum __arg3, GLboolean __arg4, GLsizei __arg5, const GLvoid * __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glVertexAttribPointer,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLboolean,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        AROS_LCA(const GLvoid *,(__arg6),A0),
        struct Library *, (__MesaBase), 645, Mesa    );
}

#define glVertexAttribPointer(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glVertexAttribPointer((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glUniformMatrix2x3fv(GLint __arg1, GLsizei __arg2, GLboolean __arg3, const GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniformMatrix2x3fv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLboolean,(__arg3),D2),
        AROS_LCA(const GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 646, Mesa    );
}

#define glUniformMatrix2x3fv(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniformMatrix2x3fv((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glUniformMatrix3x2fv(GLint __arg1, GLsizei __arg2, GLboolean __arg3, const GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniformMatrix3x2fv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLboolean,(__arg3),D2),
        AROS_LCA(const GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 647, Mesa    );
}

#define glUniformMatrix3x2fv(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniformMatrix3x2fv((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glUniformMatrix2x4fv(GLint __arg1, GLsizei __arg2, GLboolean __arg3, const GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniformMatrix2x4fv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLboolean,(__arg3),D2),
        AROS_LCA(const GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 648, Mesa    );
}

#define glUniformMatrix2x4fv(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniformMatrix2x4fv((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glUniformMatrix4x2fv(GLint __arg1, GLsizei __arg2, GLboolean __arg3, const GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniformMatrix4x2fv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLboolean,(__arg3),D2),
        AROS_LCA(const GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 649, Mesa    );
}

#define glUniformMatrix4x2fv(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniformMatrix4x2fv((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glUniformMatrix3x4fv(GLint __arg1, GLsizei __arg2, GLboolean __arg3, const GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniformMatrix3x4fv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLboolean,(__arg3),D2),
        AROS_LCA(const GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 650, Mesa    );
}

#define glUniformMatrix3x4fv(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniformMatrix3x4fv((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glUniformMatrix4x3fv(GLint __arg1, GLsizei __arg2, GLboolean __arg3, const GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniformMatrix4x3fv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLboolean,(__arg3),D2),
        AROS_LCA(const GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 651, Mesa    );
}

#define glUniformMatrix4x3fv(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniformMatrix4x3fv((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glLoadTransposeMatrixfARB(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glLoadTransposeMatrixfARB,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 652, Mesa    );
}

#define glLoadTransposeMatrixfARB(arg1) \
    __inline_Mesa_glLoadTransposeMatrixfARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glLoadTransposeMatrixdARB(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glLoadTransposeMatrixdARB,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 653, Mesa    );
}

#define glLoadTransposeMatrixdARB(arg1) \
    __inline_Mesa_glLoadTransposeMatrixdARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glMultTransposeMatrixfARB(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glMultTransposeMatrixfARB,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 654, Mesa    );
}

#define glMultTransposeMatrixfARB(arg1) \
    __inline_Mesa_glMultTransposeMatrixfARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glMultTransposeMatrixdARB(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glMultTransposeMatrixdARB,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 655, Mesa    );
}

#define glMultTransposeMatrixdARB(arg1) \
    __inline_Mesa_glMultTransposeMatrixdARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSampleCoverageARB(GLclampf __arg1, GLboolean __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glSampleCoverageARB,
        AROS_LCA(GLclampf,(__arg1),D0),
        AROS_LCA(GLboolean,(__arg2),D1),
        struct Library *, (__MesaBase), 656, Mesa    );
}

#define glSampleCoverageARB(arg1, arg2) \
    __inline_Mesa_glSampleCoverageARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glCompressedTexImage3DARB(GLenum __arg1, GLint __arg2, GLenum __arg3, GLsizei __arg4, GLsizei __arg5, GLsizei __arg6, GLint __arg7, GLsizei __arg8, const GLvoid * __arg9, APTR __MesaBase)
{
    AROS_LC9NR(void, glCompressedTexImage3DARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(GLint,(__arg7),D6),
        AROS_LCA(GLsizei,(__arg8),D7),
        AROS_LCA(const GLvoid *,(__arg9),A0),
        struct Library *, (__MesaBase), 657, Mesa    );
}

#define glCompressedTexImage3DARB(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Mesa_glCompressedTexImage3DARB((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)MesaBase)

static inline void __inline_Mesa_glCompressedTexImage2DARB(GLenum __arg1, GLint __arg2, GLenum __arg3, GLsizei __arg4, GLsizei __arg5, GLint __arg6, GLsizei __arg7, const GLvoid * __arg8, APTR __MesaBase)
{
    AROS_LC8NR(void, glCompressedTexImage2DARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        AROS_LCA(GLint,(__arg6),D5),
        AROS_LCA(GLsizei,(__arg7),D6),
        AROS_LCA(const GLvoid *,(__arg8),A0),
        struct Library *, (__MesaBase), 658, Mesa    );
}

#define glCompressedTexImage2DARB(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
    __inline_Mesa_glCompressedTexImage2DARB((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (APTR)MesaBase)

static inline void __inline_Mesa_glCompressedTexImage1DARB(GLenum __arg1, GLint __arg2, GLenum __arg3, GLsizei __arg4, GLint __arg5, GLsizei __arg6, const GLvoid * __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glCompressedTexImage1DARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(const GLvoid *,(__arg7),A0),
        struct Library *, (__MesaBase), 659, Mesa    );
}

#define glCompressedTexImage1DARB(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glCompressedTexImage1DARB((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glCompressedTexSubImage3DARB(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, GLsizei __arg6, GLsizei __arg7, GLsizei __arg8, GLenum __arg9, GLsizei __arg10, const GLvoid * __arg11, APTR __MesaBase)
{
    AROS_LC11NR(void, glCompressedTexSubImage3DARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(GLsizei,(__arg7),D6),
        AROS_LCA(GLsizei,(__arg8),D7),
        AROS_LCA(GLenum,(__arg9),A0),
        AROS_LCA(GLsizei,(__arg10),A1),
        AROS_LCA(const GLvoid *,(__arg11),A2),
        struct Library *, (__MesaBase), 660, Mesa    );
}

#define glCompressedTexSubImage3DARB(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) \
    __inline_Mesa_glCompressedTexSubImage3DARB((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (arg11), (APTR)MesaBase)

static inline void __inline_Mesa_glCompressedTexSubImage2DARB(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLsizei __arg5, GLsizei __arg6, GLenum __arg7, GLsizei __arg8, const GLvoid * __arg9, APTR __MesaBase)
{
    AROS_LC9NR(void, glCompressedTexSubImage2DARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(GLenum,(__arg7),D6),
        AROS_LCA(GLsizei,(__arg8),D7),
        AROS_LCA(const GLvoid *,(__arg9),A0),
        struct Library *, (__MesaBase), 661, Mesa    );
}

#define glCompressedTexSubImage2DARB(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Mesa_glCompressedTexSubImage2DARB((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)MesaBase)

static inline void __inline_Mesa_glCompressedTexSubImage1DARB(GLenum __arg1, GLint __arg2, GLint __arg3, GLsizei __arg4, GLenum __arg5, GLsizei __arg6, const GLvoid * __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glCompressedTexSubImage1DARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(const GLvoid *,(__arg7),A0),
        struct Library *, (__MesaBase), 662, Mesa    );
}

#define glCompressedTexSubImage1DARB(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glCompressedTexSubImage1DARB((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glGetCompressedTexImageARB(GLenum __arg1, GLint __arg2, GLvoid * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetCompressedTexImageARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLvoid *,(__arg3),A0),
        struct Library *, (__MesaBase), 663, Mesa    );
}

#define glGetCompressedTexImageARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetCompressedTexImageARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glPointParameterfARB(GLenum __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPointParameterfARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 664, Mesa    );
}

#define glPointParameterfARB(arg1, arg2) \
    __inline_Mesa_glPointParameterfARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPointParameterfvARB(GLenum __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPointParameterfvARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 665, Mesa    );
}

#define glPointParameterfvARB(arg1, arg2) \
    __inline_Mesa_glPointParameterfvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos2dARB(GLdouble __arg1, GLdouble __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glWindowPos2dARB,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        struct Library *, (__MesaBase), 666, Mesa    );
}

#define glWindowPos2dARB(arg1, arg2) \
    __inline_Mesa_glWindowPos2dARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos2dvARB(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos2dvARB,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 667, Mesa    );
}

#define glWindowPos2dvARB(arg1) \
    __inline_Mesa_glWindowPos2dvARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos2fARB(GLfloat __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glWindowPos2fARB,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 668, Mesa    );
}

#define glWindowPos2fARB(arg1, arg2) \
    __inline_Mesa_glWindowPos2fARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos2fvARB(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos2fvARB,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 669, Mesa    );
}

#define glWindowPos2fvARB(arg1) \
    __inline_Mesa_glWindowPos2fvARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos2iARB(GLint __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glWindowPos2iARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 670, Mesa    );
}

#define glWindowPos2iARB(arg1, arg2) \
    __inline_Mesa_glWindowPos2iARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos2ivARB(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos2ivARB,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 671, Mesa    );
}

#define glWindowPos2ivARB(arg1) \
    __inline_Mesa_glWindowPos2ivARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos2sARB(GLshort __arg1, GLshort __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glWindowPos2sARB,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        struct Library *, (__MesaBase), 672, Mesa    );
}

#define glWindowPos2sARB(arg1, arg2) \
    __inline_Mesa_glWindowPos2sARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos2svARB(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos2svARB,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 673, Mesa    );
}

#define glWindowPos2svARB(arg1) \
    __inline_Mesa_glWindowPos2svARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos3dARB(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glWindowPos3dARB,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 674, Mesa    );
}

#define glWindowPos3dARB(arg1, arg2, arg3) \
    __inline_Mesa_glWindowPos3dARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos3dvARB(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos3dvARB,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 675, Mesa    );
}

#define glWindowPos3dvARB(arg1) \
    __inline_Mesa_glWindowPos3dvARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos3fARB(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glWindowPos3fARB,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 676, Mesa    );
}

#define glWindowPos3fARB(arg1, arg2, arg3) \
    __inline_Mesa_glWindowPos3fARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos3fvARB(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos3fvARB,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 677, Mesa    );
}

#define glWindowPos3fvARB(arg1) \
    __inline_Mesa_glWindowPos3fvARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos3iARB(GLint __arg1, GLint __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glWindowPos3iARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 678, Mesa    );
}

#define glWindowPos3iARB(arg1, arg2, arg3) \
    __inline_Mesa_glWindowPos3iARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos3ivARB(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos3ivARB,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 679, Mesa    );
}

#define glWindowPos3ivARB(arg1) \
    __inline_Mesa_glWindowPos3ivARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos3sARB(GLshort __arg1, GLshort __arg2, GLshort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glWindowPos3sARB,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        struct Library *, (__MesaBase), 680, Mesa    );
}

#define glWindowPos3sARB(arg1, arg2, arg3) \
    __inline_Mesa_glWindowPos3sARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos3svARB(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos3svARB,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 681, Mesa    );
}

#define glWindowPos3svARB(arg1) \
    __inline_Mesa_glWindowPos3svARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1dARB(GLuint __arg1, GLdouble __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1dARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        struct Library *, (__MesaBase), 682, Mesa    );
}

#define glVertexAttrib1dARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1dARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1dvARB(GLuint __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1dvARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 683, Mesa    );
}

#define glVertexAttrib1dvARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1dvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1fARB(GLuint __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1fARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 684, Mesa    );
}

#define glVertexAttrib1fARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1fARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1fvARB(GLuint __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1fvARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 685, Mesa    );
}

#define glVertexAttrib1fvARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1fvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1sARB(GLuint __arg1, GLshort __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1sARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        struct Library *, (__MesaBase), 686, Mesa    );
}

#define glVertexAttrib1sARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1sARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1svARB(GLuint __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1svARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 687, Mesa    );
}

#define glVertexAttrib1svARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1svARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2dARB(GLuint __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttrib2dARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 688, Mesa    );
}

#define glVertexAttrib2dARB(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttrib2dARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2dvARB(GLuint __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib2dvARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 689, Mesa    );
}

#define glVertexAttrib2dvARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib2dvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2fARB(GLuint __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttrib2fARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 690, Mesa    );
}

#define glVertexAttrib2fARB(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttrib2fARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2fvARB(GLuint __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib2fvARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 691, Mesa    );
}

#define glVertexAttrib2fvARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib2fvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2sARB(GLuint __arg1, GLshort __arg2, GLshort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttrib2sARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        struct Library *, (__MesaBase), 692, Mesa    );
}

#define glVertexAttrib2sARB(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttrib2sARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2svARB(GLuint __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib2svARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 693, Mesa    );
}

#define glVertexAttrib2svARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib2svARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3dARB(GLuint __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertexAttrib3dARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        struct Library *, (__MesaBase), 694, Mesa    );
}

#define glVertexAttrib3dARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertexAttrib3dARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3dvARB(GLuint __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib3dvARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 695, Mesa    );
}

#define glVertexAttrib3dvARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib3dvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3fARB(GLuint __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertexAttrib3fARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        struct Library *, (__MesaBase), 696, Mesa    );
}

#define glVertexAttrib3fARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertexAttrib3fARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3fvARB(GLuint __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib3fvARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 697, Mesa    );
}

#define glVertexAttrib3fvARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib3fvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3sARB(GLuint __arg1, GLshort __arg2, GLshort __arg3, GLshort __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertexAttrib3sARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        AROS_LCA(GLshort,(__arg4),D3),
        struct Library *, (__MesaBase), 698, Mesa    );
}

#define glVertexAttrib3sARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertexAttrib3sARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3svARB(GLuint __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib3svARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 699, Mesa    );
}

#define glVertexAttrib3svARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib3svARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4NbvARB(GLuint __arg1, const GLbyte * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4NbvARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLbyte *,(__arg2),A0),
        struct Library *, (__MesaBase), 700, Mesa    );
}

#define glVertexAttrib4NbvARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4NbvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4NivARB(GLuint __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4NivARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 701, Mesa    );
}

#define glVertexAttrib4NivARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4NivARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4NsvARB(GLuint __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4NsvARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 702, Mesa    );
}

#define glVertexAttrib4NsvARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4NsvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4NubARB(GLuint __arg1, GLubyte __arg2, GLubyte __arg3, GLubyte __arg4, GLubyte __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttrib4NubARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLubyte,(__arg2),D1),
        AROS_LCA(GLubyte,(__arg3),D2),
        AROS_LCA(GLubyte,(__arg4),D3),
        AROS_LCA(GLubyte,(__arg5),D4),
        struct Library *, (__MesaBase), 703, Mesa    );
}

#define glVertexAttrib4NubARB(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttrib4NubARB((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4NubvARB(GLuint __arg1, const GLubyte * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4NubvARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLubyte *,(__arg2),A0),
        struct Library *, (__MesaBase), 704, Mesa    );
}

#define glVertexAttrib4NubvARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4NubvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4NuivARB(GLuint __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4NuivARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 705, Mesa    );
}

#define glVertexAttrib4NuivARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4NuivARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4NusvARB(GLuint __arg1, const GLushort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4NusvARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLushort *,(__arg2),A0),
        struct Library *, (__MesaBase), 706, Mesa    );
}

#define glVertexAttrib4NusvARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4NusvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4bvARB(GLuint __arg1, const GLbyte * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4bvARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLbyte *,(__arg2),A0),
        struct Library *, (__MesaBase), 707, Mesa    );
}

#define glVertexAttrib4bvARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4bvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4dARB(GLuint __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, GLdouble __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttrib4dARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        AROS_LCA(GLdouble,(__arg5),D4),
        struct Library *, (__MesaBase), 708, Mesa    );
}

#define glVertexAttrib4dARB(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttrib4dARB((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4dvARB(GLuint __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4dvARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 709, Mesa    );
}

#define glVertexAttrib4dvARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4dvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4fARB(GLuint __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, GLfloat __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttrib4fARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        AROS_LCA(GLfloat,(__arg5),D4),
        struct Library *, (__MesaBase), 710, Mesa    );
}

#define glVertexAttrib4fARB(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttrib4fARB((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4fvARB(GLuint __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4fvARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 711, Mesa    );
}

#define glVertexAttrib4fvARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4fvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4ivARB(GLuint __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4ivARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 712, Mesa    );
}

#define glVertexAttrib4ivARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4ivARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4sARB(GLuint __arg1, GLshort __arg2, GLshort __arg3, GLshort __arg4, GLshort __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttrib4sARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        AROS_LCA(GLshort,(__arg4),D3),
        AROS_LCA(GLshort,(__arg5),D4),
        struct Library *, (__MesaBase), 713, Mesa    );
}

#define glVertexAttrib4sARB(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttrib4sARB((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4svARB(GLuint __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4svARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 714, Mesa    );
}

#define glVertexAttrib4svARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4svARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4ubvARB(GLuint __arg1, const GLubyte * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4ubvARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLubyte *,(__arg2),A0),
        struct Library *, (__MesaBase), 715, Mesa    );
}

#define glVertexAttrib4ubvARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4ubvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4uivARB(GLuint __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4uivARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 716, Mesa    );
}

#define glVertexAttrib4uivARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4uivARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4usvARB(GLuint __arg1, const GLushort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4usvARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLushort *,(__arg2),A0),
        struct Library *, (__MesaBase), 717, Mesa    );
}

#define glVertexAttrib4usvARB(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4usvARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribPointerARB(GLuint __arg1, GLint __arg2, GLenum __arg3, GLboolean __arg4, GLsizei __arg5, const GLvoid * __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glVertexAttribPointerARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLboolean,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        AROS_LCA(const GLvoid *,(__arg6),A0),
        struct Library *, (__MesaBase), 718, Mesa    );
}

#define glVertexAttribPointerARB(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glVertexAttribPointerARB((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glEnableVertexAttribArrayARB(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glEnableVertexAttribArrayARB,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 719, Mesa    );
}

#define glEnableVertexAttribArrayARB(arg1) \
    __inline_Mesa_glEnableVertexAttribArrayARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDisableVertexAttribArrayARB(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glDisableVertexAttribArrayARB,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 720, Mesa    );
}

#define glDisableVertexAttribArrayARB(arg1) \
    __inline_Mesa_glDisableVertexAttribArrayARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramStringARB(GLenum __arg1, GLenum __arg2, GLsizei __arg3, const GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glProgramStringARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(const GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 721, Mesa    );
}

#define glProgramStringARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glProgramStringARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glBindProgramARB(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBindProgramARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 722, Mesa    );
}

#define glBindProgramARB(arg1, arg2) \
    __inline_Mesa_glBindProgramARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteProgramsARB(GLsizei __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDeleteProgramsARB,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 723, Mesa    );
}

#define glDeleteProgramsARB(arg1, arg2) \
    __inline_Mesa_glDeleteProgramsARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGenProgramsARB(GLsizei __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGenProgramsARB,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 724, Mesa    );
}

#define glGenProgramsARB(arg1, arg2) \
    __inline_Mesa_glGenProgramsARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramEnvParameter4dARB(GLenum __arg1, GLuint __arg2, GLdouble __arg3, GLdouble __arg4, GLdouble __arg5, GLdouble __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glProgramEnvParameter4dARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        AROS_LCA(GLdouble,(__arg5),D4),
        AROS_LCA(GLdouble,(__arg6),D5),
        struct Library *, (__MesaBase), 725, Mesa    );
}

#define glProgramEnvParameter4dARB(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glProgramEnvParameter4dARB((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramEnvParameter4dvARB(GLenum __arg1, GLuint __arg2, const GLdouble * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glProgramEnvParameter4dvARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(const GLdouble *,(__arg3),A0),
        struct Library *, (__MesaBase), 726, Mesa    );
}

#define glProgramEnvParameter4dvARB(arg1, arg2, arg3) \
    __inline_Mesa_glProgramEnvParameter4dvARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramEnvParameter4fARB(GLenum __arg1, GLuint __arg2, GLfloat __arg3, GLfloat __arg4, GLfloat __arg5, GLfloat __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glProgramEnvParameter4fARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        AROS_LCA(GLfloat,(__arg5),D4),
        AROS_LCA(GLfloat,(__arg6),D5),
        struct Library *, (__MesaBase), 727, Mesa    );
}

#define glProgramEnvParameter4fARB(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glProgramEnvParameter4fARB((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramEnvParameter4fvARB(GLenum __arg1, GLuint __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glProgramEnvParameter4fvARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 728, Mesa    );
}

#define glProgramEnvParameter4fvARB(arg1, arg2, arg3) \
    __inline_Mesa_glProgramEnvParameter4fvARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramLocalParameter4dARB(GLenum __arg1, GLuint __arg2, GLdouble __arg3, GLdouble __arg4, GLdouble __arg5, GLdouble __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glProgramLocalParameter4dARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        AROS_LCA(GLdouble,(__arg5),D4),
        AROS_LCA(GLdouble,(__arg6),D5),
        struct Library *, (__MesaBase), 729, Mesa    );
}

#define glProgramLocalParameter4dARB(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glProgramLocalParameter4dARB((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramLocalParameter4dvARB(GLenum __arg1, GLuint __arg2, const GLdouble * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glProgramLocalParameter4dvARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(const GLdouble *,(__arg3),A0),
        struct Library *, (__MesaBase), 730, Mesa    );
}

#define glProgramLocalParameter4dvARB(arg1, arg2, arg3) \
    __inline_Mesa_glProgramLocalParameter4dvARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramLocalParameter4fARB(GLenum __arg1, GLuint __arg2, GLfloat __arg3, GLfloat __arg4, GLfloat __arg5, GLfloat __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glProgramLocalParameter4fARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        AROS_LCA(GLfloat,(__arg5),D4),
        AROS_LCA(GLfloat,(__arg6),D5),
        struct Library *, (__MesaBase), 731, Mesa    );
}

#define glProgramLocalParameter4fARB(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glProgramLocalParameter4fARB((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramLocalParameter4fvARB(GLenum __arg1, GLuint __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glProgramLocalParameter4fvARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 732, Mesa    );
}

#define glProgramLocalParameter4fvARB(arg1, arg2, arg3) \
    __inline_Mesa_glProgramLocalParameter4fvARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetProgramEnvParameterdvARB(GLenum __arg1, GLuint __arg2, GLdouble * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetProgramEnvParameterdvARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLdouble *,(__arg3),A0),
        struct Library *, (__MesaBase), 733, Mesa    );
}

#define glGetProgramEnvParameterdvARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetProgramEnvParameterdvARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetProgramEnvParameterfvARB(GLenum __arg1, GLuint __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetProgramEnvParameterfvARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 734, Mesa    );
}

#define glGetProgramEnvParameterfvARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetProgramEnvParameterfvARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetProgramLocalParameterdvARB(GLenum __arg1, GLuint __arg2, GLdouble * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetProgramLocalParameterdvARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLdouble *,(__arg3),A0),
        struct Library *, (__MesaBase), 735, Mesa    );
}

#define glGetProgramLocalParameterdvARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetProgramLocalParameterdvARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetProgramLocalParameterfvARB(GLenum __arg1, GLuint __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetProgramLocalParameterfvARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 736, Mesa    );
}

#define glGetProgramLocalParameterfvARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetProgramLocalParameterfvARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetProgramivARB(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetProgramivARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 737, Mesa    );
}

#define glGetProgramivARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetProgramivARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetProgramStringARB(GLenum __arg1, GLenum __arg2, GLvoid * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetProgramStringARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLvoid *,(__arg3),A0),
        struct Library *, (__MesaBase), 738, Mesa    );
}

#define glGetProgramStringARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetProgramStringARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetVertexAttribdvARB(GLuint __arg1, GLenum __arg2, GLdouble * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetVertexAttribdvARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLdouble *,(__arg3),A0),
        struct Library *, (__MesaBase), 739, Mesa    );
}

#define glGetVertexAttribdvARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetVertexAttribdvARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetVertexAttribfvARB(GLuint __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetVertexAttribfvARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 740, Mesa    );
}

#define glGetVertexAttribfvARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetVertexAttribfvARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetVertexAttribivARB(GLuint __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetVertexAttribivARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 741, Mesa    );
}

#define glGetVertexAttribivARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetVertexAttribivARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetVertexAttribPointervARB(GLuint __arg1, GLenum __arg2, GLvoid *  * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetVertexAttribPointervARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLvoid *  *,(__arg3),A0),
        struct Library *, (__MesaBase), 742, Mesa    );
}

#define glGetVertexAttribPointervARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetVertexAttribPointervARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsProgramARB(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsProgramARB,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 743, Mesa    );
}

#define glIsProgramARB(arg1) \
    __inline_Mesa_glIsProgramARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glBindBufferARB(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBindBufferARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 744, Mesa    );
}

#define glBindBufferARB(arg1, arg2) \
    __inline_Mesa_glBindBufferARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteBuffersARB(GLsizei __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDeleteBuffersARB,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 745, Mesa    );
}

#define glDeleteBuffersARB(arg1, arg2) \
    __inline_Mesa_glDeleteBuffersARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGenBuffersARB(GLsizei __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGenBuffersARB,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 746, Mesa    );
}

#define glGenBuffersARB(arg1, arg2) \
    __inline_Mesa_glGenBuffersARB((arg1), (arg2), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsBufferARB(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsBufferARB,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 747, Mesa    );
}

#define glIsBufferARB(arg1) \
    __inline_Mesa_glIsBufferARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glBufferDataARB(GLenum __arg1, GLsizeiptrARB __arg2, const GLvoid * __arg3, GLenum __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glBufferDataARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizeiptrARB,(__arg2),D1),
        AROS_LCA(const GLvoid *,(__arg3),A0),
        AROS_LCA(GLenum,(__arg4),D2),
        struct Library *, (__MesaBase), 748, Mesa    );
}

#define glBufferDataARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glBufferDataARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glBufferSubDataARB(GLenum __arg1, GLintptrARB __arg2, GLsizeiptrARB __arg3, const GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glBufferSubDataARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLintptrARB,(__arg2),D1),
        AROS_LCA(GLsizeiptrARB,(__arg3),D2),
        AROS_LCA(const GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 749, Mesa    );
}

#define glBufferSubDataARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glBufferSubDataARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetBufferSubDataARB(GLenum __arg1, GLintptrARB __arg2, GLsizeiptrARB __arg3, GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetBufferSubDataARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLintptrARB,(__arg2),D1),
        AROS_LCA(GLsizeiptrARB,(__arg3),D2),
        AROS_LCA(GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 750, Mesa    );
}

#define glGetBufferSubDataARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetBufferSubDataARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline GLvoid* __inline_Mesa_glMapBufferARB(GLenum __arg1, GLenum __arg2, APTR __MesaBase)
{
    return AROS_LC2(GLvoid*, glMapBufferARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        struct Library *, (__MesaBase), 751, Mesa    );
}

#define glMapBufferARB(arg1, arg2) \
    __inline_Mesa_glMapBufferARB((arg1), (arg2), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glUnmapBufferARB(GLenum __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glUnmapBufferARB,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 752, Mesa    );
}

#define glUnmapBufferARB(arg1) \
    __inline_Mesa_glUnmapBufferARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glGetBufferParameterivARB(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetBufferParameterivARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 753, Mesa    );
}

#define glGetBufferParameterivARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetBufferParameterivARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetBufferPointervARB(GLenum __arg1, GLenum __arg2, GLvoid *  * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetBufferPointervARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLvoid *  *,(__arg3),A0),
        struct Library *, (__MesaBase), 754, Mesa    );
}

#define glGetBufferPointervARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetBufferPointervARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGenQueriesARB(GLsizei __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGenQueriesARB,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 755, Mesa    );
}

#define glGenQueriesARB(arg1, arg2) \
    __inline_Mesa_glGenQueriesARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteQueriesARB(GLsizei __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDeleteQueriesARB,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 756, Mesa    );
}

#define glDeleteQueriesARB(arg1, arg2) \
    __inline_Mesa_glDeleteQueriesARB((arg1), (arg2), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsQueryARB(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsQueryARB,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 757, Mesa    );
}

#define glIsQueryARB(arg1) \
    __inline_Mesa_glIsQueryARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glBeginQueryARB(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBeginQueryARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 758, Mesa    );
}

#define glBeginQueryARB(arg1, arg2) \
    __inline_Mesa_glBeginQueryARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glEndQueryARB(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glEndQueryARB,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 759, Mesa    );
}

#define glEndQueryARB(arg1) \
    __inline_Mesa_glEndQueryARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glGetQueryivARB(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetQueryivARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 760, Mesa    );
}

#define glGetQueryivARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetQueryivARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetQueryObjectivARB(GLuint __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetQueryObjectivARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 761, Mesa    );
}

#define glGetQueryObjectivARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetQueryObjectivARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetQueryObjectuivARB(GLuint __arg1, GLenum __arg2, GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetQueryObjectuivARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 762, Mesa    );
}

#define glGetQueryObjectuivARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetQueryObjectuivARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteObjectARB(GLhandleARB __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glDeleteObjectARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        struct Library *, (__MesaBase), 763, Mesa    );
}

#define glDeleteObjectARB(arg1) \
    __inline_Mesa_glDeleteObjectARB((arg1), (APTR)MesaBase)

static inline GLhandleARB __inline_Mesa_glGetHandleARB(GLenum __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLhandleARB, glGetHandleARB,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 764, Mesa    );
}

#define glGetHandleARB(arg1) \
    __inline_Mesa_glGetHandleARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDetachObjectARB(GLhandleARB __arg1, GLhandleARB __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDetachObjectARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        AROS_LCA(GLhandleARB,(__arg2),D1),
        struct Library *, (__MesaBase), 765, Mesa    );
}

#define glDetachObjectARB(arg1, arg2) \
    __inline_Mesa_glDetachObjectARB((arg1), (arg2), (APTR)MesaBase)

static inline GLhandleARB __inline_Mesa_glCreateShaderObjectARB(GLenum __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLhandleARB, glCreateShaderObjectARB,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 766, Mesa    );
}

#define glCreateShaderObjectARB(arg1) \
    __inline_Mesa_glCreateShaderObjectARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glShaderSourceARB(GLhandleARB __arg1, GLsizei __arg2, const GLcharARB *  * __arg3, const GLint * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glShaderSourceARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLcharARB *  *,(__arg3),A0),
        AROS_LCA(const GLint *,(__arg4),A1),
        struct Library *, (__MesaBase), 767, Mesa    );
}

#define glShaderSourceARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glShaderSourceARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glCompileShaderARB(GLhandleARB __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glCompileShaderARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        struct Library *, (__MesaBase), 768, Mesa    );
}

#define glCompileShaderARB(arg1) \
    __inline_Mesa_glCompileShaderARB((arg1), (APTR)MesaBase)

static inline GLhandleARB __inline_Mesa_glCreateProgramObjectARB(APTR __MesaBase)
{
    return AROS_LC0(GLhandleARB, glCreateProgramObjectARB,
        struct Library *, (__MesaBase), 769, Mesa    );
}

#define glCreateProgramObjectARB() \
    __inline_Mesa_glCreateProgramObjectARB((APTR)MesaBase)

static inline void __inline_Mesa_glAttachObjectARB(GLhandleARB __arg1, GLhandleARB __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glAttachObjectARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        AROS_LCA(GLhandleARB,(__arg2),D1),
        struct Library *, (__MesaBase), 770, Mesa    );
}

#define glAttachObjectARB(arg1, arg2) \
    __inline_Mesa_glAttachObjectARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glLinkProgramARB(GLhandleARB __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glLinkProgramARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        struct Library *, (__MesaBase), 771, Mesa    );
}

#define glLinkProgramARB(arg1) \
    __inline_Mesa_glLinkProgramARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glUseProgramObjectARB(GLhandleARB __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glUseProgramObjectARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        struct Library *, (__MesaBase), 772, Mesa    );
}

#define glUseProgramObjectARB(arg1) \
    __inline_Mesa_glUseProgramObjectARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glValidateProgramARB(GLhandleARB __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glValidateProgramARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        struct Library *, (__MesaBase), 773, Mesa    );
}

#define glValidateProgramARB(arg1) \
    __inline_Mesa_glValidateProgramARB((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform1fARB(GLint __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glUniform1fARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 774, Mesa    );
}

#define glUniform1fARB(arg1, arg2) \
    __inline_Mesa_glUniform1fARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform2fARB(GLint __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform2fARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 775, Mesa    );
}

#define glUniform2fARB(arg1, arg2, arg3) \
    __inline_Mesa_glUniform2fARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform3fARB(GLint __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniform3fARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        struct Library *, (__MesaBase), 776, Mesa    );
}

#define glUniform3fARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniform3fARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform4fARB(GLint __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, GLfloat __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glUniform4fARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        AROS_LCA(GLfloat,(__arg5),D4),
        struct Library *, (__MesaBase), 777, Mesa    );
}

#define glUniform4fARB(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glUniform4fARB((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform1iARB(GLint __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glUniform1iARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 778, Mesa    );
}

#define glUniform1iARB(arg1, arg2) \
    __inline_Mesa_glUniform1iARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform2iARB(GLint __arg1, GLint __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform2iARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 779, Mesa    );
}

#define glUniform2iARB(arg1, arg2, arg3) \
    __inline_Mesa_glUniform2iARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform3iARB(GLint __arg1, GLint __arg2, GLint __arg3, GLint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniform3iARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        struct Library *, (__MesaBase), 780, Mesa    );
}

#define glUniform3iARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniform3iARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform4iARB(GLint __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glUniform4iARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        struct Library *, (__MesaBase), 781, Mesa    );
}

#define glUniform4iARB(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glUniform4iARB((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform1fvARB(GLint __arg1, GLsizei __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform1fvARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 782, Mesa    );
}

#define glUniform1fvARB(arg1, arg2, arg3) \
    __inline_Mesa_glUniform1fvARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform2fvARB(GLint __arg1, GLsizei __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform2fvARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 783, Mesa    );
}

#define glUniform2fvARB(arg1, arg2, arg3) \
    __inline_Mesa_glUniform2fvARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform3fvARB(GLint __arg1, GLsizei __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform3fvARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 784, Mesa    );
}

#define glUniform3fvARB(arg1, arg2, arg3) \
    __inline_Mesa_glUniform3fvARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform4fvARB(GLint __arg1, GLsizei __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform4fvARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 785, Mesa    );
}

#define glUniform4fvARB(arg1, arg2, arg3) \
    __inline_Mesa_glUniform4fvARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform1ivARB(GLint __arg1, GLsizei __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform1ivARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 786, Mesa    );
}

#define glUniform1ivARB(arg1, arg2, arg3) \
    __inline_Mesa_glUniform1ivARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform2ivARB(GLint __arg1, GLsizei __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform2ivARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 787, Mesa    );
}

#define glUniform2ivARB(arg1, arg2, arg3) \
    __inline_Mesa_glUniform2ivARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform3ivARB(GLint __arg1, GLsizei __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform3ivARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 788, Mesa    );
}

#define glUniform3ivARB(arg1, arg2, arg3) \
    __inline_Mesa_glUniform3ivARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform4ivARB(GLint __arg1, GLsizei __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform4ivARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 789, Mesa    );
}

#define glUniform4ivARB(arg1, arg2, arg3) \
    __inline_Mesa_glUniform4ivARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniformMatrix2fvARB(GLint __arg1, GLsizei __arg2, GLboolean __arg3, const GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniformMatrix2fvARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLboolean,(__arg3),D2),
        AROS_LCA(const GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 790, Mesa    );
}

#define glUniformMatrix2fvARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniformMatrix2fvARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glUniformMatrix3fvARB(GLint __arg1, GLsizei __arg2, GLboolean __arg3, const GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniformMatrix3fvARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLboolean,(__arg3),D2),
        AROS_LCA(const GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 791, Mesa    );
}

#define glUniformMatrix3fvARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniformMatrix3fvARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glUniformMatrix4fvARB(GLint __arg1, GLsizei __arg2, GLboolean __arg3, const GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniformMatrix4fvARB,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLboolean,(__arg3),D2),
        AROS_LCA(const GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 792, Mesa    );
}

#define glUniformMatrix4fvARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniformMatrix4fvARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetObjectParameterfvARB(GLhandleARB __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetObjectParameterfvARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 793, Mesa    );
}

#define glGetObjectParameterfvARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetObjectParameterfvARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetObjectParameterivARB(GLhandleARB __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetObjectParameterivARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 794, Mesa    );
}

#define glGetObjectParameterivARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetObjectParameterivARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetInfoLogARB(GLhandleARB __arg1, GLsizei __arg2, GLsizei * __arg3, GLcharARB * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetInfoLogARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLsizei *,(__arg3),A0),
        AROS_LCA(GLcharARB *,(__arg4),A1),
        struct Library *, (__MesaBase), 795, Mesa    );
}

#define glGetInfoLogARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetInfoLogARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetAttachedObjectsARB(GLhandleARB __arg1, GLsizei __arg2, GLsizei * __arg3, GLhandleARB * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetAttachedObjectsARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLsizei *,(__arg3),A0),
        AROS_LCA(GLhandleARB *,(__arg4),A1),
        struct Library *, (__MesaBase), 796, Mesa    );
}

#define glGetAttachedObjectsARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetAttachedObjectsARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline GLint __inline_Mesa_glGetUniformLocationARB(GLhandleARB __arg1, const GLcharARB * __arg2, APTR __MesaBase)
{
    return AROS_LC2(GLint, glGetUniformLocationARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        AROS_LCA(const GLcharARB *,(__arg2),A0),
        struct Library *, (__MesaBase), 797, Mesa    );
}

#define glGetUniformLocationARB(arg1, arg2) \
    __inline_Mesa_glGetUniformLocationARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetActiveUniformARB(GLhandleARB __arg1, GLuint __arg2, GLsizei __arg3, GLsizei * __arg4, GLint * __arg5, GLenum * __arg6, GLcharARB * __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glGetActiveUniformARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei *,(__arg4),A0),
        AROS_LCA(GLint *,(__arg5),A1),
        AROS_LCA(GLenum *,(__arg6),A2),
        AROS_LCA(GLcharARB *,(__arg7),A3),
        struct Library *, (__MesaBase), 798, Mesa    );
}

#define glGetActiveUniformARB(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glGetActiveUniformARB((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glGetUniformfvARB(GLhandleARB __arg1, GLint __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetUniformfvARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 799, Mesa    );
}

#define glGetUniformfvARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetUniformfvARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetUniformivARB(GLhandleARB __arg1, GLint __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetUniformivARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 800, Mesa    );
}

#define glGetUniformivARB(arg1, arg2, arg3) \
    __inline_Mesa_glGetUniformivARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetShaderSourceARB(GLhandleARB __arg1, GLsizei __arg2, GLsizei * __arg3, GLcharARB * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetShaderSourceARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLsizei *,(__arg3),A0),
        AROS_LCA(GLcharARB *,(__arg4),A1),
        struct Library *, (__MesaBase), 801, Mesa    );
}

#define glGetShaderSourceARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetShaderSourceARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glBindAttribLocationARB(GLhandleARB __arg1, GLuint __arg2, const GLcharARB * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glBindAttribLocationARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(const GLcharARB *,(__arg3),A0),
        struct Library *, (__MesaBase), 802, Mesa    );
}

#define glBindAttribLocationARB(arg1, arg2, arg3) \
    __inline_Mesa_glBindAttribLocationARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetActiveAttribARB(GLhandleARB __arg1, GLuint __arg2, GLsizei __arg3, GLsizei * __arg4, GLint * __arg5, GLenum * __arg6, GLcharARB * __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glGetActiveAttribARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei *,(__arg4),A0),
        AROS_LCA(GLint *,(__arg5),A1),
        AROS_LCA(GLenum *,(__arg6),A2),
        AROS_LCA(GLcharARB *,(__arg7),A3),
        struct Library *, (__MesaBase), 803, Mesa    );
}

#define glGetActiveAttribARB(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glGetActiveAttribARB((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline GLint __inline_Mesa_glGetAttribLocationARB(GLhandleARB __arg1, const GLcharARB * __arg2, APTR __MesaBase)
{
    return AROS_LC2(GLint, glGetAttribLocationARB,
        AROS_LCA(GLhandleARB,(__arg1),D0),
        AROS_LCA(const GLcharARB *,(__arg2),A0),
        struct Library *, (__MesaBase), 804, Mesa    );
}

#define glGetAttribLocationARB(arg1, arg2) \
    __inline_Mesa_glGetAttribLocationARB((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDrawBuffersARB(GLsizei __arg1, const GLenum * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDrawBuffersARB,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLenum *,(__arg2),A0),
        struct Library *, (__MesaBase), 805, Mesa    );
}

#define glDrawBuffersARB(arg1, arg2) \
    __inline_Mesa_glDrawBuffersARB((arg1), (arg2), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsRenderbuffer(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsRenderbuffer,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 806, Mesa    );
}

#define glIsRenderbuffer(arg1) \
    __inline_Mesa_glIsRenderbuffer((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glBindRenderbuffer(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBindRenderbuffer,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 807, Mesa    );
}

#define glBindRenderbuffer(arg1, arg2) \
    __inline_Mesa_glBindRenderbuffer((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteRenderbuffers(GLsizei __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDeleteRenderbuffers,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 808, Mesa    );
}

#define glDeleteRenderbuffers(arg1, arg2) \
    __inline_Mesa_glDeleteRenderbuffers((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGenRenderbuffers(GLsizei __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGenRenderbuffers,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 809, Mesa    );
}

#define glGenRenderbuffers(arg1, arg2) \
    __inline_Mesa_glGenRenderbuffers((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glRenderbufferStorage(GLenum __arg1, GLenum __arg2, GLsizei __arg3, GLsizei __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glRenderbufferStorage,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        struct Library *, (__MesaBase), 810, Mesa    );
}

#define glRenderbufferStorage(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glRenderbufferStorage((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetRenderbufferParameteriv(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetRenderbufferParameteriv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 811, Mesa    );
}

#define glGetRenderbufferParameteriv(arg1, arg2, arg3) \
    __inline_Mesa_glGetRenderbufferParameteriv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsFramebuffer(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsFramebuffer,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 812, Mesa    );
}

#define glIsFramebuffer(arg1) \
    __inline_Mesa_glIsFramebuffer((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glBindFramebuffer(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBindFramebuffer,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 813, Mesa    );
}

#define glBindFramebuffer(arg1, arg2) \
    __inline_Mesa_glBindFramebuffer((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteFramebuffers(GLsizei __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDeleteFramebuffers,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 814, Mesa    );
}

#define glDeleteFramebuffers(arg1, arg2) \
    __inline_Mesa_glDeleteFramebuffers((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGenFramebuffers(GLsizei __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGenFramebuffers,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 815, Mesa    );
}

#define glGenFramebuffers(arg1, arg2) \
    __inline_Mesa_glGenFramebuffers((arg1), (arg2), (APTR)MesaBase)

static inline GLenum __inline_Mesa_glCheckFramebufferStatus(GLenum __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLenum, glCheckFramebufferStatus,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 816, Mesa    );
}

#define glCheckFramebufferStatus(arg1) \
    __inline_Mesa_glCheckFramebufferStatus((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glFramebufferTexture1D(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLuint __arg4, GLint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glFramebufferTexture1D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        struct Library *, (__MesaBase), 817, Mesa    );
}

#define glFramebufferTexture1D(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glFramebufferTexture1D((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glFramebufferTexture2D(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLuint __arg4, GLint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glFramebufferTexture2D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        struct Library *, (__MesaBase), 818, Mesa    );
}

#define glFramebufferTexture2D(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glFramebufferTexture2D((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glFramebufferTexture3D(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLuint __arg4, GLint __arg5, GLint __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glFramebufferTexture3D,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLint,(__arg6),D5),
        struct Library *, (__MesaBase), 819, Mesa    );
}

#define glFramebufferTexture3D(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glFramebufferTexture3D((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glFramebufferRenderbuffer(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLuint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glFramebufferRenderbuffer,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        struct Library *, (__MesaBase), 820, Mesa    );
}

#define glFramebufferRenderbuffer(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glFramebufferRenderbuffer((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetFramebufferAttachmentParameteriv(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLint * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetFramebufferAttachmentParameteriv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLint *,(__arg4),A0),
        struct Library *, (__MesaBase), 821, Mesa    );
}

#define glGetFramebufferAttachmentParameteriv(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetFramebufferAttachmentParameteriv((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGenerateMipmap(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glGenerateMipmap,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 822, Mesa    );
}

#define glGenerateMipmap(arg1) \
    __inline_Mesa_glGenerateMipmap((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glBlitFramebuffer(GLint __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, GLint __arg6, GLint __arg7, GLint __arg8, GLbitfield __arg9, GLenum __arg10, APTR __MesaBase)
{
    AROS_LC10NR(void, glBlitFramebuffer,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLint,(__arg6),D5),
        AROS_LCA(GLint,(__arg7),D6),
        AROS_LCA(GLint,(__arg8),D7),
        AROS_LCA(GLbitfield,(__arg9),A0),
        AROS_LCA(GLenum,(__arg10),A1),
        struct Library *, (__MesaBase), 823, Mesa    );
}

#define glBlitFramebuffer(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) \
    __inline_Mesa_glBlitFramebuffer((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (APTR)MesaBase)

static inline void __inline_Mesa_glRenderbufferStorageMultisample(GLenum __arg1, GLsizei __arg2, GLenum __arg3, GLsizei __arg4, GLsizei __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glRenderbufferStorageMultisample,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        struct Library *, (__MesaBase), 824, Mesa    );
}

#define glRenderbufferStorageMultisample(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glRenderbufferStorageMultisample((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glFramebufferTextureLayer(GLenum __arg1, GLenum __arg2, GLuint __arg3, GLint __arg4, GLint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glFramebufferTextureLayer,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        struct Library *, (__MesaBase), 825, Mesa    );
}

#define glFramebufferTextureLayer(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glFramebufferTextureLayer((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glBlendColorEXT(GLclampf __arg1, GLclampf __arg2, GLclampf __arg3, GLclampf __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glBlendColorEXT,
        AROS_LCA(GLclampf,(__arg1),D0),
        AROS_LCA(GLclampf,(__arg2),D1),
        AROS_LCA(GLclampf,(__arg3),D2),
        AROS_LCA(GLclampf,(__arg4),D3),
        struct Library *, (__MesaBase), 826, Mesa    );
}

#define glBlendColorEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glBlendColorEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glPolygonOffsetEXT(GLfloat __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPolygonOffsetEXT,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 827, Mesa    );
}

#define glPolygonOffsetEXT(arg1, arg2) \
    __inline_Mesa_glPolygonOffsetEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glTexImage3DEXT(GLenum __arg1, GLint __arg2, GLenum __arg3, GLsizei __arg4, GLsizei __arg5, GLsizei __arg6, GLint __arg7, GLenum __arg8, GLenum __arg9, const GLvoid * __arg10, APTR __MesaBase)
{
    AROS_LC10NR(void, glTexImage3DEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(GLint,(__arg7),D6),
        AROS_LCA(GLenum,(__arg8),D7),
        AROS_LCA(GLenum,(__arg9),A0),
        AROS_LCA(const GLvoid *,(__arg10),A1),
        struct Library *, (__MesaBase), 828, Mesa    );
}

#define glTexImage3DEXT(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) \
    __inline_Mesa_glTexImage3DEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (APTR)MesaBase)

static inline void __inline_Mesa_glTexSubImage3DEXT(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, GLsizei __arg6, GLsizei __arg7, GLsizei __arg8, GLenum __arg9, GLenum __arg10, const GLvoid * __arg11, APTR __MesaBase)
{
    AROS_LC11NR(void, glTexSubImage3DEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(GLsizei,(__arg7),D6),
        AROS_LCA(GLsizei,(__arg8),D7),
        AROS_LCA(GLenum,(__arg9),A0),
        AROS_LCA(GLenum,(__arg10),A1),
        AROS_LCA(const GLvoid *,(__arg11),A2),
        struct Library *, (__MesaBase), 829, Mesa    );
}

#define glTexSubImage3DEXT(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) \
    __inline_Mesa_glTexSubImage3DEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (arg11), (APTR)MesaBase)

static inline void __inline_Mesa_glTexSubImage1DEXT(GLenum __arg1, GLint __arg2, GLint __arg3, GLsizei __arg4, GLenum __arg5, GLenum __arg6, const GLvoid * __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glTexSubImage1DEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(GLenum,(__arg6),D5),
        AROS_LCA(const GLvoid *,(__arg7),A0),
        struct Library *, (__MesaBase), 830, Mesa    );
}

#define glTexSubImage1DEXT(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glTexSubImage1DEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glTexSubImage2DEXT(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLsizei __arg5, GLsizei __arg6, GLenum __arg7, GLenum __arg8, const GLvoid * __arg9, APTR __MesaBase)
{
    AROS_LC9NR(void, glTexSubImage2DEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(GLenum,(__arg7),D6),
        AROS_LCA(GLenum,(__arg8),D7),
        AROS_LCA(const GLvoid *,(__arg9),A0),
        struct Library *, (__MesaBase), 831, Mesa    );
}

#define glTexSubImage2DEXT(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Mesa_glTexSubImage2DEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyTexImage1DEXT(GLenum __arg1, GLint __arg2, GLenum __arg3, GLint __arg4, GLint __arg5, GLsizei __arg6, GLint __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glCopyTexImage1DEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(GLint,(__arg7),D6),
        struct Library *, (__MesaBase), 832, Mesa    );
}

#define glCopyTexImage1DEXT(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glCopyTexImage1DEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyTexImage2DEXT(GLenum __arg1, GLint __arg2, GLenum __arg3, GLint __arg4, GLint __arg5, GLsizei __arg6, GLsizei __arg7, GLint __arg8, APTR __MesaBase)
{
    AROS_LC8NR(void, glCopyTexImage2DEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        AROS_LCA(GLsizei,(__arg7),D6),
        AROS_LCA(GLint,(__arg8),D7),
        struct Library *, (__MesaBase), 833, Mesa    );
}

#define glCopyTexImage2DEXT(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
    __inline_Mesa_glCopyTexImage2DEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyTexSubImage1DEXT(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, GLsizei __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glCopyTexSubImage1DEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        struct Library *, (__MesaBase), 834, Mesa    );
}

#define glCopyTexSubImage1DEXT(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glCopyTexSubImage1DEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyTexSubImage2DEXT(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, GLint __arg6, GLsizei __arg7, GLsizei __arg8, APTR __MesaBase)
{
    AROS_LC8NR(void, glCopyTexSubImage2DEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLint,(__arg6),D5),
        AROS_LCA(GLsizei,(__arg7),D6),
        AROS_LCA(GLsizei,(__arg8),D7),
        struct Library *, (__MesaBase), 835, Mesa    );
}

#define glCopyTexSubImage2DEXT(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
    __inline_Mesa_glCopyTexSubImage2DEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyTexSubImage3DEXT(GLenum __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, GLint __arg6, GLint __arg7, GLsizei __arg8, GLsizei __arg9, APTR __MesaBase)
{
    AROS_LC9NR(void, glCopyTexSubImage3DEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLint,(__arg6),D5),
        AROS_LCA(GLint,(__arg7),D6),
        AROS_LCA(GLsizei,(__arg8),D7),
        AROS_LCA(GLsizei,(__arg9),A0),
        struct Library *, (__MesaBase), 836, Mesa    );
}

#define glCopyTexSubImage3DEXT(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Mesa_glCopyTexSubImage3DEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glAreTexturesResidentEXT(GLsizei __arg1, const GLuint * __arg2, GLboolean * __arg3, APTR __MesaBase)
{
    return AROS_LC3(GLboolean, glAreTexturesResidentEXT,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        AROS_LCA(GLboolean *,(__arg3),A1),
        struct Library *, (__MesaBase), 837, Mesa    );
}

#define glAreTexturesResidentEXT(arg1, arg2, arg3) \
    __inline_Mesa_glAreTexturesResidentEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glBindTextureEXT(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBindTextureEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 838, Mesa    );
}

#define glBindTextureEXT(arg1, arg2) \
    __inline_Mesa_glBindTextureEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteTexturesEXT(GLsizei __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDeleteTexturesEXT,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 839, Mesa    );
}

#define glDeleteTexturesEXT(arg1, arg2) \
    __inline_Mesa_glDeleteTexturesEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGenTexturesEXT(GLsizei __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGenTexturesEXT,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 840, Mesa    );
}

#define glGenTexturesEXT(arg1, arg2) \
    __inline_Mesa_glGenTexturesEXT((arg1), (arg2), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsTextureEXT(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsTextureEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 841, Mesa    );
}

#define glIsTextureEXT(arg1) \
    __inline_Mesa_glIsTextureEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glPrioritizeTexturesEXT(GLsizei __arg1, const GLuint * __arg2, const GLclampf * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glPrioritizeTexturesEXT,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        AROS_LCA(const GLclampf *,(__arg3),A1),
        struct Library *, (__MesaBase), 842, Mesa    );
}

#define glPrioritizeTexturesEXT(arg1, arg2, arg3) \
    __inline_Mesa_glPrioritizeTexturesEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glArrayElementEXT(GLint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glArrayElementEXT,
        AROS_LCA(GLint,(__arg1),D0),
        struct Library *, (__MesaBase), 843, Mesa    );
}

#define glArrayElementEXT(arg1) \
    __inline_Mesa_glArrayElementEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glColorPointerEXT(GLint __arg1, GLenum __arg2, GLsizei __arg3, GLsizei __arg4, const GLvoid * __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glColorPointerEXT,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(const GLvoid *,(__arg5),A0),
        struct Library *, (__MesaBase), 844, Mesa    );
}

#define glColorPointerEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glColorPointerEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glDrawArraysEXT(GLenum __arg1, GLint __arg2, GLsizei __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glDrawArraysEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        struct Library *, (__MesaBase), 845, Mesa    );
}

#define glDrawArraysEXT(arg1, arg2, arg3) \
    __inline_Mesa_glDrawArraysEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glEdgeFlagPointerEXT(GLsizei __arg1, GLsizei __arg2, const GLboolean * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glEdgeFlagPointerEXT,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLboolean *,(__arg3),A0),
        struct Library *, (__MesaBase), 846, Mesa    );
}

#define glEdgeFlagPointerEXT(arg1, arg2, arg3) \
    __inline_Mesa_glEdgeFlagPointerEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetPointervEXT(GLenum __arg1, GLvoid *  * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGetPointervEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLvoid *  *,(__arg2),A0),
        struct Library *, (__MesaBase), 847, Mesa    );
}

#define glGetPointervEXT(arg1, arg2) \
    __inline_Mesa_glGetPointervEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glIndexPointerEXT(GLenum __arg1, GLsizei __arg2, GLsizei __arg3, const GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glIndexPointerEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(const GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 848, Mesa    );
}

#define glIndexPointerEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glIndexPointerEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glNormalPointerEXT(GLenum __arg1, GLsizei __arg2, GLsizei __arg3, const GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glNormalPointerEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(const GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 849, Mesa    );
}

#define glNormalPointerEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glNormalPointerEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glTexCoordPointerEXT(GLint __arg1, GLenum __arg2, GLsizei __arg3, GLsizei __arg4, const GLvoid * __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glTexCoordPointerEXT,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(const GLvoid *,(__arg5),A0),
        struct Library *, (__MesaBase), 850, Mesa    );
}

#define glTexCoordPointerEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glTexCoordPointerEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexPointerEXT(GLint __arg1, GLenum __arg2, GLsizei __arg3, GLsizei __arg4, const GLvoid * __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexPointerEXT,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(const GLvoid *,(__arg5),A0),
        struct Library *, (__MesaBase), 851, Mesa    );
}

#define glVertexPointerEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexPointerEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glBlendEquationEXT(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glBlendEquationEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 852, Mesa    );
}

#define glBlendEquationEXT(arg1) \
    __inline_Mesa_glBlendEquationEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glPointParameterfEXT(GLenum __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPointParameterfEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 853, Mesa    );
}

#define glPointParameterfEXT(arg1, arg2) \
    __inline_Mesa_glPointParameterfEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPointParameterfvEXT(GLenum __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPointParameterfvEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 854, Mesa    );
}

#define glPointParameterfvEXT(arg1, arg2) \
    __inline_Mesa_glPointParameterfvEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glColorTableEXT(GLenum __arg1, GLenum __arg2, GLsizei __arg3, GLenum __arg4, GLenum __arg5, const GLvoid * __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glColorTableEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(const GLvoid *,(__arg6),A0),
        struct Library *, (__MesaBase), 855, Mesa    );
}

#define glColorTableEXT(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glColorTableEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glGetColorTableEXT(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetColorTableEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 856, Mesa    );
}

#define glGetColorTableEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetColorTableEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetColorTableParameterivEXT(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetColorTableParameterivEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 857, Mesa    );
}

#define glGetColorTableParameterivEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetColorTableParameterivEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetColorTableParameterfvEXT(GLenum __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetColorTableParameterfvEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 858, Mesa    );
}

#define glGetColorTableParameterfvEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetColorTableParameterfvEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glLockArraysEXT(GLint __arg1, GLsizei __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glLockArraysEXT,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        struct Library *, (__MesaBase), 859, Mesa    );
}

#define glLockArraysEXT(arg1, arg2) \
    __inline_Mesa_glLockArraysEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glUnlockArraysEXT(APTR __MesaBase)
{
    AROS_LC0NR(void, glUnlockArraysEXT,
        struct Library *, (__MesaBase), 860, Mesa    );
}

#define glUnlockArraysEXT() \
    __inline_Mesa_glUnlockArraysEXT((APTR)MesaBase)

static inline void __inline_Mesa_glDrawRangeElementsEXT(GLenum __arg1, GLuint __arg2, GLuint __arg3, GLsizei __arg4, GLenum __arg5, const GLvoid * __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glDrawRangeElementsEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(const GLvoid *,(__arg6),A0),
        struct Library *, (__MesaBase), 861, Mesa    );
}

#define glDrawRangeElementsEXT(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glDrawRangeElementsEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3bEXT(GLbyte __arg1, GLbyte __arg2, GLbyte __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glSecondaryColor3bEXT,
        AROS_LCA(GLbyte,(__arg1),D0),
        AROS_LCA(GLbyte,(__arg2),D1),
        AROS_LCA(GLbyte,(__arg3),D2),
        struct Library *, (__MesaBase), 862, Mesa    );
}

#define glSecondaryColor3bEXT(arg1, arg2, arg3) \
    __inline_Mesa_glSecondaryColor3bEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3bvEXT(const GLbyte * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSecondaryColor3bvEXT,
        AROS_LCA(const GLbyte *,(__arg1),A0),
        struct Library *, (__MesaBase), 863, Mesa    );
}

#define glSecondaryColor3bvEXT(arg1) \
    __inline_Mesa_glSecondaryColor3bvEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3dEXT(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glSecondaryColor3dEXT,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 864, Mesa    );
}

#define glSecondaryColor3dEXT(arg1, arg2, arg3) \
    __inline_Mesa_glSecondaryColor3dEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3dvEXT(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSecondaryColor3dvEXT,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 865, Mesa    );
}

#define glSecondaryColor3dvEXT(arg1) \
    __inline_Mesa_glSecondaryColor3dvEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3fEXT(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glSecondaryColor3fEXT,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 866, Mesa    );
}

#define glSecondaryColor3fEXT(arg1, arg2, arg3) \
    __inline_Mesa_glSecondaryColor3fEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3fvEXT(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSecondaryColor3fvEXT,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 867, Mesa    );
}

#define glSecondaryColor3fvEXT(arg1) \
    __inline_Mesa_glSecondaryColor3fvEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3iEXT(GLint __arg1, GLint __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glSecondaryColor3iEXT,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 868, Mesa    );
}

#define glSecondaryColor3iEXT(arg1, arg2, arg3) \
    __inline_Mesa_glSecondaryColor3iEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3ivEXT(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSecondaryColor3ivEXT,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 869, Mesa    );
}

#define glSecondaryColor3ivEXT(arg1) \
    __inline_Mesa_glSecondaryColor3ivEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3sEXT(GLshort __arg1, GLshort __arg2, GLshort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glSecondaryColor3sEXT,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        struct Library *, (__MesaBase), 870, Mesa    );
}

#define glSecondaryColor3sEXT(arg1, arg2, arg3) \
    __inline_Mesa_glSecondaryColor3sEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3svEXT(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSecondaryColor3svEXT,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 871, Mesa    );
}

#define glSecondaryColor3svEXT(arg1) \
    __inline_Mesa_glSecondaryColor3svEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3ubEXT(GLubyte __arg1, GLubyte __arg2, GLubyte __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glSecondaryColor3ubEXT,
        AROS_LCA(GLubyte,(__arg1),D0),
        AROS_LCA(GLubyte,(__arg2),D1),
        AROS_LCA(GLubyte,(__arg3),D2),
        struct Library *, (__MesaBase), 872, Mesa    );
}

#define glSecondaryColor3ubEXT(arg1, arg2, arg3) \
    __inline_Mesa_glSecondaryColor3ubEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3ubvEXT(const GLubyte * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSecondaryColor3ubvEXT,
        AROS_LCA(const GLubyte *,(__arg1),A0),
        struct Library *, (__MesaBase), 873, Mesa    );
}

#define glSecondaryColor3ubvEXT(arg1) \
    __inline_Mesa_glSecondaryColor3ubvEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3uiEXT(GLuint __arg1, GLuint __arg2, GLuint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glSecondaryColor3uiEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        struct Library *, (__MesaBase), 874, Mesa    );
}

#define glSecondaryColor3uiEXT(arg1, arg2, arg3) \
    __inline_Mesa_glSecondaryColor3uiEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3uivEXT(const GLuint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSecondaryColor3uivEXT,
        AROS_LCA(const GLuint *,(__arg1),A0),
        struct Library *, (__MesaBase), 875, Mesa    );
}

#define glSecondaryColor3uivEXT(arg1) \
    __inline_Mesa_glSecondaryColor3uivEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3usEXT(GLushort __arg1, GLushort __arg2, GLushort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glSecondaryColor3usEXT,
        AROS_LCA(GLushort,(__arg1),D0),
        AROS_LCA(GLushort,(__arg2),D1),
        AROS_LCA(GLushort,(__arg3),D2),
        struct Library *, (__MesaBase), 876, Mesa    );
}

#define glSecondaryColor3usEXT(arg1, arg2, arg3) \
    __inline_Mesa_glSecondaryColor3usEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColor3usvEXT(const GLushort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSecondaryColor3usvEXT,
        AROS_LCA(const GLushort *,(__arg1),A0),
        struct Library *, (__MesaBase), 877, Mesa    );
}

#define glSecondaryColor3usvEXT(arg1) \
    __inline_Mesa_glSecondaryColor3usvEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSecondaryColorPointerEXT(GLint __arg1, GLenum __arg2, GLsizei __arg3, const GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glSecondaryColorPointerEXT,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(const GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 878, Mesa    );
}

#define glSecondaryColorPointerEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glSecondaryColorPointerEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiDrawArraysEXT(GLenum __arg1, const GLint * __arg2, const GLsizei * __arg3, GLsizei __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glMultiDrawArraysEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        AROS_LCA(const GLsizei *,(__arg3),A1),
        AROS_LCA(GLsizei,(__arg4),D1),
        struct Library *, (__MesaBase), 879, Mesa    );
}

#define glMultiDrawArraysEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glMultiDrawArraysEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiDrawElementsEXT(GLenum __arg1, const GLsizei * __arg2, GLenum __arg3, const GLvoid *  * __arg4, GLsizei __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glMultiDrawElementsEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLsizei *,(__arg2),A0),
        AROS_LCA(GLenum,(__arg3),D1),
        AROS_LCA(const GLvoid *  *,(__arg4),A1),
        AROS_LCA(GLsizei,(__arg5),D2),
        struct Library *, (__MesaBase), 880, Mesa    );
}

#define glMultiDrawElementsEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glMultiDrawElementsEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glFogCoordfEXT(GLfloat __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glFogCoordfEXT,
        AROS_LCA(GLfloat,(__arg1),D0),
        struct Library *, (__MesaBase), 881, Mesa    );
}

#define glFogCoordfEXT(arg1) \
    __inline_Mesa_glFogCoordfEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glFogCoordfvEXT(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glFogCoordfvEXT,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 882, Mesa    );
}

#define glFogCoordfvEXT(arg1) \
    __inline_Mesa_glFogCoordfvEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glFogCoorddEXT(GLdouble __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glFogCoorddEXT,
        AROS_LCA(GLdouble,(__arg1),D0),
        struct Library *, (__MesaBase), 883, Mesa    );
}

#define glFogCoorddEXT(arg1) \
    __inline_Mesa_glFogCoorddEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glFogCoorddvEXT(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glFogCoorddvEXT,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 884, Mesa    );
}

#define glFogCoorddvEXT(arg1) \
    __inline_Mesa_glFogCoorddvEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glFogCoordPointerEXT(GLenum __arg1, GLsizei __arg2, const GLvoid * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glFogCoordPointerEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLvoid *,(__arg3),A0),
        struct Library *, (__MesaBase), 885, Mesa    );
}

#define glFogCoordPointerEXT(arg1, arg2, arg3) \
    __inline_Mesa_glFogCoordPointerEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glBlendFuncSeparateEXT(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLenum __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glBlendFuncSeparateEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        struct Library *, (__MesaBase), 886, Mesa    );
}

#define glBlendFuncSeparateEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glBlendFuncSeparateEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glFlushVertexArrayRangeNV(APTR __MesaBase)
{
    AROS_LC0NR(void, glFlushVertexArrayRangeNV,
        struct Library *, (__MesaBase), 887, Mesa    );
}

#define glFlushVertexArrayRangeNV() \
    __inline_Mesa_glFlushVertexArrayRangeNV((APTR)MesaBase)

static inline void __inline_Mesa_glVertexArrayRangeNV(GLsizei __arg1, const GLvoid * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexArrayRangeNV,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLvoid *,(__arg2),A0),
        struct Library *, (__MesaBase), 888, Mesa    );
}

#define glVertexArrayRangeNV(arg1, arg2) \
    __inline_Mesa_glVertexArrayRangeNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glCombinerParameterfvNV(GLenum __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glCombinerParameterfvNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 889, Mesa    );
}

#define glCombinerParameterfvNV(arg1, arg2) \
    __inline_Mesa_glCombinerParameterfvNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glCombinerParameterfNV(GLenum __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glCombinerParameterfNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 890, Mesa    );
}

#define glCombinerParameterfNV(arg1, arg2) \
    __inline_Mesa_glCombinerParameterfNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glCombinerParameterivNV(GLenum __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glCombinerParameterivNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 891, Mesa    );
}

#define glCombinerParameterivNV(arg1, arg2) \
    __inline_Mesa_glCombinerParameterivNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glCombinerParameteriNV(GLenum __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glCombinerParameteriNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 892, Mesa    );
}

#define glCombinerParameteriNV(arg1, arg2) \
    __inline_Mesa_glCombinerParameteriNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glCombinerInputNV(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLenum __arg4, GLenum __arg5, GLenum __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glCombinerInputNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(GLenum,(__arg6),D5),
        struct Library *, (__MesaBase), 893, Mesa    );
}

#define glCombinerInputNV(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glCombinerInputNV((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glCombinerOutputNV(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLenum __arg4, GLenum __arg5, GLenum __arg6, GLenum __arg7, GLboolean __arg8, GLboolean __arg9, GLboolean __arg10, APTR __MesaBase)
{
    AROS_LC10NR(void, glCombinerOutputNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(GLenum,(__arg6),D5),
        AROS_LCA(GLenum,(__arg7),D6),
        AROS_LCA(GLboolean,(__arg8),D7),
        AROS_LCA(GLboolean,(__arg9),A0),
        AROS_LCA(GLboolean,(__arg10),A1),
        struct Library *, (__MesaBase), 894, Mesa    );
}

#define glCombinerOutputNV(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) \
    __inline_Mesa_glCombinerOutputNV((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (APTR)MesaBase)

static inline void __inline_Mesa_glFinalCombinerInputNV(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLenum __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glFinalCombinerInputNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        struct Library *, (__MesaBase), 895, Mesa    );
}

#define glFinalCombinerInputNV(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glFinalCombinerInputNV((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetCombinerInputParameterfvNV(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLenum __arg4, GLfloat * __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glGetCombinerInputParameterfvNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLfloat *,(__arg5),A0),
        struct Library *, (__MesaBase), 896, Mesa    );
}

#define glGetCombinerInputParameterfvNV(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glGetCombinerInputParameterfvNV((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glGetCombinerInputParameterivNV(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLenum __arg4, GLint * __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glGetCombinerInputParameterivNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLint *,(__arg5),A0),
        struct Library *, (__MesaBase), 897, Mesa    );
}

#define glGetCombinerInputParameterivNV(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glGetCombinerInputParameterivNV((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glGetCombinerOutputParameterfvNV(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetCombinerOutputParameterfvNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 898, Mesa    );
}

#define glGetCombinerOutputParameterfvNV(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetCombinerOutputParameterfvNV((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetCombinerOutputParameterivNV(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLint * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetCombinerOutputParameterivNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLint *,(__arg4),A0),
        struct Library *, (__MesaBase), 899, Mesa    );
}

#define glGetCombinerOutputParameterivNV(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetCombinerOutputParameterivNV((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetFinalCombinerInputParameterfvNV(GLenum __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetFinalCombinerInputParameterfvNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 900, Mesa    );
}

#define glGetFinalCombinerInputParameterfvNV(arg1, arg2, arg3) \
    __inline_Mesa_glGetFinalCombinerInputParameterfvNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetFinalCombinerInputParameterivNV(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetFinalCombinerInputParameterivNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 901, Mesa    );
}

#define glGetFinalCombinerInputParameterivNV(arg1, arg2, arg3) \
    __inline_Mesa_glGetFinalCombinerInputParameterivNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glResizeBuffersMESA(APTR __MesaBase)
{
    AROS_LC0NR(void, glResizeBuffersMESA,
        struct Library *, (__MesaBase), 902, Mesa    );
}

#define glResizeBuffersMESA() \
    __inline_Mesa_glResizeBuffersMESA((APTR)MesaBase)

static inline void __inline_Mesa_glWindowPos2dMESA(GLdouble __arg1, GLdouble __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glWindowPos2dMESA,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        struct Library *, (__MesaBase), 903, Mesa    );
}

#define glWindowPos2dMESA(arg1, arg2) \
    __inline_Mesa_glWindowPos2dMESA((arg1), (arg2), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos2dMES(arg1, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos2dMESA((arg1), (GLdouble)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos2dvMESA(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos2dvMESA,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 904, Mesa    );
}

#define glWindowPos2dvMESA(arg1) \
    __inline_Mesa_glWindowPos2dvMESA((arg1), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos2dvMES(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos2dvMESA((const GLdouble *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos2fMESA(GLfloat __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glWindowPos2fMESA,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 905, Mesa    );
}

#define glWindowPos2fMESA(arg1, arg2) \
    __inline_Mesa_glWindowPos2fMESA((arg1), (arg2), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos2fMES(arg1, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos2fMESA((arg1), (GLfloat)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos2fvMESA(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos2fvMESA,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 906, Mesa    );
}

#define glWindowPos2fvMESA(arg1) \
    __inline_Mesa_glWindowPos2fvMESA((arg1), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos2fvMES(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos2fvMESA((const GLfloat *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos2iMESA(GLint __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glWindowPos2iMESA,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 907, Mesa    );
}

#define glWindowPos2iMESA(arg1, arg2) \
    __inline_Mesa_glWindowPos2iMESA((arg1), (arg2), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos2iMES(arg1, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos2iMESA((arg1), (GLint)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos2ivMESA(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos2ivMESA,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 908, Mesa    );
}

#define glWindowPos2ivMESA(arg1) \
    __inline_Mesa_glWindowPos2ivMESA((arg1), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos2ivMES(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos2ivMESA((const GLint *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos2sMESA(GLshort __arg1, GLshort __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glWindowPos2sMESA,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        struct Library *, (__MesaBase), 909, Mesa    );
}

#define glWindowPos2sMESA(arg1, arg2) \
    __inline_Mesa_glWindowPos2sMESA((arg1), (arg2), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos2sMES(arg1, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos2sMESA((arg1), (GLshort)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos2svMESA(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos2svMESA,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 910, Mesa    );
}

#define glWindowPos2svMESA(arg1) \
    __inline_Mesa_glWindowPos2svMESA((arg1), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos2svMES(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos2svMESA((const GLshort *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos3dMESA(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glWindowPos3dMESA,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 911, Mesa    );
}

#define glWindowPos3dMESA(arg1, arg2, arg3) \
    __inline_Mesa_glWindowPos3dMESA((arg1), (arg2), (arg3), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos3dMES(arg1, arg2, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos3dMESA((arg1), (arg2), (GLdouble)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos3dvMESA(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos3dvMESA,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 912, Mesa    );
}

#define glWindowPos3dvMESA(arg1) \
    __inline_Mesa_glWindowPos3dvMESA((arg1), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos3dvMES(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos3dvMESA((const GLdouble *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos3fMESA(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glWindowPos3fMESA,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 913, Mesa    );
}

#define glWindowPos3fMESA(arg1, arg2, arg3) \
    __inline_Mesa_glWindowPos3fMESA((arg1), (arg2), (arg3), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos3fMES(arg1, arg2, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos3fMESA((arg1), (arg2), (GLfloat)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos3fvMESA(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos3fvMESA,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 914, Mesa    );
}

#define glWindowPos3fvMESA(arg1) \
    __inline_Mesa_glWindowPos3fvMESA((arg1), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos3fvMES(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos3fvMESA((const GLfloat *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos3iMESA(GLint __arg1, GLint __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glWindowPos3iMESA,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 915, Mesa    );
}

#define glWindowPos3iMESA(arg1, arg2, arg3) \
    __inline_Mesa_glWindowPos3iMESA((arg1), (arg2), (arg3), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos3iMES(arg1, arg2, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos3iMESA((arg1), (arg2), (GLint)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos3ivMESA(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos3ivMESA,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 916, Mesa    );
}

#define glWindowPos3ivMESA(arg1) \
    __inline_Mesa_glWindowPos3ivMESA((arg1), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos3ivMES(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos3ivMESA((const GLint *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos3sMESA(GLshort __arg1, GLshort __arg2, GLshort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glWindowPos3sMESA,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        struct Library *, (__MesaBase), 917, Mesa    );
}

#define glWindowPos3sMESA(arg1, arg2, arg3) \
    __inline_Mesa_glWindowPos3sMESA((arg1), (arg2), (arg3), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos3sMES(arg1, arg2, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos3sMESA((arg1), (arg2), (GLshort)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos3svMESA(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos3svMESA,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 918, Mesa    );
}

#define glWindowPos3svMESA(arg1) \
    __inline_Mesa_glWindowPos3svMESA((arg1), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos3svMES(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos3svMESA((const GLshort *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos4dMESA(GLdouble __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glWindowPos4dMESA,
        AROS_LCA(GLdouble,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        struct Library *, (__MesaBase), 919, Mesa    );
}

#define glWindowPos4dMESA(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glWindowPos4dMESA((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos4dMES(arg1, arg2, arg3, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos4dMESA((arg1), (arg2), (arg3), (GLdouble)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos4dvMESA(const GLdouble * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos4dvMESA,
        AROS_LCA(const GLdouble *,(__arg1),A0),
        struct Library *, (__MesaBase), 920, Mesa    );
}

#define glWindowPos4dvMESA(arg1) \
    __inline_Mesa_glWindowPos4dvMESA((arg1), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos4dvMES(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos4dvMESA((const GLdouble *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos4fMESA(GLfloat __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glWindowPos4fMESA,
        AROS_LCA(GLfloat,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        struct Library *, (__MesaBase), 921, Mesa    );
}

#define glWindowPos4fMESA(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glWindowPos4fMESA((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos4fMES(arg1, arg2, arg3, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos4fMESA((arg1), (arg2), (arg3), (GLfloat)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos4fvMESA(const GLfloat * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos4fvMESA,
        AROS_LCA(const GLfloat *,(__arg1),A0),
        struct Library *, (__MesaBase), 922, Mesa    );
}

#define glWindowPos4fvMESA(arg1) \
    __inline_Mesa_glWindowPos4fvMESA((arg1), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos4fvMES(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos4fvMESA((const GLfloat *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos4iMESA(GLint __arg1, GLint __arg2, GLint __arg3, GLint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glWindowPos4iMESA,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        struct Library *, (__MesaBase), 923, Mesa    );
}

#define glWindowPos4iMESA(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glWindowPos4iMESA((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos4iMES(arg1, arg2, arg3, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos4iMESA((arg1), (arg2), (arg3), (GLint)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos4ivMESA(const GLint * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos4ivMESA,
        AROS_LCA(const GLint *,(__arg1),A0),
        struct Library *, (__MesaBase), 924, Mesa    );
}

#define glWindowPos4ivMESA(arg1) \
    __inline_Mesa_glWindowPos4ivMESA((arg1), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos4ivMES(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos4ivMESA((const GLint *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos4sMESA(GLshort __arg1, GLshort __arg2, GLshort __arg3, GLshort __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glWindowPos4sMESA,
        AROS_LCA(GLshort,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        AROS_LCA(GLshort,(__arg4),D3),
        struct Library *, (__MesaBase), 925, Mesa    );
}

#define glWindowPos4sMESA(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glWindowPos4sMESA((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos4sMES(arg1, arg2, arg3, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos4sMESA((arg1), (arg2), (arg3), (GLshort)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline void __inline_Mesa_glWindowPos4svMESA(const GLshort * __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glWindowPos4svMESA,
        AROS_LCA(const GLshort *,(__arg1),A0),
        struct Library *, (__MesaBase), 926, Mesa    );
}

#define glWindowPos4svMESA(arg1) \
    __inline_Mesa_glWindowPos4svMESA((arg1), (APTR)MesaBase)

#if !defined(NO_INLINE_STDARG) && !defined(MESA_NO_INLINE_STDARG)
#define glWindowPos4svMES(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    glWindowPos4svMESA((const GLshort *)__args); \
})
#endif /* !NO_INLINE_STDARG */

static inline GLboolean __inline_Mesa_glAreProgramsResidentNV(GLsizei __arg1, const GLuint * __arg2, GLboolean * __arg3, APTR __MesaBase)
{
    return AROS_LC3(GLboolean, glAreProgramsResidentNV,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        AROS_LCA(GLboolean *,(__arg3),A1),
        struct Library *, (__MesaBase), 927, Mesa    );
}

#define glAreProgramsResidentNV(arg1, arg2, arg3) \
    __inline_Mesa_glAreProgramsResidentNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glBindProgramNV(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBindProgramNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 928, Mesa    );
}

#define glBindProgramNV(arg1, arg2) \
    __inline_Mesa_glBindProgramNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteProgramsNV(GLsizei __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDeleteProgramsNV,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 929, Mesa    );
}

#define glDeleteProgramsNV(arg1, arg2) \
    __inline_Mesa_glDeleteProgramsNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glExecuteProgramNV(GLenum __arg1, GLuint __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glExecuteProgramNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 930, Mesa    );
}

#define glExecuteProgramNV(arg1, arg2, arg3) \
    __inline_Mesa_glExecuteProgramNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGenProgramsNV(GLsizei __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGenProgramsNV,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 931, Mesa    );
}

#define glGenProgramsNV(arg1, arg2) \
    __inline_Mesa_glGenProgramsNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetProgramParameterdvNV(GLenum __arg1, GLuint __arg2, GLenum __arg3, GLdouble * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetProgramParameterdvNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLdouble *,(__arg4),A0),
        struct Library *, (__MesaBase), 932, Mesa    );
}

#define glGetProgramParameterdvNV(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetProgramParameterdvNV((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetProgramParameterfvNV(GLenum __arg1, GLuint __arg2, GLenum __arg3, GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetProgramParameterfvNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 933, Mesa    );
}

#define glGetProgramParameterfvNV(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetProgramParameterfvNV((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetProgramivNV(GLuint __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetProgramivNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 934, Mesa    );
}

#define glGetProgramivNV(arg1, arg2, arg3) \
    __inline_Mesa_glGetProgramivNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetProgramStringNV(GLuint __arg1, GLenum __arg2, GLubyte * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetProgramStringNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLubyte *,(__arg3),A0),
        struct Library *, (__MesaBase), 935, Mesa    );
}

#define glGetProgramStringNV(arg1, arg2, arg3) \
    __inline_Mesa_glGetProgramStringNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTrackMatrixivNV(GLenum __arg1, GLuint __arg2, GLenum __arg3, GLint * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetTrackMatrixivNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLint *,(__arg4),A0),
        struct Library *, (__MesaBase), 936, Mesa    );
}

#define glGetTrackMatrixivNV(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetTrackMatrixivNV((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetVertexAttribdvNV(GLuint __arg1, GLenum __arg2, GLdouble * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetVertexAttribdvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLdouble *,(__arg3),A0),
        struct Library *, (__MesaBase), 937, Mesa    );
}

#define glGetVertexAttribdvNV(arg1, arg2, arg3) \
    __inline_Mesa_glGetVertexAttribdvNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetVertexAttribfvNV(GLuint __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetVertexAttribfvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 938, Mesa    );
}

#define glGetVertexAttribfvNV(arg1, arg2, arg3) \
    __inline_Mesa_glGetVertexAttribfvNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetVertexAttribivNV(GLuint __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetVertexAttribivNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 939, Mesa    );
}

#define glGetVertexAttribivNV(arg1, arg2, arg3) \
    __inline_Mesa_glGetVertexAttribivNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetVertexAttribPointervNV(GLuint __arg1, GLenum __arg2, GLvoid *  * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetVertexAttribPointervNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLvoid *  *,(__arg3),A0),
        struct Library *, (__MesaBase), 940, Mesa    );
}

#define glGetVertexAttribPointervNV(arg1, arg2, arg3) \
    __inline_Mesa_glGetVertexAttribPointervNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsProgramNV(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsProgramNV,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 941, Mesa    );
}

#define glIsProgramNV(arg1) \
    __inline_Mesa_glIsProgramNV((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glLoadProgramNV(GLenum __arg1, GLuint __arg2, GLsizei __arg3, const GLubyte * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glLoadProgramNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(const GLubyte *,(__arg4),A0),
        struct Library *, (__MesaBase), 942, Mesa    );
}

#define glLoadProgramNV(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glLoadProgramNV((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramParameter4dNV(GLenum __arg1, GLuint __arg2, GLdouble __arg3, GLdouble __arg4, GLdouble __arg5, GLdouble __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glProgramParameter4dNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        AROS_LCA(GLdouble,(__arg5),D4),
        AROS_LCA(GLdouble,(__arg6),D5),
        struct Library *, (__MesaBase), 943, Mesa    );
}

#define glProgramParameter4dNV(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glProgramParameter4dNV((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramParameter4dvNV(GLenum __arg1, GLuint __arg2, const GLdouble * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glProgramParameter4dvNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(const GLdouble *,(__arg3),A0),
        struct Library *, (__MesaBase), 944, Mesa    );
}

#define glProgramParameter4dvNV(arg1, arg2, arg3) \
    __inline_Mesa_glProgramParameter4dvNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramParameter4fNV(GLenum __arg1, GLuint __arg2, GLfloat __arg3, GLfloat __arg4, GLfloat __arg5, GLfloat __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glProgramParameter4fNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        AROS_LCA(GLfloat,(__arg5),D4),
        AROS_LCA(GLfloat,(__arg6),D5),
        struct Library *, (__MesaBase), 945, Mesa    );
}

#define glProgramParameter4fNV(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glProgramParameter4fNV((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramParameter4fvNV(GLenum __arg1, GLuint __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glProgramParameter4fvNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 946, Mesa    );
}

#define glProgramParameter4fvNV(arg1, arg2, arg3) \
    __inline_Mesa_glProgramParameter4fvNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramParameters4dvNV(GLenum __arg1, GLuint __arg2, GLsizei __arg3, const GLdouble * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glProgramParameters4dvNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(const GLdouble *,(__arg4),A0),
        struct Library *, (__MesaBase), 947, Mesa    );
}

#define glProgramParameters4dvNV(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glProgramParameters4dvNV((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramParameters4fvNV(GLenum __arg1, GLuint __arg2, GLsizei __arg3, const GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glProgramParameters4fvNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(const GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 948, Mesa    );
}

#define glProgramParameters4fvNV(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glProgramParameters4fvNV((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glRequestResidentProgramsNV(GLsizei __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glRequestResidentProgramsNV,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 949, Mesa    );
}

#define glRequestResidentProgramsNV(arg1, arg2) \
    __inline_Mesa_glRequestResidentProgramsNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glTrackMatrixNV(GLenum __arg1, GLuint __arg2, GLenum __arg3, GLenum __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glTrackMatrixNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        struct Library *, (__MesaBase), 950, Mesa    );
}

#define glTrackMatrixNV(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glTrackMatrixNV((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribPointerNV(GLuint __arg1, GLint __arg2, GLenum __arg3, GLsizei __arg4, const GLvoid * __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttribPointerNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(const GLvoid *,(__arg5),A0),
        struct Library *, (__MesaBase), 951, Mesa    );
}

#define glVertexAttribPointerNV(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttribPointerNV((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1dNV(GLuint __arg1, GLdouble __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1dNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        struct Library *, (__MesaBase), 952, Mesa    );
}

#define glVertexAttrib1dNV(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1dNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1dvNV(GLuint __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1dvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 953, Mesa    );
}

#define glVertexAttrib1dvNV(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1dvNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1fNV(GLuint __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1fNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 954, Mesa    );
}

#define glVertexAttrib1fNV(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1fNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1fvNV(GLuint __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1fvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 955, Mesa    );
}

#define glVertexAttrib1fvNV(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1fvNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1sNV(GLuint __arg1, GLshort __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1sNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        struct Library *, (__MesaBase), 956, Mesa    );
}

#define glVertexAttrib1sNV(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1sNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib1svNV(GLuint __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib1svNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 957, Mesa    );
}

#define glVertexAttrib1svNV(arg1, arg2) \
    __inline_Mesa_glVertexAttrib1svNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2dNV(GLuint __arg1, GLdouble __arg2, GLdouble __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttrib2dNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        struct Library *, (__MesaBase), 958, Mesa    );
}

#define glVertexAttrib2dNV(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttrib2dNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2dvNV(GLuint __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib2dvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 959, Mesa    );
}

#define glVertexAttrib2dvNV(arg1, arg2) \
    __inline_Mesa_glVertexAttrib2dvNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2fNV(GLuint __arg1, GLfloat __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttrib2fNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 960, Mesa    );
}

#define glVertexAttrib2fNV(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttrib2fNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2fvNV(GLuint __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib2fvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 961, Mesa    );
}

#define glVertexAttrib2fvNV(arg1, arg2) \
    __inline_Mesa_glVertexAttrib2fvNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2sNV(GLuint __arg1, GLshort __arg2, GLshort __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttrib2sNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        struct Library *, (__MesaBase), 962, Mesa    );
}

#define glVertexAttrib2sNV(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttrib2sNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib2svNV(GLuint __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib2svNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 963, Mesa    );
}

#define glVertexAttrib2svNV(arg1, arg2) \
    __inline_Mesa_glVertexAttrib2svNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3dNV(GLuint __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertexAttrib3dNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        struct Library *, (__MesaBase), 964, Mesa    );
}

#define glVertexAttrib3dNV(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertexAttrib3dNV((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3dvNV(GLuint __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib3dvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 965, Mesa    );
}

#define glVertexAttrib3dvNV(arg1, arg2) \
    __inline_Mesa_glVertexAttrib3dvNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3fNV(GLuint __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertexAttrib3fNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        struct Library *, (__MesaBase), 966, Mesa    );
}

#define glVertexAttrib3fNV(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertexAttrib3fNV((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3fvNV(GLuint __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib3fvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 967, Mesa    );
}

#define glVertexAttrib3fvNV(arg1, arg2) \
    __inline_Mesa_glVertexAttrib3fvNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3sNV(GLuint __arg1, GLshort __arg2, GLshort __arg3, GLshort __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertexAttrib3sNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        AROS_LCA(GLshort,(__arg4),D3),
        struct Library *, (__MesaBase), 968, Mesa    );
}

#define glVertexAttrib3sNV(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertexAttrib3sNV((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib3svNV(GLuint __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib3svNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 969, Mesa    );
}

#define glVertexAttrib3svNV(arg1, arg2) \
    __inline_Mesa_glVertexAttrib3svNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4dNV(GLuint __arg1, GLdouble __arg2, GLdouble __arg3, GLdouble __arg4, GLdouble __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttrib4dNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLdouble,(__arg2),D1),
        AROS_LCA(GLdouble,(__arg3),D2),
        AROS_LCA(GLdouble,(__arg4),D3),
        AROS_LCA(GLdouble,(__arg5),D4),
        struct Library *, (__MesaBase), 970, Mesa    );
}

#define glVertexAttrib4dNV(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttrib4dNV((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4dvNV(GLuint __arg1, const GLdouble * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4dvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLdouble *,(__arg2),A0),
        struct Library *, (__MesaBase), 971, Mesa    );
}

#define glVertexAttrib4dvNV(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4dvNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4fNV(GLuint __arg1, GLfloat __arg2, GLfloat __arg3, GLfloat __arg4, GLfloat __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttrib4fNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLfloat,(__arg4),D3),
        AROS_LCA(GLfloat,(__arg5),D4),
        struct Library *, (__MesaBase), 972, Mesa    );
}

#define glVertexAttrib4fNV(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttrib4fNV((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4fvNV(GLuint __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4fvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 973, Mesa    );
}

#define glVertexAttrib4fvNV(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4fvNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4sNV(GLuint __arg1, GLshort __arg2, GLshort __arg3, GLshort __arg4, GLshort __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttrib4sNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLshort,(__arg2),D1),
        AROS_LCA(GLshort,(__arg3),D2),
        AROS_LCA(GLshort,(__arg4),D3),
        AROS_LCA(GLshort,(__arg5),D4),
        struct Library *, (__MesaBase), 974, Mesa    );
}

#define glVertexAttrib4sNV(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttrib4sNV((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4svNV(GLuint __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4svNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 975, Mesa    );
}

#define glVertexAttrib4svNV(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4svNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4ubNV(GLuint __arg1, GLubyte __arg2, GLubyte __arg3, GLubyte __arg4, GLubyte __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttrib4ubNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLubyte,(__arg2),D1),
        AROS_LCA(GLubyte,(__arg3),D2),
        AROS_LCA(GLubyte,(__arg4),D3),
        AROS_LCA(GLubyte,(__arg5),D4),
        struct Library *, (__MesaBase), 976, Mesa    );
}

#define glVertexAttrib4ubNV(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttrib4ubNV((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttrib4ubvNV(GLuint __arg1, const GLubyte * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttrib4ubvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLubyte *,(__arg2),A0),
        struct Library *, (__MesaBase), 977, Mesa    );
}

#define glVertexAttrib4ubvNV(arg1, arg2) \
    __inline_Mesa_glVertexAttrib4ubvNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribs1dvNV(GLuint __arg1, GLsizei __arg2, const GLdouble * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttribs1dvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLdouble *,(__arg3),A0),
        struct Library *, (__MesaBase), 978, Mesa    );
}

#define glVertexAttribs1dvNV(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttribs1dvNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribs1fvNV(GLuint __arg1, GLsizei __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttribs1fvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 979, Mesa    );
}

#define glVertexAttribs1fvNV(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttribs1fvNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribs1svNV(GLuint __arg1, GLsizei __arg2, const GLshort * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttribs1svNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLshort *,(__arg3),A0),
        struct Library *, (__MesaBase), 980, Mesa    );
}

#define glVertexAttribs1svNV(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttribs1svNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribs2dvNV(GLuint __arg1, GLsizei __arg2, const GLdouble * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttribs2dvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLdouble *,(__arg3),A0),
        struct Library *, (__MesaBase), 981, Mesa    );
}

#define glVertexAttribs2dvNV(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttribs2dvNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribs2fvNV(GLuint __arg1, GLsizei __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttribs2fvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 982, Mesa    );
}

#define glVertexAttribs2fvNV(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttribs2fvNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribs2svNV(GLuint __arg1, GLsizei __arg2, const GLshort * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttribs2svNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLshort *,(__arg3),A0),
        struct Library *, (__MesaBase), 983, Mesa    );
}

#define glVertexAttribs2svNV(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttribs2svNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribs3dvNV(GLuint __arg1, GLsizei __arg2, const GLdouble * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttribs3dvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLdouble *,(__arg3),A0),
        struct Library *, (__MesaBase), 984, Mesa    );
}

#define glVertexAttribs3dvNV(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttribs3dvNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribs3fvNV(GLuint __arg1, GLsizei __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttribs3fvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 985, Mesa    );
}

#define glVertexAttribs3fvNV(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttribs3fvNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribs3svNV(GLuint __arg1, GLsizei __arg2, const GLshort * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttribs3svNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLshort *,(__arg3),A0),
        struct Library *, (__MesaBase), 986, Mesa    );
}

#define glVertexAttribs3svNV(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttribs3svNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribs4dvNV(GLuint __arg1, GLsizei __arg2, const GLdouble * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttribs4dvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLdouble *,(__arg3),A0),
        struct Library *, (__MesaBase), 987, Mesa    );
}

#define glVertexAttribs4dvNV(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttribs4dvNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribs4fvNV(GLuint __arg1, GLsizei __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttribs4fvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 988, Mesa    );
}

#define glVertexAttribs4fvNV(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttribs4fvNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribs4svNV(GLuint __arg1, GLsizei __arg2, const GLshort * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttribs4svNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLshort *,(__arg3),A0),
        struct Library *, (__MesaBase), 989, Mesa    );
}

#define glVertexAttribs4svNV(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttribs4svNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribs4ubvNV(GLuint __arg1, GLsizei __arg2, const GLubyte * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttribs4ubvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLubyte *,(__arg3),A0),
        struct Library *, (__MesaBase), 990, Mesa    );
}

#define glVertexAttribs4ubvNV(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttribs4ubvNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexBumpParameterivATI(GLenum __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glTexBumpParameterivATI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 991, Mesa    );
}

#define glTexBumpParameterivATI(arg1, arg2) \
    __inline_Mesa_glTexBumpParameterivATI((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glTexBumpParameterfvATI(GLenum __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glTexBumpParameterfvATI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 992, Mesa    );
}

#define glTexBumpParameterfvATI(arg1, arg2) \
    __inline_Mesa_glTexBumpParameterfvATI((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTexBumpParameterivATI(GLenum __arg1, GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGetTexBumpParameterivATI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 993, Mesa    );
}

#define glGetTexBumpParameterivATI(arg1, arg2) \
    __inline_Mesa_glGetTexBumpParameterivATI((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTexBumpParameterfvATI(GLenum __arg1, GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGetTexBumpParameterfvATI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 994, Mesa    );
}

#define glGetTexBumpParameterfvATI(arg1, arg2) \
    __inline_Mesa_glGetTexBumpParameterfvATI((arg1), (arg2), (APTR)MesaBase)

static inline GLuint __inline_Mesa_glGenFragmentShadersATI(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLuint, glGenFragmentShadersATI,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 995, Mesa    );
}

#define glGenFragmentShadersATI(arg1) \
    __inline_Mesa_glGenFragmentShadersATI((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glBindFragmentShaderATI(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glBindFragmentShaderATI,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 996, Mesa    );
}

#define glBindFragmentShaderATI(arg1) \
    __inline_Mesa_glBindFragmentShaderATI((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteFragmentShaderATI(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glDeleteFragmentShaderATI,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 997, Mesa    );
}

#define glDeleteFragmentShaderATI(arg1) \
    __inline_Mesa_glDeleteFragmentShaderATI((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glBeginFragmentShaderATI(APTR __MesaBase)
{
    AROS_LC0NR(void, glBeginFragmentShaderATI,
        struct Library *, (__MesaBase), 998, Mesa    );
}

#define glBeginFragmentShaderATI() \
    __inline_Mesa_glBeginFragmentShaderATI((APTR)MesaBase)

static inline void __inline_Mesa_glEndFragmentShaderATI(APTR __MesaBase)
{
    AROS_LC0NR(void, glEndFragmentShaderATI,
        struct Library *, (__MesaBase), 999, Mesa    );
}

#define glEndFragmentShaderATI() \
    __inline_Mesa_glEndFragmentShaderATI((APTR)MesaBase)

static inline void __inline_Mesa_glPassTexCoordATI(GLuint __arg1, GLuint __arg2, GLenum __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glPassTexCoordATI,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        struct Library *, (__MesaBase), 1000, Mesa    );
}

#define glPassTexCoordATI(arg1, arg2, arg3) \
    __inline_Mesa_glPassTexCoordATI((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glSampleMapATI(GLuint __arg1, GLuint __arg2, GLenum __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glSampleMapATI,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        struct Library *, (__MesaBase), 1001, Mesa    );
}

#define glSampleMapATI(arg1, arg2, arg3) \
    __inline_Mesa_glSampleMapATI((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glColorFragmentOp1ATI(GLenum __arg1, GLuint __arg2, GLuint __arg3, GLuint __arg4, GLuint __arg5, GLuint __arg6, GLuint __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glColorFragmentOp1ATI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        AROS_LCA(GLuint,(__arg5),D4),
        AROS_LCA(GLuint,(__arg6),D5),
        AROS_LCA(GLuint,(__arg7),D6),
        struct Library *, (__MesaBase), 1002, Mesa    );
}

#define glColorFragmentOp1ATI(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glColorFragmentOp1ATI((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glColorFragmentOp2ATI(GLenum __arg1, GLuint __arg2, GLuint __arg3, GLuint __arg4, GLuint __arg5, GLuint __arg6, GLuint __arg7, GLuint __arg8, GLuint __arg9, GLuint __arg10, APTR __MesaBase)
{
    AROS_LC10NR(void, glColorFragmentOp2ATI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        AROS_LCA(GLuint,(__arg5),D4),
        AROS_LCA(GLuint,(__arg6),D5),
        AROS_LCA(GLuint,(__arg7),D6),
        AROS_LCA(GLuint,(__arg8),D7),
        AROS_LCA(GLuint,(__arg9),A0),
        AROS_LCA(GLuint,(__arg10),A1),
        struct Library *, (__MesaBase), 1003, Mesa    );
}

#define glColorFragmentOp2ATI(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) \
    __inline_Mesa_glColorFragmentOp2ATI((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (APTR)MesaBase)

static inline void __inline_Mesa_glColorFragmentOp3ATI(GLenum __arg1, GLuint __arg2, GLuint __arg3, GLuint __arg4, GLuint __arg5, GLuint __arg6, GLuint __arg7, GLuint __arg8, GLuint __arg9, GLuint __arg10, GLuint __arg11, GLuint __arg12, GLuint __arg13, APTR __MesaBase)
{
    AROS_LC13NR(void, glColorFragmentOp3ATI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        AROS_LCA(GLuint,(__arg5),D4),
        AROS_LCA(GLuint,(__arg6),D5),
        AROS_LCA(GLuint,(__arg7),D6),
        AROS_LCA(GLuint,(__arg8),D7),
        AROS_LCA(GLuint,(__arg9),A0),
        AROS_LCA(GLuint,(__arg10),A1),
        AROS_LCA(GLuint,(__arg11),A2),
        AROS_LCA(GLuint,(__arg12),A3),
        AROS_LCA(GLuint,(__arg13),A4),
        struct Library *, (__MesaBase), 1004, Mesa    );
}

#define glColorFragmentOp3ATI(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13) \
    __inline_Mesa_glColorFragmentOp3ATI((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (arg11), (arg12), (arg13), (APTR)MesaBase)

static inline void __inline_Mesa_glAlphaFragmentOp1ATI(GLenum __arg1, GLuint __arg2, GLuint __arg3, GLuint __arg4, GLuint __arg5, GLuint __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glAlphaFragmentOp1ATI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        AROS_LCA(GLuint,(__arg5),D4),
        AROS_LCA(GLuint,(__arg6),D5),
        struct Library *, (__MesaBase), 1005, Mesa    );
}

#define glAlphaFragmentOp1ATI(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glAlphaFragmentOp1ATI((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glAlphaFragmentOp2ATI(GLenum __arg1, GLuint __arg2, GLuint __arg3, GLuint __arg4, GLuint __arg5, GLuint __arg6, GLuint __arg7, GLuint __arg8, GLuint __arg9, APTR __MesaBase)
{
    AROS_LC9NR(void, glAlphaFragmentOp2ATI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        AROS_LCA(GLuint,(__arg5),D4),
        AROS_LCA(GLuint,(__arg6),D5),
        AROS_LCA(GLuint,(__arg7),D6),
        AROS_LCA(GLuint,(__arg8),D7),
        AROS_LCA(GLuint,(__arg9),A0),
        struct Library *, (__MesaBase), 1006, Mesa    );
}

#define glAlphaFragmentOp2ATI(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Mesa_glAlphaFragmentOp2ATI((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)MesaBase)

static inline void __inline_Mesa_glAlphaFragmentOp3ATI(GLenum __arg1, GLuint __arg2, GLuint __arg3, GLuint __arg4, GLuint __arg5, GLuint __arg6, GLuint __arg7, GLuint __arg8, GLuint __arg9, GLuint __arg10, GLuint __arg11, GLuint __arg12, APTR __MesaBase)
{
    AROS_LC12NR(void, glAlphaFragmentOp3ATI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        AROS_LCA(GLuint,(__arg5),D4),
        AROS_LCA(GLuint,(__arg6),D5),
        AROS_LCA(GLuint,(__arg7),D6),
        AROS_LCA(GLuint,(__arg8),D7),
        AROS_LCA(GLuint,(__arg9),A0),
        AROS_LCA(GLuint,(__arg10),A1),
        AROS_LCA(GLuint,(__arg11),A2),
        AROS_LCA(GLuint,(__arg12),A3),
        struct Library *, (__MesaBase), 1007, Mesa    );
}

#define glAlphaFragmentOp3ATI(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12) \
    __inline_Mesa_glAlphaFragmentOp3ATI((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (arg11), (arg12), (APTR)MesaBase)

static inline void __inline_Mesa_glSetFragmentShaderConstantATI(GLuint __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glSetFragmentShaderConstantATI,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 1008, Mesa    );
}

#define glSetFragmentShaderConstantATI(arg1, arg2) \
    __inline_Mesa_glSetFragmentShaderConstantATI((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPointParameteriNV(GLenum __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPointParameteriNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 1009, Mesa    );
}

#define glPointParameteriNV(arg1, arg2) \
    __inline_Mesa_glPointParameteriNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPointParameterivNV(GLenum __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPointParameterivNV,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1010, Mesa    );
}

#define glPointParameterivNV(arg1, arg2) \
    __inline_Mesa_glPointParameterivNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDrawBuffersATI(GLsizei __arg1, const GLenum * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDrawBuffersATI,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLenum *,(__arg2),A0),
        struct Library *, (__MesaBase), 1011, Mesa    );
}

#define glDrawBuffersATI(arg1, arg2) \
    __inline_Mesa_glDrawBuffersATI((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramNamedParameter4fNV(GLuint __arg1, GLsizei __arg2, const GLubyte * __arg3, GLfloat __arg4, GLfloat __arg5, GLfloat __arg6, GLfloat __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glProgramNamedParameter4fNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLubyte *,(__arg3),A0),
        AROS_LCA(GLfloat,(__arg4),D2),
        AROS_LCA(GLfloat,(__arg5),D3),
        AROS_LCA(GLfloat,(__arg6),D4),
        AROS_LCA(GLfloat,(__arg7),D5),
        struct Library *, (__MesaBase), 1012, Mesa    );
}

#define glProgramNamedParameter4fNV(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glProgramNamedParameter4fNV((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramNamedParameter4dNV(GLuint __arg1, GLsizei __arg2, const GLubyte * __arg3, GLdouble __arg4, GLdouble __arg5, GLdouble __arg6, GLdouble __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glProgramNamedParameter4dNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLubyte *,(__arg3),A0),
        AROS_LCA(GLdouble,(__arg4),D2),
        AROS_LCA(GLdouble,(__arg5),D3),
        AROS_LCA(GLdouble,(__arg6),D4),
        AROS_LCA(GLdouble,(__arg7),D5),
        struct Library *, (__MesaBase), 1013, Mesa    );
}

#define glProgramNamedParameter4dNV(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glProgramNamedParameter4dNV((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramNamedParameter4fvNV(GLuint __arg1, GLsizei __arg2, const GLubyte * __arg3, const GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glProgramNamedParameter4fvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLubyte *,(__arg3),A0),
        AROS_LCA(const GLfloat *,(__arg4),A1),
        struct Library *, (__MesaBase), 1014, Mesa    );
}

#define glProgramNamedParameter4fvNV(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glProgramNamedParameter4fvNV((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramNamedParameter4dvNV(GLuint __arg1, GLsizei __arg2, const GLubyte * __arg3, const GLdouble * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glProgramNamedParameter4dvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLubyte *,(__arg3),A0),
        AROS_LCA(const GLdouble *,(__arg4),A1),
        struct Library *, (__MesaBase), 1015, Mesa    );
}

#define glProgramNamedParameter4dvNV(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glProgramNamedParameter4dvNV((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetProgramNamedParameterfvNV(GLuint __arg1, GLsizei __arg2, const GLubyte * __arg3, GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetProgramNamedParameterfvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLubyte *,(__arg3),A0),
        AROS_LCA(GLfloat *,(__arg4),A1),
        struct Library *, (__MesaBase), 1016, Mesa    );
}

#define glGetProgramNamedParameterfvNV(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetProgramNamedParameterfvNV((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetProgramNamedParameterdvNV(GLuint __arg1, GLsizei __arg2, const GLubyte * __arg3, GLdouble * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetProgramNamedParameterdvNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLubyte *,(__arg3),A0),
        AROS_LCA(GLdouble *,(__arg4),A1),
        struct Library *, (__MesaBase), 1017, Mesa    );
}

#define glGetProgramNamedParameterdvNV(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetProgramNamedParameterdvNV((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsRenderbufferEXT(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsRenderbufferEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 1018, Mesa    );
}

#define glIsRenderbufferEXT(arg1) \
    __inline_Mesa_glIsRenderbufferEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glBindRenderbufferEXT(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBindRenderbufferEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 1019, Mesa    );
}

#define glBindRenderbufferEXT(arg1, arg2) \
    __inline_Mesa_glBindRenderbufferEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteRenderbuffersEXT(GLsizei __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDeleteRenderbuffersEXT,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1020, Mesa    );
}

#define glDeleteRenderbuffersEXT(arg1, arg2) \
    __inline_Mesa_glDeleteRenderbuffersEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGenRenderbuffersEXT(GLsizei __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGenRenderbuffersEXT,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1021, Mesa    );
}

#define glGenRenderbuffersEXT(arg1, arg2) \
    __inline_Mesa_glGenRenderbuffersEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glRenderbufferStorageEXT(GLenum __arg1, GLenum __arg2, GLsizei __arg3, GLsizei __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glRenderbufferStorageEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        struct Library *, (__MesaBase), 1022, Mesa    );
}

#define glRenderbufferStorageEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glRenderbufferStorageEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetRenderbufferParameterivEXT(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetRenderbufferParameterivEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1023, Mesa    );
}

#define glGetRenderbufferParameterivEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetRenderbufferParameterivEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsFramebufferEXT(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsFramebufferEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 1024, Mesa    );
}

#define glIsFramebufferEXT(arg1) \
    __inline_Mesa_glIsFramebufferEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glBindFramebufferEXT(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBindFramebufferEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 1025, Mesa    );
}

#define glBindFramebufferEXT(arg1, arg2) \
    __inline_Mesa_glBindFramebufferEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteFramebuffersEXT(GLsizei __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDeleteFramebuffersEXT,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1026, Mesa    );
}

#define glDeleteFramebuffersEXT(arg1, arg2) \
    __inline_Mesa_glDeleteFramebuffersEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGenFramebuffersEXT(GLsizei __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGenFramebuffersEXT,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1027, Mesa    );
}

#define glGenFramebuffersEXT(arg1, arg2) \
    __inline_Mesa_glGenFramebuffersEXT((arg1), (arg2), (APTR)MesaBase)

static inline GLenum __inline_Mesa_glCheckFramebufferStatusEXT(GLenum __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLenum, glCheckFramebufferStatusEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 1028, Mesa    );
}

#define glCheckFramebufferStatusEXT(arg1) \
    __inline_Mesa_glCheckFramebufferStatusEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glFramebufferTexture1DEXT(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLuint __arg4, GLint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glFramebufferTexture1DEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        struct Library *, (__MesaBase), 1029, Mesa    );
}

#define glFramebufferTexture1DEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glFramebufferTexture1DEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glFramebufferTexture2DEXT(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLuint __arg4, GLint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glFramebufferTexture2DEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        struct Library *, (__MesaBase), 1030, Mesa    );
}

#define glFramebufferTexture2DEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glFramebufferTexture2DEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glFramebufferTexture3DEXT(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLuint __arg4, GLint __arg5, GLint __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glFramebufferTexture3DEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLint,(__arg6),D5),
        struct Library *, (__MesaBase), 1031, Mesa    );
}

#define glFramebufferTexture3DEXT(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glFramebufferTexture3DEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glFramebufferRenderbufferEXT(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLuint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glFramebufferRenderbufferEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        struct Library *, (__MesaBase), 1032, Mesa    );
}

#define glFramebufferRenderbufferEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glFramebufferRenderbufferEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetFramebufferAttachmentParameterivEXT(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLint * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetFramebufferAttachmentParameterivEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLint *,(__arg4),A0),
        struct Library *, (__MesaBase), 1033, Mesa    );
}

#define glGetFramebufferAttachmentParameterivEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetFramebufferAttachmentParameterivEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGenerateMipmapEXT(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glGenerateMipmapEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 1034, Mesa    );
}

#define glGenerateMipmapEXT(arg1) \
    __inline_Mesa_glGenerateMipmapEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glFramebufferTextureLayerEXT(GLenum __arg1, GLenum __arg2, GLuint __arg3, GLint __arg4, GLint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glFramebufferTextureLayerEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        struct Library *, (__MesaBase), 1035, Mesa    );
}

#define glFramebufferTextureLayerEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glFramebufferTextureLayerEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline GLvoid* __inline_Mesa_glMapBufferRange(GLenum __arg1, GLintptr __arg2, GLsizeiptr __arg3, GLbitfield __arg4, APTR __MesaBase)
{
    return AROS_LC4(GLvoid*, glMapBufferRange,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLintptr,(__arg2),D1),
        AROS_LCA(GLsizeiptr,(__arg3),D2),
        AROS_LCA(GLbitfield,(__arg4),D3),
        struct Library *, (__MesaBase), 1036, Mesa    );
}

#define glMapBufferRange(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glMapBufferRange((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glFlushMappedBufferRange(GLenum __arg1, GLintptr __arg2, GLsizeiptr __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glFlushMappedBufferRange,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLintptr,(__arg2),D1),
        AROS_LCA(GLsizeiptr,(__arg3),D2),
        struct Library *, (__MesaBase), 1037, Mesa    );
}

#define glFlushMappedBufferRange(arg1, arg2, arg3) \
    __inline_Mesa_glFlushMappedBufferRange((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glBindVertexArray(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glBindVertexArray,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 1038, Mesa    );
}

#define glBindVertexArray(arg1) \
    __inline_Mesa_glBindVertexArray((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteVertexArrays(GLsizei __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDeleteVertexArrays,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1039, Mesa    );
}

#define glDeleteVertexArrays(arg1, arg2) \
    __inline_Mesa_glDeleteVertexArrays((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGenVertexArrays(GLsizei __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGenVertexArrays,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1040, Mesa    );
}

#define glGenVertexArrays(arg1, arg2) \
    __inline_Mesa_glGenVertexArrays((arg1), (arg2), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsVertexArray(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsVertexArray,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 1041, Mesa    );
}

#define glIsVertexArray(arg1) \
    __inline_Mesa_glIsVertexArray((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyBufferSubData(GLenum __arg1, GLenum __arg2, GLintptr __arg3, GLintptr __arg4, GLsizeiptr __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glCopyBufferSubData,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLintptr,(__arg3),D2),
        AROS_LCA(GLintptr,(__arg4),D3),
        AROS_LCA(GLsizeiptr,(__arg5),D4),
        struct Library *, (__MesaBase), 1042, Mesa    );
}

#define glCopyBufferSubData(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glCopyBufferSubData((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline GLsync __inline_Mesa_glFenceSync(GLenum __arg1, GLbitfield __arg2, APTR __MesaBase)
{
    return AROS_LC2(GLsync, glFenceSync,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLbitfield,(__arg2),D1),
        struct Library *, (__MesaBase), 1043, Mesa    );
}

#define glFenceSync(arg1, arg2) \
    __inline_Mesa_glFenceSync((arg1), (arg2), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsSync(GLsync __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsSync,
        AROS_LCA(GLsync,(__arg1),D0),
        struct Library *, (__MesaBase), 1044, Mesa    );
}

#define glIsSync(arg1) \
    __inline_Mesa_glIsSync((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteSync(GLsync __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glDeleteSync,
        AROS_LCA(GLsync,(__arg1),D0),
        struct Library *, (__MesaBase), 1045, Mesa    );
}

#define glDeleteSync(arg1) \
    __inline_Mesa_glDeleteSync((arg1), (APTR)MesaBase)

static inline GLenum __inline_Mesa_glClientWaitSync(GLsync __arg1, GLbitfield __arg2, GLuint64 __arg3, APTR __MesaBase)
{
    return AROS_LC3(GLenum, glClientWaitSync,
        AROS_LCA(GLsync,(__arg1),D0),
        AROS_LCA(GLbitfield,(__arg2),D1),
        AROS_LCA(GLuint64,(__arg3),D2),
        struct Library *, (__MesaBase), 1046, Mesa    );
}

#define glClientWaitSync(arg1, arg2, arg3) \
    __inline_Mesa_glClientWaitSync((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glWaitSync(GLsync __arg1, GLbitfield __arg2, GLuint64 __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glWaitSync,
        AROS_LCA(GLsync,(__arg1),D0),
        AROS_LCA(GLbitfield,(__arg2),D1),
        AROS_LCA(GLuint64,(__arg3),D2),
        struct Library *, (__MesaBase), 1047, Mesa    );
}

#define glWaitSync(arg1, arg2, arg3) \
    __inline_Mesa_glWaitSync((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetInteger64v(GLenum __arg1, GLint64 * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGetInteger64v,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint64 *,(__arg2),A0),
        struct Library *, (__MesaBase), 1048, Mesa    );
}

#define glGetInteger64v(arg1, arg2) \
    __inline_Mesa_glGetInteger64v((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetSynciv(GLsync __arg1, GLenum __arg2, GLsizei __arg3, GLsizei * __arg4, GLint * __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glGetSynciv,
        AROS_LCA(GLsync,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei *,(__arg4),A0),
        AROS_LCA(GLint *,(__arg5),A1),
        struct Library *, (__MesaBase), 1049, Mesa    );
}

#define glGetSynciv(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glGetSynciv((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glProvokingVertexEXT(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glProvokingVertexEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 1050, Mesa    );
}

#define glProvokingVertexEXT(arg1) \
    __inline_Mesa_glProvokingVertexEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDrawElementsBaseVertex(GLenum __arg1, GLsizei __arg2, GLenum __arg3, const GLvoid * __arg4, GLint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glDrawElementsBaseVertex,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(const GLvoid *,(__arg4),A0),
        AROS_LCA(GLint,(__arg5),D3),
        struct Library *, (__MesaBase), 1051, Mesa    );
}

#define glDrawElementsBaseVertex(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glDrawElementsBaseVertex((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glDrawRangeElementsBaseVertex(GLenum __arg1, GLuint __arg2, GLuint __arg3, GLsizei __arg4, GLenum __arg5, const GLvoid * __arg6, GLint __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glDrawRangeElementsBaseVertex,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(const GLvoid *,(__arg6),A0),
        AROS_LCA(GLint,(__arg7),D5),
        struct Library *, (__MesaBase), 1052, Mesa    );
}

#define glDrawRangeElementsBaseVertex(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glDrawRangeElementsBaseVertex((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiDrawElementsBaseVertex(GLenum __arg1, const GLsizei * __arg2, GLenum __arg3, const GLvoid *  * __arg4, GLsizei __arg5, const GLint * __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glMultiDrawElementsBaseVertex,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLsizei *,(__arg2),A0),
        AROS_LCA(GLenum,(__arg3),D1),
        AROS_LCA(const GLvoid *  *,(__arg4),A1),
        AROS_LCA(GLsizei,(__arg5),D2),
        AROS_LCA(const GLint *,(__arg6),A2),
        struct Library *, (__MesaBase), 1053, Mesa    );
}

#define glMultiDrawElementsBaseVertex(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glMultiDrawElementsBaseVertex((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glProvokingVertex(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glProvokingVertex,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 1054, Mesa    );
}

#define glProvokingVertex(arg1) \
    __inline_Mesa_glProvokingVertex((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glRenderbufferStorageMultisampleEXT(GLenum __arg1, GLsizei __arg2, GLenum __arg3, GLsizei __arg4, GLsizei __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glRenderbufferStorageMultisampleEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        struct Library *, (__MesaBase), 1055, Mesa    );
}

#define glRenderbufferStorageMultisampleEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glRenderbufferStorageMultisampleEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glColorMaskIndexedEXT(GLuint __arg1, GLboolean __arg2, GLboolean __arg3, GLboolean __arg4, GLboolean __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glColorMaskIndexedEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLboolean,(__arg2),D1),
        AROS_LCA(GLboolean,(__arg3),D2),
        AROS_LCA(GLboolean,(__arg4),D3),
        AROS_LCA(GLboolean,(__arg5),D4),
        struct Library *, (__MesaBase), 1056, Mesa    );
}

#define glColorMaskIndexedEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glColorMaskIndexedEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glGetBooleanIndexedvEXT(GLenum __arg1, GLuint __arg2, GLboolean * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetBooleanIndexedvEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLboolean *,(__arg3),A0),
        struct Library *, (__MesaBase), 1057, Mesa    );
}

#define glGetBooleanIndexedvEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetBooleanIndexedvEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetIntegerIndexedvEXT(GLenum __arg1, GLuint __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetIntegerIndexedvEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1058, Mesa    );
}

#define glGetIntegerIndexedvEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetIntegerIndexedvEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glEnableIndexedEXT(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glEnableIndexedEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 1059, Mesa    );
}

#define glEnableIndexedEXT(arg1, arg2) \
    __inline_Mesa_glEnableIndexedEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDisableIndexedEXT(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDisableIndexedEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 1060, Mesa    );
}

#define glDisableIndexedEXT(arg1, arg2) \
    __inline_Mesa_glDisableIndexedEXT((arg1), (arg2), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsEnabledIndexedEXT(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    return AROS_LC2(GLboolean, glIsEnabledIndexedEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 1061, Mesa    );
}

#define glIsEnabledIndexedEXT(arg1, arg2) \
    __inline_Mesa_glIsEnabledIndexedEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glBeginConditionalRenderNV(GLuint __arg1, GLenum __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBeginConditionalRenderNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        struct Library *, (__MesaBase), 1062, Mesa    );
}

#define glBeginConditionalRenderNV(arg1, arg2) \
    __inline_Mesa_glBeginConditionalRenderNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glEndConditionalRenderNV(APTR __MesaBase)
{
    AROS_LC0NR(void, glEndConditionalRenderNV,
        struct Library *, (__MesaBase), 1063, Mesa    );
}

#define glEndConditionalRenderNV() \
    __inline_Mesa_glEndConditionalRenderNV((APTR)MesaBase)

static inline GLenum __inline_Mesa_glObjectPurgeableAPPLE(GLenum __arg1, GLuint __arg2, GLenum __arg3, APTR __MesaBase)
{
    return AROS_LC3(GLenum, glObjectPurgeableAPPLE,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        struct Library *, (__MesaBase), 1064, Mesa    );
}

#define glObjectPurgeableAPPLE(arg1, arg2, arg3) \
    __inline_Mesa_glObjectPurgeableAPPLE((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline GLenum __inline_Mesa_glObjectUnpurgeableAPPLE(GLenum __arg1, GLuint __arg2, GLenum __arg3, APTR __MesaBase)
{
    return AROS_LC3(GLenum, glObjectUnpurgeableAPPLE,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        struct Library *, (__MesaBase), 1065, Mesa    );
}

#define glObjectUnpurgeableAPPLE(arg1, arg2, arg3) \
    __inline_Mesa_glObjectUnpurgeableAPPLE((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetObjectParameterivAPPLE(GLenum __arg1, GLuint __arg2, GLenum __arg3, GLint * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetObjectParameterivAPPLE,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLint *,(__arg4),A0),
        struct Library *, (__MesaBase), 1066, Mesa    );
}

#define glGetObjectParameterivAPPLE(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetObjectParameterivAPPLE((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glBeginTransformFeedback(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glBeginTransformFeedback,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 1067, Mesa    );
}

#define glBeginTransformFeedback(arg1) \
    __inline_Mesa_glBeginTransformFeedback((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glEndTransformFeedback(APTR __MesaBase)
{
    AROS_LC0NR(void, glEndTransformFeedback,
        struct Library *, (__MesaBase), 1068, Mesa    );
}

#define glEndTransformFeedback() \
    __inline_Mesa_glEndTransformFeedback((APTR)MesaBase)

static inline void __inline_Mesa_glBindBufferRange(GLenum __arg1, GLuint __arg2, GLuint __arg3, GLintptr __arg4, GLsizeiptr __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glBindBufferRange,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLintptr,(__arg4),D3),
        AROS_LCA(GLsizeiptr,(__arg5),D4),
        struct Library *, (__MesaBase), 1069, Mesa    );
}

#define glBindBufferRange(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glBindBufferRange((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glBindBufferBase(GLenum __arg1, GLuint __arg2, GLuint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glBindBufferBase,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        struct Library *, (__MesaBase), 1070, Mesa    );
}

#define glBindBufferBase(arg1, arg2, arg3) \
    __inline_Mesa_glBindBufferBase((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTransformFeedbackVaryings(GLuint __arg1, GLsizei __arg2, const GLchar *  * __arg3, GLenum __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glTransformFeedbackVaryings,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLchar *  *,(__arg3),A0),
        AROS_LCA(GLenum,(__arg4),D2),
        struct Library *, (__MesaBase), 1071, Mesa    );
}

#define glTransformFeedbackVaryings(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glTransformFeedbackVaryings((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTransformFeedbackVarying(GLuint __arg1, GLuint __arg2, GLsizei __arg3, GLsizei * __arg4, GLsizei * __arg5, GLenum * __arg6, GLchar * __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glGetTransformFeedbackVarying,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei *,(__arg4),A0),
        AROS_LCA(GLsizei *,(__arg5),A1),
        AROS_LCA(GLenum *,(__arg6),A2),
        AROS_LCA(GLchar *,(__arg7),A3),
        struct Library *, (__MesaBase), 1072, Mesa    );
}

#define glGetTransformFeedbackVarying(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glGetTransformFeedbackVarying((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glDrawArraysInstanced(GLenum __arg1, GLint __arg2, GLsizei __arg3, GLsizei __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glDrawArraysInstanced,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        struct Library *, (__MesaBase), 1073, Mesa    );
}

#define glDrawArraysInstanced(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glDrawArraysInstanced((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glDrawElementsInstanced(GLenum __arg1, GLsizei __arg2, GLenum __arg3, const GLvoid * __arg4, GLsizei __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glDrawElementsInstanced,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(const GLvoid *,(__arg4),A0),
        AROS_LCA(GLsizei,(__arg5),D3),
        struct Library *, (__MesaBase), 1074, Mesa    );
}

#define glDrawElementsInstanced(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glDrawElementsInstanced((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glDrawArraysInstancedARB(GLenum __arg1, GLint __arg2, GLsizei __arg3, GLsizei __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glDrawArraysInstancedARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        struct Library *, (__MesaBase), 1075, Mesa    );
}

#define glDrawArraysInstancedARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glDrawArraysInstancedARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glDrawElementsInstancedARB(GLenum __arg1, GLsizei __arg2, GLenum __arg3, const GLvoid * __arg4, GLsizei __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glDrawElementsInstancedARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(const GLvoid *,(__arg4),A0),
        AROS_LCA(GLsizei,(__arg5),D3),
        struct Library *, (__MesaBase), 1076, Mesa    );
}

#define glDrawElementsInstancedARB(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glDrawElementsInstancedARB((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramParameteriARB(GLuint __arg1, GLenum __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glProgramParameteriARB,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 1077, Mesa    );
}

#define glProgramParameteriARB(arg1, arg2, arg3) \
    __inline_Mesa_glProgramParameteriARB((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glFramebufferTextureARB(GLenum __arg1, GLenum __arg2, GLuint __arg3, GLint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glFramebufferTextureARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        struct Library *, (__MesaBase), 1078, Mesa    );
}

#define glFramebufferTextureARB(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glFramebufferTextureARB((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glFramebufferTextureFaceARB(GLenum __arg1, GLenum __arg2, GLuint __arg3, GLint __arg4, GLenum __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glFramebufferTextureFaceARB,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        struct Library *, (__MesaBase), 1079, Mesa    );
}

#define glFramebufferTextureFaceARB(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glFramebufferTextureFaceARB((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glBindTransformFeedback(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBindTransformFeedback,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 1080, Mesa    );
}

#define glBindTransformFeedback(arg1, arg2) \
    __inline_Mesa_glBindTransformFeedback((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteTransformFeedbacks(GLsizei __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDeleteTransformFeedbacks,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1081, Mesa    );
}

#define glDeleteTransformFeedbacks(arg1, arg2) \
    __inline_Mesa_glDeleteTransformFeedbacks((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGenTransformFeedbacks(GLsizei __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGenTransformFeedbacks,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1082, Mesa    );
}

#define glGenTransformFeedbacks(arg1, arg2) \
    __inline_Mesa_glGenTransformFeedbacks((arg1), (arg2), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsTransformFeedback(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsTransformFeedback,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 1083, Mesa    );
}

#define glIsTransformFeedback(arg1) \
    __inline_Mesa_glIsTransformFeedback((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glPauseTransformFeedback(APTR __MesaBase)
{
    AROS_LC0NR(void, glPauseTransformFeedback,
        struct Library *, (__MesaBase), 1084, Mesa    );
}

#define glPauseTransformFeedback() \
    __inline_Mesa_glPauseTransformFeedback((APTR)MesaBase)

static inline void __inline_Mesa_glResumeTransformFeedback(APTR __MesaBase)
{
    AROS_LC0NR(void, glResumeTransformFeedback,
        struct Library *, (__MesaBase), 1085, Mesa    );
}

#define glResumeTransformFeedback() \
    __inline_Mesa_glResumeTransformFeedback((APTR)MesaBase)

static inline void __inline_Mesa_glDrawTransformFeedback(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDrawTransformFeedback,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 1086, Mesa    );
}

#define glDrawTransformFeedback(arg1, arg2) \
    __inline_Mesa_glDrawTransformFeedback((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDrawArraysInstancedEXT(GLenum __arg1, GLint __arg2, GLsizei __arg3, GLsizei __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glDrawArraysInstancedEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        struct Library *, (__MesaBase), 1087, Mesa    );
}

#define glDrawArraysInstancedEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glDrawArraysInstancedEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glDrawElementsInstancedEXT(GLenum __arg1, GLsizei __arg2, GLenum __arg3, const GLvoid * __arg4, GLsizei __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glDrawElementsInstancedEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(const GLvoid *,(__arg4),A0),
        AROS_LCA(GLsizei,(__arg5),D3),
        struct Library *, (__MesaBase), 1088, Mesa    );
}

#define glDrawElementsInstancedEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glDrawElementsInstancedEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glBeginTransformFeedbackEXT(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glBeginTransformFeedbackEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 1089, Mesa    );
}

#define glBeginTransformFeedbackEXT(arg1) \
    __inline_Mesa_glBeginTransformFeedbackEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glEndTransformFeedbackEXT(APTR __MesaBase)
{
    AROS_LC0NR(void, glEndTransformFeedbackEXT,
        struct Library *, (__MesaBase), 1090, Mesa    );
}

#define glEndTransformFeedbackEXT() \
    __inline_Mesa_glEndTransformFeedbackEXT((APTR)MesaBase)

static inline void __inline_Mesa_glBindBufferRangeEXT(GLenum __arg1, GLuint __arg2, GLuint __arg3, GLintptr __arg4, GLsizeiptr __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glBindBufferRangeEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLintptr,(__arg4),D3),
        AROS_LCA(GLsizeiptr,(__arg5),D4),
        struct Library *, (__MesaBase), 1091, Mesa    );
}

#define glBindBufferRangeEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glBindBufferRangeEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glBindBufferOffsetEXT(GLenum __arg1, GLuint __arg2, GLuint __arg3, GLintptr __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glBindBufferOffsetEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLintptr,(__arg4),D3),
        struct Library *, (__MesaBase), 1092, Mesa    );
}

#define glBindBufferOffsetEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glBindBufferOffsetEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glBindBufferBaseEXT(GLenum __arg1, GLuint __arg2, GLuint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glBindBufferBaseEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        struct Library *, (__MesaBase), 1093, Mesa    );
}

#define glBindBufferBaseEXT(arg1, arg2, arg3) \
    __inline_Mesa_glBindBufferBaseEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTransformFeedbackVaryingsEXT(GLuint __arg1, GLsizei __arg2, const GLchar *  * __arg3, GLenum __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glTransformFeedbackVaryingsEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLchar *  *,(__arg3),A0),
        AROS_LCA(GLenum,(__arg4),D2),
        struct Library *, (__MesaBase), 1094, Mesa    );
}

#define glTransformFeedbackVaryingsEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glTransformFeedbackVaryingsEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTransformFeedbackVaryingEXT(GLuint __arg1, GLuint __arg2, GLsizei __arg3, GLsizei * __arg4, GLsizei * __arg5, GLenum * __arg6, GLchar * __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glGetTransformFeedbackVaryingEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei *,(__arg4),A0),
        AROS_LCA(GLsizei *,(__arg5),A1),
        AROS_LCA(GLenum *,(__arg6),A2),
        AROS_LCA(GLchar *,(__arg7),A3),
        struct Library *, (__MesaBase), 1095, Mesa    );
}

#define glGetTransformFeedbackVaryingEXT(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glGetTransformFeedbackVaryingEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glEGLImageTargetTexture2DOES(GLenum __arg1, GLeglImageOES __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glEGLImageTargetTexture2DOES,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLeglImageOES,(__arg2),D1),
        struct Library *, (__MesaBase), 1096, Mesa    );
}

#define glEGLImageTargetTexture2DOES(arg1, arg2) \
    __inline_Mesa_glEGLImageTargetTexture2DOES((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glEGLImageTargetRenderbufferStorageOES(GLenum __arg1, GLeglImageOES __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glEGLImageTargetRenderbufferStorageOES,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLeglImageOES,(__arg2),D1),
        struct Library *, (__MesaBase), 1097, Mesa    );
}

#define glEGLImageTargetRenderbufferStorageOES(arg1, arg2) \
    __inline_Mesa_glEGLImageTargetRenderbufferStorageOES((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glColorMaski(GLuint __arg1, GLboolean __arg2, GLboolean __arg3, GLboolean __arg4, GLboolean __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glColorMaski,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLboolean,(__arg2),D1),
        AROS_LCA(GLboolean,(__arg3),D2),
        AROS_LCA(GLboolean,(__arg4),D3),
        AROS_LCA(GLboolean,(__arg5),D4),
        struct Library *, (__MesaBase), 1098, Mesa    );
}

#define glColorMaski(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glColorMaski((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glGetBooleani_v(GLenum __arg1, GLuint __arg2, GLboolean * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetBooleani_v,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLboolean *,(__arg3),A0),
        struct Library *, (__MesaBase), 1099, Mesa    );
}

#define glGetBooleani_v(arg1, arg2, arg3) \
    __inline_Mesa_glGetBooleani_v((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetIntegeri_v(GLenum __arg1, GLuint __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetIntegeri_v,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1100, Mesa    );
}

#define glGetIntegeri_v(arg1, arg2, arg3) \
    __inline_Mesa_glGetIntegeri_v((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glEnablei(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glEnablei,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 1101, Mesa    );
}

#define glEnablei(arg1, arg2) \
    __inline_Mesa_glEnablei((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glDisablei(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDisablei,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 1102, Mesa    );
}

#define glDisablei(arg1, arg2) \
    __inline_Mesa_glDisablei((arg1), (arg2), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsEnabledi(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    return AROS_LC2(GLboolean, glIsEnabledi,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 1103, Mesa    );
}

#define glIsEnabledi(arg1, arg2) \
    __inline_Mesa_glIsEnabledi((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glClampColor(GLenum __arg1, GLenum __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glClampColor,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        struct Library *, (__MesaBase), 1104, Mesa    );
}

#define glClampColor(arg1, arg2) \
    __inline_Mesa_glClampColor((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glBeginConditionalRender(GLuint __arg1, GLenum __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBeginConditionalRender,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        struct Library *, (__MesaBase), 1105, Mesa    );
}

#define glBeginConditionalRender(arg1, arg2) \
    __inline_Mesa_glBeginConditionalRender((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glEndConditionalRender(APTR __MesaBase)
{
    AROS_LC0NR(void, glEndConditionalRender,
        struct Library *, (__MesaBase), 1106, Mesa    );
}

#define glEndConditionalRender() \
    __inline_Mesa_glEndConditionalRender((APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribIPointer(GLuint __arg1, GLint __arg2, GLenum __arg3, GLsizei __arg4, const GLvoid * __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttribIPointer,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(const GLvoid *,(__arg5),A0),
        struct Library *, (__MesaBase), 1107, Mesa    );
}

#define glVertexAttribIPointer(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttribIPointer((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glGetVertexAttribIiv(GLuint __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetVertexAttribIiv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1108, Mesa    );
}

#define glGetVertexAttribIiv(arg1, arg2, arg3) \
    __inline_Mesa_glGetVertexAttribIiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetVertexAttribIuiv(GLuint __arg1, GLenum __arg2, GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetVertexAttribIuiv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1109, Mesa    );
}

#define glGetVertexAttribIuiv(arg1, arg2, arg3) \
    __inline_Mesa_glGetVertexAttribIuiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI1i(GLuint __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI1i,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 1110, Mesa    );
}

#define glVertexAttribI1i(arg1, arg2) \
    __inline_Mesa_glVertexAttribI1i((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI2i(GLuint __arg1, GLint __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttribI2i,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 1111, Mesa    );
}

#define glVertexAttribI2i(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttribI2i((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI3i(GLuint __arg1, GLint __arg2, GLint __arg3, GLint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertexAttribI3i,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        struct Library *, (__MesaBase), 1112, Mesa    );
}

#define glVertexAttribI3i(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertexAttribI3i((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI4i(GLuint __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttribI4i,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        struct Library *, (__MesaBase), 1113, Mesa    );
}

#define glVertexAttribI4i(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttribI4i((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI1ui(GLuint __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI1ui,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 1114, Mesa    );
}

#define glVertexAttribI1ui(arg1, arg2) \
    __inline_Mesa_glVertexAttribI1ui((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI2ui(GLuint __arg1, GLuint __arg2, GLuint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttribI2ui,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        struct Library *, (__MesaBase), 1115, Mesa    );
}

#define glVertexAttribI2ui(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttribI2ui((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI3ui(GLuint __arg1, GLuint __arg2, GLuint __arg3, GLuint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertexAttribI3ui,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        struct Library *, (__MesaBase), 1116, Mesa    );
}

#define glVertexAttribI3ui(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertexAttribI3ui((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI4ui(GLuint __arg1, GLuint __arg2, GLuint __arg3, GLuint __arg4, GLuint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttribI4ui,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        AROS_LCA(GLuint,(__arg5),D4),
        struct Library *, (__MesaBase), 1117, Mesa    );
}

#define glVertexAttribI4ui(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttribI4ui((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI1iv(GLuint __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI1iv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1118, Mesa    );
}

#define glVertexAttribI1iv(arg1, arg2) \
    __inline_Mesa_glVertexAttribI1iv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI2iv(GLuint __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI2iv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1119, Mesa    );
}

#define glVertexAttribI2iv(arg1, arg2) \
    __inline_Mesa_glVertexAttribI2iv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI3iv(GLuint __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI3iv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1120, Mesa    );
}

#define glVertexAttribI3iv(arg1, arg2) \
    __inline_Mesa_glVertexAttribI3iv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI4iv(GLuint __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI4iv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1121, Mesa    );
}

#define glVertexAttribI4iv(arg1, arg2) \
    __inline_Mesa_glVertexAttribI4iv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI1uiv(GLuint __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI1uiv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1122, Mesa    );
}

#define glVertexAttribI1uiv(arg1, arg2) \
    __inline_Mesa_glVertexAttribI1uiv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI2uiv(GLuint __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI2uiv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1123, Mesa    );
}

#define glVertexAttribI2uiv(arg1, arg2) \
    __inline_Mesa_glVertexAttribI2uiv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI3uiv(GLuint __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI3uiv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1124, Mesa    );
}

#define glVertexAttribI3uiv(arg1, arg2) \
    __inline_Mesa_glVertexAttribI3uiv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI4uiv(GLuint __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI4uiv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1125, Mesa    );
}

#define glVertexAttribI4uiv(arg1, arg2) \
    __inline_Mesa_glVertexAttribI4uiv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI4bv(GLuint __arg1, const GLbyte * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI4bv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLbyte *,(__arg2),A0),
        struct Library *, (__MesaBase), 1126, Mesa    );
}

#define glVertexAttribI4bv(arg1, arg2) \
    __inline_Mesa_glVertexAttribI4bv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI4sv(GLuint __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI4sv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 1127, Mesa    );
}

#define glVertexAttribI4sv(arg1, arg2) \
    __inline_Mesa_glVertexAttribI4sv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI4ubv(GLuint __arg1, const GLubyte * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI4ubv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLubyte *,(__arg2),A0),
        struct Library *, (__MesaBase), 1128, Mesa    );
}

#define glVertexAttribI4ubv(arg1, arg2) \
    __inline_Mesa_glVertexAttribI4ubv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI4usv(GLuint __arg1, const GLushort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI4usv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLushort *,(__arg2),A0),
        struct Library *, (__MesaBase), 1129, Mesa    );
}

#define glVertexAttribI4usv(arg1, arg2) \
    __inline_Mesa_glVertexAttribI4usv((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetUniformuiv(GLuint __arg1, GLint __arg2, GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetUniformuiv,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1130, Mesa    );
}

#define glGetUniformuiv(arg1, arg2, arg3) \
    __inline_Mesa_glGetUniformuiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glBindFragDataLocation(GLuint __arg1, GLuint __arg2, const GLchar * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glBindFragDataLocation,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(const GLchar *,(__arg3),A0),
        struct Library *, (__MesaBase), 1131, Mesa    );
}

#define glBindFragDataLocation(arg1, arg2, arg3) \
    __inline_Mesa_glBindFragDataLocation((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline GLint __inline_Mesa_glGetFragDataLocation(GLuint __arg1, const GLchar * __arg2, APTR __MesaBase)
{
    return AROS_LC2(GLint, glGetFragDataLocation,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLchar *,(__arg2),A0),
        struct Library *, (__MesaBase), 1132, Mesa    );
}

#define glGetFragDataLocation(arg1, arg2) \
    __inline_Mesa_glGetFragDataLocation((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform1ui(GLint __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glUniform1ui,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 1133, Mesa    );
}

#define glUniform1ui(arg1, arg2) \
    __inline_Mesa_glUniform1ui((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform2ui(GLint __arg1, GLuint __arg2, GLuint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform2ui,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        struct Library *, (__MesaBase), 1134, Mesa    );
}

#define glUniform2ui(arg1, arg2, arg3) \
    __inline_Mesa_glUniform2ui((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform3ui(GLint __arg1, GLuint __arg2, GLuint __arg3, GLuint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniform3ui,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        struct Library *, (__MesaBase), 1135, Mesa    );
}

#define glUniform3ui(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniform3ui((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform4ui(GLint __arg1, GLuint __arg2, GLuint __arg3, GLuint __arg4, GLuint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glUniform4ui,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        AROS_LCA(GLuint,(__arg5),D4),
        struct Library *, (__MesaBase), 1136, Mesa    );
}

#define glUniform4ui(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glUniform4ui((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform1uiv(GLint __arg1, GLsizei __arg2, const GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform1uiv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1137, Mesa    );
}

#define glUniform1uiv(arg1, arg2, arg3) \
    __inline_Mesa_glUniform1uiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform2uiv(GLint __arg1, GLsizei __arg2, const GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform2uiv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1138, Mesa    );
}

#define glUniform2uiv(arg1, arg2, arg3) \
    __inline_Mesa_glUniform2uiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform3uiv(GLint __arg1, GLsizei __arg2, const GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform3uiv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1139, Mesa    );
}

#define glUniform3uiv(arg1, arg2, arg3) \
    __inline_Mesa_glUniform3uiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform4uiv(GLint __arg1, GLsizei __arg2, const GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform4uiv,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1140, Mesa    );
}

#define glUniform4uiv(arg1, arg2, arg3) \
    __inline_Mesa_glUniform4uiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexParameterIiv(GLenum __arg1, GLenum __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexParameterIiv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1141, Mesa    );
}

#define glTexParameterIiv(arg1, arg2, arg3) \
    __inline_Mesa_glTexParameterIiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexParameterIuiv(GLenum __arg1, GLenum __arg2, const GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexParameterIuiv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1142, Mesa    );
}

#define glTexParameterIuiv(arg1, arg2, arg3) \
    __inline_Mesa_glTexParameterIuiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTexParameterIiv(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetTexParameterIiv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1143, Mesa    );
}

#define glGetTexParameterIiv(arg1, arg2, arg3) \
    __inline_Mesa_glGetTexParameterIiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTexParameterIuiv(GLenum __arg1, GLenum __arg2, GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetTexParameterIuiv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1144, Mesa    );
}

#define glGetTexParameterIuiv(arg1, arg2, arg3) \
    __inline_Mesa_glGetTexParameterIuiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glClearBufferiv(GLenum __arg1, GLint __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glClearBufferiv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1145, Mesa    );
}

#define glClearBufferiv(arg1, arg2, arg3) \
    __inline_Mesa_glClearBufferiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glClearBufferuiv(GLenum __arg1, GLint __arg2, const GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glClearBufferuiv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(const GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1146, Mesa    );
}

#define glClearBufferuiv(arg1, arg2, arg3) \
    __inline_Mesa_glClearBufferuiv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glClearBufferfv(GLenum __arg1, GLint __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glClearBufferfv,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 1147, Mesa    );
}

#define glClearBufferfv(arg1, arg2, arg3) \
    __inline_Mesa_glClearBufferfv((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glClearBufferfi(GLenum __arg1, GLint __arg2, GLfloat __arg3, GLint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glClearBufferfi,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        struct Library *, (__MesaBase), 1148, Mesa    );
}

#define glClearBufferfi(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glClearBufferfi((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline const GLubyte * __inline_Mesa_glGetStringi(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    return AROS_LC2(const GLubyte *, glGetStringi,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 1149, Mesa    );
}

#define glGetStringi(arg1, arg2) \
    __inline_Mesa_glGetStringi((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glTexBuffer(GLenum __arg1, GLenum __arg2, GLuint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexBuffer,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        struct Library *, (__MesaBase), 1150, Mesa    );
}

#define glTexBuffer(arg1, arg2, arg3) \
    __inline_Mesa_glTexBuffer((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glPrimitiveRestartIndex(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glPrimitiveRestartIndex,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 1151, Mesa    );
}

#define glPrimitiveRestartIndex(arg1) \
    __inline_Mesa_glPrimitiveRestartIndex((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glGetInteger64i_v(GLenum __arg1, GLuint __arg2, GLint64 * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetInteger64i_v,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLint64 *,(__arg3),A0),
        struct Library *, (__MesaBase), 1152, Mesa    );
}

#define glGetInteger64i_v(arg1, arg2, arg3) \
    __inline_Mesa_glGetInteger64i_v((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetBufferParameteri64v(GLenum __arg1, GLenum __arg2, GLint64 * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetBufferParameteri64v,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint64 *,(__arg3),A0),
        struct Library *, (__MesaBase), 1153, Mesa    );
}

#define glGetBufferParameteri64v(arg1, arg2, arg3) \
    __inline_Mesa_glGetBufferParameteri64v((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glFramebufferTexture(GLenum __arg1, GLenum __arg2, GLuint __arg3, GLint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glFramebufferTexture,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        struct Library *, (__MesaBase), 1154, Mesa    );
}

#define glFramebufferTexture(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glFramebufferTexture((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribDivisor(GLuint __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribDivisor,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 1155, Mesa    );
}

#define glVertexAttribDivisor(arg1, arg2) \
    __inline_Mesa_glVertexAttribDivisor((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPrimitiveRestartNV(APTR __MesaBase)
{
    AROS_LC0NR(void, glPrimitiveRestartNV,
        struct Library *, (__MesaBase), 1156, Mesa    );
}

#define glPrimitiveRestartNV() \
    __inline_Mesa_glPrimitiveRestartNV((APTR)MesaBase)

static inline void __inline_Mesa_glPrimitiveRestartIndexNV(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glPrimitiveRestartIndexNV,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 1157, Mesa    );
}

#define glPrimitiveRestartIndexNV(arg1) \
    __inline_Mesa_glPrimitiveRestartIndexNV((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI1iEXT(GLuint __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI1iEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 1158, Mesa    );
}

#define glVertexAttribI1iEXT(arg1, arg2) \
    __inline_Mesa_glVertexAttribI1iEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI2iEXT(GLuint __arg1, GLint __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttribI2iEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 1159, Mesa    );
}

#define glVertexAttribI2iEXT(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttribI2iEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI3iEXT(GLuint __arg1, GLint __arg2, GLint __arg3, GLint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertexAttribI3iEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        struct Library *, (__MesaBase), 1160, Mesa    );
}

#define glVertexAttribI3iEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertexAttribI3iEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI4iEXT(GLuint __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttribI4iEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        struct Library *, (__MesaBase), 1161, Mesa    );
}

#define glVertexAttribI4iEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttribI4iEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI1uiEXT(GLuint __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI1uiEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 1162, Mesa    );
}

#define glVertexAttribI1uiEXT(arg1, arg2) \
    __inline_Mesa_glVertexAttribI1uiEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI2uiEXT(GLuint __arg1, GLuint __arg2, GLuint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glVertexAttribI2uiEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        struct Library *, (__MesaBase), 1163, Mesa    );
}

#define glVertexAttribI2uiEXT(arg1, arg2, arg3) \
    __inline_Mesa_glVertexAttribI2uiEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI3uiEXT(GLuint __arg1, GLuint __arg2, GLuint __arg3, GLuint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glVertexAttribI3uiEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        struct Library *, (__MesaBase), 1164, Mesa    );
}

#define glVertexAttribI3uiEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glVertexAttribI3uiEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI4uiEXT(GLuint __arg1, GLuint __arg2, GLuint __arg3, GLuint __arg4, GLuint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttribI4uiEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        AROS_LCA(GLuint,(__arg5),D4),
        struct Library *, (__MesaBase), 1165, Mesa    );
}

#define glVertexAttribI4uiEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttribI4uiEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI1ivEXT(GLuint __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI1ivEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1166, Mesa    );
}

#define glVertexAttribI1ivEXT(arg1, arg2) \
    __inline_Mesa_glVertexAttribI1ivEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI2ivEXT(GLuint __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI2ivEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1167, Mesa    );
}

#define glVertexAttribI2ivEXT(arg1, arg2) \
    __inline_Mesa_glVertexAttribI2ivEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI3ivEXT(GLuint __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI3ivEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1168, Mesa    );
}

#define glVertexAttribI3ivEXT(arg1, arg2) \
    __inline_Mesa_glVertexAttribI3ivEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI4ivEXT(GLuint __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI4ivEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1169, Mesa    );
}

#define glVertexAttribI4ivEXT(arg1, arg2) \
    __inline_Mesa_glVertexAttribI4ivEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI1uivEXT(GLuint __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI1uivEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1170, Mesa    );
}

#define glVertexAttribI1uivEXT(arg1, arg2) \
    __inline_Mesa_glVertexAttribI1uivEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI2uivEXT(GLuint __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI2uivEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1171, Mesa    );
}

#define glVertexAttribI2uivEXT(arg1, arg2) \
    __inline_Mesa_glVertexAttribI2uivEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI3uivEXT(GLuint __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI3uivEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1172, Mesa    );
}

#define glVertexAttribI3uivEXT(arg1, arg2) \
    __inline_Mesa_glVertexAttribI3uivEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI4uivEXT(GLuint __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI4uivEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1173, Mesa    );
}

#define glVertexAttribI4uivEXT(arg1, arg2) \
    __inline_Mesa_glVertexAttribI4uivEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI4bvEXT(GLuint __arg1, const GLbyte * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI4bvEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLbyte *,(__arg2),A0),
        struct Library *, (__MesaBase), 1174, Mesa    );
}

#define glVertexAttribI4bvEXT(arg1, arg2) \
    __inline_Mesa_glVertexAttribI4bvEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI4svEXT(GLuint __arg1, const GLshort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI4svEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLshort *,(__arg2),A0),
        struct Library *, (__MesaBase), 1175, Mesa    );
}

#define glVertexAttribI4svEXT(arg1, arg2) \
    __inline_Mesa_glVertexAttribI4svEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI4ubvEXT(GLuint __arg1, const GLubyte * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI4ubvEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLubyte *,(__arg2),A0),
        struct Library *, (__MesaBase), 1176, Mesa    );
}

#define glVertexAttribI4ubvEXT(arg1, arg2) \
    __inline_Mesa_glVertexAttribI4ubvEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribI4usvEXT(GLuint __arg1, const GLushort * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glVertexAttribI4usvEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLushort *,(__arg2),A0),
        struct Library *, (__MesaBase), 1177, Mesa    );
}

#define glVertexAttribI4usvEXT(arg1, arg2) \
    __inline_Mesa_glVertexAttribI4usvEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glVertexAttribIPointerEXT(GLuint __arg1, GLint __arg2, GLenum __arg3, GLsizei __arg4, const GLvoid * __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glVertexAttribIPointerEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(const GLvoid *,(__arg5),A0),
        struct Library *, (__MesaBase), 1178, Mesa    );
}

#define glVertexAttribIPointerEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glVertexAttribIPointerEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glGetVertexAttribIivEXT(GLuint __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetVertexAttribIivEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1179, Mesa    );
}

#define glGetVertexAttribIivEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetVertexAttribIivEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetVertexAttribIuivEXT(GLuint __arg1, GLenum __arg2, GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetVertexAttribIuivEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1180, Mesa    );
}

#define glGetVertexAttribIuivEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetVertexAttribIuivEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetUniformuivEXT(GLuint __arg1, GLint __arg2, GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetUniformuivEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1181, Mesa    );
}

#define glGetUniformuivEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetUniformuivEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glBindFragDataLocationEXT(GLuint __arg1, GLuint __arg2, const GLchar * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glBindFragDataLocationEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(const GLchar *,(__arg3),A0),
        struct Library *, (__MesaBase), 1182, Mesa    );
}

#define glBindFragDataLocationEXT(arg1, arg2, arg3) \
    __inline_Mesa_glBindFragDataLocationEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline GLint __inline_Mesa_glGetFragDataLocationEXT(GLuint __arg1, const GLchar * __arg2, APTR __MesaBase)
{
    return AROS_LC2(GLint, glGetFragDataLocationEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(const GLchar *,(__arg2),A0),
        struct Library *, (__MesaBase), 1183, Mesa    );
}

#define glGetFragDataLocationEXT(arg1, arg2) \
    __inline_Mesa_glGetFragDataLocationEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform1uiEXT(GLint __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glUniform1uiEXT,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 1184, Mesa    );
}

#define glUniform1uiEXT(arg1, arg2) \
    __inline_Mesa_glUniform1uiEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform2uiEXT(GLint __arg1, GLuint __arg2, GLuint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform2uiEXT,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        struct Library *, (__MesaBase), 1185, Mesa    );
}

#define glUniform2uiEXT(arg1, arg2, arg3) \
    __inline_Mesa_glUniform2uiEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform3uiEXT(GLint __arg1, GLuint __arg2, GLuint __arg3, GLuint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glUniform3uiEXT,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        struct Library *, (__MesaBase), 1186, Mesa    );
}

#define glUniform3uiEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glUniform3uiEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform4uiEXT(GLint __arg1, GLuint __arg2, GLuint __arg3, GLuint __arg4, GLuint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glUniform4uiEXT,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        AROS_LCA(GLuint,(__arg5),D4),
        struct Library *, (__MesaBase), 1187, Mesa    );
}

#define glUniform4uiEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glUniform4uiEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform1uivEXT(GLint __arg1, GLsizei __arg2, const GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform1uivEXT,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1188, Mesa    );
}

#define glUniform1uivEXT(arg1, arg2, arg3) \
    __inline_Mesa_glUniform1uivEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform2uivEXT(GLint __arg1, GLsizei __arg2, const GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform2uivEXT,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1189, Mesa    );
}

#define glUniform2uivEXT(arg1, arg2, arg3) \
    __inline_Mesa_glUniform2uivEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform3uivEXT(GLint __arg1, GLsizei __arg2, const GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform3uivEXT,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1190, Mesa    );
}

#define glUniform3uivEXT(arg1, arg2, arg3) \
    __inline_Mesa_glUniform3uivEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glUniform4uivEXT(GLint __arg1, GLsizei __arg2, const GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glUniform4uivEXT,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1191, Mesa    );
}

#define glUniform4uivEXT(arg1, arg2, arg3) \
    __inline_Mesa_glUniform4uivEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexParameterIivEXT(GLenum __arg1, GLenum __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexParameterIivEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1192, Mesa    );
}

#define glTexParameterIivEXT(arg1, arg2, arg3) \
    __inline_Mesa_glTexParameterIivEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTexParameterIuivEXT(GLenum __arg1, GLenum __arg2, const GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTexParameterIuivEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1193, Mesa    );
}

#define glTexParameterIuivEXT(arg1, arg2, arg3) \
    __inline_Mesa_glTexParameterIuivEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTexParameterIivEXT(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetTexParameterIivEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1194, Mesa    );
}

#define glGetTexParameterIivEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetTexParameterIivEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTexParameterIuivEXT(GLenum __arg1, GLenum __arg2, GLuint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetTexParameterIuivEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLuint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1195, Mesa    );
}

#define glGetTexParameterIuivEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetTexParameterIuivEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glClearColorIiEXT(GLint __arg1, GLint __arg2, GLint __arg3, GLint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glClearColorIiEXT,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        struct Library *, (__MesaBase), 1196, Mesa    );
}

#define glClearColorIiEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glClearColorIiEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glClearColorIuiEXT(GLuint __arg1, GLuint __arg2, GLuint __arg3, GLuint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glClearColorIuiEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLuint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        struct Library *, (__MesaBase), 1197, Mesa    );
}

#define glClearColorIuiEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glClearColorIuiEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glUseShaderProgramEXT(GLenum __arg1, GLuint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glUseShaderProgramEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        struct Library *, (__MesaBase), 1198, Mesa    );
}

#define glUseShaderProgramEXT(arg1, arg2) \
    __inline_Mesa_glUseShaderProgramEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glActiveProgramEXT(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glActiveProgramEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 1199, Mesa    );
}

#define glActiveProgramEXT(arg1) \
    __inline_Mesa_glActiveProgramEXT((arg1), (APTR)MesaBase)

static inline GLuint __inline_Mesa_glCreateShaderProgramEXT(GLenum __arg1, const GLchar * __arg2, APTR __MesaBase)
{
    return AROS_LC2(GLuint, glCreateShaderProgramEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLchar *,(__arg2),A0),
        struct Library *, (__MesaBase), 1200, Mesa    );
}

#define glCreateShaderProgramEXT(arg1, arg2) \
    __inline_Mesa_glCreateShaderProgramEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramEnvParameters4fvEXT(GLenum __arg1, GLuint __arg2, GLsizei __arg3, const GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glProgramEnvParameters4fvEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(const GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 1201, Mesa    );
}

#define glProgramEnvParameters4fvEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glProgramEnvParameters4fvEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glProgramLocalParameters4fvEXT(GLenum __arg1, GLuint __arg2, GLsizei __arg3, const GLfloat * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glProgramLocalParameters4fvEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLuint,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(const GLfloat *,(__arg4),A0),
        struct Library *, (__MesaBase), 1202, Mesa    );
}

#define glProgramLocalParameters4fvEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glProgramLocalParameters4fvEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glBlendEquationSeparateATI(GLenum __arg1, GLenum __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBlendEquationSeparateATI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        struct Library *, (__MesaBase), 1203, Mesa    );
}

#define glBlendEquationSeparateATI(arg1, arg2) \
    __inline_Mesa_glBlendEquationSeparateATI((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetHistogramEXT(GLenum __arg1, GLboolean __arg2, GLenum __arg3, GLenum __arg4, GLvoid * __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glGetHistogramEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLboolean,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLvoid *,(__arg5),A0),
        struct Library *, (__MesaBase), 1204, Mesa    );
}

#define glGetHistogramEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glGetHistogramEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glGetHistogramParameterfvEXT(GLenum __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetHistogramParameterfvEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 1205, Mesa    );
}

#define glGetHistogramParameterfvEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetHistogramParameterfvEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetHistogramParameterivEXT(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetHistogramParameterivEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1206, Mesa    );
}

#define glGetHistogramParameterivEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetHistogramParameterivEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetMinmaxEXT(GLenum __arg1, GLboolean __arg2, GLenum __arg3, GLenum __arg4, GLvoid * __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glGetMinmaxEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLboolean,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLvoid *,(__arg5),A0),
        struct Library *, (__MesaBase), 1207, Mesa    );
}

#define glGetMinmaxEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glGetMinmaxEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glGetMinmaxParameterfvEXT(GLenum __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetMinmaxParameterfvEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 1208, Mesa    );
}

#define glGetMinmaxParameterfvEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetMinmaxParameterfvEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetMinmaxParameterivEXT(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetMinmaxParameterivEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1209, Mesa    );
}

#define glGetMinmaxParameterivEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetMinmaxParameterivEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glHistogramEXT(GLenum __arg1, GLsizei __arg2, GLenum __arg3, GLboolean __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glHistogramEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLboolean,(__arg4),D3),
        struct Library *, (__MesaBase), 1210, Mesa    );
}

#define glHistogramEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glHistogramEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glMinmaxEXT(GLenum __arg1, GLenum __arg2, GLboolean __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glMinmaxEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLboolean,(__arg3),D2),
        struct Library *, (__MesaBase), 1211, Mesa    );
}

#define glMinmaxEXT(arg1, arg2, arg3) \
    __inline_Mesa_glMinmaxEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glResetHistogramEXT(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glResetHistogramEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 1212, Mesa    );
}

#define glResetHistogramEXT(arg1) \
    __inline_Mesa_glResetHistogramEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glResetMinmaxEXT(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glResetMinmaxEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 1213, Mesa    );
}

#define glResetMinmaxEXT(arg1) \
    __inline_Mesa_glResetMinmaxEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glConvolutionFilter1DEXT(GLenum __arg1, GLenum __arg2, GLsizei __arg3, GLenum __arg4, GLenum __arg5, const GLvoid * __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glConvolutionFilter1DEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(const GLvoid *,(__arg6),A0),
        struct Library *, (__MesaBase), 1214, Mesa    );
}

#define glConvolutionFilter1DEXT(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glConvolutionFilter1DEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glConvolutionFilter2DEXT(GLenum __arg1, GLenum __arg2, GLsizei __arg3, GLsizei __arg4, GLenum __arg5, GLenum __arg6, const GLvoid * __arg7, APTR __MesaBase)
{
    AROS_LC7NR(void, glConvolutionFilter2DEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(GLenum,(__arg6),D5),
        AROS_LCA(const GLvoid *,(__arg7),A0),
        struct Library *, (__MesaBase), 1215, Mesa    );
}

#define glConvolutionFilter2DEXT(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Mesa_glConvolutionFilter2DEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)MesaBase)

static inline void __inline_Mesa_glConvolutionParameterfEXT(GLenum __arg1, GLenum __arg2, GLfloat __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glConvolutionParameterfEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat,(__arg3),D2),
        struct Library *, (__MesaBase), 1216, Mesa    );
}

#define glConvolutionParameterfEXT(arg1, arg2, arg3) \
    __inline_Mesa_glConvolutionParameterfEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glConvolutionParameterfvEXT(GLenum __arg1, GLenum __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glConvolutionParameterfvEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 1217, Mesa    );
}

#define glConvolutionParameterfvEXT(arg1, arg2, arg3) \
    __inline_Mesa_glConvolutionParameterfvEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glConvolutionParameteriEXT(GLenum __arg1, GLenum __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glConvolutionParameteriEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 1218, Mesa    );
}

#define glConvolutionParameteriEXT(arg1, arg2, arg3) \
    __inline_Mesa_glConvolutionParameteriEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glConvolutionParameterivEXT(GLenum __arg1, GLenum __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glConvolutionParameterivEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1219, Mesa    );
}

#define glConvolutionParameterivEXT(arg1, arg2, arg3) \
    __inline_Mesa_glConvolutionParameterivEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyConvolutionFilter1DEXT(GLenum __arg1, GLenum __arg2, GLint __arg3, GLint __arg4, GLsizei __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glCopyConvolutionFilter1DEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        struct Library *, (__MesaBase), 1220, Mesa    );
}

#define glCopyConvolutionFilter1DEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glCopyConvolutionFilter1DEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyConvolutionFilter2DEXT(GLenum __arg1, GLenum __arg2, GLint __arg3, GLint __arg4, GLsizei __arg5, GLsizei __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glCopyConvolutionFilter2DEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        AROS_LCA(GLsizei,(__arg6),D5),
        struct Library *, (__MesaBase), 1221, Mesa    );
}

#define glCopyConvolutionFilter2DEXT(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glCopyConvolutionFilter2DEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glGetConvolutionFilterEXT(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetConvolutionFilterEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 1222, Mesa    );
}

#define glGetConvolutionFilterEXT(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetConvolutionFilterEXT((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetConvolutionParameterfvEXT(GLenum __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetConvolutionParameterfvEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 1223, Mesa    );
}

#define glGetConvolutionParameterfvEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetConvolutionParameterfvEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetConvolutionParameterivEXT(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetConvolutionParameterivEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1224, Mesa    );
}

#define glGetConvolutionParameterivEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetConvolutionParameterivEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetSeparableFilterEXT(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLvoid * __arg4, GLvoid * __arg5, GLvoid * __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glGetSeparableFilterEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLvoid *,(__arg4),A0),
        AROS_LCA(GLvoid *,(__arg5),A1),
        AROS_LCA(GLvoid *,(__arg6),A2),
        struct Library *, (__MesaBase), 1225, Mesa    );
}

#define glGetSeparableFilterEXT(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glGetSeparableFilterEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glSeparableFilter2DEXT(GLenum __arg1, GLenum __arg2, GLsizei __arg3, GLsizei __arg4, GLenum __arg5, GLenum __arg6, const GLvoid * __arg7, const GLvoid * __arg8, APTR __MesaBase)
{
    AROS_LC8NR(void, glSeparableFilter2DEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLsizei,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(GLenum,(__arg6),D5),
        AROS_LCA(const GLvoid *,(__arg7),A0),
        AROS_LCA(const GLvoid *,(__arg8),A1),
        struct Library *, (__MesaBase), 1226, Mesa    );
}

#define glSeparableFilter2DEXT(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
    __inline_Mesa_glSeparableFilter2DEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (APTR)MesaBase)

static inline void __inline_Mesa_glColorTableSGI(GLenum __arg1, GLenum __arg2, GLsizei __arg3, GLenum __arg4, GLenum __arg5, const GLvoid * __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glColorTableSGI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(const GLvoid *,(__arg6),A0),
        struct Library *, (__MesaBase), 1227, Mesa    );
}

#define glColorTableSGI(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glColorTableSGI((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glColorTableParameterfvSGI(GLenum __arg1, GLenum __arg2, const GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glColorTableParameterfvSGI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 1228, Mesa    );
}

#define glColorTableParameterfvSGI(arg1, arg2, arg3) \
    __inline_Mesa_glColorTableParameterfvSGI((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glColorTableParameterivSGI(GLenum __arg1, GLenum __arg2, const GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glColorTableParameterivSGI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(const GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1229, Mesa    );
}

#define glColorTableParameterivSGI(arg1, arg2, arg3) \
    __inline_Mesa_glColorTableParameterivSGI((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyColorTableSGI(GLenum __arg1, GLenum __arg2, GLint __arg3, GLint __arg4, GLsizei __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glCopyColorTableSGI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        struct Library *, (__MesaBase), 1230, Mesa    );
}

#define glCopyColorTableSGI(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glCopyColorTableSGI((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glGetColorTableSGI(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLvoid * __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glGetColorTableSGI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLvoid *,(__arg4),A0),
        struct Library *, (__MesaBase), 1231, Mesa    );
}

#define glGetColorTableSGI(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glGetColorTableSGI((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glGetColorTableParameterfvSGI(GLenum __arg1, GLenum __arg2, GLfloat * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetColorTableParameterfvSGI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLfloat *,(__arg3),A0),
        struct Library *, (__MesaBase), 1232, Mesa    );
}

#define glGetColorTableParameterfvSGI(arg1, arg2, arg3) \
    __inline_Mesa_glGetColorTableParameterfvSGI((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetColorTableParameterivSGI(GLenum __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetColorTableParameterivSGI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1233, Mesa    );
}

#define glGetColorTableParameterivSGI(arg1, arg2, arg3) \
    __inline_Mesa_glGetColorTableParameterivSGI((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glPixelTexGenSGIX(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glPixelTexGenSGIX,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 1234, Mesa    );
}

#define glPixelTexGenSGIX(arg1) \
    __inline_Mesa_glPixelTexGenSGIX((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glPixelTexGenParameteriSGIS(GLenum __arg1, GLint __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPixelTexGenParameteriSGIS,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        struct Library *, (__MesaBase), 1235, Mesa    );
}

#define glPixelTexGenParameteriSGIS(arg1, arg2) \
    __inline_Mesa_glPixelTexGenParameteriSGIS((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPixelTexGenParameterivSGIS(GLenum __arg1, const GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPixelTexGenParameterivSGIS,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1236, Mesa    );
}

#define glPixelTexGenParameterivSGIS(arg1, arg2) \
    __inline_Mesa_glPixelTexGenParameterivSGIS((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPixelTexGenParameterfSGIS(GLenum __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPixelTexGenParameterfSGIS,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 1237, Mesa    );
}

#define glPixelTexGenParameterfSGIS(arg1, arg2) \
    __inline_Mesa_glPixelTexGenParameterfSGIS((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPixelTexGenParameterfvSGIS(GLenum __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPixelTexGenParameterfvSGIS,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 1238, Mesa    );
}

#define glPixelTexGenParameterfvSGIS(arg1, arg2) \
    __inline_Mesa_glPixelTexGenParameterfvSGIS((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetPixelTexGenParameterivSGIS(GLenum __arg1, GLint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGetPixelTexGenParameterivSGIS,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1239, Mesa    );
}

#define glGetPixelTexGenParameterivSGIS(arg1, arg2) \
    __inline_Mesa_glGetPixelTexGenParameterivSGIS((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGetPixelTexGenParameterfvSGIS(GLenum __arg1, GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGetPixelTexGenParameterfvSGIS,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 1240, Mesa    );
}

#define glGetPixelTexGenParameterfvSGIS(arg1, arg2) \
    __inline_Mesa_glGetPixelTexGenParameterfvSGIS((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glSampleMaskSGIS(GLclampf __arg1, GLboolean __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glSampleMaskSGIS,
        AROS_LCA(GLclampf,(__arg1),D0),
        AROS_LCA(GLboolean,(__arg2),D1),
        struct Library *, (__MesaBase), 1241, Mesa    );
}

#define glSampleMaskSGIS(arg1, arg2) \
    __inline_Mesa_glSampleMaskSGIS((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glSamplePatternSGIS(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSamplePatternSGIS,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 1242, Mesa    );
}

#define glSamplePatternSGIS(arg1) \
    __inline_Mesa_glSamplePatternSGIS((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glPointParameterfSGIS(GLenum __arg1, GLfloat __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPointParameterfSGIS,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLfloat,(__arg2),D1),
        struct Library *, (__MesaBase), 1243, Mesa    );
}

#define glPointParameterfSGIS(arg1, arg2) \
    __inline_Mesa_glPointParameterfSGIS((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glPointParameterfvSGIS(GLenum __arg1, const GLfloat * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glPointParameterfvSGIS,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(const GLfloat *,(__arg2),A0),
        struct Library *, (__MesaBase), 1244, Mesa    );
}

#define glPointParameterfvSGIS(arg1, arg2) \
    __inline_Mesa_glPointParameterfvSGIS((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glColorSubTableEXT(GLenum __arg1, GLsizei __arg2, GLsizei __arg3, GLenum __arg4, GLenum __arg5, const GLvoid * __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glColorSubTableEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLsizei,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        AROS_LCA(GLenum,(__arg5),D4),
        AROS_LCA(const GLvoid *,(__arg6),A0),
        struct Library *, (__MesaBase), 1245, Mesa    );
}

#define glColorSubTableEXT(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glColorSubTableEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glCopyColorSubTableEXT(GLenum __arg1, GLsizei __arg2, GLint __arg3, GLint __arg4, GLsizei __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glCopyColorSubTableEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLsizei,(__arg5),D4),
        struct Library *, (__MesaBase), 1246, Mesa    );
}

#define glCopyColorSubTableEXT(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glCopyColorSubTableEXT((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glBlendFuncSeparateINGR(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLenum __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glBlendFuncSeparateINGR,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        struct Library *, (__MesaBase), 1247, Mesa    );
}

#define glBlendFuncSeparateINGR(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glBlendFuncSeparateINGR((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiModeDrawArraysIBM(const GLenum * __arg1, const GLint * __arg2, const GLsizei * __arg3, GLsizei __arg4, GLint __arg5, APTR __MesaBase)
{
    AROS_LC5NR(void, glMultiModeDrawArraysIBM,
        AROS_LCA(const GLenum *,(__arg1),A0),
        AROS_LCA(const GLint *,(__arg2),A1),
        AROS_LCA(const GLsizei *,(__arg3),A2),
        AROS_LCA(GLsizei,(__arg4),D0),
        AROS_LCA(GLint,(__arg5),D1),
        struct Library *, (__MesaBase), 1248, Mesa    );
}

#define glMultiModeDrawArraysIBM(arg1, arg2, arg3, arg4, arg5) \
    __inline_Mesa_glMultiModeDrawArraysIBM((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)MesaBase)

static inline void __inline_Mesa_glMultiModeDrawElementsIBM(const GLenum * __arg1, const GLsizei * __arg2, GLenum __arg3, const GLvoid * const * __arg4, GLsizei __arg5, GLint __arg6, APTR __MesaBase)
{
    AROS_LC6NR(void, glMultiModeDrawElementsIBM,
        AROS_LCA(const GLenum *,(__arg1),A0),
        AROS_LCA(const GLsizei *,(__arg2),A1),
        AROS_LCA(GLenum,(__arg3),D0),
        AROS_LCA(const GLvoid * const *,(__arg4),A2),
        AROS_LCA(GLsizei,(__arg5),D1),
        AROS_LCA(GLint,(__arg6),D2),
        struct Library *, (__MesaBase), 1249, Mesa    );
}

#define glMultiModeDrawElementsIBM(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Mesa_glMultiModeDrawElementsIBM((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)MesaBase)

static inline void __inline_Mesa_glSampleMaskEXT(GLclampf __arg1, GLboolean __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glSampleMaskEXT,
        AROS_LCA(GLclampf,(__arg1),D0),
        AROS_LCA(GLboolean,(__arg2),D1),
        struct Library *, (__MesaBase), 1250, Mesa    );
}

#define glSampleMaskEXT(arg1, arg2) \
    __inline_Mesa_glSampleMaskEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glSamplePatternEXT(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glSamplePatternEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 1251, Mesa    );
}

#define glSamplePatternEXT(arg1) \
    __inline_Mesa_glSamplePatternEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteFencesNV(GLsizei __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDeleteFencesNV,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1252, Mesa    );
}

#define glDeleteFencesNV(arg1, arg2) \
    __inline_Mesa_glDeleteFencesNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGenFencesNV(GLsizei __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGenFencesNV,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1253, Mesa    );
}

#define glGenFencesNV(arg1, arg2) \
    __inline_Mesa_glGenFencesNV((arg1), (arg2), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsFenceNV(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsFenceNV,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 1254, Mesa    );
}

#define glIsFenceNV(arg1) \
    __inline_Mesa_glIsFenceNV((arg1), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glTestFenceNV(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glTestFenceNV,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 1255, Mesa    );
}

#define glTestFenceNV(arg1) \
    __inline_Mesa_glTestFenceNV((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glGetFenceivNV(GLuint __arg1, GLenum __arg2, GLint * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetFenceivNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint *,(__arg3),A0),
        struct Library *, (__MesaBase), 1256, Mesa    );
}

#define glGetFenceivNV(arg1, arg2, arg3) \
    __inline_Mesa_glGetFenceivNV((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glFinishFenceNV(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glFinishFenceNV,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 1257, Mesa    );
}

#define glFinishFenceNV(arg1) \
    __inline_Mesa_glFinishFenceNV((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glSetFenceNV(GLuint __arg1, GLenum __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glSetFenceNV,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        struct Library *, (__MesaBase), 1258, Mesa    );
}

#define glSetFenceNV(arg1, arg2) \
    __inline_Mesa_glSetFenceNV((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glActiveStencilFaceEXT(GLenum __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glActiveStencilFaceEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        struct Library *, (__MesaBase), 1259, Mesa    );
}

#define glActiveStencilFaceEXT(arg1) \
    __inline_Mesa_glActiveStencilFaceEXT((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glBindVertexArrayAPPLE(GLuint __arg1, APTR __MesaBase)
{
    AROS_LC1NR(void, glBindVertexArrayAPPLE,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 1260, Mesa    );
}

#define glBindVertexArrayAPPLE(arg1) \
    __inline_Mesa_glBindVertexArrayAPPLE((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glDeleteVertexArraysAPPLE(GLsizei __arg1, const GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDeleteVertexArraysAPPLE,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(const GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1261, Mesa    );
}

#define glDeleteVertexArraysAPPLE(arg1, arg2) \
    __inline_Mesa_glDeleteVertexArraysAPPLE((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glGenVertexArraysAPPLE(GLsizei __arg1, GLuint * __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glGenVertexArraysAPPLE,
        AROS_LCA(GLsizei,(__arg1),D0),
        AROS_LCA(GLuint *,(__arg2),A0),
        struct Library *, (__MesaBase), 1262, Mesa    );
}

#define glGenVertexArraysAPPLE(arg1, arg2) \
    __inline_Mesa_glGenVertexArraysAPPLE((arg1), (arg2), (APTR)MesaBase)

static inline GLboolean __inline_Mesa_glIsVertexArrayAPPLE(GLuint __arg1, APTR __MesaBase)
{
    return AROS_LC1(GLboolean, glIsVertexArrayAPPLE,
        AROS_LCA(GLuint,(__arg1),D0),
        struct Library *, (__MesaBase), 1263, Mesa    );
}

#define glIsVertexArrayAPPLE(arg1) \
    __inline_Mesa_glIsVertexArrayAPPLE((arg1), (APTR)MesaBase)

static inline void __inline_Mesa_glStencilOpSeparateATI(GLenum __arg1, GLenum __arg2, GLenum __arg3, GLenum __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glStencilOpSeparateATI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLenum,(__arg3),D2),
        AROS_LCA(GLenum,(__arg4),D3),
        struct Library *, (__MesaBase), 1264, Mesa    );
}

#define glStencilOpSeparateATI(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glStencilOpSeparateATI((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glStencilFuncSeparateATI(GLenum __arg1, GLenum __arg2, GLint __arg3, GLuint __arg4, APTR __MesaBase)
{
    AROS_LC4NR(void, glStencilFuncSeparateATI,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLuint,(__arg4),D3),
        struct Library *, (__MesaBase), 1265, Mesa    );
}

#define glStencilFuncSeparateATI(arg1, arg2, arg3, arg4) \
    __inline_Mesa_glStencilFuncSeparateATI((arg1), (arg2), (arg3), (arg4), (APTR)MesaBase)

static inline void __inline_Mesa_glDepthBoundsEXT(GLclampd __arg1, GLclampd __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glDepthBoundsEXT,
        AROS_LCA(GLclampd,(__arg1),D0),
        AROS_LCA(GLclampd,(__arg2),D1),
        struct Library *, (__MesaBase), 1266, Mesa    );
}

#define glDepthBoundsEXT(arg1, arg2) \
    __inline_Mesa_glDepthBoundsEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glBlendEquationSeparateEXT(GLenum __arg1, GLenum __arg2, APTR __MesaBase)
{
    AROS_LC2NR(void, glBlendEquationSeparateEXT,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        struct Library *, (__MesaBase), 1267, Mesa    );
}

#define glBlendEquationSeparateEXT(arg1, arg2) \
    __inline_Mesa_glBlendEquationSeparateEXT((arg1), (arg2), (APTR)MesaBase)

static inline void __inline_Mesa_glBlitFramebufferEXT(GLint __arg1, GLint __arg2, GLint __arg3, GLint __arg4, GLint __arg5, GLint __arg6, GLint __arg7, GLint __arg8, GLbitfield __arg9, GLenum __arg10, APTR __MesaBase)
{
    AROS_LC10NR(void, glBlitFramebufferEXT,
        AROS_LCA(GLint,(__arg1),D0),
        AROS_LCA(GLint,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        AROS_LCA(GLint,(__arg4),D3),
        AROS_LCA(GLint,(__arg5),D4),
        AROS_LCA(GLint,(__arg6),D5),
        AROS_LCA(GLint,(__arg7),D6),
        AROS_LCA(GLint,(__arg8),D7),
        AROS_LCA(GLbitfield,(__arg9),A0),
        AROS_LCA(GLenum,(__arg10),A1),
        struct Library *, (__MesaBase), 1268, Mesa    );
}

#define glBlitFramebufferEXT(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) \
    __inline_Mesa_glBlitFramebufferEXT((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (APTR)MesaBase)

static inline void __inline_Mesa_glGetQueryObjecti64vEXT(GLuint __arg1, GLenum __arg2, GLint64EXT * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetQueryObjecti64vEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint64EXT *,(__arg3),A0),
        struct Library *, (__MesaBase), 1269, Mesa    );
}

#define glGetQueryObjecti64vEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetQueryObjecti64vEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetQueryObjectui64vEXT(GLuint __arg1, GLenum __arg2, GLuint64EXT * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetQueryObjectui64vEXT,
        AROS_LCA(GLuint,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLuint64EXT *,(__arg3),A0),
        struct Library *, (__MesaBase), 1270, Mesa    );
}

#define glGetQueryObjectui64vEXT(arg1, arg2, arg3) \
    __inline_Mesa_glGetQueryObjectui64vEXT((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glBufferParameteriAPPLE(GLenum __arg1, GLenum __arg2, GLint __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glBufferParameteriAPPLE,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLint,(__arg3),D2),
        struct Library *, (__MesaBase), 1271, Mesa    );
}

#define glBufferParameteriAPPLE(arg1, arg2, arg3) \
    __inline_Mesa_glBufferParameteriAPPLE((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glFlushMappedBufferRangeAPPLE(GLenum __arg1, GLintptr __arg2, GLsizeiptr __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glFlushMappedBufferRangeAPPLE,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLintptr,(__arg2),D1),
        AROS_LCA(GLsizeiptr,(__arg3),D2),
        struct Library *, (__MesaBase), 1272, Mesa    );
}

#define glFlushMappedBufferRangeAPPLE(arg1, arg2, arg3) \
    __inline_Mesa_glFlushMappedBufferRangeAPPLE((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glTextureRangeAPPLE(GLenum __arg1, GLsizei __arg2, const GLvoid * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glTextureRangeAPPLE,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLsizei,(__arg2),D1),
        AROS_LCA(const GLvoid *,(__arg3),A0),
        struct Library *, (__MesaBase), 1273, Mesa    );
}

#define glTextureRangeAPPLE(arg1, arg2, arg3) \
    __inline_Mesa_glTextureRangeAPPLE((arg1), (arg2), (arg3), (APTR)MesaBase)

static inline void __inline_Mesa_glGetTexParameterPointervAPPLE(GLenum __arg1, GLenum __arg2, GLvoid *  * __arg3, APTR __MesaBase)
{
    AROS_LC3NR(void, glGetTexParameterPointervAPPLE,
        AROS_LCA(GLenum,(__arg1),D0),
        AROS_LCA(GLenum,(__arg2),D1),
        AROS_LCA(GLvoid *  *,(__arg3),A0),
        struct Library *, (__MesaBase), 1274, Mesa    );
}

#define glGetTexParameterPointervAPPLE(arg1, arg2, arg3) \
    __inline_Mesa_glGetTexParameterPointervAPPLE((arg1), (arg2), (arg3), (APTR)MesaBase)

#endif /* INLINE_MESA_H*/
