/*
 * Header file created from arp_lib.typed_fd by header.typed.awk
 * Run at Tuesday 30-Jul-91 21:24:07
 */

#ifndef ARPFUNCTIONS_H
#define ARPFUNCTIONS_H

#ifndef LIBRARIES_ARPBASE_H
#include <libraries/arpbase.h>
#endif

#ifndef LIBRARIES_DOSEXTENS_H
#include <libraries/dosextens.h>
#endif

#define DEFTYPE int

__inline static BPTR
Open(const char * name, long accessMode)
{
	register const char * d1 __asm("d1");
	register long d2 __asm("d2");
	register BPTR res __asm("d0");
	d1 = name;
	d2 = accessMode;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-30)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1), "g"(d2)
		: "d1", "d2", "a0", "a1");
	return res;
}

__inline static void
Close(BPTR file)
{
	register BPTR d1 __asm("d1");
	d1 = file;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-36)
		  movel sp@+, a6"
		: : "g"(d1)
		: "d0", "d1", "a0", "a1");
}

__inline static long
Read(BPTR file, char * buffer, long length)
{
	register BPTR d1 __asm("d1");
	register char * d2 __asm("d2");
	register long d3 __asm("d3");
	register long res __asm("d0");
	d1 = file;
	d2 = buffer;
	d3 = length;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-42)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1), "g"(d2), "g"(d3)
		: "d1", "d2", "d3", "a0", "a1");
	return res;
}

__inline static long
Write(BPTR file, const char * buffer, long length)
{
	register BPTR d1 __asm("d1");
	register const char * d2 __asm("d2");
	register long d3 __asm("d3");
	register long res __asm("d0");
	d1 = file;
	d2 = buffer;
	d3 = length;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-48)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1), "g"(d2), "g"(d3)
		: "d1", "d2", "d3", "a0", "a1");
	return res;
}

__inline static BPTR
Input(void)
{
	register BPTR res __asm("d0");
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-54)
		  movel sp@+, a6"
		: "=g"(res):
		: "d1", "a0", "a1");
	return res;
}

__inline static BPTR
Output(void)
{
	register BPTR res __asm("d0");
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-60)
		  movel sp@+, a6"
		: "=g"(res):
		: "d1", "a0", "a1");
	return res;
}

__inline static long
Seek(BPTR file, long position, long offset)
{
	register BPTR d1 __asm("d1");
	register long d2 __asm("d2");
	register long d3 __asm("d3");
	register long res __asm("d0");
	d1 = file;
	d2 = position;
	d3 = offset;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-66)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1), "g"(d2), "g"(d3)
		: "d1", "d2", "d3", "a0", "a1");
	return res;
}

__inline static long
DeleteFile(const char * name)
{
	register const char * d1 __asm("d1");
	register long res __asm("d0");
	d1 = name;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-72)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
Rename(const char * oldName, const char * newName)
{
	register const char * d1 __asm("d1");
	register const char * d2 __asm("d2");
	register long res __asm("d0");
	d1 = oldName;
	d2 = newName;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-78)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1), "g"(d2)
		: "d1", "d2", "a0", "a1");
	return res;
}

__inline static BPTR
Lock(const char * name, long type)
{
	register const char * d1 __asm("d1");
	register long d2 __asm("d2");
	register BPTR res __asm("d0");
	d1 = name;
	d2 = type;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-84)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1), "g"(d2)
		: "d1", "d2", "a0", "a1");
	return res;
}

__inline static void
UnLock(BPTR lock)
{
	register BPTR d1 __asm("d1");
	d1 = lock;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-90)
		  movel sp@+, a6"
		: : "g"(d1)
		: "d0", "d1", "a0", "a1");
}

__inline static BPTR
DupLock(BPTR lock)
{
	register BPTR d1 __asm("d1");
	register BPTR res __asm("d0");
	d1 = lock;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-96)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
Examine(BPTR lock, struct FileInfoBlock * fileInfoBlock)
{
	register BPTR d1 __asm("d1");
	register struct FileInfoBlock * d2 __asm("d2");
	register long res __asm("d0");
	d1 = lock;
	d2 = fileInfoBlock;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-102)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1), "g"(d2)
		: "d1", "d2", "a0", "a1");
	return res;
}

__inline static long
ExNext(BPTR lock, struct FileInfoBlock * fileInfoBlock)
{
	register BPTR d1 __asm("d1");
	register struct FileInfoBlock * d2 __asm("d2");
	register long res __asm("d0");
	d1 = lock;
	d2 = fileInfoBlock;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-108)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1), "g"(d2)
		: "d1", "d2", "a0", "a1");
	return res;
}

__inline static long
Info(BPTR lock, struct InfoData * parameterBlock)
{
	register BPTR d1 __asm("d1");
	register struct InfoData * d2 __asm("d2");
	register long res __asm("d0");
	d1 = lock;
	d2 = parameterBlock;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-114)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1), "g"(d2)
		: "d1", "d2", "a0", "a1");
	return res;
}

__inline static BPTR
CreateDir(const char * name)
{
	register const char * d1 __asm("d1");
	register BPTR res __asm("d0");
	d1 = name;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-120)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static BPTR
CurrentDir(BPTR lock)
{
	register BPTR d1 __asm("d1");
	register BPTR res __asm("d0");
	d1 = lock;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-126)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
IoErr(void)
{
	register long res __asm("d0");
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-132)
		  movel sp@+, a6"
		: "=g"(res):
		: "d1", "a0", "a1");
	return res;
}

__inline static struct MsgPort *
CreateProc(const char * name, long pri, BPTR segList, long stackSize)
{
	register const char * d1 __asm("d1");
	register long d2 __asm("d2");
	register BPTR d3 __asm("d3");
	register long d4 __asm("d4");
	register struct MsgPort * res __asm("d0");
	d1 = name;
	d2 = pri;
	d3 = segList;
	d4 = stackSize;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-138)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1), "g"(d2), "g"(d3), "g"(d4)
		: "d1", "d2", "d3", "d4", "a0", "a1");
	return res;
}

__inline static void
Exit(long returnCode)
{
	register long d1 __asm("d1");
	d1 = returnCode;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-144)
		  movel sp@+, a6"
		: : "g"(d1)
		: "d0", "d1", "a0", "a1");
}

__inline static BPTR
LoadSeg(const char * fileName)
{
	register const char * d1 __asm("d1");
	register BPTR res __asm("d0");
	d1 = fileName;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-150)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static void
UnLoadSeg(BPTR segment)
{
	register BPTR d1 __asm("d1");
	d1 = segment;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-156)
		  movel sp@+, a6"
		: : "g"(d1)
		: "d0", "d1", "a0", "a1");
}

DEFTYPE
GetPacket(DEFTYPE wait);

DEFTYPE
QueuePacket(DEFTYPE packet);

__inline static struct MsgPort *
DeviceProc(const char * name)
{
	register const char * d1 __asm("d1");
	register struct MsgPort * res __asm("d0");
	d1 = name;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-174)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
SetComment(const char * name, const char * comment)
{
	register const char * d1 __asm("d1");
	register const char * d2 __asm("d2");
	register long res __asm("d0");
	d1 = name;
	d2 = comment;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-180)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1), "g"(d2)
		: "d1", "d2", "a0", "a1");
	return res;
}

__inline static long
SetProtection(const char * name, long mask)
{
	register const char * d1 __asm("d1");
	register long d2 __asm("d2");
	register long res __asm("d0");
	d1 = name;
	d2 = mask;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-186)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1), "g"(d2)
		: "d1", "d2", "a0", "a1");
	return res;
}

__inline static long *
DateStamp(long * date)
{
	register long * d1 __asm("d1");
	register long * res __asm("d0");
	d1 = date;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-192)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static void
Delay(long timeout)
{
	register long d1 __asm("d1");
	d1 = timeout;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-198)
		  movel sp@+, a6"
		: : "g"(d1)
		: "d0", "d1", "a0", "a1");
}

__inline static long
WaitForChar(BPTR file, long timeout)
{
	register BPTR d1 __asm("d1");
	register long d2 __asm("d2");
	register long res __asm("d0");
	d1 = file;
	d2 = timeout;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-204)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1), "g"(d2)
		: "d1", "d2", "a0", "a1");
	return res;
}

__inline static BPTR
ParentDir(BPTR lock)
{
	register BPTR d1 __asm("d1");
	register BPTR res __asm("d0");
	d1 = lock;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-210)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
IsInteractive(BPTR file)
{
	register BPTR d1 __asm("d1");
	register long res __asm("d0");
	d1 = file;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-216)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
Execute(const char * string, BPTR inputFile, BPTR outputFile)
{
	register const char * d1 __asm("d1");
	register BPTR d2 __asm("d2");
	register BPTR d3 __asm("d3");
	register long res __asm("d0");
	d1 = string;
	d2 = inputFile;
	d3 = outputFile;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-222)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1), "g"(d2), "g"(d3)
		: "d1", "d2", "d3", "a0", "a1");
	return res;
}

int
Printf(const char * string, ...);

int
FPrintf(BPTR file, const char * string, ...);

__inline static long
Puts(const char * string)
{
	register const char * a1 __asm("a1");
	register long res __asm("d0");
	a1 = string;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-240)
		  movel sp@+, a6"
		: "=g"(res): "g"(a1)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
ReadLine(char * buffer)
{
	register char * a0 __asm("a0");
	register long res __asm("d0");
	a0 = buffer;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-246)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0)
		: "d1", "a0", "a1");
	return res;
}

long
GADS(char * line, long len, char * help, char ** args, char * tplate);

long
Atol(const char * string);

__inline static unsigned long
EscapeString(char * string)
{
	register char * a0 __asm("a0");
	register unsigned long res __asm("d0");
	a0 = string;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-264)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
CheckAbort(void (*func)())
{
	register void (*a1)() __asm("a1");
	register long res __asm("d0");
	a1 = func;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-270)
		  movel sp@+, a6"
		: "=g"(res): "g"(a1)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
CheckBreak(long masks, void (*func)())
{
	register long d1 __asm("d1");
	register void (*a1)() __asm("a1");
	register long res __asm("d0");
	d1 = masks;
	a1 = func;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-276)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1), "g"(a1)
		: "d1", "a0", "a1");
	return res;
}

__inline static char *
Getenv(const char * string, char * buffer, long size)
{
	register const char * a0 __asm("a0");
	register char * a1 __asm("a1");
	register long d0 __asm("d0");
	register char * res __asm("d0");
	a0 = string;
	a1 = buffer;
	d0 = size;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-282)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0), "g"(a1), "g"(d0)
		: "d1", "a0", "a1");
	return res;
}

__inline static BOOL
Setenv(const char * varname, char * value)
{
	register const char * a0 __asm("a0");
	register char * a1 __asm("a1");
	register BOOL res __asm("d0");
	a0 = varname;
	a1 = value;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-288)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0), "g"(a1)
		: "d1", "a0", "a1");
	return res;
}

__inline static char *
FileRequest(struct FileRequester * FileRequester)
{
	register struct FileRequester * a0 __asm("a0");
	register char * res __asm("d0");
	a0 = FileRequester;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-294)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0)
		: "d1", "a0", "a1");
	return res;
}

__inline static void
CloseWindowSafely(struct Window * Window1, long Window2)
{
	register struct Window * a0 __asm("a0");
	register long a1 __asm("a1");
	a0 = Window1;
	a1 = Window2;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-300)
		  movel sp@+, a6"
		: : "g"(a0), "g"(a1)
		: "d0", "d1", "a0", "a1");
}

__inline static struct MsgPort *
CreatePort(const char * name, long pri)
{
	register const char * a0 __asm("a0");
	register long d0 __asm("d0");
	register struct MsgPort * res __asm("d0");
	a0 = name;
	d0 = pri;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-306)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0), "g"(d0)
		: "d1", "a0", "a1");
	return res;
}

__inline static void
DeletePort(struct MsgPort * port)
{
	register struct MsgPort * a1 __asm("a1");
	a1 = port;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-312)
		  movel sp@+, a6"
		: : "g"(a1)
		: "d0", "d1", "a0", "a1");
}

__inline static long
SendPacket(long action, long * args, struct MsgPort * handler)
{
	register long d0 __asm("d0");
	register long * a0 __asm("a0");
	register struct MsgPort * a1 __asm("a1");
	register long res __asm("d0");
	d0 = action;
	a0 = args;
	a1 = handler;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-318)
		  movel sp@+, a6"
		: "=g"(res): "g"(d0), "g"(a0), "g"(a1)
		: "d1", "a0", "a1");
	return res;
}

__inline static void
InitStdPacket(long action, long * args, struct DosPacket * packet, struct MsgPort * replyport)
{
	register long d0 __asm("d0");
	register long * a0 __asm("a0");
	register struct DosPacket * a1 __asm("a1");
	register struct MsgPort * a2 __asm("a2");
	d0 = action;
	a0 = args;
	a1 = packet;
	a2 = replyport;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-324)
		  movel sp@+, a6"
		: : "g"(d0), "g"(a0), "g"(a1), "g"(a2)
		: "d0", "d1", "a0", "a1", "a2");
}

__inline static unsigned long
PathName(BPTR lock, char * buffer, long componentcount)
{
	register BPTR d0 __asm("d0");
	register char * a0 __asm("a0");
	register long d1 __asm("d1");
	register unsigned long res __asm("d0");
	d0 = lock;
	a0 = buffer;
	d1 = componentcount;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-330)
		  movel sp@+, a6"
		: "=g"(res): "g"(d0), "g"(a0), "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static unsigned long
Assign(const char * logical, const char * physical)
{
	register const char * a0 __asm("a0");
	register const char * a1 __asm("a1");
	register unsigned long res __asm("d0");
	a0 = logical;
	a1 = physical;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-336)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0), "g"(a1)
		: "d1", "a0", "a1");
	return res;
}

__inline static void *
DosAllocMem(long size)
{
	register long d0 __asm("d0");
	register void * res __asm("d0");
	d0 = size;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-342)
		  movel sp@+, a6"
		: "=g"(res): "g"(d0)
		: "d1", "a0", "a1");
	return res;
}

__inline static void
DosFreeMem(void * dosblock)
{
	register void * a1 __asm("a1");
	a1 = dosblock;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-348)
		  movel sp@+, a6"
		: : "g"(a1)
		: "d0", "d1", "a0", "a1");
}

__inline static unsigned long
BtoCStr(char * cstr, BSTR bstr, long maxlength)
{
	register char * a0 __asm("a0");
	register BSTR d0 __asm("d0");
	register long d1 __asm("d1");
	register unsigned long res __asm("d0");
	a0 = cstr;
	d0 = bstr;
	d1 = maxlength;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-354)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0), "g"(d0), "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static unsigned long
CtoBstr(const char * cstr, BSTR bstr, long maxlength)
{
	register const char * a0 __asm("a0");
	register BSTR d0 __asm("d0");
	register long d1 __asm("d1");
	register unsigned long res __asm("d0");
	a0 = cstr;
	d0 = bstr;
	d1 = maxlength;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-360)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0), "g"(d0), "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static struct DeviceList *
GetDevInfo(struct DeviceList * devnode)
{
	register struct DeviceList * a2 __asm("a2");
	register struct DeviceList * res __asm("d0");
	a2 = devnode;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-366)
		  movel sp@+, a6"
		: "=g"(res): "g"(a2)
		: "d1", "a0", "a1", "a2");
	return res;
}

__inline static BOOL
FreeTaskResList(void)
{
	register BOOL res __asm("d0");
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-372)
		  movel sp@+, a6"
		: "=g"(res):
		: "d1", "a0", "a1");
	return res;
}

__inline static void
ArpExit(long rc, long result2)
{
	register long d0 __asm("d0");
	register long d2 __asm("d2");
	d0 = rc;
	d2 = result2;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-378)
		  movel sp@+, a6"
		: : "g"(d0), "g"(d2)
		: "d0", "d1", "d2", "a0", "a1");
}

void *
ArpAlloc(long size);

void *
ArpAllocMem(long size, long requirements);

BPTR
ArpOpen(const char * name, long mode);

BPTR
ArpDupLock(BPTR lock);

BPTR
ArpLock(const char * name, long mode);

void *
RListAlloc(struct ArpResList * reslist,  long size);

__inline static struct Process *
FindCLI(long clinum)
{
	register long d0 __asm("d0");
	register struct Process * res __asm("d0");
	d0 = clinum;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-420)
		  movel sp@+, a6"
		: "=g"(res): "g"(d0)
		: "d1", "a0", "a1");
	return res;
}

__inline static BOOL
QSort(void * base, long rsize, long bsize, int (*comp)())
{
	register void * a0 __asm("a0");
	register long d0 __asm("d0");
	register long d1 __asm("d1");
	register int (*a1)() __asm("a1");
	register BOOL res __asm("d0");
	a0 = base;
	d0 = rsize;
	d1 = bsize;
	a1 = comp;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-426)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0), "g"(d0), "g"(d1), "g"(a1)
		: "d1", "a0", "a1");
	return res;
}

__inline static BOOL
PatternMatch(const char * pattern, const char * string)
{
	register const char * a0 __asm("a0");
	register const char * a1 __asm("a1");
	register BOOL res __asm("d0");
	a0 = pattern;
	a1 = string;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-432)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0), "g"(a1)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
FindFirst(char * pattern, struct AnchorPath * AnchorPath)
{
	register char * d0 __asm("d0");
	register struct AnchorPath * a0 __asm("a0");
	register long res __asm("d0");
	d0 = pattern;
	a0 = AnchorPath;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-438)
		  movel sp@+, a6"
		: "=g"(res): "g"(d0), "g"(a0)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
FindNext(struct AnchorPath * AnchorPath)
{
	register struct AnchorPath * a0 __asm("a0");
	register long res __asm("d0");
	a0 = AnchorPath;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-444)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0)
		: "d1", "a0", "a1");
	return res;
}

__inline static void
FreeAnchorChain(struct AnchorPath * AnchorPath)
{
	register struct AnchorPath * a0 __asm("a0");
	a0 = AnchorPath;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-450)
		  movel sp@+, a6"
		: : "g"(a0)
		: "d0", "d1", "a0", "a1");
}

__inline static unsigned long
CompareLock(BPTR lock1, BPTR lock2)
{
	register BPTR d0 __asm("d0");
	register BPTR d1 __asm("d1");
	register unsigned long res __asm("d0");
	d0 = lock1;
	d1 = lock2;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-456)
		  movel sp@+, a6"
		: "=g"(res): "g"(d0), "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static struct ArpResList *
FindTaskResList(void)
{
	register struct ArpResList * res __asm("d0");
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-462)
		  movel sp@+, a6"
		: "=g"(res):
		: "d1", "a0", "a1");
	return res;
}

__inline static struct ArpResList *
CreateTaskResList(void)
{
	register struct ArpResList * res __asm("d0");
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-468)
		  movel sp@+, a6"
		: "=g"(res):
		: "d1", "a0", "a1");
	return res;
}

__inline static void
FreeResList(struct ArpResList * freelist)
{
	register struct ArpResList * a1 __asm("a1");
	a1 = freelist;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-474)
		  movel sp@+, a6"
		: : "g"(a1)
		: "d0", "d1", "a0", "a1");
}

__inline static void
FreeTrackedItem(struct DefaultTracker * item)
{
	register struct DefaultTracker * a1 __asm("a1");
	a1 = item;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-480)
		  movel sp@+, a6"
		: : "g"(a1)
		: "d0", "d1", "a0", "a1");
}

struct DefaultTracker *
GetTracker(void);

__inline static void *
GetAccess(struct DefaultTracker * tracker)
{
	register struct DefaultTracker * a1 __asm("a1");
	register void * res __asm("d0");
	a1 = tracker;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-492)
		  movel sp@+, a6"
		: "=g"(res): "g"(a1)
		: "d1", "a0", "a1");
	return res;
}

__inline static void
FreeAccess(struct DefaultTracker * tracker)
{
	register struct DefaultTracker * a1 __asm("a1");
	a1 = tracker;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-498)
		  movel sp@+, a6"
		: : "g"(a1)
		: "d0", "d1", "a0", "a1");
}

__inline static void
FreeDAList(struct DirectoryEntry * node)
{
	register struct DirectoryEntry * a1 __asm("a1");
	a1 = node;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-504)
		  movel sp@+, a6"
		: : "g"(a1)
		: "d0", "d1", "a0", "a1");
}

__inline static struct DirectoryEntry *
AddDANode(char * data, struct DirectoryEntry ** dalist, long length, long id)
{
	register char * a0 __asm("a0");
	register struct DirectoryEntry ** a1 __asm("a1");
	register long d0 __asm("d0");
	register long d1 __asm("d1");
	register struct DirectoryEntry * res __asm("d0");
	a0 = data;
	a1 = dalist;
	d0 = length;
	d1 = id;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-510)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0), "g"(a1), "g"(d0), "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static unsigned long
AddDADevs(struct DirectoryEntry ** dalist, long select)
{
	register struct DirectoryEntry ** a0 __asm("a0");
	register long d0 __asm("d0");
	register unsigned long res __asm("d0");
	a0 = dalist;
	d0 = select;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-516)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0), "g"(d0)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
Strcmp(const char * s1, const char * s2)
{
	register const char * a0 __asm("a0");
	register const char * a1 __asm("a1");
	register long res __asm("d0");
	a0 = s1;
	a1 = s2;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-522)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0), "g"(a1)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
Strncmp(const char * s1, const char * s2, long count)
{
	register const char * a0 __asm("a0");
	register const char * a1 __asm("a1");
	register long d0 __asm("d0");
	register long res __asm("d0");
	a0 = s1;
	a1 = s2;
	d0 = count;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-528)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0), "g"(a1), "g"(d0)
		: "d1", "a0", "a1");
	return res;
}

__inline static char
Toupper(char character)
{
	register char d0 __asm("d0");
	register char res __asm("d0");
	d0 = character;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-534)
		  movel sp@+, a6"
		: "=g"(res): "g"(d0)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
SyncRun(const char * name, const char * command, BPTR input, BPTR output)
{
	register const char * a0 __asm("a0");
	register const char * a1 __asm("a1");
	register BPTR d0 __asm("d0");
	register BPTR d1 __asm("d1");
	register long res __asm("d0");
	a0 = name;
	a1 = command;
	d0 = input;
	d1 = output;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-540)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0), "g"(a1), "g"(d0), "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
ASyncRun(const char * name, const char * command, struct ProcessControlBlock * pcb)
{
	register const char * a0 __asm("a0");
	register const char * a1 __asm("a1");
	register struct ProcessControlBlock * a2 __asm("a2");
	register long res __asm("d0");
	a0 = name;
	a1 = command;
	a2 = pcb;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-546)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0), "g"(a1), "g"(a2)
		: "d1", "a0", "a1", "a2");
	return res;
}

__inline static BPTR
LoadPrg(const char * name)
{
	register const char * d1 __asm("d1");
	register BPTR res __asm("d0");
	d1 = name;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-552)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static BOOL
PreParse(const char * source, char * dest)
{
	register const char * a0 __asm("a0");
	register char * a1 __asm("a1");
	register BOOL res __asm("d0");
	a0 = source;
	a1 = dest;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-558)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0), "g"(a1)
		: "d1", "a0", "a1");
	return res;
}

__inline static BOOL
StamptoStr(struct DateTime * datetime)
{
	register struct DateTime * a0 __asm("a0");
	register BOOL res __asm("d0");
	a0 = datetime;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-564)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0)
		: "d1", "a0", "a1");
	return res;
}

__inline static BOOL
StrtoStamp(struct DateTime * datetime)
{
	register struct DateTime * a0 __asm("a0");
	register BOOL res __asm("d0");
	a0 = datetime;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-570)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0)
		: "d1", "a0", "a1");
	return res;
}

__inline static struct ResidentProgramNode *
ObtainResidentPrg(const char * name)
{
	register const char * a0 __asm("a0");
	register struct ResidentProgramNode * res __asm("d0");
	a0 = name;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-576)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0)
		: "d1", "a0", "a1");
	return res;
}

__inline static struct ResidentProgramNode *
AddResidentPrg(BPTR Segment, const char * name)
{
	register BPTR d1 __asm("d1");
	register const char * a0 __asm("a0");
	register struct ResidentProgramNode * res __asm("d0");
	d1 = Segment;
	a0 = name;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-582)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1), "g"(a0)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
RemResidentPrg(const char * name)
{
	register const char * a0 __asm("a0");
	register long res __asm("d0");
	a0 = name;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-588)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0)
		: "d1", "a0", "a1");
	return res;
}

__inline static void
UnLoadPrg(BPTR segment)
{
	register BPTR d1 __asm("d1");
	d1 = segment;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-594)
		  movel sp@+, a6"
		: : "g"(d1)
		: "d0", "d1", "a0", "a1");
}

__inline static long
LMult(long a, long b)
{
	register long d0 __asm("d0");
	register long d1 __asm("d1");
	register long res __asm("d0");
	d0 = a;
	d1 = b;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-600)
		  movel sp@+, a6"
		: "=g"(res): "g"(d0), "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
LDiv(long a, long b)
{
	register long d0 __asm("d0");
	register long d1 __asm("d1");
	register long res __asm("d0");
	d0 = a;
	d1 = b;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-606)
		  movel sp@+, a6"
		: "=g"(res): "g"(d0), "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static long
LMod(long a, long b)
{
	register long d0 __asm("d0");
	register long d1 __asm("d1");
	register long res __asm("d0");
	d0 = a;
	d1 = b;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-612)
		  movel sp@+, a6"
		: "=g"(res): "g"(d0), "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

__inline static unsigned long
CheckSumPrg(struct ResidentProgramNode * ResidentNode)
{
	register struct ResidentProgramNode * d0 __asm("d0");
	register unsigned long res __asm("d0");
	d0 = ResidentNode;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-618)
		  movel sp@+, a6"
		: "=g"(res): "g"(d0)
		: "d1", "a0", "a1");
	return res;
}

__inline static void
TackOn(char * pathname, const char * filename)
{
	register char * a0 __asm("a0");
	register const char * a1 __asm("a1");
	a0 = pathname;
	a1 = filename;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-624)
		  movel sp@+, a6"
		: : "g"(a0), "g"(a1)
		: "d0", "d1", "a0", "a1");
}

__inline static char *
BaseName(const char * name)
{
	register const char * a0 __asm("a0");
	register char * res __asm("d0");
	a0 = name;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-630)
		  movel sp@+, a6"
		: "=g"(res): "g"(a0)
		: "d1", "a0", "a1");
	return res;
}

__inline static struct ResidentProgramNode *
ReleaseResidentPrg(BPTR segment)
{
	register BPTR d1 __asm("d1");
	register struct ResidentProgramNode * res __asm("d0");
	d1 = segment;
	__asm volatile
		("movel a6, sp@-
		  movel _ArpBase, a6
		  jsr a6@(-636)
		  movel sp@+, a6"
		: "=g"(res): "g"(d1)
		: "d1", "a0", "a1");
	return res;
}

#endif /* ARPFUNCTIONS_H */