#ifndef DEFINES_VEGA_H
#define DEFINES_VEGA_H

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

/*
    Desc: Defines for vega
*/

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

__BEGIN_DECLS


#define __GetOpenVGStateTrackerApi_WB(__VegaBase) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC0(APTR, GetOpenVGStateTrackerApi, \
        struct Library *, (__VegaBase), 5, Vega);\
})

#define GetOpenVGStateTrackerApi() \
    __GetOpenVGStateTrackerApi_WB(VegaBase)

#define __vgGetError_WB(__VegaBase) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC0(VGErrorCode, vgGetError, \
        struct Library *, (__VegaBase), 35, Vega);\
})

#define vgGetError() \
    __vgGetError_WB(VegaBase)

#define __vgFlush_WB(__VegaBase) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC0NR(void, vgFlush, \
        struct Library *, (__VegaBase), 36, Vega);\
})

#define vgFlush() \
    __vgFlush_WB(VegaBase)

#define __vgFinish_WB(__VegaBase) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC0NR(void, vgFinish, \
        struct Library *, (__VegaBase), 37, Vega);\
})

#define vgFinish() \
    __vgFinish_WB(VegaBase)

#define __vgSetf_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2NR(void, vgSetf, \
                  AROS_LCA(VGParamType,(__arg1),D0), \
                  AROS_LCA(VGfloat,(__arg2),D1), \
        struct Library *, (__VegaBase), 38, Vega);\
})

#define vgSetf(arg1, arg2) \
    __vgSetf_WB(VegaBase, (arg1), (arg2))

#define __vgSeti_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2NR(void, vgSeti, \
                  AROS_LCA(VGParamType,(__arg1),D0), \
                  AROS_LCA(VGint,(__arg2),D1), \
        struct Library *, (__VegaBase), 39, Vega);\
})

#define vgSeti(arg1, arg2) \
    __vgSeti_WB(VegaBase, (arg1), (arg2))

#define __vgSetfv_WB(__VegaBase, __arg1, __arg2, __arg3) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgSetfv_WB(VegaBase, (arg1), (arg2), (arg3))

#define __vgSetiv_WB(__VegaBase, __arg1, __arg2, __arg3) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgSetiv_WB(VegaBase, (arg1), (arg2), (arg3))

#define __vgGetf_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1(VGfloat, vgGetf, \
                  AROS_LCA(VGParamType,(__arg1),D0), \
        struct Library *, (__VegaBase), 42, Vega);\
})

#define vgGetf(arg1) \
    __vgGetf_WB(VegaBase, (arg1))

#define __vgGeti_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1(VGint, vgGeti, \
                  AROS_LCA(VGParamType,(__arg1),D0), \
        struct Library *, (__VegaBase), 43, Vega);\
})

#define vgGeti(arg1) \
    __vgGeti_WB(VegaBase, (arg1))

#define __vgGetVectorSize_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1(VGint, vgGetVectorSize, \
                  AROS_LCA(VGParamType,(__arg1),D0), \
        struct Library *, (__VegaBase), 44, Vega);\
})

#define vgGetVectorSize(arg1) \
    __vgGetVectorSize_WB(VegaBase, (arg1))

#define __vgGetfv_WB(__VegaBase, __arg1, __arg2, __arg3) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgGetfv_WB(VegaBase, (arg1), (arg2), (arg3))

#define __vgGetiv_WB(__VegaBase, __arg1, __arg2, __arg3) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgGetiv_WB(VegaBase, (arg1), (arg2), (arg3))

#define __vgSetParameterf_WB(__VegaBase, __arg1, __arg2, __arg3) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgSetParameterf_WB(VegaBase, (arg1), (arg2), (arg3))

#define __vgSetParameteri_WB(__VegaBase, __arg1, __arg2, __arg3) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgSetParameteri_WB(VegaBase, (arg1), (arg2), (arg3))

#define __vgSetParameterfv_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgSetParameterfv_WB(VegaBase, (arg1), (arg2), (arg3), (arg4))

#define __vgSetParameteriv_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgSetParameteriv_WB(VegaBase, (arg1), (arg2), (arg3), (arg4))

#define __vgGetParameterf_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2(VGfloat, vgGetParameterf, \
                  AROS_LCA(VGHandle,(__arg1),D0), \
                  AROS_LCA(VGint,(__arg2),D1), \
        struct Library *, (__VegaBase), 51, Vega);\
})

#define vgGetParameterf(arg1, arg2) \
    __vgGetParameterf_WB(VegaBase, (arg1), (arg2))

#define __vgGetParameteri_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2(VGint, vgGetParameteri, \
                  AROS_LCA(VGHandle,(__arg1),D0), \
                  AROS_LCA(VGint,(__arg2),D1), \
        struct Library *, (__VegaBase), 52, Vega);\
})

#define vgGetParameteri(arg1, arg2) \
    __vgGetParameteri_WB(VegaBase, (arg1), (arg2))

#define __vgGetParameterVectorSize_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2(VGint, vgGetParameterVectorSize, \
                  AROS_LCA(VGHandle,(__arg1),D0), \
                  AROS_LCA(VGint,(__arg2),D1), \
        struct Library *, (__VegaBase), 53, Vega);\
})

#define vgGetParameterVectorSize(arg1, arg2) \
    __vgGetParameterVectorSize_WB(VegaBase, (arg1), (arg2))

#define __vgGetParameterfv_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgGetParameterfv_WB(VegaBase, (arg1), (arg2), (arg3), (arg4))

#define __vgGetParameteriv_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgGetParameteriv_WB(VegaBase, (arg1), (arg2), (arg3), (arg4))

#define __vgLoadIdentity_WB(__VegaBase) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC0NR(void, vgLoadIdentity, \
        struct Library *, (__VegaBase), 56, Vega);\
})

#define vgLoadIdentity() \
    __vgLoadIdentity_WB(VegaBase)

#define __vgLoadMatrix_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1NR(void, vgLoadMatrix, \
                  AROS_LCA(const VGfloat *,(__arg1),A0), \
        struct Library *, (__VegaBase), 57, Vega);\
})

#define vgLoadMatrix(arg1) \
    __vgLoadMatrix_WB(VegaBase, (arg1))

#define __vgGetMatrix_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1NR(void, vgGetMatrix, \
                  AROS_LCA(VGfloat *,(__arg1),A0), \
        struct Library *, (__VegaBase), 58, Vega);\
})

#define vgGetMatrix(arg1) \
    __vgGetMatrix_WB(VegaBase, (arg1))

#define __vgMultMatrix_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1NR(void, vgMultMatrix, \
                  AROS_LCA(const VGfloat *,(__arg1),A0), \
        struct Library *, (__VegaBase), 59, Vega);\
})

#define vgMultMatrix(arg1) \
    __vgMultMatrix_WB(VegaBase, (arg1))

#define __vgTranslate_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2NR(void, vgTranslate, \
                  AROS_LCA(VGfloat,(__arg1),D0), \
                  AROS_LCA(VGfloat,(__arg2),D1), \
        struct Library *, (__VegaBase), 60, Vega);\
})

#define vgTranslate(arg1, arg2) \
    __vgTranslate_WB(VegaBase, (arg1), (arg2))

#define __vgScale_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2NR(void, vgScale, \
                  AROS_LCA(VGfloat,(__arg1),D0), \
                  AROS_LCA(VGfloat,(__arg2),D1), \
        struct Library *, (__VegaBase), 61, Vega);\
})

#define vgScale(arg1, arg2) \
    __vgScale_WB(VegaBase, (arg1), (arg2))

#define __vgShear_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2NR(void, vgShear, \
                  AROS_LCA(VGfloat,(__arg1),D0), \
                  AROS_LCA(VGfloat,(__arg2),D1), \
        struct Library *, (__VegaBase), 62, Vega);\
})

#define vgShear(arg1, arg2) \
    __vgShear_WB(VegaBase, (arg1), (arg2))

#define __vgRotate_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1NR(void, vgRotate, \
                  AROS_LCA(VGfloat,(__arg1),D0), \
        struct Library *, (__VegaBase), 63, Vega);\
})

#define vgRotate(arg1) \
    __vgRotate_WB(VegaBase, (arg1))

#define __vgMask_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgMask_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6))

#define __vgRenderToMask_WB(__VegaBase, __arg1, __arg2, __arg3) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgRenderToMask_WB(VegaBase, (arg1), (arg2), (arg3))

#define __vgCreateMaskLayer_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2(VGMaskLayer, vgCreateMaskLayer, \
                  AROS_LCA(VGint,(__arg1),D0), \
                  AROS_LCA(VGint,(__arg2),D1), \
        struct Library *, (__VegaBase), 66, Vega);\
})

#define vgCreateMaskLayer(arg1, arg2) \
    __vgCreateMaskLayer_WB(VegaBase, (arg1), (arg2))

#define __vgDestroyMaskLayer_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1NR(void, vgDestroyMaskLayer, \
                  AROS_LCA(VGMaskLayer,(__arg1),D0), \
        struct Library *, (__VegaBase), 67, Vega);\
})

#define vgDestroyMaskLayer(arg1) \
    __vgDestroyMaskLayer_WB(VegaBase, (arg1))

#define __vgFillMaskLayer_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgFillMaskLayer_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6))

#define __vgCopyMask_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgCopyMask_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7))

#define __vgClear_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgClear_WB(VegaBase, (arg1), (arg2), (arg3), (arg4))

#define __vgCreatePath_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgCreatePath_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7))

#define __vgClearPath_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2NR(void, vgClearPath, \
                  AROS_LCA(VGPath,(__arg1),D0), \
                  AROS_LCA(VGbitfield,(__arg2),D1), \
        struct Library *, (__VegaBase), 72, Vega);\
})

#define vgClearPath(arg1, arg2) \
    __vgClearPath_WB(VegaBase, (arg1), (arg2))

#define __vgDestroyPath_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1NR(void, vgDestroyPath, \
                  AROS_LCA(VGPath,(__arg1),D0), \
        struct Library *, (__VegaBase), 73, Vega);\
})

#define vgDestroyPath(arg1) \
    __vgDestroyPath_WB(VegaBase, (arg1))

#define __vgRemovePathCapabilities_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2NR(void, vgRemovePathCapabilities, \
                  AROS_LCA(VGPath,(__arg1),D0), \
                  AROS_LCA(VGbitfield,(__arg2),D1), \
        struct Library *, (__VegaBase), 74, Vega);\
})

#define vgRemovePathCapabilities(arg1, arg2) \
    __vgRemovePathCapabilities_WB(VegaBase, (arg1), (arg2))

#define __vgGetPathCapabilities_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1(VGbitfield, vgGetPathCapabilities, \
                  AROS_LCA(VGPath,(__arg1),D0), \
        struct Library *, (__VegaBase), 75, Vega);\
})

#define vgGetPathCapabilities(arg1) \
    __vgGetPathCapabilities_WB(VegaBase, (arg1))

#define __vgAppendPath_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2NR(void, vgAppendPath, \
                  AROS_LCA(VGPath,(__arg1),D0), \
                  AROS_LCA(VGPath,(__arg2),D1), \
        struct Library *, (__VegaBase), 76, Vega);\
})

#define vgAppendPath(arg1, arg2) \
    __vgAppendPath_WB(VegaBase, (arg1), (arg2))

#define __vgAppendPathData_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgAppendPathData_WB(VegaBase, (arg1), (arg2), (arg3), (arg4))

#define __vgModifyPathCoords_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgModifyPathCoords_WB(VegaBase, (arg1), (arg2), (arg3), (arg4))

#define __vgTransformPath_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2NR(void, vgTransformPath, \
                  AROS_LCA(VGPath,(__arg1),D0), \
                  AROS_LCA(VGPath,(__arg2),D1), \
        struct Library *, (__VegaBase), 79, Vega);\
})

#define vgTransformPath(arg1, arg2) \
    __vgTransformPath_WB(VegaBase, (arg1), (arg2))

#define __vgInterpolatePath_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgInterpolatePath_WB(VegaBase, (arg1), (arg2), (arg3), (arg4))

#define __vgPathLength_WB(__VegaBase, __arg1, __arg2, __arg3) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgPathLength_WB(VegaBase, (arg1), (arg2), (arg3))

#define __vgPointAlongPath_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7, __arg8) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgPointAlongPath_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8))

#define __vgPathBounds_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgPathBounds_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5))

#define __vgPathTransformedBounds_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgPathTransformedBounds_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5))

#define __vgDrawPath_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2NR(void, vgDrawPath, \
                  AROS_LCA(VGPath,(__arg1),D0), \
                  AROS_LCA(VGbitfield,(__arg2),D1), \
        struct Library *, (__VegaBase), 85, Vega);\
})

#define vgDrawPath(arg1, arg2) \
    __vgDrawPath_WB(VegaBase, (arg1), (arg2))

#define __vgCreatePaint_WB(__VegaBase) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC0(VGPaint, vgCreatePaint, \
        struct Library *, (__VegaBase), 86, Vega);\
})

#define vgCreatePaint() \
    __vgCreatePaint_WB(VegaBase)

#define __vgDestroyPaint_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1NR(void, vgDestroyPaint, \
                  AROS_LCA(VGPaint,(__arg1),D0), \
        struct Library *, (__VegaBase), 87, Vega);\
})

#define vgDestroyPaint(arg1) \
    __vgDestroyPaint_WB(VegaBase, (arg1))

#define __vgSetPaint_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2NR(void, vgSetPaint, \
                  AROS_LCA(VGPaint,(__arg1),D0), \
                  AROS_LCA(VGbitfield,(__arg2),D1), \
        struct Library *, (__VegaBase), 88, Vega);\
})

#define vgSetPaint(arg1, arg2) \
    __vgSetPaint_WB(VegaBase, (arg1), (arg2))

#define __vgGetPaint_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1(VGPaint, vgGetPaint, \
                  AROS_LCA(VGPaintMode,(__arg1),D0), \
        struct Library *, (__VegaBase), 89, Vega);\
})

#define vgGetPaint(arg1) \
    __vgGetPaint_WB(VegaBase, (arg1))

#define __vgSetColor_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2NR(void, vgSetColor, \
                  AROS_LCA(VGPaint,(__arg1),D0), \
                  AROS_LCA(VGuint,(__arg2),D1), \
        struct Library *, (__VegaBase), 90, Vega);\
})

#define vgSetColor(arg1, arg2) \
    __vgSetColor_WB(VegaBase, (arg1), (arg2))

#define __vgGetColor_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1(VGuint, vgGetColor, \
                  AROS_LCA(VGPaint,(__arg1),D0), \
        struct Library *, (__VegaBase), 91, Vega);\
})

#define vgGetColor(arg1) \
    __vgGetColor_WB(VegaBase, (arg1))

#define __vgPaintPattern_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2NR(void, vgPaintPattern, \
                  AROS_LCA(VGPaint,(__arg1),D0), \
                  AROS_LCA(VGImage,(__arg2),D1), \
        struct Library *, (__VegaBase), 92, Vega);\
})

#define vgPaintPattern(arg1, arg2) \
    __vgPaintPattern_WB(VegaBase, (arg1), (arg2))

#define __vgCreateImage_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgCreateImage_WB(VegaBase, (arg1), (arg2), (arg3), (arg4))

#define __vgDestroyImage_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1NR(void, vgDestroyImage, \
                  AROS_LCA(VGImage,(__arg1),D0), \
        struct Library *, (__VegaBase), 94, Vega);\
})

#define vgDestroyImage(arg1) \
    __vgDestroyImage_WB(VegaBase, (arg1))

#define __vgClearImage_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgClearImage_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5))

#define __vgImageSubData_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7, __arg8) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgImageSubData_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8))

#define __vgGetImageSubData_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7, __arg8) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgGetImageSubData_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8))

#define __vgChildImage_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgChildImage_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5))

#define __vgGetParent_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1(VGImage, vgGetParent, \
                  AROS_LCA(VGImage,(__arg1),D0), \
        struct Library *, (__VegaBase), 99, Vega);\
})

#define vgGetParent(arg1) \
    __vgGetParent_WB(VegaBase, (arg1))

#define __vgCopyImage_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7, __arg8, __arg9) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgCopyImage_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9))

#define __vgDrawImage_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1NR(void, vgDrawImage, \
                  AROS_LCA(VGImage,(__arg1),D0), \
        struct Library *, (__VegaBase), 101, Vega);\
})

#define vgDrawImage(arg1) \
    __vgDrawImage_WB(VegaBase, (arg1))

#define __vgSetPixels_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgSetPixels_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7))

#define __vgWritePixels_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgWritePixels_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7))

#define __vgGetPixels_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgGetPixels_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7))

#define __vgReadPixels_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgReadPixels_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7))

#define __vgCopyPixels_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgCopyPixels_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6))

#define __vgCreateFont_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1(VGFont, vgCreateFont, \
                  AROS_LCA(VGint,(__arg1),D0), \
        struct Library *, (__VegaBase), 107, Vega);\
})

#define vgCreateFont(arg1) \
    __vgCreateFont_WB(VegaBase, (arg1))

#define __vgDestroyFont_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1NR(void, vgDestroyFont, \
                  AROS_LCA(VGFont,(__arg1),D0), \
        struct Library *, (__VegaBase), 108, Vega);\
})

#define vgDestroyFont(arg1) \
    __vgDestroyFont_WB(VegaBase, (arg1))

#define __vgSetGlyphToPath_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgSetGlyphToPath_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6))

#define __vgSetGlyphToImage_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgSetGlyphToImage_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5))

#define __vgClearGlyph_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2NR(void, vgClearGlyph, \
                  AROS_LCA(VGFont,(__arg1),D0), \
                  AROS_LCA(VGuint,(__arg2),D1), \
        struct Library *, (__VegaBase), 111, Vega);\
})

#define vgClearGlyph(arg1, arg2) \
    __vgClearGlyph_WB(VegaBase, (arg1), (arg2))

#define __vgDrawGlyph_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgDrawGlyph_WB(VegaBase, (arg1), (arg2), (arg3), (arg4))

#define __vgDrawGlyphs_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgDrawGlyphs_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7))

#define __vgColorMatrix_WB(__VegaBase, __arg1, __arg2, __arg3) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgColorMatrix_WB(VegaBase, (arg1), (arg2), (arg3))

#define __vgConvolve_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7, __arg8, __arg9, __arg10) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgConvolve_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10))

#define __vgSeparableConvolve_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7, __arg8, __arg9, __arg10, __arg11) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgSeparableConvolve_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (arg10), (arg11))

#define __vgGaussianBlur_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgGaussianBlur_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5))

#define __vgLookup_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7, __arg8) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgLookup_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8))

#define __vgLookupSingle_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vgLookupSingle_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6))

#define __vgHardwareQuery_WB(__VegaBase, __arg1, __arg2) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC2(VGHardwareQueryResult, vgHardwareQuery, \
                  AROS_LCA(VGHardwareQueryType,(__arg1),D0), \
                  AROS_LCA(VGint,(__arg2),D1), \
        struct Library *, (__VegaBase), 120, Vega);\
})

#define vgHardwareQuery(arg1, arg2) \
    __vgHardwareQuery_WB(VegaBase, (arg1), (arg2))

#define __vgGetString_WB(__VegaBase, __arg1) ({\
        AROS_LIBREQ(VegaBase,0)\
        AROS_LC1(const VGubyte *, vgGetString, \
                  AROS_LCA(VGStringID,(__arg1),D0), \
        struct Library *, (__VegaBase), 121, Vega);\
})

#define vgGetString(arg1) \
    __vgGetString_WB(VegaBase, (arg1))

#define __vguLine_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vguLine_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5))

#define __vguPolygon_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vguPolygon_WB(VegaBase, (arg1), (arg2), (arg3), (arg4))

#define __vguRect_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vguRect_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5))

#define __vguRoundRect_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vguRoundRect_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7))

#define __vguEllipse_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vguEllipse_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5))

#define __vguArc_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7, __arg8) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vguArc_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8))

#define __vguComputeWarpQuadToSquare_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7, __arg8, __arg9) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vguComputeWarpQuadToSquare_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9))

#define __vguComputeWarpSquareToQuad_WB(__VegaBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7, __arg8, __arg9) ({\
        AROS_LIBREQ(VegaBase,0)\
        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) \
    __vguComputeWarpSquareToQuad_WB(VegaBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9))

__END_DECLS

#endif /* DEFINES_VEGA_H*/
