#include <inline/stub.h>
#ifndef BASE_EXT_DECL
#define BASE_EXT_DECL
#endif
#ifndef BASE_PAR_DECL
#define BASE_PAR_DECL
#define BASE_PAR_DECL0 void
#endif
#ifndef BASE_NAME
#define BASE_NAME (*(void **)4)
#endif
__inline static ULONG Supervisor(BASE_PAR_DECL long unsigned int (*userFunction)())
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register long unsigned int (*a4)() __asm("a4"); /* kludge ahead.. */

	a6 = BASE_NAME;
	a4 = userFunction;
	__asm volatile ("
	exg a4,a5
	jsr a6@(-0x1e)
	exg a4,a5"
	: "=g" (res)
	: "g" (a6), "g" (a4)
	: "d0", "d1", "a0", "a1", "a4");
	return res;
}
#ifdef PRIVATE
#endif
__inline static void InitCode(BASE_PAR_DECL long unsigned int startClass, long unsigned int version)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register long unsigned int d0 __asm("d0");
	register long unsigned int d1 __asm("d1");

	a6 = BASE_NAME;
	d0 = startClass;
	d1 = version;
	__asm volatile ("
	jsr a6@(-0x48)"
	: /* no output */
	: "g" (a6), "g" (d0), "g" (d1)
	: "d0", "d1", "a0", "a1");
}
__inline static void InitStruct(BASE_PAR_DECL APTR initTable, APTR memory, long unsigned int size)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR a1 __asm("a1");
	register APTR a2 __asm("a2");
	register long unsigned int d0 __asm("d0");

	a6 = BASE_NAME;
	a1 = initTable;
	a2 = memory;
	d0 = size;
	__asm volatile ("
	jsr a6@(-0x4e)"
	: /* no output */
	: "g" (a6), "g" (a1), "g" (a2), "g" (d0)
	: "d0", "d1", "a0", "a1", "a2");
}
__inline static struct Library* MakeLibrary(BASE_PAR_DECL APTR funcInit, APTR structInit, long unsigned int (*libInit)(), long unsigned int dataSize, long unsigned int segList)
{
	BASE_EXT_DECL
	register struct Library* res __asm("d0");
	register void *a6 __asm ("a6");
	register APTR a0 __asm("a0");
	register APTR a1 __asm("a1");
	register long unsigned int (*a2)() __asm("a2");
	register long unsigned int d0 __asm("d0");
	register long unsigned int d1 __asm("d1");

	a6 = BASE_NAME;
	a0 = funcInit;
	a1 = structInit;
	a2 = libInit;
	d0 = dataSize;
	d1 = segList;
	__asm volatile ("
	jsr a6@(-0x54)"
	: "=g" (res)
	: "g" (a6), "g" (a0), "g" (a1), "g" (a2), "g" (d0), "g" (d1)
	: "d0", "d1", "a0", "a1", "a2");
	return res;
}
__inline static void MakeFunctions(BASE_PAR_DECL APTR target, APTR functionArray, long unsigned int funcDispBase)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR a0 __asm("a0");
	register APTR a1 __asm("a1");
	register long unsigned int a2 __asm("a2");

	a6 = BASE_NAME;
	a0 = target;
	a1 = functionArray;
	a2 = funcDispBase;
	__asm volatile ("
	jsr a6@(-0x5a)"
	: /* no output */
	: "g" (a6), "g" (a0), "g" (a1), "g" (a2)
	: "d0", "d1", "a0", "a1", "a2");
}
__inline static struct Resident* FindResident(BASE_PAR_DECL UBYTE* name)
{
	BASE_EXT_DECL
	register struct Resident* res __asm("d0");
	register void *a6 __asm ("a6");
	register UBYTE* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = name;
	__asm volatile ("
	jsr a6@(-0x60)"
	: "=g" (res)
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void InitResident(BASE_PAR_DECL struct Resident* resident, long unsigned int segList)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct Resident* a1 __asm("a1");
	register long unsigned int d1 __asm("d1");

	a6 = BASE_NAME;
	a1 = resident;
	d1 = segList;
	__asm volatile ("
	jsr a6@(-0x66)"
	: /* no output */
	: "g" (a6), "g" (a1), "g" (d1)
	: "d0", "d1", "a0", "a1");
}
__inline static void Alert(BASE_PAR_DECL long unsigned int alertNum)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register long unsigned int d7 __asm("d7");

	a6 = BASE_NAME;
	d7 = alertNum;
	__asm volatile ("
	jsr a6@(-0x6c)"
	: /* no output */
	: "g" (a6), "g" (d7)
	: "d0", "d1", "a0", "a1", "d7");
}
__inline static void Debug(BASE_PAR_DECL long unsigned int flags)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register long unsigned int d0 __asm("d0");

	a6 = BASE_NAME;
	d0 = flags;
	__asm volatile ("
	jsr a6@(-0x72)"
	: /* no output */
	: "g" (a6), "g" (d0)
	: "d0", "d1", "a0", "a1");
}
__inline static void Disable(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x78)"
	: /* no output */
	: "g" (a6)
	: "d0", "d1", "a0", "a1");
}
__inline static void Enable(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x7e)"
	: /* no output */
	: "g" (a6)
	: "d0", "d1", "a0", "a1");
}
__inline static void Forbid(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x84)"
	: /* no output */
	: "g" (a6)
	: "d0", "d1", "a0", "a1");
}
__inline static void Permit(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x8a)"
	: /* no output */
	: "g" (a6)
	: "d0", "d1", "a0", "a1");
}
__inline static ULONG SetSR(BASE_PAR_DECL long unsigned int newSR, long unsigned int mask)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register long unsigned int d0 __asm("d0");
	register long unsigned int d1 __asm("d1");

	a6 = BASE_NAME;
	d0 = newSR;
	d1 = mask;
	__asm volatile ("
	jsr a6@(-0x90)"
	: "=g" (res)
	: "g" (a6), "g" (d0), "g" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static APTR SuperState(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register APTR res __asm("d0");
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x96)"
	: "=g" (res)
	: "g" (a6)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void UserState(BASE_PAR_DECL APTR sysStack)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR d0 __asm("d0");

	a6 = BASE_NAME;
	d0 = sysStack;
	__asm volatile ("
	jsr a6@(-0x9c)"
	: /* no output */
	: "g" (a6), "g" (d0)
	: "d0", "d1", "a0", "a1");
}
__inline static struct Interrupt* SetIntVector(BASE_PAR_DECL long int intNumber, struct Interrupt* interrupt)
{
	BASE_EXT_DECL
	register struct Interrupt* res __asm("d0");
	register void *a6 __asm ("a6");
	register long int d0 __asm("d0");
	register struct Interrupt* a1 __asm("a1");

	a6 = BASE_NAME;
	d0 = intNumber;
	a1 = interrupt;
	__asm volatile ("
	jsr a6@(-0xa2)"
	: "=g" (res)
	: "g" (a6), "g" (d0), "g" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void AddIntServer(BASE_PAR_DECL long int intNumber, struct Interrupt* interrupt)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register long int d0 __asm("d0");
	register struct Interrupt* a1 __asm("a1");

	a6 = BASE_NAME;
	d0 = intNumber;
	a1 = interrupt;
	__asm volatile ("
	jsr a6@(-0xa8)"
	: /* no output */
	: "g" (a6), "g" (d0), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static void RemIntServer(BASE_PAR_DECL long int intNumber, struct Interrupt* interrupt)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register long int d0 __asm("d0");
	register struct Interrupt* a1 __asm("a1");

	a6 = BASE_NAME;
	d0 = intNumber;
	a1 = interrupt;
	__asm volatile ("
	jsr a6@(-0xae)"
	: /* no output */
	: "g" (a6), "g" (d0), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static void Cause(BASE_PAR_DECL struct Interrupt* interrupt)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct Interrupt* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = interrupt;
	__asm volatile ("
	jsr a6@(-0xb4)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static APTR Allocate(BASE_PAR_DECL struct MemHeader* freeList, long unsigned int byteSize)
{
	BASE_EXT_DECL
	register APTR res __asm("d0");
	register void *a6 __asm ("a6");
	register struct MemHeader* a0 __asm("a0");
	register long unsigned int d0 __asm("d0");

	a6 = BASE_NAME;
	a0 = freeList;
	d0 = byteSize;
	__asm volatile ("
	jsr a6@(-0xba)"
	: "=g" (res)
	: "g" (a6), "g" (a0), "g" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void Deallocate(BASE_PAR_DECL struct MemHeader* freeList, APTR memoryBlock, long unsigned int byteSize)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct MemHeader* a0 __asm("a0");
	register APTR a1 __asm("a1");
	register long unsigned int d0 __asm("d0");

	a6 = BASE_NAME;
	a0 = freeList;
	a1 = memoryBlock;
	d0 = byteSize;
	__asm volatile ("
	jsr a6@(-0xc0)"
	: /* no output */
	: "g" (a6), "g" (a0), "g" (a1), "g" (d0)
	: "d0", "d1", "a0", "a1");
}
__inline static APTR AllocMem(BASE_PAR_DECL long unsigned int byteSize, long unsigned int requirements)
{
	BASE_EXT_DECL
	register APTR res __asm("d0");
	register void *a6 __asm ("a6");
	register long unsigned int d0 __asm("d0");
	register long unsigned int d1 __asm("d1");

	a6 = BASE_NAME;
	d0 = byteSize;
	d1 = requirements;
	__asm volatile ("
	jsr a6@(-0xc6)"
	: "=g" (res)
	: "g" (a6), "g" (d0), "g" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static APTR AllocAbs(BASE_PAR_DECL long unsigned int byteSize, APTR location)
{
	BASE_EXT_DECL
	register APTR res __asm("d0");
	register void *a6 __asm ("a6");
	register long unsigned int d0 __asm("d0");
	register APTR a1 __asm("a1");

	a6 = BASE_NAME;
	d0 = byteSize;
	a1 = location;
	__asm volatile ("
	jsr a6@(-0xcc)"
	: "=g" (res)
	: "g" (a6), "g" (d0), "g" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void FreeMem(BASE_PAR_DECL APTR memoryBlock, long unsigned int byteSize)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR a1 __asm("a1");
	register long unsigned int d0 __asm("d0");

	a6 = BASE_NAME;
	a1 = memoryBlock;
	d0 = byteSize;
	__asm volatile ("
	jsr a6@(-0xd2)"
	: /* no output */
	: "g" (a6), "g" (a1), "g" (d0)
	: "d0", "d1", "a0", "a1");
}
__inline static ULONG AvailMem(BASE_PAR_DECL long unsigned int requirements)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register long unsigned int d1 __asm("d1");

	a6 = BASE_NAME;
	d1 = requirements;
	__asm volatile ("
	jsr a6@(-0xd8)"
	: "=g" (res)
	: "g" (a6), "g" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static struct MemList* AllocEntry(BASE_PAR_DECL struct MemList* entry)
{
	BASE_EXT_DECL
	register struct MemList* res __asm("d0");
	register void *a6 __asm ("a6");
	register struct MemList* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = entry;
	__asm volatile ("
	jsr a6@(-0xde)"
	: "=g" (res)
	: "g" (a6), "g" (a0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void FreeEntry(BASE_PAR_DECL struct MemList* entry)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct MemList* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = entry;
	__asm volatile ("
	jsr a6@(-0xe4)"
	: /* no output */
	: "g" (a6), "g" (a0)
	: "d0", "d1", "a0", "a1");
}
__inline static void Insert(BASE_PAR_DECL struct List* list, struct Node* node, struct Node* pred)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct List* a0 __asm("a0");
	register struct Node* a1 __asm("a1");
	register struct Node* a2 __asm("a2");

	a6 = BASE_NAME;
	a0 = list;
	a1 = node;
	a2 = pred;
	__asm volatile ("
	jsr a6@(-0xea)"
	: /* no output */
	: "g" (a6), "g" (a0), "g" (a1), "g" (a2)
	: "d0", "d1", "a0", "a1", "a2");
}
__inline static void AddHead(BASE_PAR_DECL struct List* list, struct Node* node)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct List* a0 __asm("a0");
	register struct Node* a1 __asm("a1");

	a6 = BASE_NAME;
	a0 = list;
	a1 = node;
	__asm volatile ("
	jsr a6@(-0xf0)"
	: /* no output */
	: "g" (a6), "g" (a0), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static void AddTail(BASE_PAR_DECL struct List* list, struct Node* node)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct List* a0 __asm("a0");
	register struct Node* a1 __asm("a1");

	a6 = BASE_NAME;
	a0 = list;
	a1 = node;
	__asm volatile ("
	jsr a6@(-0xf6)"
	: /* no output */
	: "g" (a6), "g" (a0), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static void Remove(BASE_PAR_DECL struct Node* node)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct Node* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = node;
	__asm volatile ("
	jsr a6@(-0xfc)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static struct Node* RemHead(BASE_PAR_DECL struct List* list)
{
	BASE_EXT_DECL
	register struct Node* res __asm("d0");
	register void *a6 __asm ("a6");
	register struct List* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = list;
	__asm volatile ("
	jsr a6@(-0x102)"
	: "=g" (res)
	: "g" (a6), "g" (a0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static struct Node* RemTail(BASE_PAR_DECL struct List* list)
{
	BASE_EXT_DECL
	register struct Node* res __asm("d0");
	register void *a6 __asm ("a6");
	register struct List* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = list;
	__asm volatile ("
	jsr a6@(-0x108)"
	: "=g" (res)
	: "g" (a6), "g" (a0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void Enqueue(BASE_PAR_DECL struct List* list, struct Node* node)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct List* a0 __asm("a0");
	register struct Node* a1 __asm("a1");

	a6 = BASE_NAME;
	a0 = list;
	a1 = node;
	__asm volatile ("
	jsr a6@(-0x10e)"
	: /* no output */
	: "g" (a6), "g" (a0), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static struct Node* FindName(BASE_PAR_DECL struct List* list, UBYTE* name)
{
	BASE_EXT_DECL
	register struct Node* res __asm("d0");
	register void *a6 __asm ("a6");
	register struct List* a0 __asm("a0");
	register UBYTE* a1 __asm("a1");

	a6 = BASE_NAME;
	a0 = list;
	a1 = name;
	__asm volatile ("
	jsr a6@(-0x114)"
	: "=g" (res)
	: "g" (a6), "g" (a0), "g" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static APTR AddTask(BASE_PAR_DECL struct Task* task, APTR initPC, APTR finalPC)
{
	BASE_EXT_DECL
	register APTR res __asm("d0");
	register void *a6 __asm ("a6");
	register struct Task* a1 __asm("a1");
	register APTR a2 __asm("a2");
	register APTR a3 __asm("a3");

	a6 = BASE_NAME;
	a1 = task;
	a2 = initPC;
	a3 = finalPC;
	__asm volatile ("
	jsr a6@(-0x11a)"
	: "=g" (res)
	: "g" (a6), "g" (a1), "g" (a2), "g" (a3)
	: "d0", "d1", "a0", "a1", "a2", "a3");
	return res;
}
__inline static void RemTask(BASE_PAR_DECL struct Task* task)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct Task* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = task;
	__asm volatile ("
	jsr a6@(-0x120)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static struct Task* FindTask(BASE_PAR_DECL UBYTE* name)
{
	BASE_EXT_DECL
	register struct Task* res __asm("d0");
	register void *a6 __asm ("a6");
	register UBYTE* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = name;
	__asm volatile ("
	jsr a6@(-0x126)"
	: "=g" (res)
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static BYTE SetTaskPri(BASE_PAR_DECL struct Task* task, long int priority)
{
	BASE_EXT_DECL
	register BYTE res __asm("d0");
	register void *a6 __asm ("a6");
	register struct Task* a1 __asm("a1");
	register long int d0 __asm("d0");

	a6 = BASE_NAME;
	a1 = task;
	d0 = priority;
	__asm volatile ("
	jsr a6@(-0x12c)"
	: "=g" (res)
	: "g" (a6), "g" (a1), "g" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static ULONG SetSignal(BASE_PAR_DECL long unsigned int newSignals, long unsigned int signalSet)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register long unsigned int d0 __asm("d0");
	register long unsigned int d1 __asm("d1");

	a6 = BASE_NAME;
	d0 = newSignals;
	d1 = signalSet;
	__asm volatile ("
	jsr a6@(-0x132)"
	: "=g" (res)
	: "g" (a6), "g" (d0), "g" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static ULONG SetExcept(BASE_PAR_DECL long unsigned int newSignals, long unsigned int signalSet)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register long unsigned int d0 __asm("d0");
	register long unsigned int d1 __asm("d1");

	a6 = BASE_NAME;
	d0 = newSignals;
	d1 = signalSet;
	__asm volatile ("
	jsr a6@(-0x138)"
	: "=g" (res)
	: "g" (a6), "g" (d0), "g" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static ULONG Wait(BASE_PAR_DECL long unsigned int signalSet)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register long unsigned int d0 __asm("d0");

	a6 = BASE_NAME;
	d0 = signalSet;
	__asm volatile ("
	jsr a6@(-0x13e)"
	: "=g" (res)
	: "g" (a6), "g" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void Signal(BASE_PAR_DECL struct Task* task, long unsigned int signalSet)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct Task* a1 __asm("a1");
	register long unsigned int d0 __asm("d0");

	a6 = BASE_NAME;
	a1 = task;
	d0 = signalSet;
	__asm volatile ("
	jsr a6@(-0x144)"
	: /* no output */
	: "g" (a6), "g" (a1), "g" (d0)
	: "d0", "d1", "a0", "a1");
}
__inline static BYTE AllocSignal(BASE_PAR_DECL long int signalNum)
{
	BASE_EXT_DECL
	register BYTE res __asm("d0");
	register void *a6 __asm ("a6");
	register long int d0 __asm("d0");

	a6 = BASE_NAME;
	d0 = signalNum;
	__asm volatile ("
	jsr a6@(-0x14a)"
	: "=g" (res)
	: "g" (a6), "g" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void FreeSignal(BASE_PAR_DECL long int signalNum)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register long int d0 __asm("d0");

	a6 = BASE_NAME;
	d0 = signalNum;
	__asm volatile ("
	jsr a6@(-0x150)"
	: /* no output */
	: "g" (a6), "g" (d0)
	: "d0", "d1", "a0", "a1");
}
__inline static LONG AllocTrap(BASE_PAR_DECL long int trapNum)
{
	BASE_EXT_DECL
	register LONG res __asm("d0");
	register void *a6 __asm ("a6");
	register long int d0 __asm("d0");

	a6 = BASE_NAME;
	d0 = trapNum;
	__asm volatile ("
	jsr a6@(-0x156)"
	: "=g" (res)
	: "g" (a6), "g" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void FreeTrap(BASE_PAR_DECL long int trapNum)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register long int d0 __asm("d0");

	a6 = BASE_NAME;
	d0 = trapNum;
	__asm volatile ("
	jsr a6@(-0x15c)"
	: /* no output */
	: "g" (a6), "g" (d0)
	: "d0", "d1", "a0", "a1");
}
__inline static void AddPort(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@(-0x162)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static void RemPort(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@(-0x168)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static void PutMsg(BASE_PAR_DECL struct MsgPort* port, struct Message* message)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct MsgPort* a0 __asm("a0");
	register struct Message* a1 __asm("a1");

	a6 = BASE_NAME;
	a0 = port;
	a1 = message;
	__asm volatile ("
	jsr a6@(-0x16e)"
	: /* no output */
	: "g" (a6), "g" (a0), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static struct Message* GetMsg(BASE_PAR_DECL struct MsgPort* port)
{
	BASE_EXT_DECL
	register struct Message* res __asm("d0");
	register void *a6 __asm ("a6");
	register struct MsgPort* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = port;
	__asm volatile ("
	jsr a6@(-0x174)"
	: "=g" (res)
	: "g" (a6), "g" (a0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void ReplyMsg(BASE_PAR_DECL struct Message* message)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct Message* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = message;
	__asm volatile ("
	jsr a6@(-0x17a)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static struct Message* WaitPort(BASE_PAR_DECL struct MsgPort* port)
{
	BASE_EXT_DECL
	register struct Message* res __asm("d0");
	register void *a6 __asm ("a6");
	register struct MsgPort* a0 __asm("a0");

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

	a6 = BASE_NAME;
	a1 = name;
	__asm volatile ("
	jsr a6@(-0x186)"
	: "=g" (res)
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void AddLibrary(BASE_PAR_DECL struct Library* library)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct Library* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = library;
	__asm volatile ("
	jsr a6@(-0x18c)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static void RemLibrary(BASE_PAR_DECL struct Library* library)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct Library* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = library;
	__asm volatile ("
	jsr a6@(-0x192)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static struct Library* OldOpenLibrary(BASE_PAR_DECL UBYTE* libName)
{
	BASE_EXT_DECL
	register struct Library* res __asm("d0");
	register void *a6 __asm ("a6");
	register UBYTE* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = libName;
	__asm volatile ("
	jsr a6@(-0x198)"
	: "=g" (res)
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void CloseLibrary(BASE_PAR_DECL struct Library* library)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct Library* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = library;
	__asm volatile ("
	jsr a6@(-0x19e)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static APTR SetFunction(BASE_PAR_DECL struct Library* library, long int funcOffset, long unsigned int (*newFunction)())
{
	BASE_EXT_DECL
	register APTR res __asm("d0");
	register void *a6 __asm ("a6");
	register struct Library* a1 __asm("a1");
	register long int a0 __asm("a0");
	register long unsigned int (*d0)() __asm("d0");

	a6 = BASE_NAME;
	a1 = library;
	a0 = funcOffset;
	d0 = newFunction;
	__asm volatile ("
	jsr a6@(-0x1a4)"
	: "=g" (res)
	: "g" (a6), "g" (a1), "g" (a0), "g" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void SumLibrary(BASE_PAR_DECL struct Library* library)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct Library* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = library;
	__asm volatile ("
	jsr a6@(-0x1aa)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static void AddDevice(BASE_PAR_DECL struct Device* device)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct Device* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = device;
	__asm volatile ("
	jsr a6@(-0x1b0)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static void RemDevice(BASE_PAR_DECL struct Device* device)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct Device* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = device;
	__asm volatile ("
	jsr a6@(-0x1b6)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static BYTE OpenDevice(BASE_PAR_DECL UBYTE* devName, long unsigned int unit, struct IORequest* ioRequest, long unsigned int flags)
{
	BASE_EXT_DECL
	register BYTE res __asm("d0");
	register void *a6 __asm ("a6");
	register UBYTE* a0 __asm("a0");
	register long unsigned int d0 __asm("d0");
	register struct IORequest* a1 __asm("a1");
	register long unsigned int d1 __asm("d1");

	a6 = BASE_NAME;
	a0 = devName;
	d0 = unit;
	a1 = ioRequest;
	d1 = flags;
	__asm volatile ("
	jsr a6@(-0x1bc)"
	: "=g" (res)
	: "g" (a6), "g" (a0), "g" (d0), "g" (a1), "g" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void CloseDevice(BASE_PAR_DECL struct IORequest* ioRequest)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct IORequest* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = ioRequest;
	__asm volatile ("
	jsr a6@(-0x1c2)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static BYTE DoIO(BASE_PAR_DECL struct IORequest* ioRequest)
{
	BASE_EXT_DECL
	register BYTE res __asm("d0");
	register void *a6 __asm ("a6");
	register struct IORequest* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = ioRequest;
	__asm volatile ("
	jsr a6@(-0x1c8)"
	: "=g" (res)
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void SendIO(BASE_PAR_DECL struct IORequest* ioRequest)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct IORequest* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = ioRequest;
	__asm volatile ("
	jsr a6@(-0x1ce)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static BOOL CheckIO(BASE_PAR_DECL struct IORequest* ioRequest)
{
	BASE_EXT_DECL
	register BOOL res __asm("d0");
	register void *a6 __asm ("a6");
	register struct IORequest* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = ioRequest;
	__asm volatile ("
	jsr a6@(-0x1d4)"
	: "=g" (res)
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static BYTE WaitIO(BASE_PAR_DECL struct IORequest* ioRequest)
{
	BASE_EXT_DECL
	register BYTE res __asm("d0");
	register void *a6 __asm ("a6");
	register struct IORequest* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = ioRequest;
	__asm volatile ("
	jsr a6@(-0x1da)"
	: "=g" (res)
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void AbortIO(BASE_PAR_DECL struct IORequest* ioRequest)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct IORequest* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = ioRequest;
	__asm volatile ("
	jsr a6@(-0x1e0)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static void AddResource(BASE_PAR_DECL APTR resource)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = resource;
	__asm volatile ("
	jsr a6@(-0x1e6)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static void RemResource(BASE_PAR_DECL APTR resource)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = resource;
	__asm volatile ("
	jsr a6@(-0x1ec)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static APTR OpenResource(BASE_PAR_DECL UBYTE* resName)
{
	BASE_EXT_DECL
	register APTR res __asm("d0");
	register void *a6 __asm ("a6");
	register UBYTE* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = resName;
	__asm volatile ("
	jsr a6@(-0x1f2)"
	: "=g" (res)
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
#ifdef PRIVATE
#endif
__inline static void RawDoFmt(BASE_PAR_DECL UBYTE* formatString, APTR dataStream, void (*putChProc)(), APTR putChData)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register UBYTE* a0 __asm("a0");
	register APTR a1 __asm("a1");
	register void (*a2)() __asm("a2");
	register APTR a3 __asm("a3");

	a6 = BASE_NAME;
	a0 = formatString;
	a1 = dataStream;
	a2 = putChProc;
	a3 = putChData;
	__asm volatile ("
	jsr a6@(-0x20a)"
	: /* no output */
	: "g" (a6), "g" (a0), "g" (a1), "g" (a2), "g" (a3)
	: "d0", "d1", "a0", "a1", "a2", "a3");
}
__inline static ULONG GetCC(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x210)"
	: "=g" (res)
	: "g" (a6)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static ULONG TypeOfMem(BASE_PAR_DECL APTR address)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register APTR a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = address;
	__asm volatile ("
	jsr a6@(-0x216)"
	: "=g" (res)
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static ULONG Procure(BASE_PAR_DECL struct Semaphore* semaport, struct Message* bidMsg)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register struct Semaphore* a0 __asm("a0");
	register struct Message* a1 __asm("a1");

	a6 = BASE_NAME;
	a0 = semaport;
	a1 = bidMsg;
	__asm volatile ("
	jsr a6@(-0x21c)"
	: "=g" (res)
	: "g" (a6), "g" (a0), "g" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void Vacate(BASE_PAR_DECL struct Semaphore* semaport)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct Semaphore* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = semaport;
	__asm volatile ("
	jsr a6@(-0x222)"
	: /* no output */
	: "g" (a6), "g" (a0)
	: "d0", "d1", "a0", "a1");
}
__inline static struct Library* OpenLibrary(BASE_PAR_DECL UBYTE* libName, long unsigned int version)
{
	BASE_EXT_DECL
	register struct Library* res __asm("d0");
	register void *a6 __asm ("a6");
	register UBYTE* a1 __asm("a1");
	register long unsigned int d0 __asm("d0");

	a6 = BASE_NAME;
	a1 = libName;
	d0 = version;
	__asm volatile ("
	jsr a6@(-0x228)"
	: "=g" (res)
	: "g" (a6), "g" (a1), "g" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void InitSemaphore(BASE_PAR_DECL struct SignalSemaphore* sigSem)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct SignalSemaphore* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = sigSem;
	__asm volatile ("
	jsr a6@(-0x22e)"
	: /* no output */
	: "g" (a6), "g" (a0)
	: "d0", "d1", "a0", "a1");
}
__inline static void ObtainSemaphore(BASE_PAR_DECL struct SignalSemaphore* sigSem)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct SignalSemaphore* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = sigSem;
	__asm volatile ("
	jsr a6@(-0x234)"
	: /* no output */
	: "g" (a6), "g" (a0)
	: "d0", "d1", "a0", "a1");
}
__inline static void ReleaseSemaphore(BASE_PAR_DECL struct SignalSemaphore* sigSem)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct SignalSemaphore* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = sigSem;
	__asm volatile ("
	jsr a6@(-0x23a)"
	: /* no output */
	: "g" (a6), "g" (a0)
	: "d0", "d1", "a0", "a1");
}
__inline static ULONG AttemptSemaphore(BASE_PAR_DECL struct SignalSemaphore* sigSem)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register struct SignalSemaphore* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = sigSem;
	__asm volatile ("
	jsr a6@(-0x240)"
	: "=g" (res)
	: "g" (a6), "g" (a0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void ObtainSemaphoreList(BASE_PAR_DECL struct List* sigSem)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct List* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = sigSem;
	__asm volatile ("
	jsr a6@(-0x246)"
	: /* no output */
	: "g" (a6), "g" (a0)
	: "d0", "d1", "a0", "a1");
}
__inline static void ReleaseSemaphoreList(BASE_PAR_DECL struct List* sigSem)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct List* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = sigSem;
	__asm volatile ("
	jsr a6@(-0x24c)"
	: /* no output */
	: "g" (a6), "g" (a0)
	: "d0", "d1", "a0", "a1");
}
__inline static struct SignalSemaphore* FindSemaphore(BASE_PAR_DECL UBYTE* sigSem)
{
	BASE_EXT_DECL
	register struct SignalSemaphore* res __asm("d0");
	register void *a6 __asm ("a6");
	register UBYTE* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = sigSem;
	__asm volatile ("
	jsr a6@(-0x252)"
	: "=g" (res)
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void AddSemaphore(BASE_PAR_DECL struct SignalSemaphore* sigSem)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct SignalSemaphore* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = sigSem;
	__asm volatile ("
	jsr a6@(-0x258)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static void RemSemaphore(BASE_PAR_DECL struct SignalSemaphore* sigSem)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct SignalSemaphore* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = sigSem;
	__asm volatile ("
	jsr a6@(-0x25e)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static ULONG SumKickData(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x264)"
	: "=g" (res)
	: "g" (a6)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static ULONG AddMemList(BASE_PAR_DECL long unsigned int size, long unsigned int attributes, long unsigned int pri, APTR base, UBYTE* name)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register long unsigned int d0 __asm("d0");
	register long unsigned int d1 __asm("d1");
	register long unsigned int d2 __asm("d2");
	register APTR a0 __asm("a0");
	register UBYTE* a1 __asm("a1");

	a6 = BASE_NAME;
	d0 = size;
	d1 = attributes;
	d2 = pri;
	a0 = base;
	a1 = name;
	__asm volatile ("
	jsr a6@(-0x26a)"
	: "=g" (res)
	: "g" (a6), "g" (d0), "g" (d1), "g" (d2), "g" (a0), "g" (a1)
	: "d0", "d1", "a0", "a1", "d2");
	return res;
}
__inline static void CopyMem(BASE_PAR_DECL APTR source, APTR dest, long unsigned int size)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR a0 __asm("a0");
	register APTR a1 __asm("a1");
	register long unsigned int d0 __asm("d0");

	a6 = BASE_NAME;
	a0 = source;
	a1 = dest;
	d0 = size;
	__asm volatile ("
	jsr a6@(-0x270)"
	: /* no output */
	: "g" (a6), "g" (a0), "g" (a1), "g" (d0)
	: "d0", "d1", "a0", "a1");
}
__inline static void CopyMemQuick(BASE_PAR_DECL APTR source, APTR dest, long unsigned int size)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR a0 __asm("a0");
	register APTR a1 __asm("a1");
	register long unsigned int d0 __asm("d0");

	a6 = BASE_NAME;
	a0 = source;
	a1 = dest;
	d0 = size;
	__asm volatile ("
	jsr a6@(-0x276)"
	: /* no output */
	: "g" (a6), "g" (a0), "g" (a1), "g" (d0)
	: "d0", "d1", "a0", "a1");
}
__inline static void CacheClearU(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x27c)"
	: /* no output */
	: "g" (a6)
	: "d0", "d1", "a0", "a1");
}
__inline static void CacheClearE(BASE_PAR_DECL APTR address, long unsigned int length, long unsigned int caches)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR a0 __asm("a0");
	register long unsigned int d0 __asm("d0");
	register long unsigned int d1 __asm("d1");

	a6 = BASE_NAME;
	a0 = address;
	d0 = length;
	d1 = caches;
	__asm volatile ("
	jsr a6@(-0x282)"
	: /* no output */
	: "g" (a6), "g" (a0), "g" (d0), "g" (d1)
	: "d0", "d1", "a0", "a1");
}
__inline static ULONG CacheControl(BASE_PAR_DECL long unsigned int cacheBits, long unsigned int cacheMask)
{
	BASE_EXT_DECL
	register ULONG res __asm("d0");
	register void *a6 __asm ("a6");
	register long unsigned int d0 __asm("d0");
	register long unsigned int d1 __asm("d1");

	a6 = BASE_NAME;
	d0 = cacheBits;
	d1 = cacheMask;
	__asm volatile ("
	jsr a6@(-0x288)"
	: "=g" (res)
	: "g" (a6), "g" (d0), "g" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static APTR CreateIORequest(BASE_PAR_DECL struct MsgPort* port, long unsigned int size)
{
	BASE_EXT_DECL
	register APTR res __asm("d0");
	register void *a6 __asm ("a6");
	register struct MsgPort* a0 __asm("a0");
	register long unsigned int d0 __asm("d0");

	a6 = BASE_NAME;
	a0 = port;
	d0 = size;
	__asm volatile ("
	jsr a6@(-0x28e)"
	: "=g" (res)
	: "g" (a6), "g" (a0), "g" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void DeleteIORequest(BASE_PAR_DECL APTR iorequest)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = iorequest;
	__asm volatile ("
	jsr a6@(-0x294)"
	: /* no output */
	: "g" (a6), "g" (a0)
	: "d0", "d1", "a0", "a1");
}
__inline static struct MsgPort* CreateMsgPort(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register struct MsgPort* res __asm("d0");
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x29a)"
	: "=g" (res)
	: "g" (a6)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void DeleteMsgPort(BASE_PAR_DECL struct MsgPort* port)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct MsgPort* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = port;
	__asm volatile ("
	jsr a6@(-0x2a0)"
	: /* no output */
	: "g" (a6), "g" (a0)
	: "d0", "d1", "a0", "a1");
}
__inline static void ObtainSemaphoreShared(BASE_PAR_DECL struct SignalSemaphore* sigSem)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register struct SignalSemaphore* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = sigSem;
	__asm volatile ("
	jsr a6@(-0x2a6)"
	: /* no output */
	: "g" (a6), "g" (a0)
	: "d0", "d1", "a0", "a1");
}
__inline static APTR AllocVec(BASE_PAR_DECL long unsigned int byteSize, long unsigned int requirements)
{
	BASE_EXT_DECL
	register APTR res __asm("d0");
	register void *a6 __asm ("a6");
	register long unsigned int d0 __asm("d0");
	register long unsigned int d1 __asm("d1");

	a6 = BASE_NAME;
	d0 = byteSize;
	d1 = requirements;
	__asm volatile ("
	jsr a6@(-0x2ac)"
	: "=g" (res)
	: "g" (a6), "g" (d0), "g" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void FreeVec(BASE_PAR_DECL APTR memoryBlock)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = memoryBlock;
	__asm volatile ("
	jsr a6@(-0x2b2)"
	: /* no output */
	: "g" (a6), "g" (a1)
	: "d0", "d1", "a0", "a1");
}
__inline static APTR CreatePrivatePool(BASE_PAR_DECL long unsigned int requirements, long unsigned int puddleSize, long unsigned int puddleThresh)
{
	BASE_EXT_DECL
	register APTR res __asm("d0");
	register void *a6 __asm ("a6");
	register long unsigned int d0 __asm("d0");
	register long unsigned int d1 __asm("d1");
	register long unsigned int d2 __asm("d2");

	a6 = BASE_NAME;
	d0 = requirements;
	d1 = puddleSize;
	d2 = puddleThresh;
	__asm volatile ("
	jsr a6@(-0x2b8)"
	: "=g" (res)
	: "g" (a6), "g" (d0), "g" (d1), "g" (d2)
	: "d0", "d1", "a0", "a1", "d2");
	return res;
}
__inline static void DeletePrivatePool(BASE_PAR_DECL APTR poolHeader)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = poolHeader;
	__asm volatile ("
	jsr a6@(-0x2be)"
	: /* no output */
	: "g" (a6), "g" (a0)
	: "d0", "d1", "a0", "a1");
}
__inline static APTR AllocPooled(BASE_PAR_DECL long unsigned int memSize, APTR poolHeader)
{
	BASE_EXT_DECL
	register APTR res __asm("d0");
	register void *a6 __asm ("a6");
	register long unsigned int d0 __asm("d0");
	register APTR a0 __asm("a0");

	a6 = BASE_NAME;
	d0 = memSize;
	a0 = poolHeader;
	__asm volatile ("
	jsr a6@(-0x2c4)"
	: "=g" (res)
	: "g" (a6), "g" (d0), "g" (a0)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void FreePooled(BASE_PAR_DECL APTR memory, APTR poolHeader)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR a1 __asm("a1");
	register APTR a0 __asm("a0");

	a6 = BASE_NAME;
	a1 = memory;
	a0 = poolHeader;
	__asm volatile ("
	jsr a6@(-0x2ca)"
	: /* no output */
	: "g" (a6), "g" (a1), "g" (a0)
	: "d0", "d1", "a0", "a1");
}
__inline static void ColdReboot(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x2d6)"
	: /* no output */
	: "g" (a6)
	: "d0", "d1", "a0", "a1");
}
__inline static void StackSwap(BASE_PAR_DECL APTR newSize, APTR newSP, APTR newStack)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR d0 __asm("d0");
	register APTR d1 __asm("d1");
	register APTR a0 __asm("a0");

	a6 = BASE_NAME;
	d0 = newSize;
	d1 = newSP;
	a0 = newStack;
	__asm volatile ("
	jsr a6@(-0x2dc)"
	: /* no output */
	: "g" (a6), "g" (d0), "g" (d1), "g" (a0)
	: "d0", "d1", "a0", "a1");
}
__inline static void ChildFree(BASE_PAR_DECL APTR tid)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR d0 __asm("d0");

	a6 = BASE_NAME;
	d0 = tid;
	__asm volatile ("
	jsr a6@(-0x2e2)"
	: /* no output */
	: "g" (a6), "g" (d0)
	: "d0", "d1", "a0", "a1");
}
__inline static void ChildOrphan(BASE_PAR_DECL APTR tid)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR d0 __asm("d0");

	a6 = BASE_NAME;
	d0 = tid;
	__asm volatile ("
	jsr a6@(-0x2e8)"
	: /* no output */
	: "g" (a6), "g" (d0)
	: "d0", "d1", "a0", "a1");
}
__inline static void ChildStatus(BASE_PAR_DECL APTR tid)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR d0 __asm("d0");

	a6 = BASE_NAME;
	d0 = tid;
	__asm volatile ("
	jsr a6@(-0x2ee)"
	: /* no output */
	: "g" (a6), "g" (d0)
	: "d0", "d1", "a0", "a1");
}
__inline static void ChildWait(BASE_PAR_DECL APTR tid)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register APTR d0 __asm("d0");

	a6 = BASE_NAME;
	d0 = tid;
	__asm volatile ("
	jsr a6@(-0x2f4)"
	: /* no output */
	: "g" (a6), "g" (d0)
	: "d0", "d1", "a0", "a1");
}
#ifdef PRIVATE
#endif
__inline static struct List *NewList(struct List *list)
{
  list->lh_Tail = NULL;
  list->lh_TailPred = (struct Node *)list;
  list->lh_Head = (struct Node *)&list->lh_Tail;
}
#undef BASE_EXT_DECL
#undef BASE_PAR_DECL
#undef BASE_PAR_DECL0
#undef BASE_NAME