#ifndef DEFINES_RENDER_H
#define DEFINES_RENDER_H

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

/*
    Desc: Defines for render
*/

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

__BEGIN_DECLS


#define __TurboFillMem_WB(__RenderBase, __arg1, __arg2, __arg3) \
        AROS_LC3NR(void, TurboFillMem, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(ULONG,(__arg2),D0), \
                  AROS_LCA(ULONG,(__arg3),D1), \
        struct Library *, (__RenderBase), 5, Render)

#define TurboFillMem(arg1, arg2, arg3) \
    __TurboFillMem_WB(RenderBase, (arg1), (arg2), (arg3))

#define __TurboCopyMem_WB(__RenderBase, __arg1, __arg2, __arg3) \
        AROS_LC3NR(void, TurboCopyMem, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(APTR,(__arg2),A1), \
                  AROS_LCA(ULONG,(__arg3),D0), \
        struct Library *, (__RenderBase), 6, Render)

#define TurboCopyMem(arg1, arg2, arg3) \
    __TurboCopyMem_WB(RenderBase, (arg1), (arg2), (arg3))

#define __CreateRMHandlerA_WB(__RenderBase, __arg1) \
        AROS_LC1(APTR, CreateRMHandlerA, \
                  AROS_LCA(struct TagItem *,(__arg1),A1), \
        struct Library *, (__RenderBase), 7, Render)

#define CreateRMHandlerA(arg1) \
    __CreateRMHandlerA_WB(RenderBase, (arg1))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define CreateRMHandler(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    CreateRMHandlerA((struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __DeleteRMHandler_WB(__RenderBase, __arg1) \
        AROS_LC1NR(void, DeleteRMHandler, \
                  AROS_LCA(APTR,(__arg1),A0), \
        struct Library *, (__RenderBase), 8, Render)

#define DeleteRMHandler(arg1) \
    __DeleteRMHandler_WB(RenderBase, (arg1))

#define __AllocRenderMem_WB(__RenderBase, __arg1, __arg2) \
        AROS_LC2(APTR, AllocRenderMem, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(ULONG,(__arg2),D0), \
        struct Library *, (__RenderBase), 9, Render)

#define AllocRenderMem(arg1, arg2) \
    __AllocRenderMem_WB(RenderBase, (arg1), (arg2))

#define __FreeRenderMem_WB(__RenderBase, __arg1, __arg2, __arg3) \
        AROS_LC3NR(void, FreeRenderMem, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(APTR,(__arg2),A1), \
                  AROS_LCA(ULONG,(__arg3),D0), \
        struct Library *, (__RenderBase), 10, Render)

#define FreeRenderMem(arg1, arg2, arg3) \
    __FreeRenderMem_WB(RenderBase, (arg1), (arg2), (arg3))

#define __AllocRenderVec_WB(__RenderBase, __arg1, __arg2) \
        AROS_LC2(APTR, AllocRenderVec, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(ULONG,(__arg2),D0), \
        struct Library *, (__RenderBase), 11, Render)

#define AllocRenderVec(arg1, arg2) \
    __AllocRenderVec_WB(RenderBase, (arg1), (arg2))

#define __FreeRenderVec_WB(__RenderBase, __arg1) \
        AROS_LC1NR(void, FreeRenderVec, \
                  AROS_LCA(APTR,(__arg1),A0), \
        struct Library *, (__RenderBase), 12, Render)

#define FreeRenderVec(arg1) \
    __FreeRenderVec_WB(RenderBase, (arg1))

#define __CreateHistogramA_WB(__RenderBase, __arg1) \
        AROS_LC1(APTR, CreateHistogramA, \
                  AROS_LCA(struct TagItem *,(__arg1),A1), \
        struct Library *, (__RenderBase), 13, Render)

#define CreateHistogramA(arg1) \
    __CreateHistogramA_WB(RenderBase, (arg1))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define CreateHistogram(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    CreateHistogramA((struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __DeleteHistogram_WB(__RenderBase, __arg1) \
        AROS_LC1NR(void, DeleteHistogram, \
                  AROS_LCA(APTR,(__arg1),A0), \
        struct Library *, (__RenderBase), 14, Render)

#define DeleteHistogram(arg1) \
    __DeleteHistogram_WB(RenderBase, (arg1))

#define __QueryHistogram_WB(__RenderBase, __arg1, __arg2) \
        AROS_LC2(ULONG, QueryHistogram, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(Tag,(__arg2),D0), \
        struct Library *, (__RenderBase), 15, Render)

#define QueryHistogram(arg1, arg2) \
    __QueryHistogram_WB(RenderBase, (arg1), (arg2))

#define __AddRGB_WB(__RenderBase, __arg1, __arg2, __arg3) \
        AROS_LC3(ULONG, AddRGB, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(ULONG,(__arg2),D0), \
                  AROS_LCA(ULONG,(__arg3),D1), \
        struct Library *, (__RenderBase), 16, Render)

#define AddRGB(arg1, arg2, arg3) \
    __AddRGB_WB(RenderBase, (arg1), (arg2), (arg3))

#define __AddRGBImageA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5) \
        AROS_LC5(ULONG, AddRGBImageA, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(ULONG *,(__arg2),A1), \
                  AROS_LCA(UWORD,(__arg3),D0), \
                  AROS_LCA(ULONG,(__arg4),D1), \
                  AROS_LCA(struct TagItem *,(__arg5),A2), \
        struct Library *, (__RenderBase), 17, Render)

#define AddRGBImageA(arg1, arg2, arg3, arg4, arg5) \
    __AddRGBImageA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define AddRGBImage(arg1, arg2, arg3, arg4, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    AddRGBImageA((arg1), (arg2), (arg3), (arg4), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __AddChunkyImageA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6) \
        AROS_LC6(ULONG, AddChunkyImageA, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(UBYTE *,(__arg2),A1), \
                  AROS_LCA(UWORD,(__arg3),D0), \
                  AROS_LCA(ULONG,(__arg4),D1), \
                  AROS_LCA(APTR,(__arg5),A2), \
                  AROS_LCA(struct TagItem *,(__arg6),A3), \
        struct Library *, (__RenderBase), 18, Render)

#define AddChunkyImageA(arg1, arg2, arg3, arg4, arg5, arg6) \
    __AddChunkyImageA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define AddChunkyImage(arg1, arg2, arg3, arg4, arg5, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    AddChunkyImageA((arg1), (arg2), (arg3), (arg4), (arg5), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __ExtractPaletteA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4) \
        AROS_LC4(ULONG, ExtractPaletteA, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(ULONG *,(__arg2),A1), \
                  AROS_LCA(UWORD,(__arg3),D0), \
                  AROS_LCA(struct TagItem *,(__arg4),A2), \
        struct Library *, (__RenderBase), 19, Render)

#define ExtractPaletteA(arg1, arg2, arg3, arg4) \
    __ExtractPaletteA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define ExtractPalette(arg1, arg2, arg3, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    ExtractPaletteA((arg1), (arg2), (arg3), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __RenderA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6) \
        AROS_LC6(ULONG, RenderA, \
                  AROS_LCA(ULONG *,(__arg1),A0), \
                  AROS_LCA(UWORD,(__arg2),D0), \
                  AROS_LCA(UWORD,(__arg3),D1), \
                  AROS_LCA(UBYTE *,(__arg4),A1), \
                  AROS_LCA(APTR,(__arg5),A2), \
                  AROS_LCA(struct TagItem *,(__arg6),A3), \
        struct Library *, (__RenderBase), 20, Render)

#define RenderA(arg1, arg2, arg3, arg4, arg5, arg6) \
    __RenderA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define Render(arg1, arg2, arg3, arg4, arg5, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    RenderA((arg1), (arg2), (arg3), (arg4), (arg5), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __Planar2ChunkyA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7) \
        AROS_LC7NR(void, Planar2ChunkyA, \
                  AROS_LCA(PLANEPTR *,(__arg1),A0), \
                  AROS_LCA(UWORD,(__arg2),D0), \
                  AROS_LCA(UWORD,(__arg3),D1), \
                  AROS_LCA(UWORD,(__arg4),D2), \
                  AROS_LCA(UWORD,(__arg5),D3), \
                  AROS_LCA(UBYTE *,(__arg6),A1), \
                  AROS_LCA(struct TagItem *,(__arg7),A2), \
        struct Library *, (__RenderBase), 21, Render)

#define Planar2ChunkyA(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __Planar2ChunkyA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define Planar2Chunky(arg1, arg2, arg3, arg4, arg5, arg6, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    Planar2ChunkyA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __Chunky2RGBA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6) \
        AROS_LC6(ULONG, Chunky2RGBA, \
                  AROS_LCA(UBYTE *,(__arg1),A0), \
                  AROS_LCA(UWORD,(__arg2),D0), \
                  AROS_LCA(ULONG,(__arg3),D1), \
                  AROS_LCA(ULONG *,(__arg4),A1), \
                  AROS_LCA(APTR,(__arg5),A2), \
                  AROS_LCA(struct TagItem *,(__arg6),A3), \
        struct Library *, (__RenderBase), 22, Render)

#define Chunky2RGBA(arg1, arg2, arg3, arg4, arg5, arg6) \
    __Chunky2RGBA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define Chunky2RGB(arg1, arg2, arg3, arg4, arg5, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    Chunky2RGBA((arg1), (arg2), (arg3), (arg4), (arg5), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __Chunky2BitMapA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7, __arg8, __arg9) \
        AROS_LC9NR(void, Chunky2BitMapA, \
                  AROS_LCA(UBYTE *,(__arg1),A0), \
                  AROS_LCA(UWORD,(__arg2),D0), \
                  AROS_LCA(UWORD,(__arg3),D1), \
                  AROS_LCA(UWORD,(__arg4),D2), \
                  AROS_LCA(UWORD,(__arg5),D3), \
                  AROS_LCA(struct BitMap *,(__arg6),A1), \
                  AROS_LCA(UWORD,(__arg7),D4), \
                  AROS_LCA(UWORD,(__arg8),D5), \
                  AROS_LCA(struct TagItem *,(__arg9),A2), \
        struct Library *, (__RenderBase), 23, Render)

#define Chunky2BitMapA(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \
    __Chunky2BitMapA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define Chunky2BitMap(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    Chunky2BitMapA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __CreateScaleEngineA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5) \
        AROS_LC5(APTR, CreateScaleEngineA, \
                  AROS_LCA(UWORD,(__arg1),D0), \
                  AROS_LCA(UWORD,(__arg2),D1), \
                  AROS_LCA(UWORD,(__arg3),D2), \
                  AROS_LCA(UWORD,(__arg4),A3), \
                  AROS_LCA(struct TagItem *,(__arg5),A1), \
        struct Library *, (__RenderBase), 24, Render)

#define CreateScaleEngineA(arg1, arg2, arg3, arg4, arg5) \
    __CreateScaleEngineA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define CreateScaleEngine(arg1, arg2, arg3, arg4, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    CreateScaleEngineA((arg1), (arg2), (arg3), (arg4), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __DeleteScaleEngine_WB(__RenderBase, __arg1) \
        AROS_LC1NR(void, DeleteScaleEngine, \
                  AROS_LCA(APTR,(__arg1),A0), \
        struct Library *, (__RenderBase), 25, Render)

#define DeleteScaleEngine(arg1) \
    __DeleteScaleEngine_WB(RenderBase, (arg1))

#define __ScaleA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4) \
        AROS_LC4(ULONG, ScaleA, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(APTR,(__arg2),A1), \
                  AROS_LCA(APTR,(__arg3),A2), \
                  AROS_LCA(struct TagItem *,(__arg4),A3), \
        struct Library *, (__RenderBase), 26, Render)

#define ScaleA(arg1, arg2, arg3, arg4) \
    __ScaleA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define Scale(arg1, arg2, arg3, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    ScaleA((arg1), (arg2), (arg3), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __ConvertChunkyA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7) \
        AROS_LC7(ULONG, ConvertChunkyA, \
                  AROS_LCA(UBYTE *,(__arg1),A0), \
                  AROS_LCA(APTR,(__arg2),A1), \
                  AROS_LCA(UWORD,(__arg3),D0), \
                  AROS_LCA(UWORD,(__arg4),D1), \
                  AROS_LCA(UBYTE *,(__arg5),A2), \
                  AROS_LCA(APTR,(__arg6),A3), \
                  AROS_LCA(struct TagItem *,(__arg7),A4), \
        struct Library *, (__RenderBase), 27, Render)

#define ConvertChunkyA(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __ConvertChunkyA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define ConvertChunky(arg1, arg2, arg3, arg4, arg5, arg6, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    ConvertChunkyA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __CreatePenTableA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7) \
        AROS_LC7NR(void, CreatePenTableA, \
                  AROS_LCA(UBYTE *,(__arg1),A0), \
                  AROS_LCA(APTR,(__arg2),A1), \
                  AROS_LCA(UWORD,(__arg3),D0), \
                  AROS_LCA(UWORD,(__arg4),D1), \
                  AROS_LCA(APTR,(__arg5),A2), \
                  AROS_LCA(UBYTE *,(__arg6),A3), \
                  AROS_LCA(struct TagItem *,(__arg7),A4), \
        struct Library *, (__RenderBase), 28, Render)

#define CreatePenTableA(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __CreatePenTableA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define CreatePenTable(arg1, arg2, arg3, arg4, arg5, arg6, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    CreatePenTableA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __CreatePaletteA_WB(__RenderBase, __arg1) \
        AROS_LC1(APTR, CreatePaletteA, \
                  AROS_LCA(struct TagItem *,(__arg1),A1), \
        struct Library *, (__RenderBase), 29, Render)

#define CreatePaletteA(arg1) \
    __CreatePaletteA_WB(RenderBase, (arg1))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define CreatePalette(...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    CreatePaletteA((struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __DeletePalette_WB(__RenderBase, __arg1) \
        AROS_LC1NR(void, DeletePalette, \
                  AROS_LCA(APTR,(__arg1),A0), \
        struct Library *, (__RenderBase), 30, Render)

#define DeletePalette(arg1) \
    __DeletePalette_WB(RenderBase, (arg1))

#define __ImportPaletteA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4) \
        AROS_LC4NR(void, ImportPaletteA, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(APTR,(__arg2),A1), \
                  AROS_LCA(UWORD,(__arg3),D0), \
                  AROS_LCA(struct TagItem *,(__arg4),A2), \
        struct Library *, (__RenderBase), 31, Render)

#define ImportPaletteA(arg1, arg2, arg3, arg4) \
    __ImportPaletteA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define ImportPalette(arg1, arg2, arg3, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    ImportPaletteA((arg1), (arg2), (arg3), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __ExportPaletteA_WB(__RenderBase, __arg1, __arg2, __arg3) \
        AROS_LC3NR(void, ExportPaletteA, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(APTR,(__arg2),A1), \
                  AROS_LCA(struct TagItem *,(__arg3),A2), \
        struct Library *, (__RenderBase), 32, Render)

#define ExportPaletteA(arg1, arg2, arg3) \
    __ExportPaletteA_WB(RenderBase, (arg1), (arg2), (arg3))

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

#define __CountRGB_WB(__RenderBase, __arg1, __arg2) \
        AROS_LC2(ULONG, CountRGB, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(ULONG,(__arg2),D0), \
        struct Library *, (__RenderBase), 33, Render)

#define CountRGB(arg1, arg2) \
    __CountRGB_WB(RenderBase, (arg1), (arg2))

#define __BestPen_WB(__RenderBase, __arg1, __arg2) \
        AROS_LC2(LONG, BestPen, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(ULONG,(__arg2),D0), \
        struct Library *, (__RenderBase), 34, Render)

#define BestPen(arg1, arg2) \
    __BestPen_WB(RenderBase, (arg1), (arg2))

#define __FlushPalette_WB(__RenderBase, __arg1) \
        AROS_LC1NR(void, FlushPalette, \
                  AROS_LCA(APTR,(__arg1),A0), \
        struct Library *, (__RenderBase), 35, Render)

#define FlushPalette(arg1) \
    __FlushPalette_WB(RenderBase, (arg1))

#define __SortPaletteA_WB(__RenderBase, __arg1, __arg2, __arg3) \
        AROS_LC3(ULONG, SortPaletteA, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(ULONG,(__arg2),D0), \
                  AROS_LCA(struct TagItem *,(__arg3),A1), \
        struct Library *, (__RenderBase), 36, Render)

#define SortPaletteA(arg1, arg2, arg3) \
    __SortPaletteA_WB(RenderBase, (arg1), (arg2), (arg3))

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

#define __AddHistogramA_WB(__RenderBase, __arg1, __arg2, __arg3) \
        AROS_LC3(ULONG, AddHistogramA, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(APTR,(__arg2),A1), \
                  AROS_LCA(struct TagItem *,(__arg3),A2), \
        struct Library *, (__RenderBase), 37, Render)

#define AddHistogramA(arg1, arg2, arg3) \
    __AddHistogramA_WB(RenderBase, (arg1), (arg2), (arg3))

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

#define __ScaleOrdinate_WB(__RenderBase, __arg1, __arg2, __arg3) \
        AROS_LC3(UWORD, ScaleOrdinate, \
                  AROS_LCA(UWORD,(__arg1),D0), \
                  AROS_LCA(UWORD,(__arg2),D1), \
                  AROS_LCA(UWORD,(__arg3),D2), \
        struct Library *, (__RenderBase), 38, Render)

#define ScaleOrdinate(arg1, arg2, arg3) \
    __ScaleOrdinate_WB(RenderBase, (arg1), (arg2), (arg3))

#define __CreateHistogramPointerArray_WB(__RenderBase, __arg1) \
        AROS_LC1(ULONG *, CreateHistogramPointerArray, \
                  AROS_LCA(APTR,(__arg1),A0), \
        struct Library *, (__RenderBase), 39, Render)

#define CreateHistogramPointerArray(arg1) \
    __CreateHistogramPointerArray_WB(RenderBase, (arg1))

#define __CountHistogram_WB(__RenderBase, __arg1) \
        AROS_LC1(ULONG, CountHistogram, \
                  AROS_LCA(APTR,(__arg1),A0), \
        struct Library *, (__RenderBase), 40, Render)

#define CountHistogram(arg1) \
    __CountHistogram_WB(RenderBase, (arg1))

#define __CreateMapEngineA_WB(__RenderBase, __arg1, __arg2) \
        AROS_LC2(APTR, CreateMapEngineA, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(struct TagItem *,(__arg2),A1), \
        struct Library *, (__RenderBase), 41, Render)

#define CreateMapEngineA(arg1, arg2) \
    __CreateMapEngineA_WB(RenderBase, (arg1), (arg2))

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

#define __DeleteMapEngine_WB(__RenderBase, __arg1) \
        AROS_LC1NR(void, DeleteMapEngine, \
                  AROS_LCA(APTR,(__arg1),A0), \
        struct Library *, (__RenderBase), 42, Render)

#define DeleteMapEngine(arg1) \
    __DeleteMapEngine_WB(RenderBase, (arg1))

#define __MapRGBArrayA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6) \
        AROS_LC6(ULONG, MapRGBArrayA, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(ULONG *,(__arg2),A1), \
                  AROS_LCA(UWORD,(__arg3),D0), \
                  AROS_LCA(ULONG,(__arg4),D1), \
                  AROS_LCA(UBYTE *,(__arg5),A2), \
                  AROS_LCA(struct TagItem *,(__arg6),A3), \
        struct Library *, (__RenderBase), 43, Render)

#define MapRGBArrayA(arg1, arg2, arg3, arg4, arg5, arg6) \
    __MapRGBArrayA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define MapRGBArray(arg1, arg2, arg3, arg4, arg5, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    MapRGBArrayA((arg1), (arg2), (arg3), (arg4), (arg5), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __RGBArrayDiversityA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4) \
        AROS_LC4(LONG, RGBArrayDiversityA, \
                  AROS_LCA(ULONG *,(__arg1),A0), \
                  AROS_LCA(UWORD,(__arg2),D0), \
                  AROS_LCA(UWORD,(__arg3),D1), \
                  AROS_LCA(struct TagItem *,(__arg4),A1), \
        struct Library *, (__RenderBase), 44, Render)

#define RGBArrayDiversityA(arg1, arg2, arg3, arg4) \
    __RGBArrayDiversityA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define RGBArrayDiversity(arg1, arg2, arg3, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    RGBArrayDiversityA((arg1), (arg2), (arg3), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __ChunkyArrayDiversityA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5) \
        AROS_LC5(LONG, ChunkyArrayDiversityA, \
                  AROS_LCA(UBYTE *,(__arg1),A0), \
                  AROS_LCA(APTR,(__arg2),A1), \
                  AROS_LCA(UWORD,(__arg3),D0), \
                  AROS_LCA(UWORD,(__arg4),D1), \
                  AROS_LCA(struct TagItem *,(__arg5),A2), \
        struct Library *, (__RenderBase), 45, Render)

#define ChunkyArrayDiversityA(arg1, arg2, arg3, arg4, arg5) \
    __ChunkyArrayDiversityA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define ChunkyArrayDiversity(arg1, arg2, arg3, arg4, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    ChunkyArrayDiversityA((arg1), (arg2), (arg3), (arg4), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __MapChunkyArrayA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7) \
        AROS_LC7(ULONG, MapChunkyArrayA, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(UBYTE *,(__arg2),A1), \
                  AROS_LCA(APTR,(__arg3),A2), \
                  AROS_LCA(UWORD,(__arg4),D0), \
                  AROS_LCA(UWORD,(__arg5),D1), \
                  AROS_LCA(UBYTE *,(__arg6),A3), \
                  AROS_LCA(struct TagItem *,(__arg7),A4), \
        struct Library *, (__RenderBase), 46, Render)

#define MapChunkyArrayA(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __MapChunkyArrayA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define MapChunkyArray(arg1, arg2, arg3, arg4, arg5, arg6, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    MapChunkyArrayA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __InsertAlphaChannelA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5) \
        AROS_LC5NR(void, InsertAlphaChannelA, \
                  AROS_LCA(UBYTE *,(__arg1),A0), \
                  AROS_LCA(UWORD,(__arg2),D0), \
                  AROS_LCA(UWORD,(__arg3),D1), \
                  AROS_LCA(ULONG *,(__arg4),A1), \
                  AROS_LCA(struct TagItem *,(__arg5),A2), \
        struct Library *, (__RenderBase), 47, Render)

#define InsertAlphaChannelA(arg1, arg2, arg3, arg4, arg5) \
    __InsertAlphaChannelA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define InsertAlphaChannel(arg1, arg2, arg3, arg4, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    InsertAlphaChannelA((arg1), (arg2), (arg3), (arg4), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __ExtractAlphaChannelA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5) \
        AROS_LC5NR(void, ExtractAlphaChannelA, \
                  AROS_LCA(ULONG *,(__arg1),A0), \
                  AROS_LCA(UWORD,(__arg2),D0), \
                  AROS_LCA(UWORD,(__arg3),D1), \
                  AROS_LCA(UBYTE *,(__arg4),A1), \
                  AROS_LCA(struct TagItem *,(__arg5),A2), \
        struct Library *, (__RenderBase), 48, Render)

#define ExtractAlphaChannelA(arg1, arg2, arg3, arg4, arg5) \
    __ExtractAlphaChannelA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define ExtractAlphaChannel(arg1, arg2, arg3, arg4, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    ExtractAlphaChannelA((arg1), (arg2), (arg3), (arg4), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __ApplyAlphaChannelA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5) \
        AROS_LC5NR(void, ApplyAlphaChannelA, \
                  AROS_LCA(ULONG *,(__arg1),A0), \
                  AROS_LCA(UWORD,(__arg2),D0), \
                  AROS_LCA(UWORD,(__arg3),D1), \
                  AROS_LCA(ULONG *,(__arg4),A1), \
                  AROS_LCA(struct TagItem *,(__arg5),A2), \
        struct Library *, (__RenderBase), 49, Render)

#define ApplyAlphaChannelA(arg1, arg2, arg3, arg4, arg5) \
    __ApplyAlphaChannelA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define ApplyAlphaChannel(arg1, arg2, arg3, arg4, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    ApplyAlphaChannelA((arg1), (arg2), (arg3), (arg4), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __MixRGBArrayA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6) \
        AROS_LC6NR(void, MixRGBArrayA, \
                  AROS_LCA(ULONG *,(__arg1),A0), \
                  AROS_LCA(UWORD,(__arg2),D0), \
                  AROS_LCA(UWORD,(__arg3),D1), \
                  AROS_LCA(ULONG *,(__arg4),A1), \
                  AROS_LCA(UWORD,(__arg5),D2), \
                  AROS_LCA(struct TagItem *,(__arg6),A2), \
        struct Library *, (__RenderBase), 50, Render)

#define MixRGBArrayA(arg1, arg2, arg3, arg4, arg5, arg6) \
    __MixRGBArrayA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define MixRGBArray(arg1, arg2, arg3, arg4, arg5, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    MixRGBArrayA((arg1), (arg2), (arg3), (arg4), (arg5), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __AllocRenderVecClear_WB(__RenderBase, __arg1, __arg2) \
        AROS_LC2(APTR, AllocRenderVecClear, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(ULONG,(__arg2),D0), \
        struct Library *, (__RenderBase), 51, Render)

#define AllocRenderVecClear(arg1, arg2) \
    __AllocRenderVecClear_WB(RenderBase, (arg1), (arg2))

#define __CreateAlphaArrayA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4) \
        AROS_LC4NR(void, CreateAlphaArrayA, \
                  AROS_LCA(ULONG *,(__arg1),A0), \
                  AROS_LCA(UWORD,(__arg2),D0), \
                  AROS_LCA(UWORD,(__arg3),D1), \
                  AROS_LCA(struct TagItem *,(__arg4),A1), \
        struct Library *, (__RenderBase), 52, Render)

#define CreateAlphaArrayA(arg1, arg2, arg3, arg4) \
    __CreateAlphaArrayA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define CreateAlphaArray(arg1, arg2, arg3, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    CreateAlphaArrayA((arg1), (arg2), (arg3), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __MixAlphaChannelA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6) \
        AROS_LC6NR(void, MixAlphaChannelA, \
                  AROS_LCA(ULONG *,(__arg1),A0), \
                  AROS_LCA(ULONG *,(__arg2),A1), \
                  AROS_LCA(UWORD,(__arg3),D0), \
                  AROS_LCA(UWORD,(__arg4),D1), \
                  AROS_LCA(ULONG *,(__arg5),A2), \
                  AROS_LCA(struct TagItem *,(__arg6),A3), \
        struct Library *, (__RenderBase), 53, Render)

#define MixAlphaChannelA(arg1, arg2, arg3, arg4, arg5, arg6) \
    __MixAlphaChannelA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define MixAlphaChannel(arg1, arg2, arg3, arg4, arg5, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    MixAlphaChannelA((arg1), (arg2), (arg3), (arg4), (arg5), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __TintRGBArrayA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6, __arg7) \
        AROS_LC7NR(void, TintRGBArrayA, \
                  AROS_LCA(ULONG *,(__arg1),A0), \
                  AROS_LCA(UWORD,(__arg2),D0), \
                  AROS_LCA(UWORD,(__arg3),D1), \
                  AROS_LCA(ULONG,(__arg4),D2), \
                  AROS_LCA(UWORD,(__arg5),D3), \
                  AROS_LCA(ULONG *,(__arg6),A1), \
                  AROS_LCA(struct TagItem *,(__arg7),A2), \
        struct Library *, (__RenderBase), 54, Render)

#define TintRGBArrayA(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \
    __TintRGBArrayA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define TintRGBArray(arg1, arg2, arg3, arg4, arg5, arg6, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    TintRGBArrayA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

#define __GetPaletteAttrs_WB(__RenderBase, __arg1, __arg2) \
        AROS_LC2(ULONG, GetPaletteAttrs, \
                  AROS_LCA(APTR,(__arg1),A0), \
                  AROS_LCA(ULONG,(__arg2),D0), \
        struct Library *, (__RenderBase), 55, Render)

#define GetPaletteAttrs(arg1, arg2) \
    __GetPaletteAttrs_WB(RenderBase, (arg1), (arg2))

#define __RemapArrayA_WB(__RenderBase, __arg1, __arg2, __arg3, __arg4, __arg5, __arg6) \
        AROS_LC6NR(void, RemapArrayA, \
                  AROS_LCA(UBYTE *,(__arg1),A0), \
                  AROS_LCA(UWORD,(__arg2),D0), \
                  AROS_LCA(UWORD,(__arg3),D1), \
                  AROS_LCA(UBYTE *,(__arg4),A1), \
                  AROS_LCA(UBYTE *,(__arg5),A2), \
                  AROS_LCA(struct TagItem *,(__arg6),A3), \
        struct Library *, (__RenderBase), 56, Render)

#define RemapArrayA(arg1, arg2, arg3, arg4, arg5, arg6) \
    __RemapArrayA_WB(RenderBase, (arg1), (arg2), (arg3), (arg4), (arg5), (arg6))

#if !defined(NO_INLINE_STDARG) && !defined(RENDER_NO_INLINE_STDARG)
#define RemapArray(arg1, arg2, arg3, arg4, arg5, ...) \
({ \
    IPTR __args[] = { AROS_PP_VARIADIC_CAST2IPTR(__VA_ARGS__) }; \
    RemapArrayA((arg1), (arg2), (arg3), (arg4), (arg5), (struct TagItem *)__args); \
})
#endif /* !NO_INLINE_STDARG */

__END_DECLS

#endif /* DEFINES_RENDER_H*/
