#include <inline/stub.h>
#ifndef BASE_EXT_DECL
#define BASE_EXT_DECL extern struct ArpBase * ArpBase;
#endif
#ifndef BASE_PAR_DECL
#define BASE_PAR_DECL
#define BASE_PAR_DECL0
#endif
#ifndef BASE_NAME
#define BASE_NAME ArpBase
#endif
#ifdef PRIVATE
/* if you want the DOS compatible functions, include inline/dos.h with the
 * libbase as arpbase */
#ifdef DOTDOTDOT
__inline static LONG Printf(BASE_PAR_DECL const char* string, ...  stream)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");
	register ... a1 __asm("a1");

	a6 = BASE_NAME;
	a0 = string;
	a1 =  stream;
	__asm volatile ("
	jsr a6@(-0xe4)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static LONG FPrintf(BASE_PAR_DECL BPTR file, char* string, ... stream)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register BPTR d0 __asm("d0");
	register char* a0 __asm("a0");
	register ... a1 __asm("a1");

	a6 = BASE_NAME;
	d0 = file;
	a0 = string;
	a1 = stream;
	__asm volatile ("
	jsr a6@(-0xea)"
	: "=r" (res)
	: "r" (a6), "r" (d0), "r" (a0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
#endif
#endif
__inline static LONG Puts(BASE_PAR_DECL const char* string)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = string;
	__asm volatile ("
	jsr a6@(-0xf0)"
	: "=r" (res)
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static LONG ReadLine(BASE_PAR_DECL char* buffer)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register char* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = buffer;
	__asm volatile ("
	jsr a6@(-0xf6)"
	: "=r" (res)
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	return res;
}
__inline static LONG GADS(BASE_PAR_DECL char* line, LONG len, const char* help, char** args, const char* tplate)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register char* a0 __asm("a0");
	register LONG d0 __asm("d0");
	register const char* a1 __asm("a1");
	register char** a2 __asm("a2");
	register const char* a3 __asm("a3");

	a6 = BASE_NAME;
	a0 = line;
	d0 = len;
	a1 = help;
	a2 = args;
	a3 = tplate;
	__asm volatile ("
	jsr a6@(-0xfc)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (d0), "r" (a1), "r" (a2), "r" (a3)
	: "d0", "d1", "a0", "a1", "a2", "a3");
	*line=*line; *args=*args;
	return res;
}
__inline static LONG const Atol(BASE_PAR_DECL const char* string)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = string;
	__asm volatile ("
	jsr a6@(-0x102)"
	: "=r" (res)
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static ULONG const EscapeString(BASE_PAR_DECL char* string)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register char* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = string;
	__asm volatile ("
	jsr a6@(-0x108)"
	: "=r" (res)
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	return res;
}
__inline static LONG CheckAbort(BASE_PAR_DECL const void (*func)())
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register const void(*a1)() __asm("a1");

	a6 = BASE_NAME;
	a1 = func;
	__asm volatile ("
	jsr a6@(-0x10e)"
	: "=r" (res)
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static LONG CheckBreak(BASE_PAR_DECL LONG masks, const void(*func)())
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register LONG d1 __asm("d1");
	register const void(*a1)() __asm("a1");

	a6 = BASE_NAME;
	d1 = masks;
	a1 = func;
	__asm volatile ("
	jsr a6@(-0x114)"
	: "=r" (res)
	: "r" (a6), "r" (d1), "r" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static BYTE* const Getenv(BASE_PAR_DECL const char* string, char* buffer, LONG size)
{
	BASE_EXT_DECL
	register BYTE* res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");
	register char* a1 __asm("a1");
	register LONG d0 __asm("d0");

	a6 = BASE_NAME;
	a0 = string;
	a1 = buffer;
	d0 = size;
	__asm volatile ("
	jsr a6@(-0x11a)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (a1), "r" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static BOOL Setenv(BASE_PAR_DECL const char* varname, const char* value)
{
	BASE_EXT_DECL
	register BOOL res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");
	register const char* a1 __asm("a1");

	a6 = BASE_NAME;
	a0 = varname;
	a1 = value;
	__asm volatile ("
	jsr a6@(-0x120)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static BYTE* FileRequest(BASE_PAR_DECL struct FileRequester* FileRequester)
{
	BASE_EXT_DECL
	register BYTE* res __asm("d0");
	register void *a6 __asm ("a6");
	register struct FileRequester* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = FileRequester;
	__asm volatile ("
	jsr a6@(-0x126)"
	: "=r" (res)
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	return res;
}
__inline static void CloseWindowSafely(BASE_PAR_DECL struct Window* Window1, LONG Window2)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct Window* a0 __asm("a0");
	register LONG a1 __asm("a1");

	a6 = BASE_NAME;
	a0 = Window1;
	a1 = Window2;
	__asm volatile ("
	jsr a6@(-0x12c)"
	: /* no output */
	: "r" (a6), "r" (a0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
}
__inline static struct	MsgPort* CreatePort(BASE_PAR_DECL const char* name, LONG pri)
{
	BASE_EXT_DECL
	register struct	MsgPort* res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");
	register LONG d0 __asm("d0");

	a6 = BASE_NAME;
	a0 = name;
	d0 = pri;
	__asm volatile ("
	jsr a6@(-0x132)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void DeletePort(BASE_PAR_DECL struct MsgPort* port)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct MsgPort* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = port;
	__asm volatile ("
	jsr a6@(-0x138)"
	: /* no output */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
}
__inline static LONG SendPacket(BASE_PAR_DECL LONG action, LONG* args, struct MsgPort* handler)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register LONG d0 __asm("d0");
	register LONG* a0 __asm("a0");
	register struct MsgPort* a1 __asm("a1");

	a6 = BASE_NAME;
	d0 = action;
	a0 = args;
	a1 = handler;
	__asm volatile ("
	jsr a6@(-0x13e)"
	: "=r" (res)
	: "r" (a6), "r" (d0), "r" (a0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	return res;
}
__inline static void InitStdPacket(BASE_PAR_DECL LONG action, LONG* args, struct DosPacket* packet, const struct MsgPort* replyport)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register LONG d0 __asm("d0");
	register LONG* a0 __asm("a0");
	register struct DosPacket* a1 __asm("a1");
	register const struct MsgPort* a2 __asm("a2");

	a6 = BASE_NAME;
	d0 = action;
	a0 = args;
	a1 = packet;
	a2 = replyport;
	__asm volatile ("
	jsr a6@(-0x144)"
	: /* no output */
	: "r" (a6), "r" (d0), "r" (a0), "r" (a1), "r" (a2)
	: "d0", "d1", "a0", "a1", "a2");
	*(char *)a0=*(char *)a0; *(char *)a1=*(char *)a1;
}
__inline static ULONG PathName(BASE_PAR_DECL BPTR lock, char* buffer, LONG componentcount)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register BPTR d0 __asm("d0");
	register char* a0 __asm("a0");
	register LONG d1 __asm("d1");

	a6 = BASE_NAME;
	d0 = lock;
	a0 = buffer;
	d1 = componentcount;
	__asm volatile ("
	jsr a6@(-0x14a)"
	: "=r" (res)
	: "r" (a6), "r" (d0), "r" (a0), "r" (d1)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	return res;
}
__inline static ULONG Assign(BASE_PAR_DECL const char* logical, const char* physical)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");
	register const char* a1 __asm("a1");

	a6 = BASE_NAME;
	a0 = logical;
	a1 = physical;
	__asm volatile ("
	jsr a6@(-0x150)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void* DosAllocMem(BASE_PAR_DECL LONG size)
{
	BASE_EXT_DECL
	register void* res __asm("d0");
	register void *a6 __asm ("a6");
	register LONG d0 __asm("d0");

	a6 = BASE_NAME;
	d0 = size;
	__asm volatile ("
	jsr a6@(-0x156)"
	: "=r" (res)
	: "r" (a6), "r" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void DosFreeMem(BASE_PAR_DECL void* dosblock)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register void* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = dosblock;
	__asm volatile ("
	jsr a6@(-0x15c)"
	: /* no output */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
}
__inline static ULONG BtoCStr(BASE_PAR_DECL char* cstr, BSTR bstr, LONG maxlength)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register char* a0 __asm("a0");
	register BSTR d0 __asm("d0");
	register LONG d1 __asm("d1");

	a6 = BASE_NAME;
	a0 = cstr;
	d0 = bstr;
	d1 = maxlength;
	__asm volatile ("
	jsr a6@(-0x162)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (d0), "r" (d1)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	return res;
}
__inline static ULONG CtoBStr(BASE_PAR_DECL const char* cstr, BSTR bstr, LONG maxlength)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");
	register BSTR d0 __asm("d0");
	register LONG d1 __asm("d1");

	a6 = BASE_NAME;
	a0 = cstr;
	d0 = bstr;
	d1 = maxlength;
	__asm volatile ("
	jsr a6@(-0x168)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (d0), "r" (d1)
	: "d0", "d1", "a0", "a1");
	*(unsigned long *)d0 = *(unsigned long *)d0;
	return res;
}
__inline static struct	DeviceList* GetDevInfo(BASE_PAR_DECL struct DeviceList* devnode)
{
	BASE_EXT_DECL
	register struct	DeviceList* res __asm("d0");
	register void *a6 __asm ("a6");
	register struct DeviceList* a2 __asm("a2");

	a6 = BASE_NAME;
	a2 = devnode;
	__asm volatile ("
	jsr a6@(-0x16e)"
	: "=r" (res)
	: "r" (a6), "r" (a2)
	: "d0", "d1", "a0", "a1", "a2");
	*(char *)a2=*(char *)a2;
	return res;
}
__inline static BOOL FreeTaskResList(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register BOOL res __asm("d0");
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x174)"
	: "=r" (res)
	: "r" (a6)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void ArpExit(BASE_PAR_DECL LONG rc)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register LONG d0 __asm("d0");
	register LONG d2 __asm("d2");

	a6 = BASE_NAME;
	d0 = rc;
	d2 = 0;
	__asm volatile ("
	jsr a6@(-0x17a)"
	: /* no output */
	: "r" (a6), "r" (d0), "r" (d2)
	: "d0", "d1", "a0", "a1", "d2");
}
__inline static void ArpExit2(BASE_PAR_DECL LONG rc, LONG result2)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register LONG d0 __asm("d0");
	register LONG d2 __asm("d2");

	a6 = BASE_NAME;
	d0 = rc;
	d2 = result2;
	__asm volatile ("
	jsr a6@(-0x17a)"
	: /* no output */
	: "r" (a6), "r" (d0), "r" (d2)
	: "d0", "d1", "a0", "a1", "d2");
}
#ifdef PRIVATE
/* NOTE!: private functions are not (yet?) converted to `const' notation! */

__inline static void* ArpAlloc(BASE_PAR_DECL LONG size)
{
	BASE_EXT_DECL
	register void* res __asm("d0");
	register void *a6 __asm ("a6");
	register LONG d0 __asm("d0");

	a6 = BASE_NAME;
	d0 = size;
	__asm volatile ("
	jsr a6@(-0x180)"
	: "=r" (res)
	: "r" (a6), "r" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void* ArpAllocMem(BASE_PAR_DECL LONG size, LONG requirements)
{
	BASE_EXT_DECL
	register void* res __asm("d0");
	register void *a6 __asm ("a6");
	register LONG d0 __asm("d0");
	register LONG d1 __asm("d1");

	a6 = BASE_NAME;
	d0 = size;
	d1 = requirements;
	__asm volatile ("
	jsr a6@(-0x186)"
	: "=r" (res)
	: "r" (a6), "r" (d0), "r" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static BPTR ArpOpen(BASE_PAR_DECL char* name, LONG mode)
{
	BASE_EXT_DECL
	register BPTR res __asm("d0");
	register void *a6 __asm ("a6");
	register char* d1 __asm("d1");
	register LONG d2 __asm("d2");

	a6 = BASE_NAME;
	d1 = name;
	d2 = mode;
	__asm volatile ("
	jsr a6@(-0x18c)"
	: "=r" (res)
	: "r" (a6), "r" (d1), "r" (d2)
	: "d0", "d1", "a0", "a1", "d2");
	return res;
}
__inline static BPTR ArpDupLock(BASE_PAR_DECL BPTR lock)
{
	BASE_EXT_DECL
	register BPTR res __asm("d0");
	register void *a6 __asm ("a6");
	register BPTR d1 __asm("d1");

	a6 = BASE_NAME;
	d1 = lock;
	__asm volatile ("
	jsr a6@(-0x192)"
	: "=r" (res)
	: "r" (a6), "r" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static BPTR ArpLock(BASE_PAR_DECL char* name, LONG mode)
{
	BASE_EXT_DECL
	register BPTR res __asm("d0");
	register void *a6 __asm ("a6");
	register char* d1 __asm("d1");
	register LONG d2 __asm("d2");

	a6 = BASE_NAME;
	d1 = name;
	d2 = mode;
	__asm volatile ("
	jsr a6@(-0x198)"
	: "=r" (res)
	: "r" (a6), "r" (d1), "r" (d2)
	: "d0", "d1", "a0", "a1", "d2");
	return res;
}
__inline static void* RListAlloc(BASE_PAR_DECL struct ResList* reslist, LONG size)
{
	BASE_EXT_DECL
	register void* res __asm("d0");
	register void *a6 __asm ("a6");
	register struct ResList* a0 __asm("a0");
	register LONG d0 __asm("d0");

	a6 = BASE_NAME;
	a0 = reslist;
	d0 = size;
	__asm volatile ("
	jsr a6@(-0x19e)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
#endif
__inline static struct	Process* FindCLI(BASE_PAR_DECL LONG clinum)
{
	BASE_EXT_DECL
	register struct	Process* res __asm("d0");
	register void *a6 __asm ("a6");
	register LONG d0 __asm("d0");

	a6 = BASE_NAME;
	d0 = clinum;
	__asm volatile ("
	jsr a6@(-0x1a4)"
	: "=r" (res)
	: "r" (a6), "r" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static BOOL QSort(BASE_PAR_DECL void* base, LONG rsize, LONG bsize, int(*comp)())
{
	BASE_EXT_DECL
	register BOOL res __asm("d0");
	register void *a6 __asm ("a6");
	register void* a0 __asm("a0");
	register LONG d0 __asm("d0");
	register LONG d1 __asm("d1");
	register int(*a1)() __asm("a1");

	a6 = BASE_NAME;
	a0 = base;
	d0 = rsize;
	d1 = bsize;
	a1 = comp;
	__asm volatile ("
	jsr a6@(-0x1aa)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (d0), "r" (d1), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	return res;
}
__inline static BOOL PatternMatch(BASE_PAR_DECL const char* pattern, const char* string)
{
	BASE_EXT_DECL
	register BOOL res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");
	register const char* a1 __asm("a1");

	a6 = BASE_NAME;
	a0 = pattern;
	a1 = string;
	__asm volatile ("
	jsr a6@(-0x1b0)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static LONG FindFirst(BASE_PAR_DECL const char* pattern, struct AnchorPath* AnchorPath)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* d0 __asm("d0");
	register struct AnchorPath* a0 __asm("a0");

	a6 = BASE_NAME;
	d0 = pattern;
	a0 = AnchorPath;
	__asm volatile ("
	jsr a6@(-0x1b6)"
	: "=r" (res)
	: "r" (a6), "r" (d0), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	return res;
}
__inline static LONG FindNext(BASE_PAR_DECL struct AnchorPath* AnchorPath)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register struct AnchorPath* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = AnchorPath;
	__asm volatile ("
	jsr a6@(-0x1bc)"
	: "=r" (res)
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	return res;
}
__inline static void FreeAnchorChain(BASE_PAR_DECL struct AnchorPath* AnchorPath)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct AnchorPath* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = AnchorPath;
	__asm volatile ("
	jsr a6@(-0x1c2)"
	: /* no output */
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
}
__inline static ULONG CompareLock(BASE_PAR_DECL BPTR lock1, BPTR lock2)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register BPTR d0 __asm("d0");
	register BPTR d1 __asm("d1");

	a6 = BASE_NAME;
	d0 = lock1;
	d1 = lock2;
	__asm volatile ("
	jsr a6@(-0x1c8)"
	: "=r" (res)
	: "r" (a6), "r" (d0), "r" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static struct	ResList* FindTaskResList(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register struct	ResList* res __asm("d0");
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x1ce)"
	: "=r" (res)
	: "r" (a6)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static struct	ResList* CreateTaskResList(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register struct	ResList* res __asm("d0");
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x1d4)"
	: "=r" (res)
	: "r" (a6)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void FreeResList(BASE_PAR_DECL struct ResList* freelist)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct ResList* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = freelist;
	__asm volatile ("
	jsr a6@(-0x1da)"
	: /* no output */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
}
__inline static void FreeTrackedItem(BASE_PAR_DECL struct DefaultTracker* item)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct DefaultTracker* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = item;
	__asm volatile ("
	jsr a6@(-0x1e0)"
	: /* no output */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
}
#ifdef PRIVATE
__inline static struct	DefaultTracker* GetTracker(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register struct	DefaultTracker* res __asm("d0");
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x1e6)"
	: "=r" (res)
	: "r" (a6)
	: "d0", "d1", "a0", "a1");
	return res;
}
#endif
__inline static void* GetAccess(BASE_PAR_DECL struct DefaultTracker* tracker)
{
	BASE_EXT_DECL
	register void* res __asm("d0");
	register void *a6 __asm ("a6");
	register struct DefaultTracker* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = tracker;
	__asm volatile ("
	jsr a6@(-0x1ec)"
	: "=r" (res)
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
	return res;
}
__inline static void FreeAccess(BASE_PAR_DECL struct DefaultTracker* tracker)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct DefaultTracker* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = tracker;
	__asm volatile ("
	jsr a6@(-0x1f2)"
	: /* no output */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
}
__inline static void FreeDAList(BASE_PAR_DECL struct DirectoryEntry* node)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct DirectoryEntry* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = node;
	__asm volatile ("
	jsr a6@(-0x1f8)"
	: /* no output */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
}
__inline static struct	DirectoryEntry* AddDANode(BASE_PAR_DECL const char* data, struct DirectoryEntry** dalist, LONG length, LONG id)
{
	BASE_EXT_DECL
	register struct	DirectoryEntry* res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");
	register struct DirectoryEntry** a1 __asm("a1");
	register LONG d0 __asm("d0");
	register LONG d1 __asm("d1");

	a6 = BASE_NAME;
	a0 = data;
	a1 = dalist;
	d0 = length;
	d1 = id;
	__asm volatile ("
	jsr a6@(-0x1fe)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (a1), "r" (d0), "r" (d1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
	return res;
}
__inline static ULONG AddDADevs(BASE_PAR_DECL struct DirectoryEntry** dalist, LONG select)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register struct DirectoryEntry** a0 __asm("a0");
	register LONG d0 __asm("d0");

	a6 = BASE_NAME;
	a0 = dalist;
	d0 = select;
	__asm volatile ("
	jsr a6@(-0x204)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (d0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	return res;
}
__inline static LONG Strcmp(BASE_PAR_DECL const char* s1, const char* s2)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");
	register const char* a1 __asm("a1");

	a6 = BASE_NAME;
	a0 = s1;
	a1 = s2;
	__asm volatile ("
	jsr a6@(-0x20a)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static LONG Strncmp(BASE_PAR_DECL const char* s1, const char* s2, LONG count)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");
	register const char* a1 __asm("a1");
	register LONG d0 __asm("d0");

	a6 = BASE_NAME;
	a0 = s1;
	a1 = s2;
	d0 = count;
	__asm volatile ("
	jsr a6@(-0x210)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (a1), "r" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
#ifdef PRIVATE
__inline static BYTE Toupper(BASE_PAR_DECL BYTE character)
{
	BASE_EXT_DECL
	register BYTE res __asm("d0");
	register void *a6 __asm ("a6");
	register BYTE d0 __asm("d0");

	a6 = BASE_NAME;
	d0 = character;
	__asm volatile ("
	jsr a6@(-0x216)"
	: "=r" (res)
	: "r" (a6), "r" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
#endif
__inline static LONG SyncRun(BASE_PAR_DECL const char* name, const char* command, BPTR input, BPTR output)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");
	register const char* a1 __asm("a1");
	register BPTR d0 __asm("d0");
	register BPTR d1 __asm("d1");

	a6 = BASE_NAME;
	a0 = name;
	a1 = command;
	d0 = input;
	d1 = output;
	__asm volatile ("
	jsr a6@(-0x21c)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (a1), "r" (d0), "r" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static LONG ASyncRun(BASE_PAR_DECL const char* name, const char* command, struct ProcessControlBlock* pcb)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");
	register const char* a1 __asm("a1");
	register struct ProcessControlBlock* a2 __asm("a2");

	a6 = BASE_NAME;
	a0 = name;
	a1 = command;
	a2 = pcb;
	__asm volatile ("
	jsr a6@(-0x222)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (a1), "r" (a2)
	: "d0", "d1", "a0", "a1", "a2");
	*(char *)a2=*(char *)a2;
	return res;
}
__inline static BPTR LoadPrg(BASE_PAR_DECL const char* name)
{
	BASE_EXT_DECL
	register BPTR res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* d1 __asm("d1");

	a6 = BASE_NAME;
	d1 = name;
	__asm volatile ("
	jsr a6@(-0x228)"
	: "=r" (res)
	: "r" (a6), "r" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static BOOL PreParse(BASE_PAR_DECL const char* source, char* dest)
{
	BASE_EXT_DECL
	register BOOL res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");
	register char* a1 __asm("a1");

	a6 = BASE_NAME;
	a0 = source;
	a1 = dest;
	__asm volatile ("
	jsr a6@(-0x22e)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
	return res;
}
__inline static BOOL StamptoStr(BASE_PAR_DECL struct DateTime* datetime)
{
	BASE_EXT_DECL
	register BOOL res __asm("d0");
	register void *a6 __asm ("a6");
	register struct DateTime* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = datetime;
	__asm volatile ("
	jsr a6@(-0x234)"
	: "=r" (res)
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	return res;
}
__inline static BOOL StrtoStamp(BASE_PAR_DECL struct DateTime* datetime)
{
	BASE_EXT_DECL
	register BOOL res __asm("d0");
	register void *a6 __asm ("a6");
	register struct DateTime* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = datetime;
	__asm volatile ("
	jsr a6@(-0x23a)"
	: "=r" (res)
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	return res;
}
__inline static struct	ResidentProgramNode* ObtainResidentPrg(BASE_PAR_DECL const char* name)
{
	BASE_EXT_DECL
	register struct	ResidentProgramNode* res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = name;
	__asm volatile ("
	jsr a6@(-0x240)"
	: "=r" (res)
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static struct	ResidentProgramNode* AddResidentPrg(BASE_PAR_DECL BPTR Segment, const char* name)
{
	BASE_EXT_DECL
	register struct	ResidentProgramNode* res __asm("d0");
	register void *a6 __asm ("a6");
	register BPTR d1 __asm("d1");
	register const char* a0 __asm("a0");

	a6 = BASE_NAME;
	d1 = Segment;
	a0 = name;
	__asm volatile ("
	jsr a6@(-0x246)"
	: "=r" (res)
	: "r" (a6), "r" (d1), "r" (a0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static LONG RemResidentPrg(BASE_PAR_DECL const char* name)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = name;
	__asm volatile ("
	jsr a6@(-0x24c)"
	: "=r" (res)
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void UnLoadPrg(BASE_PAR_DECL BPTR segment)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register BPTR d1 __asm("d1");

	a6 = BASE_NAME;
	d1 = segment;
	__asm volatile ("
	jsr a6@(-0x252)"
	: /* no output */
	: "r" (a6), "r" (d1)
	: "d0", "d1", "a0", "a1");
}
__inline static LONG const LMult(BASE_PAR_DECL LONG a, LONG b)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register LONG d0 __asm("d0");
	register LONG d1 __asm("d1");

	a6 = BASE_NAME;
	d0 = a;
	d1 = b;
	__asm volatile ("
	jsr a6@(-0x258)"
	: "=r" (res)
	: "r" (a6), "r" (d0), "r" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static LONG const LDiv(BASE_PAR_DECL LONG a, LONG b)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register LONG d0 __asm("d0");
	register LONG d1 __asm("d1");

	a6 = BASE_NAME;
	d0 = a;
	d1 = b;
	__asm volatile ("
	jsr a6@(-0x25e)"
	: "=r" (res)
	: "r" (a6), "r" (d0), "r" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static LONG const LMod(BASE_PAR_DECL LONG a, LONG b)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register LONG d0 __asm("d0");
	register LONG d1 __asm("d1");

	a6 = BASE_NAME;
	d0 = a;
	d1 = b;
	__asm volatile ("
	jsr a6@(-0x264)"
	: "=r" (res)
	: "r" (a6), "r" (d0), "r" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static ULONG CheckSumPrg(BASE_PAR_DECL const struct ResidentProgramNode* ResidentNode)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register const struct ResidentProgramNode* d0 __asm("d0");

	a6 = BASE_NAME;
	d0 = ResidentNode;
	__asm volatile ("
	jsr a6@(-0x26a)"
	: "=r" (res)
	: "r" (a6), "r" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void TackOn(BASE_PAR_DECL char* pathname, const char* filename)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register char* a0 __asm("a0");
	register const char* a1 __asm("a1");

	a6 = BASE_NAME;
	a0 = pathname;
	a1 = filename;
	__asm volatile ("
	jsr a6@(-0x270)"
	: /* no output */
	: "r" (a6), "r" (a0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
}
__inline static BYTE* BaseName(BASE_PAR_DECL const char* name)
{
	BASE_EXT_DECL
	register BYTE* res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = name;
	__asm volatile ("
	jsr a6@(-0x276)"
	: "=r" (res)
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static struct	ResidentProgramNode* ReleaseResidentPrg(BASE_PAR_DECL BPTR segment)
{
	BASE_EXT_DECL
	register struct	ResidentProgramNode* res __asm("d0");
	register void *a6 __asm ("a6");
	register BPTR d1 __asm("d1");

	a6 = BASE_NAME;
	d1 = segment;
	__asm volatile ("
	jsr a6@(-0x27c)"
	: "=r" (res)
	: "r" (a6), "r" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
#ifdef PRIVATE
#ifdef DOTDOTDOT
__inline static LONG SPrintf(BASE_PAR_DECL char* file, char* string, ... stream)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register char* d0 __asm("d0");
	register char* a0 __asm("a0");
	register ... a1 __asm("a1");

	a6 = BASE_NAME;
	d0 = file;
	a0 = string;
	a1 = stream;
	__asm volatile ("
	jsr a6@(-0x282)"
	: "=r" (res)
	: "r" (a6), "r" (d0), "r" (a0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
#endif
__inline static LONG GetKeywordIndex(BASE_PAR_DECL char* char *, char* char *)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register char* a0 __asm("a0");
	register char* a1 __asm("a1");

	a6 = BASE_NAME;
	a0 = char *;
	a1 = char *;
	__asm volatile ("
	jsr a6@(-0x288)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static struct	Library* ArpOpenLibrary(BASE_PAR_DECL char* name, LONG vers)
{
	BASE_EXT_DECL
	register struct	Library* res __asm("d0");
	register void *a6 __asm ("a6");
	register char* a1 __asm("a1");
	register LONG d0 __asm("d0");

	a6 = BASE_NAME;
	a1 = name;
	d0 = vers;
	__asm volatile ("
	jsr a6@(-0x28e)"
	: "=r" (res)
	: "r" (a6), "r" (a1), "r" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static struct	FileRequester* ArpAllocFreq(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register struct	FileRequester* res __asm("d0");
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x294)"
	: "=r" (res)
	: "r" (a6)
	: "d0", "d1", "a0", "a1");
	return res;
}
#endif
#undef BASE_EXT_DECL
#undef BASE_PAR_DECL
#undef BASE_PAR_DECL0
#undef BASE_NAME