#ifndef INLINE_VEGA_H
#define INLINE_VEGA_H

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

/*
    Desc: Inline function for vega
*/

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


static inline APTR __inline_Vega_GetOpenVGStateTrackerApi(APTR __VegaBase)
{
    return AROS_LC0(APTR, GetOpenVGStateTrackerApi,
        struct Library *, (__VegaBase), 5, Vega    );
}

#define GetOpenVGStateTrackerApi() \
    __inline_Vega_GetOpenVGStateTrackerApi((APTR)VegaBase)

static inline VGErrorCode __inline_Vega_vgGetError(APTR __VegaBase)
{
    return AROS_LC0(VGErrorCode, vgGetError,
        struct Library *, (__VegaBase), 35, Vega    );
}

#define vgGetError() \
    __inline_Vega_vgGetError((APTR)VegaBase)

static inline void __inline_Vega_vgFlush(APTR __VegaBase)
{
    AROS_LC0NR(void, vgFlush,
        struct Library *, (__VegaBase), 36, Vega    );
}

#define vgFlush() \
    __inline_Vega_vgFlush((APTR)VegaBase)

static inline void __inline_Vega_vgFinish(APTR __VegaBase)
{
    AROS_LC0NR(void, vgFinish,
        struct Library *, (__VegaBase), 37, Vega    );
}

#define vgFinish() \
    __inline_Vega_vgFinish((APTR)VegaBase)

static inline void __inline_Vega_vgSetf(VGParamType __arg1, VGfloat __arg2, APTR __VegaBase)
{
    AROS_LC2NR(void, vgSetf,
        AROS_LCA(VGParamType,(__arg1),D0),
        AROS_LCA(VGfloat,(__arg2),D1),
        struct Library *, (__VegaBase), 38, Vega    );
}

#define vgSetf(arg1, arg2) \
    __inline_Vega_vgSetf((arg1), (arg2), (APTR)VegaBase)

static inline void __inline_Vega_vgSeti(VGParamType __arg1, VGint __arg2, APTR __VegaBase)
{
    AROS_LC2NR(void, vgSeti,
        AROS_LCA(VGParamType,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        struct Library *, (__VegaBase), 39, Vega    );
}

#define vgSeti(arg1, arg2) \
    __inline_Vega_vgSeti((arg1), (arg2), (APTR)VegaBase)

static inline void __inline_Vega_vgSetfv(VGParamType __arg1, VGint __arg2, const VGfloat * __arg3, APTR __VegaBase)
{
    AROS_LC3NR(void, vgSetfv,
        AROS_LCA(VGParamType,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(const VGfloat *,(__arg3),A0),
        struct Library *, (__VegaBase), 40, Vega    );
}

#define vgSetfv(arg1, arg2, arg3) \
    __inline_Vega_vgSetfv((arg1), (arg2), (arg3), (APTR)VegaBase)

static inline void __inline_Vega_vgSetiv(VGParamType __arg1, VGint __arg2, const VGint * __arg3, APTR __VegaBase)
{
    AROS_LC3NR(void, vgSetiv,
        AROS_LCA(VGParamType,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(const VGint *,(__arg3),A0),
        struct Library *, (__VegaBase), 41, Vega    );
}

#define vgSetiv(arg1, arg2, arg3) \
    __inline_Vega_vgSetiv((arg1), (arg2), (arg3), (APTR)VegaBase)

static inline VGfloat __inline_Vega_vgGetf(VGParamType __arg1, APTR __VegaBase)
{
    return AROS_LC1(VGfloat, vgGetf,
        AROS_LCA(VGParamType,(__arg1),D0),
        struct Library *, (__VegaBase), 42, Vega    );
}

#define vgGetf(arg1) \
    __inline_Vega_vgGetf((arg1), (APTR)VegaBase)

static inline VGint __inline_Vega_vgGeti(VGParamType __arg1, APTR __VegaBase)
{
    return AROS_LC1(VGint, vgGeti,
        AROS_LCA(VGParamType,(__arg1),D0),
        struct Library *, (__VegaBase), 43, Vega    );
}

#define vgGeti(arg1) \
    __inline_Vega_vgGeti((arg1), (APTR)VegaBase)

static inline VGint __inline_Vega_vgGetVectorSize(VGParamType __arg1, APTR __VegaBase)
{
    return AROS_LC1(VGint, vgGetVectorSize,
        AROS_LCA(VGParamType,(__arg1),D0),
        struct Library *, (__VegaBase), 44, Vega    );
}

#define vgGetVectorSize(arg1) \
    __inline_Vega_vgGetVectorSize((arg1), (APTR)VegaBase)

static inline void __inline_Vega_vgGetfv(VGParamType __arg1, VGint __arg2, VGfloat * __arg3, APTR __VegaBase)
{
    AROS_LC3NR(void, vgGetfv,
        AROS_LCA(VGParamType,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGfloat *,(__arg3),A0),
        struct Library *, (__VegaBase), 45, Vega    );
}

#define vgGetfv(arg1, arg2, arg3) \
    __inline_Vega_vgGetfv((arg1), (arg2), (arg3), (APTR)VegaBase)

static inline void __inline_Vega_vgGetiv(VGParamType __arg1, VGint __arg2, VGint * __arg3, APTR __VegaBase)
{
    AROS_LC3NR(void, vgGetiv,
        AROS_LCA(VGParamType,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint *,(__arg3),A0),
        struct Library *, (__VegaBase), 46, Vega    );
}

#define vgGetiv(arg1, arg2, arg3) \
    __inline_Vega_vgGetiv((arg1), (arg2), (arg3), (APTR)VegaBase)

static inline void __inline_Vega_vgSetParameterf(VGHandle __arg1, VGint __arg2, VGfloat __arg3, APTR __VegaBase)
{
    AROS_LC3NR(void, vgSetParameterf,
        AROS_LCA(VGHandle,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGfloat,(__arg3),D2),
        struct Library *, (__VegaBase), 47, Vega    );
}

#define vgSetParameterf(arg1, arg2, arg3) \
    __inline_Vega_vgSetParameterf((arg1), (arg2), (arg3), (APTR)VegaBase)

static inline void __inline_Vega_vgSetParameteri(VGHandle __arg1, VGint __arg2, VGint __arg3, APTR __VegaBase)
{
    AROS_LC3NR(void, vgSetParameteri,
        AROS_LCA(VGHandle,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        struct Library *, (__VegaBase), 48, Vega    );
}

#define vgSetParameteri(arg1, arg2, arg3) \
    __inline_Vega_vgSetParameteri((arg1), (arg2), (arg3), (APTR)VegaBase)

static inline void __inline_Vega_vgSetParameterfv(VGHandle __arg1, VGint __arg2, VGint __arg3, const VGfloat * __arg4, APTR __VegaBase)
{
    AROS_LC4NR(void, vgSetParameterfv,
        AROS_LCA(VGHandle,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(const VGfloat *,(__arg4),A0),
        struct Library *, (__VegaBase), 49, Vega    );
}

#define vgSetParameterfv(arg1, arg2, arg3, arg4) \
    __inline_Vega_vgSetParameterfv((arg1), (arg2), (arg3), (arg4), (APTR)VegaBase)

static inline void __inline_Vega_vgSetParameteriv(VGHandle __arg1, VGint __arg2, VGint __arg3, const VGint * __arg4, APTR __VegaBase)
{
    AROS_LC4NR(void, vgSetParameteriv,
        AROS_LCA(VGHandle,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(const VGint *,(__arg4),A0),
        struct Library *, (__VegaBase), 50, Vega    );
}

#define vgSetParameteriv(arg1, arg2, arg3, arg4) \
    __inline_Vega_vgSetParameteriv((arg1), (arg2), (arg3), (arg4), (APTR)VegaBase)

static inline VGfloat __inline_Vega_vgGetParameterf(VGHandle __arg1, VGint __arg2, APTR __VegaBase)
{
    return AROS_LC2(VGfloat, vgGetParameterf,
        AROS_LCA(VGHandle,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        struct Library *, (__VegaBase), 51, Vega    );
}

#define vgGetParameterf(arg1, arg2) \
    __inline_Vega_vgGetParameterf((arg1), (arg2), (APTR)VegaBase)

static inline VGint __inline_Vega_vgGetParameteri(VGHandle __arg1, VGint __arg2, APTR __VegaBase)
{
    return AROS_LC2(VGint, vgGetParameteri,
        AROS_LCA(VGHandle,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        struct Library *, (__VegaBase), 52, Vega    );
}

#define vgGetParameteri(arg1, arg2) \
    __inline_Vega_vgGetParameteri((arg1), (arg2), (APTR)VegaBase)

static inline VGint __inline_Vega_vgGetParameterVectorSize(VGHandle __arg1, VGint __arg2, APTR __VegaBase)
{
    return AROS_LC2(VGint, vgGetParameterVectorSize,
        AROS_LCA(VGHandle,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        struct Library *, (__VegaBase), 53, Vega    );
}

#define vgGetParameterVectorSize(arg1, arg2) \
    __inline_Vega_vgGetParameterVectorSize((arg1), (arg2), (APTR)VegaBase)

static inline void __inline_Vega_vgGetParameterfv(VGHandle __arg1, VGint __arg2, VGint __arg3, VGfloat * __arg4, APTR __VegaBase)
{
    AROS_LC4NR(void, vgGetParameterfv,
        AROS_LCA(VGHandle,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(VGfloat *,(__arg4),A0),
        struct Library *, (__VegaBase), 54, Vega    );
}

#define vgGetParameterfv(arg1, arg2, arg3, arg4) \
    __inline_Vega_vgGetParameterfv((arg1), (arg2), (arg3), (arg4), (APTR)VegaBase)

static inline void __inline_Vega_vgGetParameteriv(VGHandle __arg1, VGint __arg2, VGint __arg3, VGint * __arg4, APTR __VegaBase)
{
    AROS_LC4NR(void, vgGetParameteriv,
        AROS_LCA(VGHandle,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(VGint *,(__arg4),A0),
        struct Library *, (__VegaBase), 55, Vega    );
}

#define vgGetParameteriv(arg1, arg2, arg3, arg4) \
    __inline_Vega_vgGetParameteriv((arg1), (arg2), (arg3), (arg4), (APTR)VegaBase)

static inline void __inline_Vega_vgLoadIdentity(APTR __VegaBase)
{
    AROS_LC0NR(void, vgLoadIdentity,
        struct Library *, (__VegaBase), 56, Vega    );
}

#define vgLoadIdentity() \
    __inline_Vega_vgLoadIdentity((APTR)VegaBase)

static inline void __inline_Vega_vgLoadMatrix(const VGfloat * __arg1, APTR __VegaBase)
{
    AROS_LC1NR(void, vgLoadMatrix,
        AROS_LCA(const VGfloat *,(__arg1),A0),
        struct Library *, (__VegaBase), 57, Vega    );
}

#define vgLoadMatrix(arg1) \
    __inline_Vega_vgLoadMatrix((arg1), (APTR)VegaBase)

static inline void __inline_Vega_vgGetMatrix(VGfloat * __arg1, APTR __VegaBase)
{
    AROS_LC1NR(void, vgGetMatrix,
        AROS_LCA(VGfloat *,(__arg1),A0),
        struct Library *, (__VegaBase), 58, Vega    );
}

#define vgGetMatrix(arg1) \
    __inline_Vega_vgGetMatrix((arg1), (APTR)VegaBase)

static inline void __inline_Vega_vgMultMatrix(const VGfloat * __arg1, APTR __VegaBase)
{
    AROS_LC1NR(void, vgMultMatrix,
        AROS_LCA(const VGfloat *,(__arg1),A0),
        struct Library *, (__VegaBase), 59, Vega    );
}

#define vgMultMatrix(arg1) \
    __inline_Vega_vgMultMatrix((arg1), (APTR)VegaBase)

static inline void __inline_Vega_vgTranslate(VGfloat __arg1, VGfloat __arg2, APTR __VegaBase)
{
    AROS_LC2NR(void, vgTranslate,
        AROS_LCA(VGfloat,(__arg1),D0),
        AROS_LCA(VGfloat,(__arg2),D1),
        struct Library *, (__VegaBase), 60, Vega    );
}

#define vgTranslate(arg1, arg2) \
    __inline_Vega_vgTranslate((arg1), (arg2), (APTR)VegaBase)

static inline void __inline_Vega_vgScale(VGfloat __arg1, VGfloat __arg2, APTR __VegaBase)
{
    AROS_LC2NR(void, vgScale,
        AROS_LCA(VGfloat,(__arg1),D0),
        AROS_LCA(VGfloat,(__arg2),D1),
        struct Library *, (__VegaBase), 61, Vega    );
}

#define vgScale(arg1, arg2) \
    __inline_Vega_vgScale((arg1), (arg2), (APTR)VegaBase)

static inline void __inline_Vega_vgShear(VGfloat __arg1, VGfloat __arg2, APTR __VegaBase)
{
    AROS_LC2NR(void, vgShear,
        AROS_LCA(VGfloat,(__arg1),D0),
        AROS_LCA(VGfloat,(__arg2),D1),
        struct Library *, (__VegaBase), 62, Vega    );
}

#define vgShear(arg1, arg2) \
    __inline_Vega_vgShear((arg1), (arg2), (APTR)VegaBase)

static inline void __inline_Vega_vgRotate(VGfloat __arg1, APTR __VegaBase)
{
    AROS_LC1NR(void, vgRotate,
        AROS_LCA(VGfloat,(__arg1),D0),
        struct Library *, (__VegaBase), 63, Vega    );
}

#define vgRotate(arg1) \
    __inline_Vega_vgRotate((arg1), (APTR)VegaBase)

static inline void __inline_Vega_vgMask(VGHandle __arg1, VGMaskOperation __arg2, VGint __arg3, VGint __arg4, VGint __arg5, VGint __arg6, APTR __VegaBase)
{
    AROS_LC6NR(void, vgMask,
        AROS_LCA(VGHandle,(__arg1),D0),
        AROS_LCA(VGMaskOperation,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(VGint,(__arg4),D3),
        AROS_LCA(VGint,(__arg5),D4),
        AROS_LCA(VGint,(__arg6),D5),
        struct Library *, (__VegaBase), 64, Vega    );
}

#define vgMask(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Vega_vgMask((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)VegaBase)

static inline void __inline_Vega_vgRenderToMask(VGPath __arg1, VGbitfield __arg2, VGMaskOperation __arg3, APTR __VegaBase)
{
    AROS_LC3NR(void, vgRenderToMask,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGbitfield,(__arg2),D1),
        AROS_LCA(VGMaskOperation,(__arg3),D2),
        struct Library *, (__VegaBase), 65, Vega    );
}

#define vgRenderToMask(arg1, arg2, arg3) \
    __inline_Vega_vgRenderToMask((arg1), (arg2), (arg3), (APTR)VegaBase)

static inline VGMaskLayer __inline_Vega_vgCreateMaskLayer(VGint __arg1, VGint __arg2, APTR __VegaBase)
{
    return AROS_LC2(VGMaskLayer, vgCreateMaskLayer,
        AROS_LCA(VGint,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        struct Library *, (__VegaBase), 66, Vega    );
}

#define vgCreateMaskLayer(arg1, arg2) \
    __inline_Vega_vgCreateMaskLayer((arg1), (arg2), (APTR)VegaBase)

static inline void __inline_Vega_vgDestroyMaskLayer(VGMaskLayer __arg1, APTR __VegaBase)
{
    AROS_LC1NR(void, vgDestroyMaskLayer,
        AROS_LCA(VGMaskLayer,(__arg1),D0),
        struct Library *, (__VegaBase), 67, Vega    );
}

#define vgDestroyMaskLayer(arg1) \
    __inline_Vega_vgDestroyMaskLayer((arg1), (APTR)VegaBase)

static inline void __inline_Vega_vgFillMaskLayer(VGMaskLayer __arg1, VGint __arg2, VGint __arg3, VGint __arg4, VGint __arg5, VGfloat __arg6, APTR __VegaBase)
{
    AROS_LC6NR(void, vgFillMaskLayer,
        AROS_LCA(VGMaskLayer,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(VGint,(__arg4),D3),
        AROS_LCA(VGint,(__arg5),D4),
        AROS_LCA(VGfloat,(__arg6),D5),
        struct Library *, (__VegaBase), 68, Vega    );
}

#define vgFillMaskLayer(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Vega_vgFillMaskLayer((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)VegaBase)

static inline void __inline_Vega_vgCopyMask(VGMaskLayer __arg1, VGint __arg2, VGint __arg3, VGint __arg4, VGint __arg5, VGint __arg6, VGint __arg7, APTR __VegaBase)
{
    AROS_LC7NR(void, vgCopyMask,
        AROS_LCA(VGMaskLayer,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(VGint,(__arg4),D3),
        AROS_LCA(VGint,(__arg5),D4),
        AROS_LCA(VGint,(__arg6),D5),
        AROS_LCA(VGint,(__arg7),D6),
        struct Library *, (__VegaBase), 69, Vega    );
}

#define vgCopyMask(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Vega_vgCopyMask((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)VegaBase)

static inline void __inline_Vega_vgClear(VGint __arg1, VGint __arg2, VGint __arg3, VGint __arg4, APTR __VegaBase)
{
    AROS_LC4NR(void, vgClear,
        AROS_LCA(VGint,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(VGint,(__arg4),D3),
        struct Library *, (__VegaBase), 70, Vega    );
}

#define vgClear(arg1, arg2, arg3, arg4) \
    __inline_Vega_vgClear((arg1), (arg2), (arg3), (arg4), (APTR)VegaBase)

static inline VGPath __inline_Vega_vgCreatePath(VGint __arg1, VGPathDatatype __arg2, VGfloat __arg3, VGfloat __arg4, VGint __arg5, VGint __arg6, VGbitfield __arg7, APTR __VegaBase)
{
    return AROS_LC7(VGPath, vgCreatePath,
        AROS_LCA(VGint,(__arg1),D0),
        AROS_LCA(VGPathDatatype,(__arg2),D1),
        AROS_LCA(VGfloat,(__arg3),D2),
        AROS_LCA(VGfloat,(__arg4),D3),
        AROS_LCA(VGint,(__arg5),D4),
        AROS_LCA(VGint,(__arg6),D5),
        AROS_LCA(VGbitfield,(__arg7),D6),
        struct Library *, (__VegaBase), 71, Vega    );
}

#define vgCreatePath(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Vega_vgCreatePath((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)VegaBase)

static inline void __inline_Vega_vgClearPath(VGPath __arg1, VGbitfield __arg2, APTR __VegaBase)
{
    AROS_LC2NR(void, vgClearPath,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGbitfield,(__arg2),D1),
        struct Library *, (__VegaBase), 72, Vega    );
}

#define vgClearPath(arg1, arg2) \
    __inline_Vega_vgClearPath((arg1), (arg2), (APTR)VegaBase)

static inline void __inline_Vega_vgDestroyPath(VGPath __arg1, APTR __VegaBase)
{
    AROS_LC1NR(void, vgDestroyPath,
        AROS_LCA(VGPath,(__arg1),D0),
        struct Library *, (__VegaBase), 73, Vega    );
}

#define vgDestroyPath(arg1) \
    __inline_Vega_vgDestroyPath((arg1), (APTR)VegaBase)

static inline void __inline_Vega_vgRemovePathCapabilities(VGPath __arg1, VGbitfield __arg2, APTR __VegaBase)
{
    AROS_LC2NR(void, vgRemovePathCapabilities,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGbitfield,(__arg2),D1),
        struct Library *, (__VegaBase), 74, Vega    );
}

#define vgRemovePathCapabilities(arg1, arg2) \
    __inline_Vega_vgRemovePathCapabilities((arg1), (arg2), (APTR)VegaBase)

static inline VGbitfield __inline_Vega_vgGetPathCapabilities(VGPath __arg1, APTR __VegaBase)
{
    return AROS_LC1(VGbitfield, vgGetPathCapabilities,
        AROS_LCA(VGPath,(__arg1),D0),
        struct Library *, (__VegaBase), 75, Vega    );
}

#define vgGetPathCapabilities(arg1) \
    __inline_Vega_vgGetPathCapabilities((arg1), (APTR)VegaBase)

static inline void __inline_Vega_vgAppendPath(VGPath __arg1, VGPath __arg2, APTR __VegaBase)
{
    AROS_LC2NR(void, vgAppendPath,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGPath,(__arg2),D1),
        struct Library *, (__VegaBase), 76, Vega    );
}

#define vgAppendPath(arg1, arg2) \
    __inline_Vega_vgAppendPath((arg1), (arg2), (APTR)VegaBase)

static inline void __inline_Vega_vgAppendPathData(VGPath __arg1, VGint __arg2, const VGubyte * __arg3, const void * __arg4, APTR __VegaBase)
{
    AROS_LC4NR(void, vgAppendPathData,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(const VGubyte *,(__arg3),A0),
        AROS_LCA(const void *,(__arg4),A1),
        struct Library *, (__VegaBase), 77, Vega    );
}

#define vgAppendPathData(arg1, arg2, arg3, arg4) \
    __inline_Vega_vgAppendPathData((arg1), (arg2), (arg3), (arg4), (APTR)VegaBase)

static inline void __inline_Vega_vgModifyPathCoords(VGPath __arg1, VGint __arg2, VGint __arg3, const void * __arg4, APTR __VegaBase)
{
    AROS_LC4NR(void, vgModifyPathCoords,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(const void *,(__arg4),A0),
        struct Library *, (__VegaBase), 78, Vega    );
}

#define vgModifyPathCoords(arg1, arg2, arg3, arg4) \
    __inline_Vega_vgModifyPathCoords((arg1), (arg2), (arg3), (arg4), (APTR)VegaBase)

static inline void __inline_Vega_vgTransformPath(VGPath __arg1, VGPath __arg2, APTR __VegaBase)
{
    AROS_LC2NR(void, vgTransformPath,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGPath,(__arg2),D1),
        struct Library *, (__VegaBase), 79, Vega    );
}

#define vgTransformPath(arg1, arg2) \
    __inline_Vega_vgTransformPath((arg1), (arg2), (APTR)VegaBase)

static inline VGboolean __inline_Vega_vgInterpolatePath(VGPath __arg1, VGPath __arg2, VGPath __arg3, VGfloat __arg4, APTR __VegaBase)
{
    return AROS_LC4(VGboolean, vgInterpolatePath,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGPath,(__arg2),D1),
        AROS_LCA(VGPath,(__arg3),D2),
        AROS_LCA(VGfloat,(__arg4),D3),
        struct Library *, (__VegaBase), 80, Vega    );
}

#define vgInterpolatePath(arg1, arg2, arg3, arg4) \
    __inline_Vega_vgInterpolatePath((arg1), (arg2), (arg3), (arg4), (APTR)VegaBase)

static inline VGfloat __inline_Vega_vgPathLength(VGPath __arg1, VGint __arg2, VGint __arg3, APTR __VegaBase)
{
    return AROS_LC3(VGfloat, vgPathLength,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        struct Library *, (__VegaBase), 81, Vega    );
}

#define vgPathLength(arg1, arg2, arg3) \
    __inline_Vega_vgPathLength((arg1), (arg2), (arg3), (APTR)VegaBase)

static inline void __inline_Vega_vgPointAlongPath(VGPath __arg1, VGint __arg2, VGint __arg3, VGfloat __arg4, VGfloat * __arg5, VGfloat * __arg6, VGfloat * __arg7, VGfloat * __arg8, APTR __VegaBase)
{
    AROS_LC8NR(void, vgPointAlongPath,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(VGfloat,(__arg4),D3),
        AROS_LCA(VGfloat *,(__arg5),A0),
        AROS_LCA(VGfloat *,(__arg6),A1),
        AROS_LCA(VGfloat *,(__arg7),A2),
        AROS_LCA(VGfloat *,(__arg8),A3),
        struct Library *, (__VegaBase), 82, Vega    );
}

#define vgPointAlongPath(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
    __inline_Vega_vgPointAlongPath((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (APTR)VegaBase)

static inline void __inline_Vega_vgPathBounds(VGPath __arg1, VGfloat * __arg2, VGfloat * __arg3, VGfloat * __arg4, VGfloat * __arg5, APTR __VegaBase)
{
    AROS_LC5NR(void, vgPathBounds,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGfloat *,(__arg2),A0),
        AROS_LCA(VGfloat *,(__arg3),A1),
        AROS_LCA(VGfloat *,(__arg4),A2),
        AROS_LCA(VGfloat *,(__arg5),A3),
        struct Library *, (__VegaBase), 83, Vega    );
}

#define vgPathBounds(arg1, arg2, arg3, arg4, arg5) \
    __inline_Vega_vgPathBounds((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)VegaBase)

static inline void __inline_Vega_vgPathTransformedBounds(VGPath __arg1, VGfloat * __arg2, VGfloat * __arg3, VGfloat * __arg4, VGfloat * __arg5, APTR __VegaBase)
{
    AROS_LC5NR(void, vgPathTransformedBounds,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGfloat *,(__arg2),A0),
        AROS_LCA(VGfloat *,(__arg3),A1),
        AROS_LCA(VGfloat *,(__arg4),A2),
        AROS_LCA(VGfloat *,(__arg5),A3),
        struct Library *, (__VegaBase), 84, Vega    );
}

#define vgPathTransformedBounds(arg1, arg2, arg3, arg4, arg5) \
    __inline_Vega_vgPathTransformedBounds((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)VegaBase)

static inline void __inline_Vega_vgDrawPath(VGPath __arg1, VGbitfield __arg2, APTR __VegaBase)
{
    AROS_LC2NR(void, vgDrawPath,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGbitfield,(__arg2),D1),
        struct Library *, (__VegaBase), 85, Vega    );
}

#define vgDrawPath(arg1, arg2) \
    __inline_Vega_vgDrawPath((arg1), (arg2), (APTR)VegaBase)

static inline VGPaint __inline_Vega_vgCreatePaint(APTR __VegaBase)
{
    return AROS_LC0(VGPaint, vgCreatePaint,
        struct Library *, (__VegaBase), 86, Vega    );
}

#define vgCreatePaint() \
    __inline_Vega_vgCreatePaint((APTR)VegaBase)

static inline void __inline_Vega_vgDestroyPaint(VGPaint __arg1, APTR __VegaBase)
{
    AROS_LC1NR(void, vgDestroyPaint,
        AROS_LCA(VGPaint,(__arg1),D0),
        struct Library *, (__VegaBase), 87, Vega    );
}

#define vgDestroyPaint(arg1) \
    __inline_Vega_vgDestroyPaint((arg1), (APTR)VegaBase)

static inline void __inline_Vega_vgSetPaint(VGPaint __arg1, VGbitfield __arg2, APTR __VegaBase)
{
    AROS_LC2NR(void, vgSetPaint,
        AROS_LCA(VGPaint,(__arg1),D0),
        AROS_LCA(VGbitfield,(__arg2),D1),
        struct Library *, (__VegaBase), 88, Vega    );
}

#define vgSetPaint(arg1, arg2) \
    __inline_Vega_vgSetPaint((arg1), (arg2), (APTR)VegaBase)

static inline VGPaint __inline_Vega_vgGetPaint(VGPaintMode __arg1, APTR __VegaBase)
{
    return AROS_LC1(VGPaint, vgGetPaint,
        AROS_LCA(VGPaintMode,(__arg1),D0),
        struct Library *, (__VegaBase), 89, Vega    );
}

#define vgGetPaint(arg1) \
    __inline_Vega_vgGetPaint((arg1), (APTR)VegaBase)

static inline void __inline_Vega_vgSetColor(VGPaint __arg1, VGuint __arg2, APTR __VegaBase)
{
    AROS_LC2NR(void, vgSetColor,
        AROS_LCA(VGPaint,(__arg1),D0),
        AROS_LCA(VGuint,(__arg2),D1),
        struct Library *, (__VegaBase), 90, Vega    );
}

#define vgSetColor(arg1, arg2) \
    __inline_Vega_vgSetColor((arg1), (arg2), (APTR)VegaBase)

static inline VGuint __inline_Vega_vgGetColor(VGPaint __arg1, APTR __VegaBase)
{
    return AROS_LC1(VGuint, vgGetColor,
        AROS_LCA(VGPaint,(__arg1),D0),
        struct Library *, (__VegaBase), 91, Vega    );
}

#define vgGetColor(arg1) \
    __inline_Vega_vgGetColor((arg1), (APTR)VegaBase)

static inline void __inline_Vega_vgPaintPattern(VGPaint __arg1, VGImage __arg2, APTR __VegaBase)
{
    AROS_LC2NR(void, vgPaintPattern,
        AROS_LCA(VGPaint,(__arg1),D0),
        AROS_LCA(VGImage,(__arg2),D1),
        struct Library *, (__VegaBase), 92, Vega    );
}

#define vgPaintPattern(arg1, arg2) \
    __inline_Vega_vgPaintPattern((arg1), (arg2), (APTR)VegaBase)

static inline VGImage __inline_Vega_vgCreateImage(VGImageFormat __arg1, VGint __arg2, VGint __arg3, VGbitfield __arg4, APTR __VegaBase)
{
    return AROS_LC4(VGImage, vgCreateImage,
        AROS_LCA(VGImageFormat,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(VGbitfield,(__arg4),D3),
        struct Library *, (__VegaBase), 93, Vega    );
}

#define vgCreateImage(arg1, arg2, arg3, arg4) \
    __inline_Vega_vgCreateImage((arg1), (arg2), (arg3), (arg4), (APTR)VegaBase)

static inline void __inline_Vega_vgDestroyImage(VGImage __arg1, APTR __VegaBase)
{
    AROS_LC1NR(void, vgDestroyImage,
        AROS_LCA(VGImage,(__arg1),D0),
        struct Library *, (__VegaBase), 94, Vega    );
}

#define vgDestroyImage(arg1) \
    __inline_Vega_vgDestroyImage((arg1), (APTR)VegaBase)

static inline void __inline_Vega_vgClearImage(VGImage __arg1, VGint __arg2, VGint __arg3, VGint __arg4, VGint __arg5, APTR __VegaBase)
{
    AROS_LC5NR(void, vgClearImage,
        AROS_LCA(VGImage,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(VGint,(__arg4),D3),
        AROS_LCA(VGint,(__arg5),D4),
        struct Library *, (__VegaBase), 95, Vega    );
}

#define vgClearImage(arg1, arg2, arg3, arg4, arg5) \
    __inline_Vega_vgClearImage((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)VegaBase)

static inline void __inline_Vega_vgImageSubData(VGImage __arg1, const void * __arg2, VGint __arg3, VGImageFormat __arg4, VGint __arg5, VGint __arg6, VGint __arg7, VGint __arg8, APTR __VegaBase)
{
    AROS_LC8NR(void, vgImageSubData,
        AROS_LCA(VGImage,(__arg1),D0),
        AROS_LCA(const void *,(__arg2),A0),
        AROS_LCA(VGint,(__arg3),D1),
        AROS_LCA(VGImageFormat,(__arg4),D2),
        AROS_LCA(VGint,(__arg5),D3),
        AROS_LCA(VGint,(__arg6),D4),
        AROS_LCA(VGint,(__arg7),D5),
        AROS_LCA(VGint,(__arg8),D6),
        struct Library *, (__VegaBase), 96, Vega    );
}

#define vgImageSubData(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
    __inline_Vega_vgImageSubData((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (APTR)VegaBase)

static inline void __inline_Vega_vgGetImageSubData(VGImage __arg1, void * __arg2, VGint __arg3, VGImageFormat __arg4, VGint __arg5, VGint __arg6, VGint __arg7, VGint __arg8, APTR __VegaBase)
{
    AROS_LC8NR(void, vgGetImageSubData,
        AROS_LCA(VGImage,(__arg1),D0),
        AROS_LCA(void *,(__arg2),A0),
        AROS_LCA(VGint,(__arg3),D1),
        AROS_LCA(VGImageFormat,(__arg4),D2),
        AROS_LCA(VGint,(__arg5),D3),
        AROS_LCA(VGint,(__arg6),D4),
        AROS_LCA(VGint,(__arg7),D5),
        AROS_LCA(VGint,(__arg8),D6),
        struct Library *, (__VegaBase), 97, Vega    );
}

#define vgGetImageSubData(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
    __inline_Vega_vgGetImageSubData((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (APTR)VegaBase)

static inline VGImage __inline_Vega_vgChildImage(VGImage __arg1, VGint __arg2, VGint __arg3, VGint __arg4, VGint __arg5, APTR __VegaBase)
{
    return AROS_LC5(VGImage, vgChildImage,
        AROS_LCA(VGImage,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(VGint,(__arg4),D3),
        AROS_LCA(VGint,(__arg5),D4),
        struct Library *, (__VegaBase), 98, Vega    );
}

#define vgChildImage(arg1, arg2, arg3, arg4, arg5) \
    __inline_Vega_vgChildImage((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)VegaBase)

static inline VGImage __inline_Vega_vgGetParent(VGImage __arg1, APTR __VegaBase)
{
    return AROS_LC1(VGImage, vgGetParent,
        AROS_LCA(VGImage,(__arg1),D0),
        struct Library *, (__VegaBase), 99, Vega    );
}

#define vgGetParent(arg1) \
    __inline_Vega_vgGetParent((arg1), (APTR)VegaBase)

static inline void __inline_Vega_vgCopyImage(VGImage __arg1, VGint __arg2, VGint __arg3, VGImage __arg4, VGint __arg5, VGint __arg6, VGint __arg7, VGint __arg8, VGboolean __arg9, APTR __VegaBase)
{
    AROS_LC9NR(void, vgCopyImage,
        AROS_LCA(VGImage,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(VGImage,(__arg4),D3),
        AROS_LCA(VGint,(__arg5),D4),
        AROS_LCA(VGint,(__arg6),D5),
        AROS_LCA(VGint,(__arg7),D6),
        AROS_LCA(VGint,(__arg8),D7),
        AROS_LCA(VGboolean,(__arg9),A0),
        struct Library *, (__VegaBase), 100, Vega    );
}

#define vgCopyImage(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Vega_vgCopyImage((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)VegaBase)

static inline void __inline_Vega_vgDrawImage(VGImage __arg1, APTR __VegaBase)
{
    AROS_LC1NR(void, vgDrawImage,
        AROS_LCA(VGImage,(__arg1),D0),
        struct Library *, (__VegaBase), 101, Vega    );
}

#define vgDrawImage(arg1) \
    __inline_Vega_vgDrawImage((arg1), (APTR)VegaBase)

static inline void __inline_Vega_vgSetPixels(VGint __arg1, VGint __arg2, VGImage __arg3, VGint __arg4, VGint __arg5, VGint __arg6, VGint __arg7, APTR __VegaBase)
{
    AROS_LC7NR(void, vgSetPixels,
        AROS_LCA(VGint,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGImage,(__arg3),D2),
        AROS_LCA(VGint,(__arg4),D3),
        AROS_LCA(VGint,(__arg5),D4),
        AROS_LCA(VGint,(__arg6),D5),
        AROS_LCA(VGint,(__arg7),D6),
        struct Library *, (__VegaBase), 102, Vega    );
}

#define vgSetPixels(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Vega_vgSetPixels((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)VegaBase)

static inline void __inline_Vega_vgWritePixels(const void * __arg1, VGint __arg2, VGImageFormat __arg3, VGint __arg4, VGint __arg5, VGint __arg6, VGint __arg7, APTR __VegaBase)
{
    AROS_LC7NR(void, vgWritePixels,
        AROS_LCA(const void *,(__arg1),A0),
        AROS_LCA(VGint,(__arg2),D0),
        AROS_LCA(VGImageFormat,(__arg3),D1),
        AROS_LCA(VGint,(__arg4),D2),
        AROS_LCA(VGint,(__arg5),D3),
        AROS_LCA(VGint,(__arg6),D4),
        AROS_LCA(VGint,(__arg7),D5),
        struct Library *, (__VegaBase), 103, Vega    );
}

#define vgWritePixels(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Vega_vgWritePixels((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)VegaBase)

static inline void __inline_Vega_vgGetPixels(VGImage __arg1, VGint __arg2, VGint __arg3, VGint __arg4, VGint __arg5, VGint __arg6, VGint __arg7, APTR __VegaBase)
{
    AROS_LC7NR(void, vgGetPixels,
        AROS_LCA(VGImage,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(VGint,(__arg4),D3),
        AROS_LCA(VGint,(__arg5),D4),
        AROS_LCA(VGint,(__arg6),D5),
        AROS_LCA(VGint,(__arg7),D6),
        struct Library *, (__VegaBase), 104, Vega    );
}

#define vgGetPixels(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Vega_vgGetPixels((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)VegaBase)

static inline void __inline_Vega_vgReadPixels(void * __arg1, VGint __arg2, VGImageFormat __arg3, VGint __arg4, VGint __arg5, VGint __arg6, VGint __arg7, APTR __VegaBase)
{
    AROS_LC7NR(void, vgReadPixels,
        AROS_LCA(void *,(__arg1),A0),
        AROS_LCA(VGint,(__arg2),D0),
        AROS_LCA(VGImageFormat,(__arg3),D1),
        AROS_LCA(VGint,(__arg4),D2),
        AROS_LCA(VGint,(__arg5),D3),
        AROS_LCA(VGint,(__arg6),D4),
        AROS_LCA(VGint,(__arg7),D5),
        struct Library *, (__VegaBase), 105, Vega    );
}

#define vgReadPixels(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Vega_vgReadPixels((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)VegaBase)

static inline void __inline_Vega_vgCopyPixels(VGint __arg1, VGint __arg2, VGint __arg3, VGint __arg4, VGint __arg5, VGint __arg6, APTR __VegaBase)
{
    AROS_LC6NR(void, vgCopyPixels,
        AROS_LCA(VGint,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(VGint,(__arg4),D3),
        AROS_LCA(VGint,(__arg5),D4),
        AROS_LCA(VGint,(__arg6),D5),
        struct Library *, (__VegaBase), 106, Vega    );
}

#define vgCopyPixels(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Vega_vgCopyPixels((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)VegaBase)

static inline VGFont __inline_Vega_vgCreateFont(VGint __arg1, APTR __VegaBase)
{
    return AROS_LC1(VGFont, vgCreateFont,
        AROS_LCA(VGint,(__arg1),D0),
        struct Library *, (__VegaBase), 107, Vega    );
}

#define vgCreateFont(arg1) \
    __inline_Vega_vgCreateFont((arg1), (APTR)VegaBase)

static inline void __inline_Vega_vgDestroyFont(VGFont __arg1, APTR __VegaBase)
{
    AROS_LC1NR(void, vgDestroyFont,
        AROS_LCA(VGFont,(__arg1),D0),
        struct Library *, (__VegaBase), 108, Vega    );
}

#define vgDestroyFont(arg1) \
    __inline_Vega_vgDestroyFont((arg1), (APTR)VegaBase)

static inline void __inline_Vega_vgSetGlyphToPath(VGFont __arg1, VGuint __arg2, VGPath __arg3, VGboolean __arg4, const VGfloat * __arg5, const VGfloat * __arg6, APTR __VegaBase)
{
    AROS_LC6NR(void, vgSetGlyphToPath,
        AROS_LCA(VGFont,(__arg1),D0),
        AROS_LCA(VGuint,(__arg2),D1),
        AROS_LCA(VGPath,(__arg3),D2),
        AROS_LCA(VGboolean,(__arg4),D3),
        AROS_LCA(const VGfloat *,(__arg5),A0),
        AROS_LCA(const VGfloat *,(__arg6),A1),
        struct Library *, (__VegaBase), 109, Vega    );
}

#define vgSetGlyphToPath(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Vega_vgSetGlyphToPath((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)VegaBase)

static inline void __inline_Vega_vgSetGlyphToImage(VGFont __arg1, VGuint __arg2, VGImage __arg3, const VGfloat * __arg4, const VGfloat * __arg5, APTR __VegaBase)
{
    AROS_LC5NR(void, vgSetGlyphToImage,
        AROS_LCA(VGFont,(__arg1),D0),
        AROS_LCA(VGuint,(__arg2),D1),
        AROS_LCA(VGImage,(__arg3),D2),
        AROS_LCA(const VGfloat *,(__arg4),A0),
        AROS_LCA(const VGfloat *,(__arg5),A1),
        struct Library *, (__VegaBase), 110, Vega    );
}

#define vgSetGlyphToImage(arg1, arg2, arg3, arg4, arg5) \
    __inline_Vega_vgSetGlyphToImage((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)VegaBase)

static inline void __inline_Vega_vgClearGlyph(VGFont __arg1, VGuint __arg2, APTR __VegaBase)
{
    AROS_LC2NR(void, vgClearGlyph,
        AROS_LCA(VGFont,(__arg1),D0),
        AROS_LCA(VGuint,(__arg2),D1),
        struct Library *, (__VegaBase), 111, Vega    );
}

#define vgClearGlyph(arg1, arg2) \
    __inline_Vega_vgClearGlyph((arg1), (arg2), (APTR)VegaBase)

static inline void __inline_Vega_vgDrawGlyph(VGFont __arg1, VGuint __arg2, VGbitfield __arg3, VGboolean __arg4, APTR __VegaBase)
{
    AROS_LC4NR(void, vgDrawGlyph,
        AROS_LCA(VGFont,(__arg1),D0),
        AROS_LCA(VGuint,(__arg2),D1),
        AROS_LCA(VGbitfield,(__arg3),D2),
        AROS_LCA(VGboolean,(__arg4),D3),
        struct Library *, (__VegaBase), 112, Vega    );
}

#define vgDrawGlyph(arg1, arg2, arg3, arg4) \
    __inline_Vega_vgDrawGlyph((arg1), (arg2), (arg3), (arg4), (APTR)VegaBase)

static inline void __inline_Vega_vgDrawGlyphs(VGFont __arg1, VGint __arg2, const VGuint * __arg3, const VGfloat * __arg4, const VGfloat * __arg5, VGbitfield __arg6, VGboolean __arg7, APTR __VegaBase)
{
    AROS_LC7NR(void, vgDrawGlyphs,
        AROS_LCA(VGFont,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        AROS_LCA(const VGuint *,(__arg3),A0),
        AROS_LCA(const VGfloat *,(__arg4),A1),
        AROS_LCA(const VGfloat *,(__arg5),A2),
        AROS_LCA(VGbitfield,(__arg6),D2),
        AROS_LCA(VGboolean,(__arg7),D3),
        struct Library *, (__VegaBase), 113, Vega    );
}

#define vgDrawGlyphs(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Vega_vgDrawGlyphs((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)VegaBase)

static inline void __inline_Vega_vgColorMatrix(VGImage __arg1, VGImage __arg2, const VGfloat * __arg3, APTR __VegaBase)
{
    AROS_LC3NR(void, vgColorMatrix,
        AROS_LCA(VGImage,(__arg1),D0),
        AROS_LCA(VGImage,(__arg2),D1),
        AROS_LCA(const VGfloat *,(__arg3),A0),
        struct Library *, (__VegaBase), 114, Vega    );
}

#define vgColorMatrix(arg1, arg2, arg3) \
    __inline_Vega_vgColorMatrix((arg1), (arg2), (arg3), (APTR)VegaBase)

static inline void __inline_Vega_vgConvolve(VGImage __arg1, VGImage __arg2, VGint __arg3, VGint __arg4, VGint __arg5, VGint __arg6, const VGshort * __arg7, VGfloat __arg8, VGfloat __arg9, VGTilingMode __arg10, APTR __VegaBase)
{
    AROS_LC10NR(void, vgConvolve,
        AROS_LCA(VGImage,(__arg1),D0),
        AROS_LCA(VGImage,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(VGint,(__arg4),D3),
        AROS_LCA(VGint,(__arg5),D4),
        AROS_LCA(VGint,(__arg6),D5),
        AROS_LCA(const VGshort *,(__arg7),A0),
        AROS_LCA(VGfloat,(__arg8),D6),
        AROS_LCA(VGfloat,(__arg9),D7),
        AROS_LCA(VGTilingMode,(__arg10),A1),
        struct Library *, (__VegaBase), 115, Vega    );
}

#define vgConvolve(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) \
    __inline_Vega_vgConvolve((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (APTR)VegaBase)

static inline void __inline_Vega_vgSeparableConvolve(VGImage __arg1, VGImage __arg2, VGint __arg3, VGint __arg4, VGint __arg5, VGint __arg6, const VGshort * __arg7, const VGshort * __arg8, VGfloat __arg9, VGfloat __arg10, VGTilingMode __arg11, APTR __VegaBase)
{
    AROS_LC11NR(void, vgSeparableConvolve,
        AROS_LCA(VGImage,(__arg1),D0),
        AROS_LCA(VGImage,(__arg2),D1),
        AROS_LCA(VGint,(__arg3),D2),
        AROS_LCA(VGint,(__arg4),D3),
        AROS_LCA(VGint,(__arg5),D4),
        AROS_LCA(VGint,(__arg6),D5),
        AROS_LCA(const VGshort *,(__arg7),A0),
        AROS_LCA(const VGshort *,(__arg8),A1),
        AROS_LCA(VGfloat,(__arg9),D6),
        AROS_LCA(VGfloat,(__arg10),D7),
        AROS_LCA(VGTilingMode,(__arg11),A2),
        struct Library *, (__VegaBase), 116, Vega    );
}

#define vgSeparableConvolve(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) \
    __inline_Vega_vgSeparableConvolve((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (arg11), (APTR)VegaBase)

static inline void __inline_Vega_vgGaussianBlur(VGImage __arg1, VGImage __arg2, VGfloat __arg3, VGfloat __arg4, VGTilingMode __arg5, APTR __VegaBase)
{
    AROS_LC5NR(void, vgGaussianBlur,
        AROS_LCA(VGImage,(__arg1),D0),
        AROS_LCA(VGImage,(__arg2),D1),
        AROS_LCA(VGfloat,(__arg3),D2),
        AROS_LCA(VGfloat,(__arg4),D3),
        AROS_LCA(VGTilingMode,(__arg5),D4),
        struct Library *, (__VegaBase), 117, Vega    );
}

#define vgGaussianBlur(arg1, arg2, arg3, arg4, arg5) \
    __inline_Vega_vgGaussianBlur((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)VegaBase)

static inline void __inline_Vega_vgLookup(VGImage __arg1, VGImage __arg2, const VGubyte * __arg3, const VGubyte * __arg4, const VGubyte * __arg5, const VGubyte * __arg6, VGboolean __arg7, VGboolean __arg8, APTR __VegaBase)
{
    AROS_LC8NR(void, vgLookup,
        AROS_LCA(VGImage,(__arg1),D0),
        AROS_LCA(VGImage,(__arg2),D1),
        AROS_LCA(const VGubyte *,(__arg3),A0),
        AROS_LCA(const VGubyte *,(__arg4),A1),
        AROS_LCA(const VGubyte *,(__arg5),A2),
        AROS_LCA(const VGubyte *,(__arg6),A3),
        AROS_LCA(VGboolean,(__arg7),D2),
        AROS_LCA(VGboolean,(__arg8),D3),
        struct Library *, (__VegaBase), 118, Vega    );
}

#define vgLookup(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
    __inline_Vega_vgLookup((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (APTR)VegaBase)

static inline void __inline_Vega_vgLookupSingle(VGImage __arg1, VGImage __arg2, const VGuint * __arg3, VGImageChannel __arg4, VGboolean __arg5, VGboolean __arg6, APTR __VegaBase)
{
    AROS_LC6NR(void, vgLookupSingle,
        AROS_LCA(VGImage,(__arg1),D0),
        AROS_LCA(VGImage,(__arg2),D1),
        AROS_LCA(const VGuint *,(__arg3),A0),
        AROS_LCA(VGImageChannel,(__arg4),D2),
        AROS_LCA(VGboolean,(__arg5),D3),
        AROS_LCA(VGboolean,(__arg6),D4),
        struct Library *, (__VegaBase), 119, Vega    );
}

#define vgLookupSingle(arg1, arg2, arg3, arg4, arg5, arg6) \
    __inline_Vega_vgLookupSingle((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)VegaBase)

static inline VGHardwareQueryResult __inline_Vega_vgHardwareQuery(VGHardwareQueryType __arg1, VGint __arg2, APTR __VegaBase)
{
    return AROS_LC2(VGHardwareQueryResult, vgHardwareQuery,
        AROS_LCA(VGHardwareQueryType,(__arg1),D0),
        AROS_LCA(VGint,(__arg2),D1),
        struct Library *, (__VegaBase), 120, Vega    );
}

#define vgHardwareQuery(arg1, arg2) \
    __inline_Vega_vgHardwareQuery((arg1), (arg2), (APTR)VegaBase)

static inline const VGubyte * __inline_Vega_vgGetString(VGStringID __arg1, APTR __VegaBase)
{
    return AROS_LC1(const VGubyte *, vgGetString,
        AROS_LCA(VGStringID,(__arg1),D0),
        struct Library *, (__VegaBase), 121, Vega    );
}

#define vgGetString(arg1) \
    __inline_Vega_vgGetString((arg1), (APTR)VegaBase)

static inline VGUErrorCode __inline_Vega_vguLine(VGPath __arg1, VGfloat __arg2, VGfloat __arg3, VGfloat __arg4, VGfloat __arg5, APTR __VegaBase)
{
    return AROS_LC5(VGUErrorCode, vguLine,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGfloat,(__arg2),D1),
        AROS_LCA(VGfloat,(__arg3),D2),
        AROS_LCA(VGfloat,(__arg4),D3),
        AROS_LCA(VGfloat,(__arg5),D4),
        struct Library *, (__VegaBase), 122, Vega    );
}

#define vguLine(arg1, arg2, arg3, arg4, arg5) \
    __inline_Vega_vguLine((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)VegaBase)

static inline VGUErrorCode __inline_Vega_vguPolygon(VGPath __arg1, const VGfloat * __arg2, VGint __arg3, VGboolean __arg4, APTR __VegaBase)
{
    return AROS_LC4(VGUErrorCode, vguPolygon,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(const VGfloat *,(__arg2),A0),
        AROS_LCA(VGint,(__arg3),D1),
        AROS_LCA(VGboolean,(__arg4),D2),
        struct Library *, (__VegaBase), 123, Vega    );
}

#define vguPolygon(arg1, arg2, arg3, arg4) \
    __inline_Vega_vguPolygon((arg1), (arg2), (arg3), (arg4), (APTR)VegaBase)

static inline VGUErrorCode __inline_Vega_vguRect(VGPath __arg1, VGfloat __arg2, VGfloat __arg3, VGfloat __arg4, VGfloat __arg5, APTR __VegaBase)
{
    return AROS_LC5(VGUErrorCode, vguRect,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGfloat,(__arg2),D1),
        AROS_LCA(VGfloat,(__arg3),D2),
        AROS_LCA(VGfloat,(__arg4),D3),
        AROS_LCA(VGfloat,(__arg5),D4),
        struct Library *, (__VegaBase), 124, Vega    );
}

#define vguRect(arg1, arg2, arg3, arg4, arg5) \
    __inline_Vega_vguRect((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)VegaBase)

static inline VGUErrorCode __inline_Vega_vguRoundRect(VGPath __arg1, VGfloat __arg2, VGfloat __arg3, VGfloat __arg4, VGfloat __arg5, VGfloat __arg6, VGfloat __arg7, APTR __VegaBase)
{
    return AROS_LC7(VGUErrorCode, vguRoundRect,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGfloat,(__arg2),D1),
        AROS_LCA(VGfloat,(__arg3),D2),
        AROS_LCA(VGfloat,(__arg4),D3),
        AROS_LCA(VGfloat,(__arg5),D4),
        AROS_LCA(VGfloat,(__arg6),D5),
        AROS_LCA(VGfloat,(__arg7),D6),
        struct Library *, (__VegaBase), 125, Vega    );
}

#define vguRoundRect(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __inline_Vega_vguRoundRect((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)VegaBase)

static inline VGUErrorCode __inline_Vega_vguEllipse(VGPath __arg1, VGfloat __arg2, VGfloat __arg3, VGfloat __arg4, VGfloat __arg5, APTR __VegaBase)
{
    return AROS_LC5(VGUErrorCode, vguEllipse,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGfloat,(__arg2),D1),
        AROS_LCA(VGfloat,(__arg3),D2),
        AROS_LCA(VGfloat,(__arg4),D3),
        AROS_LCA(VGfloat,(__arg5),D4),
        struct Library *, (__VegaBase), 126, Vega    );
}

#define vguEllipse(arg1, arg2, arg3, arg4, arg5) \
    __inline_Vega_vguEllipse((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)VegaBase)

static inline VGUErrorCode __inline_Vega_vguArc(VGPath __arg1, VGfloat __arg2, VGfloat __arg3, VGfloat __arg4, VGfloat __arg5, VGfloat __arg6, VGfloat __arg7, VGUArcType __arg8, APTR __VegaBase)
{
    return AROS_LC8(VGUErrorCode, vguArc,
        AROS_LCA(VGPath,(__arg1),D0),
        AROS_LCA(VGfloat,(__arg2),D1),
        AROS_LCA(VGfloat,(__arg3),D2),
        AROS_LCA(VGfloat,(__arg4),D3),
        AROS_LCA(VGfloat,(__arg5),D4),
        AROS_LCA(VGfloat,(__arg6),D5),
        AROS_LCA(VGfloat,(__arg7),D6),
        AROS_LCA(VGUArcType,(__arg8),D7),
        struct Library *, (__VegaBase), 127, Vega    );
}

#define vguArc(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \
    __inline_Vega_vguArc((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (APTR)VegaBase)

static inline VGUErrorCode __inline_Vega_vguComputeWarpQuadToSquare(VGfloat __arg1, VGfloat __arg2, VGfloat __arg3, VGfloat __arg4, VGfloat __arg5, VGfloat __arg6, VGfloat __arg7, VGfloat __arg8, VGfloat * __arg9, APTR __VegaBase)
{
    return AROS_LC9(VGUErrorCode, vguComputeWarpQuadToSquare,
        AROS_LCA(VGfloat,(__arg1),D0),
        AROS_LCA(VGfloat,(__arg2),D1),
        AROS_LCA(VGfloat,(__arg3),D2),
        AROS_LCA(VGfloat,(__arg4),D3),
        AROS_LCA(VGfloat,(__arg5),D4),
        AROS_LCA(VGfloat,(__arg6),D5),
        AROS_LCA(VGfloat,(__arg7),D6),
        AROS_LCA(VGfloat,(__arg8),D7),
        AROS_LCA(VGfloat *,(__arg9),A0),
        struct Library *, (__VegaBase), 128, Vega    );
}

#define vguComputeWarpQuadToSquare(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Vega_vguComputeWarpQuadToSquare((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)VegaBase)

static inline VGUErrorCode __inline_Vega_vguComputeWarpSquareToQuad(VGfloat __arg1, VGfloat __arg2, VGfloat __arg3, VGfloat __arg4, VGfloat __arg5, VGfloat __arg6, VGfloat __arg7, VGfloat __arg8, VGfloat * __arg9, APTR __VegaBase)
{
    return AROS_LC9(VGUErrorCode, vguComputeWarpSquareToQuad,
        AROS_LCA(VGfloat,(__arg1),D0),
        AROS_LCA(VGfloat,(__arg2),D1),
        AROS_LCA(VGfloat,(__arg3),D2),
        AROS_LCA(VGfloat,(__arg4),D3),
        AROS_LCA(VGfloat,(__arg5),D4),
        AROS_LCA(VGfloat,(__arg6),D5),
        AROS_LCA(VGfloat,(__arg7),D6),
        AROS_LCA(VGfloat,(__arg8),D7),
        AROS_LCA(VGfloat *,(__arg9),A0),
        struct Library *, (__VegaBase), 129, Vega    );
}

#define vguComputeWarpSquareToQuad(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __inline_Vega_vguComputeWarpSquareToQuad((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)VegaBase)

#endif /* INLINE_VEGA_H*/
