/* Automatically generated header! Do not edit! */

#ifndef _PPCPRAGMA_GUIGFX_H
#define _PPCPRAGMA_GUIGFX_H
#ifdef __GNUC__
#ifndef _PPCINLINE__GUIGFX_H
#include <ppcinline/guigfx.h>
#endif
#else

#ifndef POWERUP_PPCLIB_INTERFACE_H
#include <powerup/ppclib/interface.h>
#endif

#ifndef POWERUP_GCCLIB_PROTOS_H
#include <powerup/gcclib/powerup_protos.h>
#endif

#ifndef NO_PPCINLINE_STDARG
#define NO_PPCINLINE_STDARG
#endif/* SAS C PPC inlines */

#ifndef GUIGFX_BASE_NAME
#define GUIGFX_BASE_NAME GuiGFXBase
#endif /* !GUIGFX_BASE_NAME */

#define	AddPaletteA(psm, palette, tags)	_AddPaletteA(GUIGFX_BASE_NAME, psm, palette, tags)

static __inline APTR
_AddPaletteA(void *GuiGFXBase, APTR psm, APTR palette, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) psm;
	MyCaos.a1		=(ULONG) palette;
	MyCaos.a2		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-72);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((APTR)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define AddPalette(a0, a1, tags...) \
	({ULONG _tags[] = { tags }; AddPaletteA((a0), (a1), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	AddPictureA(psm, pic, tags)	_AddPictureA(GUIGFX_BASE_NAME, psm, pic, tags)

static __inline APTR
_AddPictureA(void *GuiGFXBase, APTR psm, APTR pic, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) psm;
	MyCaos.a1		=(ULONG) pic;
	MyCaos.a2		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-66);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((APTR)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define AddPicture(a0, a1, tags...) \
	({ULONG _tags[] = { tags }; AddPictureA((a0), (a1), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	AddPixelArrayA(psm, array, width, height, tags)	_AddPixelArrayA(GUIGFX_BASE_NAME, psm, array, width, height, tags)

static __inline APTR
_AddPixelArrayA(void *GuiGFXBase, APTR psm, APTR array, UWORD width, UWORD height, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) psm;
	MyCaos.a1		=(ULONG) array;
	MyCaos.d0		=(ULONG) width;
	MyCaos.d1		=(ULONG) height;
	MyCaos.a2		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-78);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((APTR)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define AddPixelArray(a0, a1, a2, a3, tags...) \
	({ULONG _tags[] = { tags }; AddPixelArrayA((a0), (a1), (a2), (a3), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	ClonePictureA(pic, tags)	_ClonePictureA(GUIGFX_BASE_NAME, pic, tags)

static __inline APTR
_ClonePictureA(void *GuiGFXBase, APTR pic, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) pic;
	MyCaos.a1		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-48);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((APTR)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define ClonePicture(a0, tags...) \
	({ULONG _tags[] = { tags }; ClonePictureA((a0), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	CreateDirectDrawHandleA(drawhandle, sw, sh, dw, dh, tags)	_CreateDirectDrawHandleA(GUIGFX_BASE_NAME, drawhandle, sw, sh, dw, dh, tags)

static __inline APTR
_CreateDirectDrawHandleA(void *GuiGFXBase, APTR drawhandle, UWORD sw, UWORD sh, UWORD dw, UWORD dh, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) drawhandle;
	MyCaos.d0		=(ULONG) sw;
	MyCaos.d1		=(ULONG) sh;
	MyCaos.d2		=(ULONG) dw;
	MyCaos.d3		=(ULONG) dh;
	MyCaos.a1		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-168);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((APTR)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define CreateDirectDrawHandle(a0, a1, a2, a3, a4, tags...) \
	({ULONG _tags[] = { tags }; CreateDirectDrawHandleA((a0), (a1), (a2), (a3), (a4), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	CreatePenShareMapA(tags)	_CreatePenShareMapA(GUIGFX_BASE_NAME, tags)

static __inline APTR
_CreatePenShareMapA(void *GuiGFXBase, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-90);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((APTR)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define CreatePenShareMap(tags...) \
	({ULONG _tags[] = { tags }; CreatePenShareMapA((struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	CreatePictureBitMapA(drawhandle, pic, tags)	_CreatePictureBitMapA(GUIGFX_BASE_NAME, drawhandle, pic, tags)

static __inline struct BitMap *
_CreatePictureBitMapA(void *GuiGFXBase, APTR drawhandle, APTR pic, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) drawhandle;
	MyCaos.a1		=(ULONG) pic;
	MyCaos.a2		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-132);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((struct BitMap *)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define CreatePictureBitMap(a0, a1, tags...) \
	({ULONG _tags[] = { tags }; CreatePictureBitMapA((a0), (a1), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	CreatePictureMaskA(pic, mask, maskwidth, tags)	_CreatePictureMaskA(GUIGFX_BASE_NAME, pic, mask, maskwidth, tags)

static __inline BOOL
_CreatePictureMaskA(void *GuiGFXBase, APTR pic, UBYTE *mask, UWORD maskwidth, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) pic;
	MyCaos.a1		=(ULONG) mask;
	MyCaos.d0		=(ULONG) maskwidth;
	MyCaos.a2		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-186);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((BOOL)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define CreatePictureMask(a0, a1, a2, tags...) \
	({ULONG _tags[] = { tags }; CreatePictureMaskA((a0), (a1), (a2), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	DeleteDirectDrawHandle(ddh)	_DeleteDirectDrawHandle(GUIGFX_BASE_NAME, ddh)

static __inline void
_DeleteDirectDrawHandle(void *GuiGFXBase, APTR ddh)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) ddh;
	MyCaos.caos_Un.Offset	=	(-174);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	PPCCallOS(&MyCaos);
}

#define	DeletePenShareMap(psm)	_DeletePenShareMap(GUIGFX_BASE_NAME, psm)

static __inline void
_DeletePenShareMap(void *GuiGFXBase, APTR psm)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) psm;
	MyCaos.caos_Un.Offset	=	(-96);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	PPCCallOS(&MyCaos);
}

#define	DeletePicture(pic)	_DeletePicture(GUIGFX_BASE_NAME, pic)

static __inline void
_DeletePicture(void *GuiGFXBase, APTR pic)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) pic;
	MyCaos.caos_Un.Offset	=	(-54);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	PPCCallOS(&MyCaos);
}

#define	DirectDrawTrueColorA(ddh, array, x, y, tags)	_DirectDrawTrueColorA(GUIGFX_BASE_NAME, ddh, array, x, y, tags)

static __inline BOOL
_DirectDrawTrueColorA(void *GuiGFXBase, APTR ddh, ULONG *array, UWORD x, UWORD y, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) ddh;
	MyCaos.a1		=(ULONG) array;
	MyCaos.d0		=(ULONG) x;
	MyCaos.d1		=(ULONG) y;
	MyCaos.a2		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-180);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((BOOL)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define DirectDrawTrueColor(a0, a1, a2, a3, tags...) \
	({ULONG _tags[] = { tags }; DirectDrawTrueColorA((a0), (a1), (a2), (a3), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	DoPictureMethodA(pic, method, arguments)	_DoPictureMethodA(GUIGFX_BASE_NAME, pic, method, arguments)

static __inline ULONG
_DoPictureMethodA(void *GuiGFXBase, APTR pic, ULONG method, ULONG *arguments)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) pic;
	MyCaos.d0		=(ULONG) method;
	MyCaos.a1		=(ULONG) arguments;
	MyCaos.caos_Un.Offset	=	(-138);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((ULONG)PPCCallOS(&MyCaos));
}

#define	DrawPictureA(drawhandle, pic, x, y, tags)	_DrawPictureA(GUIGFX_BASE_NAME, drawhandle, pic, x, y, tags)

static __inline BOOL
_DrawPictureA(void *GuiGFXBase, APTR drawhandle, APTR pic, UWORD x, UWORD y, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) drawhandle;
	MyCaos.a1		=(ULONG) pic;
	MyCaos.d0		=(ULONG) x;
	MyCaos.d1		=(ULONG) y;
	MyCaos.a2		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-114);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((BOOL)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define DrawPicture(a0, a1, a2, a3, tags...) \
	({ULONG _tags[] = { tags }; DrawPictureA((a0), (a1), (a2), (a3), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	GetPictureAttrsA(pic, tags)	_GetPictureAttrsA(GUIGFX_BASE_NAME, pic, tags)

static __inline ULONG
_GetPictureAttrsA(void *GuiGFXBase, APTR pic, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) pic;
	MyCaos.a1		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-144);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((ULONG)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define GetPictureAttrs(a0, tags...) \
	({ULONG _tags[] = { tags }; GetPictureAttrsA((a0), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	IsPictureA(filename, tags)	_IsPictureA(GUIGFX_BASE_NAME, filename, tags)

static __inline BOOL
_IsPictureA(void *GuiGFXBase, char *filename, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) filename;
	MyCaos.a1		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-162);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((BOOL)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define IsPicture(a0, tags...) \
	({ULONG _tags[] = { tags }; IsPictureA((a0), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	LoadPictureA(filename, tags)	_LoadPictureA(GUIGFX_BASE_NAME, filename, tags)

static __inline APTR
_LoadPictureA(void *GuiGFXBase, STRPTR filename, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) filename;
	MyCaos.a1		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-36);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((APTR)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define LoadPicture(a0, tags...) \
	({ULONG _tags[] = { tags }; LoadPictureA((a0), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	LockPictureA(pic, mode, args)	_LockPictureA(GUIGFX_BASE_NAME, pic, mode, args)

static __inline ULONG
_LockPictureA(void *GuiGFXBase, APTR pic, ULONG mode, ULONG *args)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) pic;
	MyCaos.d0		=(ULONG) mode;
	MyCaos.a1		=(ULONG) args;
	MyCaos.caos_Un.Offset	=	(-150);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((ULONG)PPCCallOS(&MyCaos));
}

#define	MakePictureA(array, width, height, tags)	_MakePictureA(GUIGFX_BASE_NAME, array, width, height, tags)

static __inline APTR
_MakePictureA(void *GuiGFXBase, APTR array, UWORD width, UWORD height, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) array;
	MyCaos.d0		=(ULONG) width;
	MyCaos.d1		=(ULONG) height;
	MyCaos.a1		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-30);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((APTR)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define MakePicture(a0, a1, a2, tags...) \
	({ULONG _tags[] = { tags }; MakePictureA((a0), (a1), (a2), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	MapPaletteA(drawhandle, palette, pentab, tags)	_MapPaletteA(GUIGFX_BASE_NAME, drawhandle, palette, pentab, tags)

static __inline BOOL
_MapPaletteA(void *GuiGFXBase, APTR drawhandle, APTR palette, UBYTE *pentab, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) drawhandle;
	MyCaos.a1		=(ULONG) palette;
	MyCaos.a2		=(ULONG) pentab;
	MyCaos.a3		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-120);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((BOOL)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define MapPalette(a0, a1, a2, tags...) \
	({ULONG _tags[] = { tags }; MapPaletteA((a0), (a1), (a2), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	MapPenA(drawhandle, rgb, tags)	_MapPenA(GUIGFX_BASE_NAME, drawhandle, rgb, tags)

static __inline LONG
_MapPenA(void *GuiGFXBase, APTR drawhandle, ULONG rgb, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) drawhandle;
	MyCaos.a1		=(ULONG) rgb;
	MyCaos.a2		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-126);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((LONG)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define MapPen(a0, a1, tags...) \
	({ULONG _tags[] = { tags }; MapPenA((a0), (a1), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	ObtainDrawHandleA(psm, rastport, cm, tags)	_ObtainDrawHandleA(GUIGFX_BASE_NAME, psm, rastport, cm, tags)

static __inline APTR
_ObtainDrawHandleA(void *GuiGFXBase, APTR psm, struct RastPort *rastport, struct ColorMap *cm, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) psm;
	MyCaos.a1		=(ULONG) rastport;
	MyCaos.a2		=(ULONG) cm;
	MyCaos.a3		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-102);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((APTR)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define ObtainDrawHandle(a0, a1, a2, tags...) \
	({ULONG _tags[] = { tags }; ObtainDrawHandleA((a0), (a1), (a2), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	ReadPictureA(rastport, colormap, x, y, width, height, tags)	_ReadPictureA(GUIGFX_BASE_NAME, rastport, colormap, x, y, width, height, tags)

static __inline APTR
_ReadPictureA(void *GuiGFXBase, struct RastPort *rastport, struct ColorMap *colormap, UWORD x, UWORD y, UWORD width, UWORD height, struct TagItem *tags)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) rastport;
	MyCaos.a1		=(ULONG) colormap;
	MyCaos.d0		=(ULONG) x;
	MyCaos.d1		=(ULONG) y;
	MyCaos.d2		=(ULONG) width;
	MyCaos.d3		=(ULONG) height;
	MyCaos.a2		=(ULONG) tags;
	MyCaos.caos_Un.Offset	=	(-42);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	return((APTR)PPCCallOS(&MyCaos));
}

#ifndef NO_PPCINLINE_STDARG
#define ReadPicture(a0, a1, a2, a3, a4, a5, tags...) \
	({ULONG _tags[] = { tags }; ReadPictureA((a0), (a1), (a2), (a3), (a4), (a5), (struct TagItem *)_tags);})
#endif /* !NO_PPCINLINE_STDARG */

#define	ReleaseDrawHandle(drawhandle)	_ReleaseDrawHandle(GUIGFX_BASE_NAME, drawhandle)

static __inline void
_ReleaseDrawHandle(void *GuiGFXBase, APTR drawhandle)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) drawhandle;
	MyCaos.caos_Un.Offset	=	(-108);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	PPCCallOS(&MyCaos);
}

#define	RemColorHandle(colorhandle)	_RemColorHandle(GUIGFX_BASE_NAME, colorhandle)

static __inline void
_RemColorHandle(void *GuiGFXBase, APTR colorhandle)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) colorhandle;
	MyCaos.caos_Un.Offset	=	(-84);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	PPCCallOS(&MyCaos);
}

#define	UnLockPicture(pic, mode)	_UnLockPicture(GUIGFX_BASE_NAME, pic, mode)

static __inline void
_UnLockPicture(void *GuiGFXBase, APTR pic, ULONG mode)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a0		=(ULONG) pic;
	MyCaos.d0		=(ULONG) mode;
	MyCaos.caos_Un.Offset	=	(-156);
	MyCaos.a6		=(ULONG) GuiGFXBase;	
	PPCCallOS(&MyCaos);
}

#endif /* SASC Pragmas */
#endif /* !_PPCPRAGMA_GUIGFX_H */