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

#ifndef _PPCPRAGMA_PICASSO96API_H
#define _PPCPRAGMA_PICASSO96API_H
#ifdef __GNUC__
#ifndef _PPCINLINE__PICASSO96API_H
#include <ppcinline/Picasso96API.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 PICASSO96API_BASE_NAME
#define PICASSO96API_BASE_NAME P96Base
#endif /* !PICASSO96API_BASE_NAME */

#define	p96AllocBitMap(SizeX, SizeY, Depth, Flags, Friend, RGBFormat)	_p96AllocBitMap(PICASSO96API_BASE_NAME, SizeX, SizeY, Depth, Flags, Friend, RGBFormat)

static __inline struct BitMap *
_p96AllocBitMap(void *P96Base, ULONG SizeX, ULONG SizeY, ULONG Depth, ULONG Flags, struct BitMap *Friend, RGBFTYPE RGBFormat)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.d0		=(ULONG) SizeX;
	MyCaos.d1		=(ULONG) SizeY;
	MyCaos.d2		=(ULONG) Depth;
	MyCaos.d3		=(ULONG) Flags;
	MyCaos.a0		=(ULONG) Friend;
	MyCaos.d7		=(ULONG) RGBFormat;
	MyCaos.caos_Un.Offset	=	(-30);
	MyCaos.a6		=(ULONG) P96Base;	
	return((struct BitMap *)PPCCallOS(&MyCaos));
}

#define	p96AllocModeListTagList(Tags)	_p96AllocModeListTagList(PICASSO96API_BASE_NAME, Tags)

static __inline struct List *
_p96AllocModeListTagList(void *P96Base, 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	=	(-72);
	MyCaos.a6		=(ULONG) P96Base;	
	return((struct List *)PPCCallOS(&MyCaos));
}

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

#define	p96BestModeIDTagList(Tags)	_p96BestModeIDTagList(PICASSO96API_BASE_NAME, Tags)

static __inline ULONG
_p96BestModeIDTagList(void *P96Base, 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	=	(-60);
	MyCaos.a6		=(ULONG) P96Base;	
	return((ULONG)PPCCallOS(&MyCaos));
}

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

#define	p96CloseScreen(Screen)	_p96CloseScreen(PICASSO96API_BASE_NAME, Screen)

static __inline BOOL
_p96CloseScreen(void *P96Base, struct Screen *Screen)
{
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) Screen;
	MyCaos.caos_Un.Offset	=	(-96);
	MyCaos.a6		=(ULONG) P96Base;	
	return((BOOL)PPCCallOS(&MyCaos));
}

#define	p96FreeBitMap(BitMap)	_p96FreeBitMap(PICASSO96API_BASE_NAME, BitMap)

static __inline void
_p96FreeBitMap(void *P96Base, struct BitMap *BitMap)
{
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) BitMap;
	MyCaos.caos_Un.Offset	=	(-36);
	MyCaos.a6		=(ULONG) P96Base;	
	PPCCallOS(&MyCaos);
}

#define	p96FreeModeList(List)	_p96FreeModeList(PICASSO96API_BASE_NAME, List)

static __inline void
_p96FreeModeList(void *P96Base, struct List *List)
{
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) List;
	MyCaos.caos_Un.Offset	=	(-78);
	MyCaos.a6		=(ULONG) P96Base;	
	PPCCallOS(&MyCaos);
}

#define	p96GetBitMapAttr(BitMap, Attribute)	_p96GetBitMapAttr(PICASSO96API_BASE_NAME, BitMap, Attribute)

static __inline ULONG
_p96GetBitMapAttr(void *P96Base, struct BitMap *BitMap, ULONG Attribute)
{
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) BitMap;
	MyCaos.d0		=(ULONG) Attribute;
	MyCaos.caos_Un.Offset	=	(-42);
	MyCaos.a6		=(ULONG) P96Base;	
	return((ULONG)PPCCallOS(&MyCaos));
}

#define	p96GetModeIDAttr(Mode, Attribute)	_p96GetModeIDAttr(PICASSO96API_BASE_NAME, Mode, Attribute)

static __inline ULONG
_p96GetModeIDAttr(void *P96Base, ULONG Mode, ULONG Attribute)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.d0		=(ULONG) Mode;
	MyCaos.d1		=(ULONG) Attribute;
	MyCaos.caos_Un.Offset	=	(-84);
	MyCaos.a6		=(ULONG) P96Base;	
	return((ULONG)PPCCallOS(&MyCaos));
}

#define	p96LockBitMap(BitMap, Buffer, Size)	_p96LockBitMap(PICASSO96API_BASE_NAME, BitMap, Buffer, Size)

static __inline LONG
_p96LockBitMap(void *P96Base, struct BitMap *BitMap, UBYTE *Buffer, ULONG Size)
{
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) BitMap;
	MyCaos.a1		=(ULONG) Buffer;
	MyCaos.d0		=(ULONG) Size;
	MyCaos.caos_Un.Offset	=	(-48);
	MyCaos.a6		=(ULONG) P96Base;	
	return((LONG)PPCCallOS(&MyCaos));
}

#define	p96OpenScreenTagList(Tags)	_p96OpenScreenTagList(PICASSO96API_BASE_NAME, Tags)

static __inline struct Screen *
_p96OpenScreenTagList(void *P96Base, 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) P96Base;	
	return((struct Screen *)PPCCallOS(&MyCaos));
}

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

#define	p96PIP_Close(Window)	_p96PIP_Close(PICASSO96API_BASE_NAME, Window)

static __inline BOOL
_p96PIP_Close(void *P96Base, struct Window *Window)
{
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) Window;
	MyCaos.caos_Un.Offset	=	(-150);
	MyCaos.a6		=(ULONG) P96Base;	
	return((BOOL)PPCCallOS(&MyCaos));
}

#define	p96PIP_GetIMsg(Port)	_p96PIP_GetIMsg(PICASSO96API_BASE_NAME, Port)

static __inline struct IntuiMessage *
_p96PIP_GetIMsg(void *P96Base, struct MsgPort *Port)
{
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) Port;
	MyCaos.caos_Un.Offset	=	(-168);
	MyCaos.a6		=(ULONG) P96Base;	
	return((struct IntuiMessage *)PPCCallOS(&MyCaos));
}

#define	p96PIP_GetTagList(Window, Tags)	_p96PIP_GetTagList(PICASSO96API_BASE_NAME, Window, Tags)

static __inline LONG
_p96PIP_GetTagList(void *P96Base, struct Window *Window, 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) Window;
	MyCaos.a1		=(ULONG) Tags;
	MyCaos.caos_Un.Offset	=	(-162);
	MyCaos.a6		=(ULONG) P96Base;	
	return((LONG)PPCCallOS(&MyCaos));
}

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

#define	p96PIP_OpenTagList(Tags)	_p96PIP_OpenTagList(PICASSO96API_BASE_NAME, Tags)

static __inline struct Window *
_p96PIP_OpenTagList(void *P96Base, 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	=	(-144);
	MyCaos.a6		=(ULONG) P96Base;	
	return((struct Window *)PPCCallOS(&MyCaos));
}

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

#define	p96PIP_ReplyIMsg(IntuiMessage)	_p96PIP_ReplyIMsg(PICASSO96API_BASE_NAME, IntuiMessage)

static __inline void
_p96PIP_ReplyIMsg(void *P96Base, struct IntuiMessage *IntuiMessage)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a1		=(ULONG) IntuiMessage;
	MyCaos.caos_Un.Offset	=	(-174);
	MyCaos.a6		=(ULONG) P96Base;	
	PPCCallOS(&MyCaos);
}

#define	p96PIP_SetTagList(Window, Tags)	_p96PIP_SetTagList(PICASSO96API_BASE_NAME, Window, Tags)

static __inline LONG
_p96PIP_SetTagList(void *P96Base, struct Window *Window, 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) Window;
	MyCaos.a1		=(ULONG) Tags;
	MyCaos.caos_Un.Offset	=	(-156);
	MyCaos.a6		=(ULONG) P96Base;	
	return((LONG)PPCCallOS(&MyCaos));
}

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

#define	p96ReadPixel(rp, x, y)	_p96ReadPixel(PICASSO96API_BASE_NAME, rp, x, y)

static __inline ULONG
_p96ReadPixel(void *P96Base, struct RastPort *rp, UWORD x, UWORD y)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a1		=(ULONG) rp;
	MyCaos.d0		=(ULONG) x;
	MyCaos.d1		=(ULONG) y;
	MyCaos.caos_Un.Offset	=	(-120);
	MyCaos.a6		=(ULONG) P96Base;	
	return((ULONG)PPCCallOS(&MyCaos));
}

#define	p96ReadPixelArray(ri, DestX, DestY, rp, SrcX, SrcY, SizeX, SizeY)	_p96ReadPixelArray(PICASSO96API_BASE_NAME, ri, DestX, DestY, rp, SrcX, SrcY, SizeX, SizeY)

static __inline void
_p96ReadPixelArray(void *P96Base, struct RenderInfo *ri, UWORD DestX, UWORD DestY, struct RastPort *rp, UWORD SrcX, UWORD SrcY, UWORD SizeX, UWORD SizeY)
{
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) ri;
	MyCaos.d0		=(ULONG) DestX;
	MyCaos.d1		=(ULONG) DestY;
	MyCaos.a1		=(ULONG) rp;
	MyCaos.d2		=(ULONG) SrcX;
	MyCaos.d3		=(ULONG) SrcY;
	MyCaos.d4		=(ULONG) SizeX;
	MyCaos.d5		=(ULONG) SizeY;
	MyCaos.caos_Un.Offset	=	(-108);
	MyCaos.a6		=(ULONG) P96Base;	
	PPCCallOS(&MyCaos);
}

#define	p96ReadTrueColorData(tci, DestX, DestY, rp, SrcX, SrcY, SizeX, SizeY)	_p96ReadTrueColorData(PICASSO96API_BASE_NAME, tci, DestX, DestY, rp, SrcX, SrcY, SizeX, SizeY)

static __inline void
_p96ReadTrueColorData(void *P96Base, struct TrueColorInfo *tci, UWORD DestX, UWORD DestY, struct RastPort *rp, UWORD SrcX, UWORD SrcY, UWORD SizeX, UWORD SizeY)
{
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) tci;
	MyCaos.d0		=(ULONG) DestX;
	MyCaos.d1		=(ULONG) DestY;
	MyCaos.a1		=(ULONG) rp;
	MyCaos.d2		=(ULONG) SrcX;
	MyCaos.d3		=(ULONG) SrcY;
	MyCaos.d4		=(ULONG) SizeX;
	MyCaos.d5		=(ULONG) SizeY;
	MyCaos.caos_Un.Offset	=	(-138);
	MyCaos.a6		=(ULONG) P96Base;	
	PPCCallOS(&MyCaos);
}

#define	p96RectFill(rp, MinX, MinY, MaxX, MaxY, color)	_p96RectFill(PICASSO96API_BASE_NAME, rp, MinX, MinY, MaxX, MaxY, color)

static __inline void
_p96RectFill(void *P96Base, struct RastPort *rp, UWORD MinX, UWORD MinY, UWORD MaxX, UWORD MaxY, ULONG color)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a1		=(ULONG) rp;
	MyCaos.d0		=(ULONG) MinX;
	MyCaos.d1		=(ULONG) MinY;
	MyCaos.d2		=(ULONG) MaxX;
	MyCaos.d3		=(ULONG) MaxY;
	MyCaos.d4		=(ULONG) color;
	MyCaos.caos_Un.Offset	=	(-126);
	MyCaos.a6		=(ULONG) P96Base;	
	PPCCallOS(&MyCaos);
}

#define	p96RequestModeIDTagList(Tags)	_p96RequestModeIDTagList(PICASSO96API_BASE_NAME, Tags)

static __inline ULONG
_p96RequestModeIDTagList(void *P96Base, 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	=	(-66);
	MyCaos.a6		=(ULONG) P96Base;	
	return((ULONG)PPCCallOS(&MyCaos));
}

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

#define	p96UnlockBitMap(BitMap, Lock)	_p96UnlockBitMap(PICASSO96API_BASE_NAME, BitMap, Lock)

static __inline void
_p96UnlockBitMap(void *P96Base, struct BitMap *BitMap, LONG Lock)
{
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) BitMap;
	MyCaos.d0		=(ULONG) Lock;
	MyCaos.caos_Un.Offset	=	(-54);
	MyCaos.a6		=(ULONG) P96Base;	
	PPCCallOS(&MyCaos);
}

#define	p96WritePixel(rp, x, y, color)	_p96WritePixel(PICASSO96API_BASE_NAME, rp, x, y, color)

static __inline ULONG
_p96WritePixel(void *P96Base, struct RastPort *rp, UWORD x, UWORD y, ULONG color)
{
struct Caos	MyCaos;
	MyCaos.M68kCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.M68kStart	=	NULL;
//	MyCaos.M68kSize		=	0;
	MyCaos.PPCCacheMode	=	IF_CACHEFLUSHALL;
//	MyCaos.PPCStart		=	NULL;
//	MyCaos.PPCSize		=	0;
	MyCaos.a1		=(ULONG) rp;
	MyCaos.d0		=(ULONG) x;
	MyCaos.d1		=(ULONG) y;
	MyCaos.d2		=(ULONG) color;
	MyCaos.caos_Un.Offset	=	(-114);
	MyCaos.a6		=(ULONG) P96Base;	
	return((ULONG)PPCCallOS(&MyCaos));
}

#define	p96WritePixelArray(ri, SrcX, SrcY, rp, DestX, DestY, SizeX, SizeY)	_p96WritePixelArray(PICASSO96API_BASE_NAME, ri, SrcX, SrcY, rp, DestX, DestY, SizeX, SizeY)

static __inline void
_p96WritePixelArray(void *P96Base, struct RenderInfo *ri, UWORD SrcX, UWORD SrcY, struct RastPort *rp, UWORD DestX, UWORD DestY, UWORD SizeX, UWORD SizeY)
{
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) ri;
	MyCaos.d0		=(ULONG) SrcX;
	MyCaos.d1		=(ULONG) SrcY;
	MyCaos.a1		=(ULONG) rp;
	MyCaos.d2		=(ULONG) DestX;
	MyCaos.d3		=(ULONG) DestY;
	MyCaos.d4		=(ULONG) SizeX;
	MyCaos.d5		=(ULONG) SizeY;
	MyCaos.caos_Un.Offset	=	(-102);
	MyCaos.a6		=(ULONG) P96Base;	
	PPCCallOS(&MyCaos);
}

#define	p96WriteTrueColorData(tci, SrcX, SrcY, rp, DestX, DestY, SizeX, SizeY)	_p96WriteTrueColorData(PICASSO96API_BASE_NAME, tci, SrcX, SrcY, rp, DestX, DestY, SizeX, SizeY)

static __inline void
_p96WriteTrueColorData(void *P96Base, struct TrueColorInfo *tci, UWORD SrcX, UWORD SrcY, struct RastPort *rp, UWORD DestX, UWORD DestY, UWORD SizeX, UWORD SizeY)
{
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) tci;
	MyCaos.d0		=(ULONG) SrcX;
	MyCaos.d1		=(ULONG) SrcY;
	MyCaos.a1		=(ULONG) rp;
	MyCaos.d2		=(ULONG) DestX;
	MyCaos.d3		=(ULONG) DestY;
	MyCaos.d4		=(ULONG) SizeX;
	MyCaos.d5		=(ULONG) SizeY;
	MyCaos.caos_Un.Offset	=	(-132);
	MyCaos.a6		=(ULONG) P96Base;	
	PPCCallOS(&MyCaos);
}

#endif /* SASC Pragmas */
#endif /* !_PPCPRAGMA_PICASSO96API_H */