/* This is the modified sl-aztec.c file which I call "manx.c".  It includes *
 * most (but probably not all) standard library, Aztec C68K, and Amiga      *
 * specific functions.  DOS 1.2 functions are missing.  Some of the return  * 
 * types may be incorrect.  Please correct any errors you find, add any     * 
 * of the missing functions, and let me know of any changes so I can be     *
 * current also. Bixmail to althoff.                                        *
 *                                                                          * 
 * Modified 7/2/86 by althoff                                               *
 *                                                                          *
 * Modified 4/10/87 by althoff. Additional 1.2 functions added.             *
 * Updated for Lint 2.0.  Corrected some typo errors and updated function   *
 * return types per Gamma Auto-docs, where possible.  This file *STILL*     *
 * needs close inspection and correction.                                   *
 *                                                                          *
 * Modified 5/10/87 by althoff. More corrections.                           *
 ***************************************************************************/
/*lint -save */
#include "exec/types.h"
#include "stdio.h"
extern long Enable_Abort;
/*lint -e715 */
/*lint -e530 */
/*lint -e533 */
/*lint -library */
/*lint +fvr */

long lseek();
long fseek();
int fwrite();
int close();
int fclose();
int creat();

int strcpy();
int strcat();
int strncpy();
int putc();
int puts();
int aputc();
long time();
int unlink();
int write();
/*lint +fva */

int fprintf() {}
int printf() {}
int sprintf() {}
int scanf() {}
int fscanf() {}
int sscanf() {}
int format() {}
/*lint -fvr */
/*lint -fva */

/*lint -e718 */

s_y_s_t_e_m()
{
int argc;
char * *argv;
main( argc, argv );
}

/*lint +e718 */


FILE Cbuffs[];
void flsh_(f,n)
     FILE * f;
     int n; { }

int agetc(stream) FILE * stream; {}
int aputc( c, f) 
      char c;
      FILE * f; {}
double atof(cp) char * cp; { }
int atoi(cp) char * cp; { }
long atol(cp) char * cp; { }

char * calloc(nelem,elemsize)
       unsigned int nelem,elemsize;{ }
int close(fd) int fd; { }
int creat( fname, mode ) char * fname; int mode; { }
void exit(n) int n; { }

double fabs(x) double x; { }
int fclose(stream) FILE * stream; { }
FILE * fdopen(fd,mode) char *mode; int fd;{ }
char * fgets( buf, len, f ) char * buf; int len; FILE * f; { }
FILE * fopen(filename, mode ) char * filename, *mode; { }
int fputs(s,f)
      char * s;
      FILE * f; {}
    
int fread(buffer,size,count,stream)
      char * buffer;int size, count; FILE * stream; {}
FILE * freopen(filename,mode,stream)
       char * filename,* mode; FILE * stream; { }
int free(ptr) char * ptr; {}
long ftell( f ) FILE * f; { }
int ftoa(val,buf,precision,type)
      double val; char *buf; int precision,type;{}
      
int fwrite(buffer,size,count,stream) 
      char *buffer; int size,count; FILE *stream;{ }
char * gets( buf) char * buf; { }
int getw(stream) FILE *stream;{}


char * index(s,c)
       char *s;
       char c;{}
int isalpha(c) int c;{}
int isupper(c) int c;{}
int islower(c) int c;{}
int isdigit(c) int c;{}
int isalnum(c) int c;{}
int isspace(c) int c;{}
int ispunct(c) int c;{}
int isprint(c) int c;{}
int iscntrl(c) int c;{}
int isascii(c) int c;{}

long int lseek( fd, offset, origin ) int fd, origin; long offset; { }
char * malloc(size) unsigned int size; { }
int movmem(src,dest,length) char * src, *dest; int length; { }
int open( name, mode )
      char * name; 
      int mode; { }

int putc(c,stream)
      char c;
      FILE *stream;{}
      
int puterr(c)
      char c;{}
    
int puts(s)
      char * s; {}

int putw(w,stream)
     int w;
     FILE * stream;{}

int qsort(array,number,width,func)
      char * array;
      unsigned int number,width;
      int(*func)();{}

double ran();
int read( fd, buf, bufsize) 
    int fd, bufsize; 
    char * buf; { }
int rename(oldname,newname) char *oldname,*newname;{}
int realloc(ptr, size ) char * ptr; unsigned int size; { }
int rindex(s,c)
       char *s;
       char c;{}
int setmem(area,length,value) char *area; int length; char value;{}
int swapmem(s1,s2,len) char * s1,*s2; int len;{}

int strcat( s1, s2 ) char * s1,* s2; { }
int strcmp( s1, s2 ) char * s1,* s2; { }

int strcpy( s1, s2 ) char * s1, *s2; { }

int strlen(s) char * s; { }
int strncat( s1, s2, n ) char * s1,* s2; int n; { }
int strncmp( s1, s2, n ) char * s1, *s2; int n; { }
int strncpy( s1, s2, n ) char * s1,* s2; int n; { }
int tolower(c) char c; { }
int toupper(c) char c; { }
int unlink( nm ) char * nm; { }
int ungetc(c,stream) 
      char c;
      FILE *stream;{ }
int write( fd, buf, bufsize) int fd, bufsize; char * buf; { }


long AbleICR(mask) long mask;{}

long AbortIO(ioRequest) 
     struct IORequest *ioRequest;{}

BOOL ActivateGadget(Gadget, Window, Request) 
     struct Gadget *Gadget;
     struct Window *Window;
     struct Requester *Request;{}
     
void ActivateWindow (Window) struct Window *Window; {}
void AddAnimOb(anOb,anKey,rPort) struct AnimOb *anOb, **anKey;
struct RastPort *rPort;{}
void AddBob(bob,rPort) struct Bob *bob; struct RastPort *rPort; {}
void AddConfigDev(configDev) struct ConfigDev *configDev; {}

void AddDevice(device)
     struct Device *device;{}
     
long AddDosNode(bootPri, flags, deviceNode) long bootPri, flags; 
struct Node *deviceNode; {}
void AddFont(textFont) struct TextFont *textFont;{}
void AddFreeList(free,mem,len) struct FreeList *free;char *mem;long len;{}

USHORT AddGadget(window,gadget,position)
       struct Window *window;
       struct Gadget *gadget;
       long position;{}

USHORT AddGList(Window, Gadget, Position, Numgad, Requester) 
       struct Window *Window;
       struct Gadget *Gadget;
       USHORT Position, Numgad;
       struct Requester *Requester; {}
       
void AddHead(list,node) 
     struct List *list; 
     struct Node *node;{}
     
struct Interrupt * AddICRVector(iCRBit, interrupt) long iCRBit;
struct Interrupt *interrupt;{}

void AddIntServer(intNum,interrupt)
     long intNum;
     struct Interrupt *interrupt;{}
     
void AddLibrary(library)
     struct Library *library;{}
     
long AddMemList (size, attributes, pri, base, name) 
     long size, attributes, pri,base; 
     UBYTE *name; {}
     
void AddPort(port)
     struct MsgPort *port;{}
     
void AddResource(resource)
     struct MiscResource *resource;{}
     
void AddSemaphore (signalSemaphore)
     struct Semaphore *signalSemaphore; {}
     
void AddTail(list,node)
     struct List *list;
     struct Node *node;{}
     
void AddTask(task,initialPC,finalPC)
     struct Task *task;
     long initialPC,finalPC;{}
     
void AddTime(dest,source) struct TimeVal *dest, *source;{}
void AddVSprite(vs,rPort)
struct VSprite *vs; struct RastPort *rPort;{}

long Alert(alertNum,parameters)
     long alertNum,parameters;{}
     
void * AllocAbs(bytSiz,location)
       long bytSiz;
       UBYTE *location;{}
       
long AllocBoardMem(slotSpec) long slotSpec; {}
long AllocCList(cLPool) long cLPool;{}
struct ConfigDev *AllocConfigDev();

struct MemList * AllocEntry(memList)
       struct MemList *memList;{}
       
CPTR AllocExpansionMem(numSlots, slotOffset)
     long numSlots, slotOffset ; {}

char * AllocMem(byteSize,requirements)
       long byteSize,requirements;{}
       
long AllocPotBits(bits) long bits;{}
void *AllocRaster(width,height) long width,height;{}

char * AllocRemember(rememberKey, size, flags)
     struct Remember **rememberKey;
     ULONG size, flags;{}
     
long AllocSignal(signalNum)
     long signalNum;{}
     
long AllocTrap(trapNum) 
     long trapNum;{}
     
long AllocUnit (unitNum) long unitNum; {}
struct WBObject * AllocWBObject();

void * Allocate(freeList,byteSize)
       struct List *freeList;
       long byteSize;{}
       
void AlohaWorkBench(wbPort) struct MsgPort *wbPort;{}
void AndRectRegion(region, rectangle)
struct Region *region; struct Rectangle *rectangle;{}
void Animate(key,rPort) struct AnimOb **key; struct RastPort *rPort;{}
long AreaCircle(rp, cx,cy,radius) struct RastPort *rp; long cx,cy,radius; {}
long AreaDraw(rp,x,y) struct RastPort *rp; long x,y;{}
long AreaEllipse(rp, cx, cy, a, b) struct RastPort *rp; long cx,cy,a,b;{}
long AreaEnd(rp) struct RastPort *rp;{}
long AreaMove(rp,x,y) struct RastPort *rp; long x,y;{}
void AskFont(rp,textAttr)struct RastPort *rp; struct TextAttr *textAttr;{}
long AskSoftStyle(rp) struct RastPort *rp;{}
long AttemptLockLayerRom(layer) struct Layer *layer; {}

long AttemptSemaphore(signalSemaphore) 
     struct Semaphore *signalSemaphore; {}

BOOL AutoRequest(window,body,positive,negative,posFlags,negFlags,width,height)
     struct Window *window;
     struct IntuiText *body,*positive,*negative;
     ULONG posFlags,negFlags;
     SHORT width,height;{}
     
long AvailFonts(buffer,bufBytes,types)char *buffer;long bufBytes,types;{}

long AvailMem(requirements)
      long requirements;{}
     
void BeginIO(ioRequest) struct IORequest *ioRequest;{}

void BeginRefresh(window)
     struct Window *window;{}

BOOL BeginUpdate(l) struct Layer *l;{}
long BehindLayer(dummy,l) long dummy; struct Layer *l;{}
long BltBitMap(srcBM,srcX,srcY,dstBM,dstX,dstY,sizX,sizY,minTerm,mask,tempA)
struct BitMap *srcBM,*dstBM;long srcX,srcY,dstX,dstY,sizX,sizY,minTerm,mask;{}
long BltBitMapRastPort(srcBitMap,srcX,srcY,dstBitMap,dstX,dstY,sizX,sizY,
minTerm)
struct BitMap *srcBitMap,*dstBitMap;long srcX,srcY,dstX,dstY,sizX,sizY,
minTerm;{}
void BltClear(memBlock,byteCount,flags) char *memBlock;long byteCount,flags;{}
void BltMaskBitMapRastPort(srcBM,srcX,srcY,dstrp,dstX,dstY,sizX,sizY,minTerm,
bltmask)
struct BitMap *srcBM; long srcX, srcY; struct RastPort *dstrp;
long dstX,dstY,sizX,sizY, minTerm; char *bltmask; {}
void BltPattern(rp,buf,x1,y1,maxX,maxY,byteCnt)struct RastPort *rp;char *buf;
long x1,y1,maxX,maxY,byteCnt;{}
void BltTemplate(src,srcX,srcMod,dstRastPort,dstX,dstY,sizX,sizY)
char *src;struct RastPort *dstRastPort;
long srcX,srcMod,dstX,dstY,sizX,sizY;{}

struct Window * BuildSysRequest(wind,body,positive,negative,IDCMPflags,width,height)
                struct Window *wind;
                struct IntuiText *body,*positive, *negative;
                ULONG IDCMPflags;
                SHORT width,height;{}
                
char * BumpRevision(newbuf,oldname) char *newbuf,*oldname;{}
void CBump(c) struct UCopList *c;{}
struct Events *CDInputHandler(events,consoleDevice) struct Events *events;
struct Device *consoleDevice;{}
void CWait(c,v,h) struct UCopList *c; long v,h;{}

void Cause(interrupt)
     struct Interrupt *interrupt;{}
     
void ChangeSprite(vp,s,newdata) struct ViewPort *vp;struct SimpleSprite *s;
struct spriteimage *newdata;{}

long Chk_Abort(void);

struct IORequest* CheckIO(ioRequest)
                  struct IORequest *ioRequest;{}

BOOL ClearDMRequest(window) 
     struct Window *window;{}
     
void ClearEOL(rp) struct RastPort *rp;{}

void ClearMenuStrip(window)
     struct Window *window;{}
     
void ClearPointer(window)
     struct Window *window;{}
     
long ClearRectRegion(region, rectangle) struct Region *region; 
struct Rectangle *rectangle; {}
void ClearRegion(region) struct Region *region;{}
void ClearScreen(rp) struct RastPort *rp;{}
void ClipBlit(src,srcX,srcY,dst,dstX,dstY,xSize,ySize,mode)
struct RastPort *src,*dst;long srcX,srcY,dstX,dstY,xSize,ySize,mode;{}
void Close(file) struct fileHandle *file;{}

void CloseDevice(ioRequest)
     struct IORequest *ioRequest;{}
     
void CloseFont(font) struct TextFont *font;{}

void CloseLibrary(library)
     struct Library *library;{}

void CloseScreen(screen)
     struct Screen *screen;{}

void CloseWindow(window)
     struct Window *window;{}
     
BOOL CloseWorkBench();

void Cmove(c,a,v) struct UCopList *c; long *a,v;{}
long CmpTime(dest,source)
      struct TimeVal *dest,*source;{}
      
long ConcatCList(sourceCList,destCList) long sourceCList,destCList;{}
long ConfigBoard(board, configDev) long board; struct ConfigDev *configDev;{}
long ConfigChain(baseAddr) long baseAddr;{}
long CopyCList(cList) long cList;{}

void CopyMem (source, dest, size) 
     char *source, *dest;
     long size; {}
     
void CopyMemQuick (source, dest, size)
     char *source, *dest; 
     long size; {}
     
void CopySBitMap(layer) struct Layer *layer;{}
struct Layer *CreateBehindLayer(li,bm,x0,y0,x1,y1,flags) struct LayerInfo *li;
struct BitMap *bm; long x0,y0,x1,y1,flags;{}
struct FileLock * CreateDir(name) char *name;{}
struct IORequest *CreateExtIO(ioReplyPort, size) struct MsgPort *ioReplyPort;
long size; {}
struct MsgPort* CreatePort(name,pri) char *name; long pri;{}
struct Process * CreateProc(name,pri,segment,stackSize) char *name;
struct Segment *segment; long pri,stackSize;{}
struct IOStdReq * CreateStdIO(mp) struct MsgPort *mp;{}
struct Task * CreateTask(name,pri,start_pc,stksiz) char *name;
long pri,start_pc,stksiz;{}
struct Layer *CreateUpfrontLayer(li,bm,x0,y0,x1,y1,flags) struct LayerInfo *li;
struct BitMap *bm; long x0,y0,x1,y1,flags;{}
struct FileLock * CurrentDir(lock) struct FileLock *lock;{}

void CurrentTime(seconds,micros)
     ULONG *seconds, *micros;{}
     
long * DateStamp(v) long *v;{}

void Deallocate(freeList,memoryBlock,byteSize) 
     struct List *freeList;
     char *memoryBlock;
     long byteSize;{}
     
void Debug();

void Delay(timeout) long timeout;{}
void DeleteExtIO (ioReq) struct IORequest *ioReq; {}
long DeleteFile(name) char *name;{} /* check value */
BOOL DeleteLayer(li,l)long li;struct Layer *l;{}
void DeletePort(port) struct MsgPort *port;{}
void DeleteStdIO(iop) struct IOStdReq *iop;{}
void DeleteTask(tp) struct Task *tp;{}
struct Process * DeviceProc(name) char *name;{}

void Disable();

struct DiscResourceUnit *GetUnit (unitPointer) 
struct DiscResourceUnit *unitPointer; {}
void DisownBlitter();

BOOL DisplayAlert(alertNumber,string,height)
     ULONG alertNumber;
     UBYTE *string; 
     SHORT height;{}
     
void DisplayBeep(screen)
     struct Screen *screen;{}
     
void DisposeLayerInfo(li) struct Layer_Info *li; {}
void DisposeRegion(region) struct Region *region;{}
void DoCollision(rPort) struct RastPort *rPort;{}

/*lint +fva */
long DoIO();
     /* struct IORequest *ioRequest;{}  */
     /* long ioRequest;{}               */
/*lint -fva */

BOOL DoubleClick(startSeconds,startMicros,currentSeconds,currentMicros)
     LONG startSeconds,startMicros,currentSeconds,currentMicros;{}
     
void Draw(rp,x,y) struct RastPort *rp; long x,y;{}

void DrawBorder(rp,b,leftOffset,topOffset)
     struct RastPort *rp;
     struct Border *b;
     SHORT leftOffset, topOffset;{}
     
void DrawEllipse(rp,cx,cy,a,b) struct RastPort *rp; long cx,cy,a,b;{}
void DrawGList(rPort,vPort)struct RastPort *rPort;struct ViewPort *vPort;{}

void DrawImage(rp,image,leftOffset,topOffset)
     struct RastPort *rp;
     struct Image *image;
     SHORT leftOffset,topOffset;{}

struct FileLock * DupLock(lock) struct FileLock *lock;{}

void Enable();

void EndRefresh(window,complete)
     struct Window *window;
     BOOL complete;{}
     
void EndRequest(Requester, Window)
     struct Requester *Requester;
     struct Window *Window; {}
     
void EndUpdate(l,flag) struct Layer *l; long flag;{}

void Enqueue(list,node) 
     struct List *list;
     struct Node *node;{}
     
long ExNext(lock,fileInfoBlock) struct FileLock *lock;/*check value */
struct FileInfoBlock *fileInfoBlock;{}
long Examine(lock,fileInfoBlock)struct FileLock *lock;/*check value */
struct FileInfoBlock *fileInfoBlock;{}
long Execute(commandString,input,output) char *commandString;/*check value*/
struct FileHandle *input, *output;{}
void Exit(returnCode) long returnCode;{}
void FattenLayerInfo (li)struct Layer_Info *li; {}
struct ConfigDev *FindConfigDev(oldConfigDev, manufacturer, product)
struct ConfigDev *oldConfigDev; long manufacturer, product; {}

struct Node * FindName(list,name)
       struct List *list;
       char *name;{}
       
struct MsgPort * FindPort(name)
       char *name;{}
       
struct Resident * FindResident(name)
                  char *name; {}
                  
struct Semaphore *FindSemaphore(name)
       char *name; {}
       
struct Task * FindTask(name) 
              char *name;{}
              
char * FindToolType(toolTypeArray,typeName)char **toolTypeArray,*typeName;{}

BOOL Flood(rp,mode,x,y)
     struct RastPort *rp;
     ULONG mode;
     SHORT x,y;{}

void FlushCList(cList) long cList;{}

void Forbid();

void FreeBoardMem(startSlot, slotSpec) long startSlot, slotSpec; {}
void FreeCList(cList) long cList;{}
void FreeColorMap(colormap) struct ColorMap *colormap;{}
void FreeConfigDev(configDev) struct ConfigDev *configDev; {}
void FreeCopList(coplist) struct CopList *coplist;{}
void FreeCPrList(cprList) struct CprList *cprList;{}
void FreeDiskObject(diskobj) struct DiskObject *diskobj;{}

void FreeEntry(memList) 
     struct MemList *memList;{}
     
void FreeExpansionMem (startSlot, numSlots) long startSlot, numSlots; {}
void FreeFreeList(free) struct FreeList *free; {}
void FreeGBuffers(anOb,rPort,db)struct AnimOB *anOb;
struct RastPort *rPort; long db;{}

void FreeMem(memoryBlock,byteSize) 
     char *memoryBlock;
     long byteSize;{}
     
void FreeMiscResource(unitNum) long unitNum; {}
void FreePotBits(allocated) long allocated;{}
void FreeRaster(p,width,height) char *p;long width,height;{}

void FreeRemember(key,reallyForget)
     struct Remember *key;
     BOOL reallyForget;{}

void FreeSignal(signalNum)
     long signalNum;{}
     
void FreeSprite(pick) long pick;{}

void FreeSysRequest(wind)
     struct Window *wind;{}
     
void FreeTrap(trapNum) 
     long trapNum;{}
     
void FreeUnit (unitNum) long unitNum; {}
void FreeVPortCopLists(viewPort) struct ViewPort *viewPort;{}
void FreeWBObject(obj) struct WBObject *obj;{}

long GetCC();

long GetCLBuf(cList,buffer,maxlength) long cList;char *buffer;long maxlength;{}
BYTE GetCLChar(cList) long cList;{}
WORD GetCLWord(cList) long cList;{}
struct ColorMap * GetColorMap(entries) long entries;{}
long GetCurrentBinding (currentBinding, size) 
struct CurrentBinding *currentBinding; long size;{}

struct Preferences * GetDefPrefs(prefBuffer,size) 
       struct Preferences *prefBuffer;
       SHORT size;{}
       
struct DiskObject * GetDiskObject(name) char *name;{}
BOOL GetGBuffers(anOb,rPort,db) struct AnimOb *anOb;
struct RastPort *rPort; long db;{}
long GetIcon(name,icon,free) char *name;struct DiskObject *icon;
struct FreeList *free;{}
char *GetMiscResource(unitNum, name) long unitNum; char *name;{}

struct Message * GetMsg(port)
                 struct MsgPort *port;{}

struct Preferences* GetPrefs(buffer,size)
       struct Preferences *buffer;
       long size;{}
       
ULONG GetRGB4(colormap, entry) struct ColorMap *colormap; long entry;{}

BOOL GetScreenData(Buffer, Size, Type, Screen)
     char * Buffer; 
     USHORT Size, Type;
     struct Screen *Screen; {}
     
long GetSprite(sprite,pick) struct SimpleSprite *sprite; long pick;{}
long GetUnitID (unitNum) long unitNum; {}
struct WBObject * GetWBObject(name) char *name;{}

void GiveUnit(); 

long IncrCLMark(cList) long cList;{}

long Info(lock,info_Data)
     struct FileLock *lock;
     struct Info_Data *info_Data;{} /*check value*/
     
void InitArea(areaInfo,buffer,maxVectors)
     struct AreaInfo *areaInfo;
     char *buffer; long maxVectors;{}
void InitBitMap(bm,depth,width,height) struct BitMap *bm;
long depth,width, height;{}
long InitCLPool(cLPool,size) struct cLPool *cLPool; long size;{}

void InitCode(startClass,version) 
     long startClass, version;{}
     
void InitGels(head,tail,gInfo)
     struct VSprite *head,*tail;
     struct GelsInfo *gInfo;{}
     
void InitGMasks(anOb)
     struct AnimOb *anOb;{}


void InitLayers (li)struct Layer_Info *li; {}
void InitMasks(vs) struct VSprite *vs;{}
void InitRastPort(rp) struct RastPort *rp;{}

void InitRequester(req) 
     struct Requester *req;{}

void InitResident(resident,segList)
     long resident, segList;{}
     
void InitSemaphore(signalSemaphore)
     struct Semaphore *signalSemaphore; {}
     
void InitStruct(initTable,memory,size)
     long *initTable;
     char *memory;
     long size;{}
     
void InitTmpRas(tmpRas,buffer,size)struct TmpRas *tmpRas;
char *buffer; long size;{}
void InitVPort(vp) struct ViewPort *vp;{}
void InitView(view) struct View *view;{}
struct FileHandle * Input();
void Insert(list,node,listNode)
     struct List *list;
     struct Node *node, *listNode;{}
     
struct Region *InstallClipRegion(l, region) struct Layer *l; 
struct Region *region; {}

long IntuiTextLength(iText) 
     struct IntuiText *iText;{}
     
struct InputEvent* Intuition(inputEvent) struct InputEvent *inputEvent;{}
long IoErr();
long IsInteractive(file) struct FileHandle *file;{}/*check value*/

struct MenuItem * ItemAddress(menuStrip,menuNumber) 
                  struct Menu *menuStrip;
                  USHORT menuNumber;{}
                 
void LoadRGB4(vp,colorMap,count) struct ViewPort *vp;
long *colorMap; long count;{}
struct Segment * LoadSeg(name) char *name;{}
void LoadView(view) struct View *view;{}
struct FileLock * Lock(name,accessMode) char *name; long accessMode;{}

ULONG LockIBase(LockNumber)
      ULONG LockNumber; {}
     
void LockLayer(li,l) long li; struct Layer *l;{}
void LockLayerInfo(li) struct LayerInfo *li;{}
void LockLayerRom(layer) struct Layer *layer;{}
void LockLayers(li) struct LayerInfo *li;{}
struct Node *MakeDosNode(parameterPkt) long *parameterPkt; {}

long MakeFunctions(target, functionArray, funcDispBase) 
     char *target, funcDispBase;
     void (*functionArray)();{}
     
struct Library * MakeLibrary(vectors,structure,Init,dataSize,segList)
                 void(*vectors[])(),(*Init)();
                 long *structure;
                 long dataSize; 
                 struct MemList *segList;{}

void MakeScreen(screen)
     struct Screen *screen;{}

void MakeVPort(view,viewPort) struct View *view;struct ViewPort *viewPort;{}
long MarkClist(cList,offset) long cList; long offset;{}
long MatchToolValue(typeString,value) char *typeString, *value;{}

void ModifyIDCMP(wind,IDCMPFlags)
     struct Window *wind;
     ULONG IDCMPFlags;{}
     
void ModifyProp(gad,wind,req,flags,horizPot,vertPot,horizBody,verBody)
     struct Gadget *gad;
     struct Window *wind;
     struct Requester *req;
     USHORT flags, horizPot, vertPot, horizBody, verBody;{}
     
void Move(rp,x,y) struct RastPort *rp; long x,y;{}
BOOL MoveLayer(li,l,dx,dy) long li;struct Layer *l;long dx,dy;{}
long MoveLayerInFrontOf(layertomove, targetlayer) struct Layer *layertomove,
*targetlayer;{}

void MoveScreen(screen,deltaX,deltaY)
     struct Screen *screen;
     SHORT deltaX,deltaY;{}
     
void MoveSprite(vp,sprite,x,y) struct ViewPort *vp;
struct SimpleSprite *sprite; long x,y;{}

void MoveWindow(wind,deltaX,deltaY)
     struct Window *wind;
     SHORT deltaX,deltaY;{}
     
void MrgCop(view) struct View *view;{}
struct Layer_Info *NewLayerInfo();
void NewList(list) struct List *list;{}

void NewModifyProp(gad,wind,req,flags,hpot,vpot,hbody,vbody,numgad)
     struct Gadget *gad; 
     struct Window *wind;
     struct Requester *req;
     USHORT flags,hpot,vpot,hbody,vbody; 
     long numgad; {}
     
struct Region * NewRegion();
void NotRegion(rgn) struct Region *rgn;{}
void ObtainConfigBinding();

void ObtainSemaphore (signalSemaphore)
     struct Semaphore *signalSemaphore; {}
     
void ObtainSemaphoreList(list)
     struct List *list; {}

void OffGadget(gad,wind,req)
     struct Gadget *gad;
     struct Window *wind;
     struct Requester *req;{}
     
void OffMenu(wind,menuNumber)
     struct Window *wind; 
     USHORT menuNumber;{}
     
struct Library *OldOpenLibrary(libName)
       char *libName; {}

void OnGadget(gad,wind,req)
     struct Gadget *gad;
     struct Window *wind;
     struct Requester *req;{}
     
void OnMenu(wind,menuNumber) 
     struct Window *wind; 
     USHORT menuNumber;{}
     
struct FileHandle * Open(name,accessMode) char *name; long accessMode;{}

long OpenDevice(name,unitNumber,ioRequest,flags)
     char *name;
     struct IORequest *ioRequest;
     long unitNumber,flags;{}
     
struct Font * OpenDiskFont(textAttr) struct TextAttr *textAttr;{}
struct TextFont * OpenFont(textAttr) struct TextAttr *textAttr;{}
void OpenIntuition();

struct Library * OpenLibrary(libName, version)
       char *libName;long version;{}
       
struct MiscResource * OpenResource(resName)
       char *resName;{}

struct Screen *OpenScreen(newScreen)
       struct NewScreen *newScreen;{}
       
struct Window *OpenWindow(newWindow) 
       struct NewWindow *newWindow;{}

struct Screen * OpenWorkbench();

void OrRectRegion(region,rectangle) struct Region *region;
struct Rectangle *rectangle;{}
struct FileHandle * Output();
void OwnBlitter();
struct FileLock * ParentDir(lock) struct FileLock *lock;{}
long PeekCLMark(cList) long cList;{}/*check value*/

void Permit();

void PolyDraw(rp,count,array) struct RastPort *rp; long count,*array;{}
void PrintText(rp,iText,leftEdge,topEdge) struct RastPort *rp;
struct IntuiText *iText; long leftEdge,topEdge;{}

void PrintIText(rp,iText,leftEdge,topEdge)
     struct RastPort *rp;
     struct IntuiText *iText;
     SHORT leftEdge,topEdge;{}
     
long Procure (semaphore, bidMessage)
     struct Semaphore *semaphore; 
     struct Message *bidMessage; {}
     
long PutCLBuf(cList,buffer,length)char *buffer;long length,cList;{}
long PutCLChar(cList,byte) long cList,byte;{}
long PutCLWord(cList,word) long cList,word;{}
long PutDiskObject(name,diskobj) char *name;struct DiskObject *diskobj;{}
long PutIcon(name,icon) char *name; struct DiskObject *icon;{}

void PutMsg(port,message)
     struct MsgPort *port;  
     struct Message *message;{}
     
long PutWBObject(name,object) char *name;struct WBObject *object;{}
void QBSBlit(bsp) struct bltnode *bsp;{}
void QBlit(bp) struct bltnode *bp;{}
long QueuePacket (packet)  long *packet ;{}

void RawDoFmt(FormatString,DataStream,PutChProc,PutChData) 
     char *FormatString;
     char *DataStream;
     void *PutChProc;
     long PutChData; {}
     
long RawKeyConvert(events,buffer,length,keyMap)
     struct InputEvent *events;
     char *buffer;
     long length; 
     struct KeyMap *keyMap;{}
     
long Read(file,buffer,length) struct FileHandle *file;char *buffer;
long length;{}
BYTE ReadExpansionByte (board, offset)
     BYTE *board; 
     long offset; {}
     
long ReadExpansionRom (board, configDev)
     char *board;
     struct ConfigDev *configDev; {}
     
long ReadPixel(rp,x,y) struct RastPort *rp; long x,y;{}
void RectFill(rp,xMin,yMin,xMax,yMax)
     struct RastPort *rp;
     long xMin,yMin,xMax,yMax;{}

void RefreshGadgets(gad,wind,req)
     struct Gadgets *gad;
     struct Window *wind;
     struct Requester *req;{}
     
void RefreshGList(Gadgets, Window, Requester, NumGad)
     struct Gadget *Gadgets;
     struct Window *Window;
     struct Requester *Requester;
     SHORT NumGad;{}
     
void RefreshWindowFrame(Window)
     struct Window *Window; {}
     
void ReleaseConfigBinding() ;

void ReleaseSemaphore(signalSemaphore)
     struct Semaphore *signalSemaphore; {}
     
void ReleaseSemaphoreList(list)
     struct List *list; {}
     
void RemConfigDev (configDev) struct ConfigDev *configDev ;{}

long RemDevice(device)
     struct Device *device;{}
     
void RemFont(textFont) struct TextFont *textFont;{}

void *RemHead(list)
     struct List *list;{}
     
void RemBob(bob) struct Bob *bob; {}
void RemIBob (bob, rp, vp) struct Bob *bob; struct RastPort *rp;
struct ViewPort *vp; {}
void RemICRVector(iCRBit,interrupt)long iCRBit;struct Interrupt *interrupt;{}

void RemIntServer(intNum,interrupt)
     long intNum;
     struct Interrupt *interrupt;{}
     
long RemLibrary(library) 
     struct Library *library;{}
     
void RemPort(port)
     struct MsgPort *port;{}
     
void RemResource(resource)
     struct MiscResource *resource;{}
     
struct Node * RemTail(list)
              struct List *list;{}

void RemSemaphore(signalSemaphore)
     struct Semaphore *signalSemaphore; {}
     
void RemTask(task)
     struct Task *task;{}
     
void RemVSprite(vs) struct VSprite *vs;{}

void RemakeDisplay();

void Remove(list,node)
     struct List *list;
     struct Node *node;{}

USHORT RemoveGadget(wind,gad)
       struct Window *wind;
       struct Gadget *gad;{}
     
USHORT RemoveGList(Gadget, Window, NumGad)
       struct Gadget *Gadget;
       struct Window *Window;
       SHORT NumGad;{}
     
long Rename(oldName,newName)char *oldName, *newName;{}/*check value*/

void ReplyMsg(message)
     struct Message *message;{}

void ReportMouse(wind,boolean) 
     struct Window *wind;
     BOOL boolean;{}
     

BOOL Request(req,wind)
     struct Requester *req;
     struct Window *wind;{}
     
void RethinkDisplay();

void ScreenToBack(screen)
     struct Screen *screen;{}
     
void ScreenToFront(screen)
     struct Screen *screen;{}
     
void ScrollLayer(li,l,dx,dy)long li;struct Layer *l;long dx,dy;{}
void ScrollRaster(rp,dx,dy,xMin,yMin,xMax,yMax) struct RastPort *rp;
long dx,dy,xMin,yMin,xMax,yMax;{}
void ScrollVPort(vp) struct ViewPort *vp;{}
long Seek(file,position,mode) struct FileHandle *file;long position,mode;{}

void SendIO(ioRequest)
     struct IORequest *ioRequest;{}
     
void SetAPen(rp,pen) struct RastPort *rp; long pen;{}
void SetBPen(rp,pen) struct RastPort *rp; long pen;{}
void SetCollision(num,routine,gInfo)long num; char (*routine)();
struct GelsInfo *gInfo;{}
long SetComment(name,comment)char *name,*comment;{}/*check value*/
void SetCurrentBinding (currentBinding, size) 
struct CurrentBinding *currentBinding; long size; {}

BOOL SetDMRequest(wind,DMRequester)
     struct Window *wind;
     struct Requester *DMRequester;{}
     
void SetDrMd(rp,mode) struct RastPort *rp; long mode;{}

long SetExcept(newSignals,signalMask)
     long newSignals,signalMask;{}
     
void SetFont(rp,font) struct RastPort *rp; struct TextFont *font;{}

long SetFunction(library,funcOffset,funcEntry)
     struct Library *library;
     long funcOffset; 
     void (*funcEntry)();{}
     
long SetICR(mask) long mask;{}

struct Interrupt * SetIntVector(intNumber,interrupt)
                   long intNumber;
                   struct Interrupt *interrupt;{}

BOOL SetMenuStrip(wind,menu)
     struct Window *wind; 
     struct Menu *menu;{}
     
void SetOPen (rp, pen) struct RastPort *rp; long pen; {}

void SetPointer(wind,sp,height,width,xOffset, yOffset)
     struct Window *wind;
     USHORT *sp;
     SHORT height,width, xOffset, yOffset;{}
     
struct Preferences * SetPrefs(p,size,Inform)
                     struct Preferences *p;
                     long size;
                     BOOL Inform;{}
                     
long SetProtection(name,mask) char *name; long mask;{}/*check value*/
void SetRGB4(vp,n,r,g,b)struct ViewPort *vp;long n,r,g,b;{}
void SetRGB4CM (cm,n,r,g,b) struct ColorMap *cm; long n,r,g,b; {}
void SetRast(rp,pen) struct RastPort *rp; long pen;{}

long SetSR(newSR,mask)
     long newSR, mask;{}

long SetSignal(newSignals,signalMask)
     long newSignals,signalMask;{}
     
long SetSoftStyle(rp,style,enable)struct RastPort *rp;long style,enable;{}

long SetTaskPri(task,priority)
     struct Task *task;
     long priority;{}

void SetWindowTitles(wind,windowTitle,screenTitle)
     struct Window *wind;
     UBYTE *windowTitle, *screenTitle;{}
     
void ShowTitle(screen, showIt) struct Screen *screen;
     BOOL showIt;{}
     
void Signal(task,signals) 
     struct Task *task;
     long signals;{}
     
long SizeCList(cList) long cList;{}
BOOL SizeLayer(li,l,dx,dy) long li;struct Layer *l;long dx,dy;{}

void SizeWindow(wind,deltaX,deltaY)
     struct Window *wind;
     SHORT deltaX,deltaY;{}
     
void SortGList(rPort) struct RastPort *rPort;{}
long SplitCList(cList) long cList;{}
long SubCList(cList,index,length) long cList,index, length;{}
void SubTime(dest,source) struct TimeVal *dest, *source;{}

void SumKickData();

void SumLibrary(library)
     struct Library *library;{}
     
long SuperState();

void SwapBitsRastPortClipRect(rp, cr) struct RastPort *rp;struct ClipRect *cr;{}
void SyncSBitMap(layer) struct Layer *layer;{}
long Text(rp,string,count) struct RastPort *rp; char *string; long count;{}
long TextLength(rp,string,count) struct RastPort *rp;
char *string; long count;{}
void ThinLayerInfo(li) struct Layer_Info *li; {}
long Translate(instring,inlen,outbuf,outlen) 
     char *instring, *outbuf;
     long inlen, outlen;{}

long TypeOfMem(address) 
     char *address;{}
     
BOOL UnGetCLChar(cList,byte) long cList,byte;{}
long UnGetCLWord(cList,word) long cList,word;{}
long UnLoadSeg(segment) struct Segment *segment;{}/*check value*/
void UnLock(lock) struct FileLock *lock;{}

void UnlockIBase(Lock) 
     ULONG Lock; {}
     
BYTE UnPutCLChar(cList) long cList;{}
WORD UnPutCLWord(cList) long cList;{}
void UnlockLayer(l) struct Layer *l;{}
void UnlockLayerInfo(li) struct LayerInfo *li;{}
void UnlockLayerRom(layer) struct LayerInfo *layer;{}
void UnlockLayers(li) struct LayerInfo *li;{}
BOOL UpfrontLayer(li,l) long li; struct Layer *l;{}

void UserState(sysStack)
     long sysStack;{}
     
void Vacate(semaphore)
     struct Semaphore *semaphore; {}
     
long VBeamPos();

struct View *ViewAddress();

struct ViewPort *ViewPortAddress(wind)
       struct Window *wind;{}
       
BOOL WBenchToBack();

BOOL WBenchToFront();

long Wait(signalSet)
     long signalSet;{}
     
void WaitBOVP(viewPort) struct ViewPort *viewPort;{}
void WaitBlit();

BYTE WaitForChar(file,timeout)
     struct FileHandle *file;
     long timeout;{}/*check value!*/

long WaitIO(ioRequest)
     struct IORequest *ioRequest;{}
     
struct Message *WaitPort(port)
       struct MsgPort *port;{}
       
void WaitTOF();
struct Layer * WhichLayer(li,x,y)struct LayerInfo *li;long x,y;{}

BOOL WindowLimits(wind,minWidth,minHeight,maxWidth,maxHeight)
     struct Window *wind;
     SHORT minWidth,minHeight;
     USHORT maxWidth,maxHeight;{}
     
void WindowToBack(wind)
     struct Window *wind;{}
     
void WindowToFront(wind)
     struct Window *wind;{}
     
long Write(file,buffer,length) struct FileHandle *file; char *buffer;
long length;{}
long WriteExpansionByte (board, offset, byte) char *board; long offset, byte;{}
void WritePixel(rp,x,y)struct RastPort *rp;long x,y;{}
void WritePotgo(word,mask) long word,mask;{}

void XorRectRegion(region,rectangle)
     struct Region *region;
     struct Rectangle *rectangle;{}

long XorRegionRegion (region1, region2)
     struct Region *region1, *region2; {}

/*lint -restore */
/*lint -e715 -e533 */
short access(filename, mode) char *filename; short mode;{}
void assert(expr) short expr; {}
void *sbrk(size) unsigned short size; {}/*lint -e??? */
void execl(name,arg0,arg1,arg2,...,argn,) char *name,*arg0,*arg1,*arg2,...;{}
void execlp(name,arg0,arg1,arg2,...,argn,) char *nam,*arg0,*arg1,*arg2,...;{}
short fexecl(name,arg0,arg1,arg2,...,argn,) char *name,*arg0,*arg1,*arg2,...,;{}
void execv(name,argv) char *name,*argv[];{}
void execvp(name,argv) char *name,*argv[];{}
short fexecv(name,argv) char *name, *argv[]; {}
char *getenv(name) char *name; {}
char *mktemp(template) char *template; {}
short perror(s) char *s;{}
char *scdir(pat) char *pat;{}
void scr_beep();
void scr_bs();
void scr_tab();
void scr_lf();
void scr_cursup();
void scr_cursrt();
void scr_cr();
void scr_clear();
void scr_home();
void scr_eol();
void scr_linsert();
void scr_ldelete();
void scr_cinsert();
void scr_cdelete();
void scr_curs(lin,col) short lin, col; {}
long time(tloc) long *tloc;{} 
char *ctime(clock) long *clock;{}
struct tm *localtime(clock) long *clock;{}
struct tm *gmtime(clock) long *clock;{}
char *asctime(t) struct tm *t; {}
FILE *tmpfile();
char *tmpnam(s) char *s; {}
/*lint -restore */