#ifndef INLINE_RENDER_H
#define INLINE_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: Inline function for render
*/

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


static inline void __inline_Render_TurboFillMem(APTR __arg1, ULONG __arg2, ULONG __arg3, APTR __RenderBase)
{
    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) \
    __inline_Render_TurboFillMem((arg1), (arg2), (arg3), (APTR)RenderBase)

static inline void __inline_Render_TurboCopyMem(APTR __arg1, APTR __arg2, ULONG __arg3, APTR __RenderBase)
{
    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) \
    __inline_Render_TurboCopyMem((arg1), (arg2), (arg3), (APTR)RenderBase)

static inline APTR __inline_Render_CreateRMHandlerA(struct TagItem * __arg1, APTR __RenderBase)
{
    return AROS_LC1(APTR, CreateRMHandlerA,
        AROS_LCA(struct TagItem *,(__arg1),A1),
        struct Library *, (__RenderBase), 7, Render    );
}

#define CreateRMHandlerA(arg1) \
    __inline_Render_CreateRMHandlerA((arg1), (APTR)RenderBase)

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

static inline void __inline_Render_DeleteRMHandler(APTR __arg1, APTR __RenderBase)
{
    AROS_LC1NR(void, DeleteRMHandler,
        AROS_LCA(APTR,(__arg1),A0),
        struct Library *, (__RenderBase), 8, Render    );
}

#define DeleteRMHandler(arg1) \
    __inline_Render_DeleteRMHandler((arg1), (APTR)RenderBase)

static inline APTR __inline_Render_AllocRenderMem(APTR __arg1, ULONG __arg2, APTR __RenderBase)
{
    return AROS_LC2(APTR, AllocRenderMem,
        AROS_LCA(APTR,(__arg1),A0),
        AROS_LCA(ULONG,(__arg2),D0),
        struct Library *, (__RenderBase), 9, Render    );
}

#define AllocRenderMem(arg1, arg2) \
    __inline_Render_AllocRenderMem((arg1), (arg2), (APTR)RenderBase)

static inline void __inline_Render_FreeRenderMem(APTR __arg1, APTR __arg2, ULONG __arg3, APTR __RenderBase)
{
    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) \
    __inline_Render_FreeRenderMem((arg1), (arg2), (arg3), (APTR)RenderBase)

static inline APTR __inline_Render_AllocRenderVec(APTR __arg1, ULONG __arg2, APTR __RenderBase)
{
    return AROS_LC2(APTR, AllocRenderVec,
        AROS_LCA(APTR,(__arg1),A0),
        AROS_LCA(ULONG,(__arg2),D0),
        struct Library *, (__RenderBase), 11, Render    );
}

#define AllocRenderVec(arg1, arg2) \
    __inline_Render_AllocRenderVec((arg1), (arg2), (APTR)RenderBase)

static inline void __inline_Render_FreeRenderVec(APTR __arg1, APTR __RenderBase)
{
    AROS_LC1NR(void, FreeRenderVec,
        AROS_LCA(APTR,(__arg1),A0),
        struct Library *, (__RenderBase), 12, Render    );
}

#define FreeRenderVec(arg1) \
    __inline_Render_FreeRenderVec((arg1), (APTR)RenderBase)

static inline APTR __inline_Render_CreateHistogramA(struct TagItem * __arg1, APTR __RenderBase)
{
    return AROS_LC1(APTR, CreateHistogramA,
        AROS_LCA(struct TagItem *,(__arg1),A1),
        struct Library *, (__RenderBase), 13, Render    );
}

#define CreateHistogramA(arg1) \
    __inline_Render_CreateHistogramA((arg1), (APTR)RenderBase)

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

static inline void __inline_Render_DeleteHistogram(APTR __arg1, APTR __RenderBase)
{
    AROS_LC1NR(void, DeleteHistogram,
        AROS_LCA(APTR,(__arg1),A0),
        struct Library *, (__RenderBase), 14, Render    );
}

#define DeleteHistogram(arg1) \
    __inline_Render_DeleteHistogram((arg1), (APTR)RenderBase)

static inline ULONG __inline_Render_QueryHistogram(APTR __arg1, Tag __arg2, APTR __RenderBase)
{
    return AROS_LC2(ULONG, QueryHistogram,
        AROS_LCA(APTR,(__arg1),A0),
        AROS_LCA(Tag,(__arg2),D0),
        struct Library *, (__RenderBase), 15, Render    );
}

#define QueryHistogram(arg1, arg2) \
    __inline_Render_QueryHistogram((arg1), (arg2), (APTR)RenderBase)

static inline ULONG __inline_Render_AddRGB(APTR __arg1, ULONG __arg2, ULONG __arg3, APTR __RenderBase)
{
    return 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) \
    __inline_Render_AddRGB((arg1), (arg2), (arg3), (APTR)RenderBase)

static inline ULONG __inline_Render_AddRGBImageA(APTR __arg1, ULONG * __arg2, UWORD __arg3, ULONG __arg4, struct TagItem * __arg5, APTR __RenderBase)
{
    return 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) \
    __inline_Render_AddRGBImageA((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)RenderBase)

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

static inline ULONG __inline_Render_AddChunkyImageA(APTR __arg1, UBYTE * __arg2, UWORD __arg3, ULONG __arg4, APTR __arg5, struct TagItem * __arg6, APTR __RenderBase)
{
    return 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) \
    __inline_Render_AddChunkyImageA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)RenderBase)

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

static inline ULONG __inline_Render_ExtractPaletteA(APTR __arg1, ULONG * __arg2, UWORD __arg3, struct TagItem * __arg4, APTR __RenderBase)
{
    return 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) \
    __inline_Render_ExtractPaletteA((arg1), (arg2), (arg3), (arg4), (APTR)RenderBase)

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

static inline ULONG __inline_Render_RenderA(ULONG * __arg1, UWORD __arg2, UWORD __arg3, UBYTE * __arg4, APTR __arg5, struct TagItem * __arg6, APTR __RenderBase)
{
    return 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) \
    __inline_Render_RenderA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)RenderBase)

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

static inline void __inline_Render_Planar2ChunkyA(PLANEPTR * __arg1, UWORD __arg2, UWORD __arg3, UWORD __arg4, UWORD __arg5, UBYTE * __arg6, struct TagItem * __arg7, APTR __RenderBase)
{
    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) \
    __inline_Render_Planar2ChunkyA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)RenderBase)

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

static inline ULONG __inline_Render_Chunky2RGBA(UBYTE * __arg1, UWORD __arg2, ULONG __arg3, ULONG * __arg4, APTR __arg5, struct TagItem * __arg6, APTR __RenderBase)
{
    return 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) \
    __inline_Render_Chunky2RGBA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)RenderBase)

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

static inline void __inline_Render_Chunky2BitMapA(UBYTE * __arg1, UWORD __arg2, UWORD __arg3, UWORD __arg4, UWORD __arg5, struct BitMap * __arg6, UWORD __arg7, UWORD __arg8, struct TagItem * __arg9, APTR __RenderBase)
{
    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) \
    __inline_Render_Chunky2BitMapA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (arg8), (arg9), (APTR)RenderBase)

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

static inline APTR __inline_Render_CreateScaleEngineA(UWORD __arg1, UWORD __arg2, UWORD __arg3, UWORD __arg4, struct TagItem * __arg5, APTR __RenderBase)
{
    return 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) \
    __inline_Render_CreateScaleEngineA((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)RenderBase)

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

static inline void __inline_Render_DeleteScaleEngine(APTR __arg1, APTR __RenderBase)
{
    AROS_LC1NR(void, DeleteScaleEngine,
        AROS_LCA(APTR,(__arg1),A0),
        struct Library *, (__RenderBase), 25, Render    );
}

#define DeleteScaleEngine(arg1) \
    __inline_Render_DeleteScaleEngine((arg1), (APTR)RenderBase)

static inline ULONG __inline_Render_ScaleA(APTR __arg1, APTR __arg2, APTR __arg3, struct TagItem * __arg4, APTR __RenderBase)
{
    return 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) \
    __inline_Render_ScaleA((arg1), (arg2), (arg3), (arg4), (APTR)RenderBase)

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

static inline ULONG __inline_Render_ConvertChunkyA(UBYTE * __arg1, APTR __arg2, UWORD __arg3, UWORD __arg4, UBYTE * __arg5, APTR __arg6, struct TagItem * __arg7, APTR __RenderBase)
{
    return 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) \
    __inline_Render_ConvertChunkyA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)RenderBase)

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

static inline void __inline_Render_CreatePenTableA(UBYTE * __arg1, APTR __arg2, UWORD __arg3, UWORD __arg4, APTR __arg5, UBYTE * __arg6, struct TagItem * __arg7, APTR __RenderBase)
{
    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) \
    __inline_Render_CreatePenTableA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)RenderBase)

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

static inline APTR __inline_Render_CreatePaletteA(struct TagItem * __arg1, APTR __RenderBase)
{
    return AROS_LC1(APTR, CreatePaletteA,
        AROS_LCA(struct TagItem *,(__arg1),A1),
        struct Library *, (__RenderBase), 29, Render    );
}

#define CreatePaletteA(arg1) \
    __inline_Render_CreatePaletteA((arg1), (APTR)RenderBase)

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

static inline void __inline_Render_DeletePalette(APTR __arg1, APTR __RenderBase)
{
    AROS_LC1NR(void, DeletePalette,
        AROS_LCA(APTR,(__arg1),A0),
        struct Library *, (__RenderBase), 30, Render    );
}

#define DeletePalette(arg1) \
    __inline_Render_DeletePalette((arg1), (APTR)RenderBase)

static inline void __inline_Render_ImportPaletteA(APTR __arg1, APTR __arg2, UWORD __arg3, struct TagItem * __arg4, APTR __RenderBase)
{
    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) \
    __inline_Render_ImportPaletteA((arg1), (arg2), (arg3), (arg4), (APTR)RenderBase)

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

static inline void __inline_Render_ExportPaletteA(APTR __arg1, APTR __arg2, struct TagItem * __arg3, APTR __RenderBase)
{
    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) \
    __inline_Render_ExportPaletteA((arg1), (arg2), (arg3), (APTR)RenderBase)

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

static inline ULONG __inline_Render_CountRGB(APTR __arg1, ULONG __arg2, APTR __RenderBase)
{
    return AROS_LC2(ULONG, CountRGB,
        AROS_LCA(APTR,(__arg1),A0),
        AROS_LCA(ULONG,(__arg2),D0),
        struct Library *, (__RenderBase), 33, Render    );
}

#define CountRGB(arg1, arg2) \
    __inline_Render_CountRGB((arg1), (arg2), (APTR)RenderBase)

static inline LONG __inline_Render_BestPen(APTR __arg1, ULONG __arg2, APTR __RenderBase)
{
    return AROS_LC2(LONG, BestPen,
        AROS_LCA(APTR,(__arg1),A0),
        AROS_LCA(ULONG,(__arg2),D0),
        struct Library *, (__RenderBase), 34, Render    );
}

#define BestPen(arg1, arg2) \
    __inline_Render_BestPen((arg1), (arg2), (APTR)RenderBase)

static inline void __inline_Render_FlushPalette(APTR __arg1, APTR __RenderBase)
{
    AROS_LC1NR(void, FlushPalette,
        AROS_LCA(APTR,(__arg1),A0),
        struct Library *, (__RenderBase), 35, Render    );
}

#define FlushPalette(arg1) \
    __inline_Render_FlushPalette((arg1), (APTR)RenderBase)

static inline ULONG __inline_Render_SortPaletteA(APTR __arg1, ULONG __arg2, struct TagItem * __arg3, APTR __RenderBase)
{
    return 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) \
    __inline_Render_SortPaletteA((arg1), (arg2), (arg3), (APTR)RenderBase)

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

static inline ULONG __inline_Render_AddHistogramA(APTR __arg1, APTR __arg2, struct TagItem * __arg3, APTR __RenderBase)
{
    return 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) \
    __inline_Render_AddHistogramA((arg1), (arg2), (arg3), (APTR)RenderBase)

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

static inline UWORD __inline_Render_ScaleOrdinate(UWORD __arg1, UWORD __arg2, UWORD __arg3, APTR __RenderBase)
{
    return 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) \
    __inline_Render_ScaleOrdinate((arg1), (arg2), (arg3), (APTR)RenderBase)

static inline ULONG * __inline_Render_CreateHistogramPointerArray(APTR __arg1, APTR __RenderBase)
{
    return AROS_LC1(ULONG *, CreateHistogramPointerArray,
        AROS_LCA(APTR,(__arg1),A0),
        struct Library *, (__RenderBase), 39, Render    );
}

#define CreateHistogramPointerArray(arg1) \
    __inline_Render_CreateHistogramPointerArray((arg1), (APTR)RenderBase)

static inline ULONG __inline_Render_CountHistogram(APTR __arg1, APTR __RenderBase)
{
    return AROS_LC1(ULONG, CountHistogram,
        AROS_LCA(APTR,(__arg1),A0),
        struct Library *, (__RenderBase), 40, Render    );
}

#define CountHistogram(arg1) \
    __inline_Render_CountHistogram((arg1), (APTR)RenderBase)

static inline APTR __inline_Render_CreateMapEngineA(APTR __arg1, struct TagItem * __arg2, APTR __RenderBase)
{
    return AROS_LC2(APTR, CreateMapEngineA,
        AROS_LCA(APTR,(__arg1),A0),
        AROS_LCA(struct TagItem *,(__arg2),A1),
        struct Library *, (__RenderBase), 41, Render    );
}

#define CreateMapEngineA(arg1, arg2) \
    __inline_Render_CreateMapEngineA((arg1), (arg2), (APTR)RenderBase)

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

static inline void __inline_Render_DeleteMapEngine(APTR __arg1, APTR __RenderBase)
{
    AROS_LC1NR(void, DeleteMapEngine,
        AROS_LCA(APTR,(__arg1),A0),
        struct Library *, (__RenderBase), 42, Render    );
}

#define DeleteMapEngine(arg1) \
    __inline_Render_DeleteMapEngine((arg1), (APTR)RenderBase)

static inline ULONG __inline_Render_MapRGBArrayA(APTR __arg1, ULONG * __arg2, UWORD __arg3, ULONG __arg4, UBYTE * __arg5, struct TagItem * __arg6, APTR __RenderBase)
{
    return 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) \
    __inline_Render_MapRGBArrayA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)RenderBase)

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

static inline LONG __inline_Render_RGBArrayDiversityA(ULONG * __arg1, UWORD __arg2, UWORD __arg3, struct TagItem * __arg4, APTR __RenderBase)
{
    return 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) \
    __inline_Render_RGBArrayDiversityA((arg1), (arg2), (arg3), (arg4), (APTR)RenderBase)

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

static inline LONG __inline_Render_ChunkyArrayDiversityA(UBYTE * __arg1, APTR __arg2, UWORD __arg3, UWORD __arg4, struct TagItem * __arg5, APTR __RenderBase)
{
    return 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) \
    __inline_Render_ChunkyArrayDiversityA((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)RenderBase)

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

static inline ULONG __inline_Render_MapChunkyArrayA(APTR __arg1, UBYTE * __arg2, APTR __arg3, UWORD __arg4, UWORD __arg5, UBYTE * __arg6, struct TagItem * __arg7, APTR __RenderBase)
{
    return 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) \
    __inline_Render_MapChunkyArrayA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)RenderBase)

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

static inline void __inline_Render_InsertAlphaChannelA(UBYTE * __arg1, UWORD __arg2, UWORD __arg3, ULONG * __arg4, struct TagItem * __arg5, APTR __RenderBase)
{
    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) \
    __inline_Render_InsertAlphaChannelA((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)RenderBase)

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

static inline void __inline_Render_ExtractAlphaChannelA(ULONG * __arg1, UWORD __arg2, UWORD __arg3, UBYTE * __arg4, struct TagItem * __arg5, APTR __RenderBase)
{
    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) \
    __inline_Render_ExtractAlphaChannelA((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)RenderBase)

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

static inline void __inline_Render_ApplyAlphaChannelA(ULONG * __arg1, UWORD __arg2, UWORD __arg3, ULONG * __arg4, struct TagItem * __arg5, APTR __RenderBase)
{
    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) \
    __inline_Render_ApplyAlphaChannelA((arg1), (arg2), (arg3), (arg4), (arg5), (APTR)RenderBase)

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

static inline void __inline_Render_MixRGBArrayA(ULONG * __arg1, UWORD __arg2, UWORD __arg3, ULONG * __arg4, UWORD __arg5, struct TagItem * __arg6, APTR __RenderBase)
{
    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) \
    __inline_Render_MixRGBArrayA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)RenderBase)

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

static inline APTR __inline_Render_AllocRenderVecClear(APTR __arg1, ULONG __arg2, APTR __RenderBase)
{
    return AROS_LC2(APTR, AllocRenderVecClear,
        AROS_LCA(APTR,(__arg1),A0),
        AROS_LCA(ULONG,(__arg2),D0),
        struct Library *, (__RenderBase), 51, Render    );
}

#define AllocRenderVecClear(arg1, arg2) \
    __inline_Render_AllocRenderVecClear((arg1), (arg2), (APTR)RenderBase)

static inline void __inline_Render_CreateAlphaArrayA(ULONG * __arg1, UWORD __arg2, UWORD __arg3, struct TagItem * __arg4, APTR __RenderBase)
{
    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) \
    __inline_Render_CreateAlphaArrayA((arg1), (arg2), (arg3), (arg4), (APTR)RenderBase)

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

static inline void __inline_Render_MixAlphaChannelA(ULONG * __arg1, ULONG * __arg2, UWORD __arg3, UWORD __arg4, ULONG * __arg5, struct TagItem * __arg6, APTR __RenderBase)
{
    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) \
    __inline_Render_MixAlphaChannelA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)RenderBase)

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

static inline void __inline_Render_TintRGBArrayA(ULONG * __arg1, UWORD __arg2, UWORD __arg3, ULONG __arg4, UWORD __arg5, ULONG * __arg6, struct TagItem * __arg7, APTR __RenderBase)
{
    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) \
    __inline_Render_TintRGBArrayA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (arg7), (APTR)RenderBase)

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

static inline ULONG __inline_Render_GetPaletteAttrs(APTR __arg1, ULONG __arg2, APTR __RenderBase)
{
    return AROS_LC2(ULONG, GetPaletteAttrs,
        AROS_LCA(APTR,(__arg1),A0),
        AROS_LCA(ULONG,(__arg2),D0),
        struct Library *, (__RenderBase), 55, Render    );
}

#define GetPaletteAttrs(arg1, arg2) \
    __inline_Render_GetPaletteAttrs((arg1), (arg2), (APTR)RenderBase)

static inline void __inline_Render_RemapArrayA(UBYTE * __arg1, UWORD __arg2, UWORD __arg3, UBYTE * __arg4, UBYTE * __arg5, struct TagItem * __arg6, APTR __RenderBase)
{
    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) \
    __inline_Render_RemapArrayA((arg1), (arg2), (arg3), (arg4), (arg5), (arg6), (APTR)RenderBase)

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

#endif /* INLINE_RENDER_H*/
