#ifndef _INLINE_EXEC_H
#define _INLINE_EXEC_H
#if defined(__GNUC__) && __GNUC__ < 2
#pragma once
#endif

#ifndef __GNUG__
#include <inline/stub.h>
#endif
#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
#ifdef PRIVATE
__inline static void Supervisor(BASE_PAR_DECL const void *func)
{
	BASE_EXT_DECL
	register const void *a5 __asm ("a4");
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	a5 = func;
	__asm volatile ("
	exg a4,a5
	jsr a6@(-0x1e)
	exg a4,a5"
	: /* no output */
	: "r" (a6), "r" (a5)
	: "d0", "d1", "a0", "a1", "a4");
}
__inline static void ExitIntr(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x24)"
	: /* no output */
	: "r" (a6)
	: "d0", "d1", "a0", "a1");
}
__inline static void Schedule(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x2a)"
	: /* no output */
	: "r" (a6)
	: "d0", "d1", "a0", "a1");
}
__inline static void Reschedule(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x30)"
	: /* no output */
	: "r" (a6)
	: "d0", "d1", "a0", "a1");
}
__inline static void Switch(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x36)"
	: /* no output */
	: "r" (a6)
	: "d0", "d1", "a0", "a1");
}
__inline static void Dispatch(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x3c)"
	: /* no output */
	: "r" (a6)
	: "d0", "d1", "a0", "a1");
}
__inline static void Exception(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x42)"
	: /* no output */
	: "r" (a6)
	: "d0", "d1", "a0", "a1");
}
#endif
__inline static void InitCode(BASE_PAR_DECL long startClass, long version)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register long d0 __asm("d0");
	register long d1 __asm("d1");

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

	a6 = BASE_NAME;
	a1 = initTable;
	a2 = memory;
	d0 = size;
	__asm volatile ("
	jsr a6@(-0x4e)"
	: /* no output */
	: "r" (a6), "r" (a1), "r" (a2), "r" (d0)
	: "d0", "d1", "a0", "a1", "a2");
	*(char *)a1=*(char *)a1;*(char *)a2=*(char *)a2;
}
/* g++ bug.. */
typedef void (*__ie_fp)();
typedef struct Library *(*__ie_lfp)();
__inline static struct Library * MakeLibrary(BASE_PAR_DECL __ie_fp *funcInit, short* structInit, __ie_lfp libInit, long dataSize, struct MemList* codeSize)
{
	BASE_EXT_DECL
	register struct Library * res __asm("d0");
	register void *a6 __asm ("a6");
	register void (**a0)() __asm("a0");
	register short* a1 __asm("a1");
	register struct Library *(*a2)() __asm("a2");
	register long d0 __asm("d0");
	register struct MemList* d1 __asm("d1");

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

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

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

	a6 = BASE_NAME;
	a1 = resident;
	d1 = segList;
	__asm volatile ("
	jsr a6@(-0x66)"
	: /* no output */
	: "r" (a6), "r" (a1), "r" (d1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
}
__inline static long Alert(BASE_PAR_DECL long alertNum, long parameters)
{
	BASE_EXT_DECL
	register long res __asm("d0");
	register void *a6 __asm ("a6");
	register long d7 __asm("d7");
	register long a4 __asm("a4"); /* cheat .. */

	a6 = BASE_NAME;
	d7 = alertNum;
	a4 = parameters;
	__asm volatile ("
	exg a4,a5
	jsr a6@(-0x6c)
	exg a4,a5"
	: "=r" (res)
	: "r" (a6), "r" (d7), "r" (a4)
	: "d0", "d1", "a0", "a1", "d7", "a4");
	return res;
}
__inline static void Debug(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x72)"
	: /* no output */
	: "r" (a6)
	: "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 */
	: "r" (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 */
	: "r" (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 */
	: "r" (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 */
	: "r" (a6)
	: "d0", "d1", "a0", "a1");
}
__inline static long SetSR(BASE_PAR_DECL long newSR, long mask)
{
	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 = newSR;
	d1 = mask;
	__asm volatile ("
	jsr a6@(-0x90)"
	: "=r" (res)
	: "r" (a6), "r" (d0), "r" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static long SuperState(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register long res __asm("d0");
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x96)"
	: "=r" (res)
	: "r" (a6)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void UserState(BASE_PAR_DECL void* sysStack)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register void* d0 __asm("d0");

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

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

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

	a6 = BASE_NAME;
	d0 = intNumber;
	a1 = interrupt;
	__asm volatile ("
	jsr a6@(-0xae)"
	: /* no output */
	: "r" (a6), "r" (d0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)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 */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
}
__inline static void * Allocate(BASE_PAR_DECL struct MemHeader* freeList, long byteSize)
{
	BASE_EXT_DECL
	register void * res __asm("d0");
	register void *a6 __asm ("a6");
	register struct MemHeader* a0 __asm("a0");
	register long d0 __asm("d0");

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

	a6 = BASE_NAME;
	a0 = freeList;
	a1 = memoryBlock;
	d0 = byteSize;
	__asm volatile ("
	jsr a6@(-0xc0)"
	: /* no output */
	: "r" (a6), "r" (a0), "r" (a1), "r" (d0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;*(char *)a1=*(char *)a1;
}
__inline static void * AllocMem(BASE_PAR_DECL long byteSize, 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 = byteSize;
	d1 = requirements;
	__asm volatile ("
	jsr a6@(-0xc6)"
	: "=r" (res)
	: "r" (a6), "r" (d0), "r" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void * AllocAbs(BASE_PAR_DECL long byteSize, void* location)
{
	BASE_EXT_DECL
	register void * res __asm("d0");
	register void *a6 __asm ("a6");
	register long d0 __asm("d0");
	register void* a1 __asm("a1");

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

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

	a6 = BASE_NAME;
	d1 = requirements;
	__asm volatile ("
	jsr a6@(-0xd8)"
	: "=r" (res)
	: "r" (a6), "r" (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)"
	: "=r" (res)
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	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 */
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
}
__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 */
	: "r" (a6), "r" (a0), "r" (a1), "r" (a2)
	: "d0", "d1", "a0", "a1", "a2");
	*(char *)a0=*(char *)a0;*(char *)a1=*(char *)a1;*(char *)a2=*(char *)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 */
	: "r" (a6), "r" (a0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;*(char *)a1=*(char *)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 */
	: "r" (a6), "r" (a0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;*(char *)a1=*(char *)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 */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)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)"
	: "=r" (res)
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	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)"
	: "=r" (res)
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	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 */
	: "r" (a6), "r" (a0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;*(char *)a1=*(char *)a1;
}
__inline static struct Node * FindName(BASE_PAR_DECL const struct List* list, const char* name)
{
	BASE_EXT_DECL
	register struct Node * res __asm("d0");
	register void *a6 __asm ("a6");
	register const struct List* a0 __asm("a0");
	register const char* a1 __asm("a1");

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

	a6 = BASE_NAME;
	a1 = task;
	a2 = initPC;
	a3 = finalPC;
	__asm volatile ("
	jsr a6@(-0x11a)"
	: /* no output */
	: "r" (a6), "r" (a1), "r" (a2), "r" (a3)
	: "d0", "d1", "a0", "a1", "a2", "a3");
	*(char *)a1=*(char *)a1;*(char *)a2=*(char *)a2;*(char *)a3=*(char *)a3;
}
__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 */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
}
__inline static struct Task * FindTask(BASE_PAR_DECL const char* name)
{
	BASE_EXT_DECL
	register struct Task * res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a1 __asm("a1");

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

	a6 = BASE_NAME;
	a1 = task;
	d0 = priority;
	__asm volatile ("
	jsr a6@(-0x12c)"
	: "=r" (res)
	: "r" (a6), "r" (a1), "r" (d0)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
	return res;
}
__inline static long SetSignal(BASE_PAR_DECL long newSignals, long signalSet)
{
	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 = newSignals;
	d1 = signalSet;
	__asm volatile ("
	jsr a6@(-0x132)"
	: "=r" (res)
	: "r" (a6), "r" (d0), "r" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static long SetExcept(BASE_PAR_DECL long newSignals, long signalSet)
{
	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 = newSignals;
	d1 = signalSet;
	__asm volatile ("
	jsr a6@(-0x138)"
	: "=r" (res)
	: "r" (a6), "r" (d0), "r" (d1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static long Wait(BASE_PAR_DECL long signalSet)
{
	BASE_EXT_DECL
	register long res __asm("d0");
	register void *a6 __asm ("a6");
	register long d0 __asm("d0");

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

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

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

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

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

	a6 = BASE_NAME;
	d0 = trapNum;
	__asm volatile ("
	jsr a6@(-0x15c)"
	: /* no output */
	: "r" (a6), "r" (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 */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)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 */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)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 */
	: "r" (a6), "r" (a0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;*(char *)a1=*(char *)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)"
	: "=r" (res)
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	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 */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)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)"
	: "=r" (res)
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	return res;
}
__inline static struct MsgPort * FindPort(BASE_PAR_DECL const char* name)
{
	BASE_EXT_DECL
	register struct MsgPort * res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = name;
	__asm volatile ("
	jsr a6@(-0x186)"
	: "=r" (res)
	: "r" (a6), "r" (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 */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
}
__inline static long RemLibrary(BASE_PAR_DECL struct Library* library)
{
	BASE_EXT_DECL
	register long res __asm("d0");
	register void *a6 __asm ("a6");
	register struct Library* a1 __asm("a1");

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

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

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

	a6 = BASE_NAME;
	a1 = library;
	a0 = funcOffset;
	d0 = funcEntry;
	__asm volatile ("
	jsr a6@(-0x1a4)"
	: "=r" (res)
	: "r" (a6), "r" (a1), "r" (a0), "r" (d0)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)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 */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)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 */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
}
__inline static long RemDevice(BASE_PAR_DECL struct Device* device)
{
	BASE_EXT_DECL
	register long res __asm("d0");
	register void *a6 __asm ("a6");
	register struct Device* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = device;
	__asm volatile ("
	jsr a6@(-0x1b6)"
	: "=r" (res)
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
	return res;
}
__inline static long OpenDevice(BASE_PAR_DECL const char* devName, long unit, struct IORequest* ioRequest, long flags)
{
	BASE_EXT_DECL
	register long res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");
	register long d0 __asm("d0");
	register struct IORequest* a1 __asm("a1");
	register long d1 __asm("d1");

	a6 = BASE_NAME;
	a0 = devName;
	d0 = unit;
	a1 = ioRequest;
	d1 = flags;
	__asm volatile ("
	jsr a6@(-0x1bc)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (d0), "r" (a1), "r" (d1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)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 */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
}
__inline static long DoIO(BASE_PAR_DECL struct IORequest* ioRequest)
{
	BASE_EXT_DECL
	register long res __asm("d0");
	register void *a6 __asm ("a6");
	register struct IORequest* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = ioRequest;
	__asm volatile ("
	jsr a6@(-0x1c8)"
	: "=r" (res)
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)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 */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
}
__inline static struct IORequest * CheckIO(BASE_PAR_DECL const struct IORequest* ioRequest)
{
	BASE_EXT_DECL
	register struct IORequest * res __asm("d0");
	register void *a6 __asm ("a6");
	register const struct IORequest* a1 __asm("a1");

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

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

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

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

	a6 = BASE_NAME;
	a1 = resource;
	__asm volatile ("
	jsr a6@(-0x1ec)"
	: /* no output */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
}
__inline static struct MiscResource * OpenResource(BASE_PAR_DECL const char* resName, long version)
{
	BASE_EXT_DECL
	register struct MiscResource * res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a1 __asm("a1");
	register long d0 __asm("d0");

	a6 = BASE_NAME;
	a1 = resName;
	d0 = version;
	__asm volatile ("
	jsr a6@(-0x1f2)"
	: "=r" (res)
	: "r" (a6), "r" (a1), "r" (d0)
	: "d0", "d1", "a0", "a1");
	return res;
}
#ifdef PRIVATE
__inline static void RawIOInit(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x1f8)"
	: /* no output */
	: "r" (a6)
	: "d0", "d1", "a0", "a1");
}
__inline static long RawMayGetChar(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register long res __asm("d0");
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x1fe)"
	: "=r" (res)
	: "r" (a6)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static void RawPutChar(BASE_PAR_DECL long ch)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register long d0 __asm("d0");

	a6 = BASE_NAME;
	d0 = ch;
	__asm volatile ("
	jsr a6@(-0x204)"
	: /* no output */
	: "r" (a6), "r" (d0)
	: "d0", "d1", "a0", "a1");
}
__inline static void RawDoFmt(BASE_PAR_DECL const char* FormatString, char *DataStream, void (*PutChProc)(), long PutChData)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	register const char* a0 __asm("a0");
	register char* a1 __asm("a1");
	register void (*a2)() __asm("a2");
	register long a3 __asm("a3");

	a6 = BASE_NAME;
	a0 = FormatString;
	a1 = DataStream;
	a2 = PutChProc;
	a3 = PutChData;
	__asm volatile ("
	jsr a6@(-0x20a)"
	: /* no output */
	: "r" (a6), "r" (a0), "r" (a1), "r" (a2), "r" (a3)
	: "d0", "d1", "a0", "a1", "a2", "a3");
	*(char *)a1=*(char *)a1;
}
#endif
__inline static long GetCC(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register long res __asm("d0");
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x210)"
	: "=r" (res)
	: "r" (a6)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static long TypeOfMem(BASE_PAR_DECL const char* address)
{
	BASE_EXT_DECL
	register long res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = address;
	__asm volatile ("
	jsr a6@(-0x216)"
	: "=r" (res)
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	return res;
}
__inline static long Procure(BASE_PAR_DECL struct Semaphore* semaport, struct Message* bidMsg)
{
	BASE_EXT_DECL
	register long 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)"
	: "=r" (res)
	: "r" (a6), "r" (a0), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;*(char *)a1=*(char *)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 */
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
}
__inline static void * OpenLibrary(BASE_PAR_DECL const char* libName, long version)
{
	BASE_EXT_DECL
	register void * res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a1 __asm("a1");
	register long d0 __asm("d0");

	a6 = BASE_NAME;
	a1 = libName;
	d0 = version;
	__asm volatile ("
	jsr a6@(-0x228)"
	: "=r" (res)
	: "r" (a6), "r" (a1), "r" (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 */
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
}
__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 */
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
}
__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 */
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
}
__inline static long AttemptSemaphore(BASE_PAR_DECL struct SignalSemaphore* sigSem)
{
	BASE_EXT_DECL
	register long res __asm("d0");
	register void *a6 __asm ("a6");
	register struct SignalSemaphore* a0 __asm("a0");

	a6 = BASE_NAME;
	a0 = sigSem;
	__asm volatile ("
	jsr a6@(-0x240)"
	: "=r" (res)
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
	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 */
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
}
__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 */
	: "r" (a6), "r" (a0)
	: "d0", "d1", "a0", "a1");
	*(char *)a0=*(char *)a0;
}
__inline static struct SignalSemaphore * FindSemaphore(BASE_PAR_DECL const char* sigSem)
{
	BASE_EXT_DECL
	register struct SignalSemaphore * res __asm("d0");
	register void *a6 __asm ("a6");
	register const char* a1 __asm("a1");

	a6 = BASE_NAME;
	a1 = sigSem;
	__asm volatile ("
	jsr a6@(-0x252)"
	: "=r" (res)
	: "r" (a6), "r" (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 */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)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 */
	: "r" (a6), "r" (a1)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
}
__inline static void SumKickData(BASE_PAR_DECL0)
{
	BASE_EXT_DECL
	register void *a6 __asm ("a6");
	a6 = BASE_NAME;
	__asm volatile ("
	jsr a6@(-0x264)"
	: /* no output */
	: "r" (a6)
	: "d0", "d1", "a0", "a1");
}
__inline static long AddMemList(BASE_PAR_DECL long size, long attributes, long pri, void* base, const char* name)
{
	BASE_EXT_DECL
	register long res __asm("d0");
	register void *a6 __asm ("a6");
	register long d0 __asm("d0");
	register long d1 __asm("d1");
	register long d2 __asm("d2");
	register void* a0 __asm("a0");
	register const char* a1 __asm("a1");

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

	a6 = BASE_NAME;
	a0 = source;
	a1 = dest;
	d0 = size;
	__asm volatile ("
	jsr a6@(-0x270)"
	: /* no output */
	: "r" (a6), "r" (a0), "r" (a1), "r" (d0)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
}
__inline static void CopyMemQuick(BASE_PAR_DECL const char* source, char* dest, long size)
{
	BASE_EXT_DECL
	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 = source;
	a1 = dest;
	d0 = size;
	__asm volatile ("
	jsr a6@(-0x276)"
	: /* no output */
	: "r" (a6), "r" (a0), "r" (a1), "r" (d0)
	: "d0", "d1", "a0", "a1");
	*(char *)a1=*(char *)a1;
}
#ifndef __GNUG__
__inline static struct List *NewList(struct List *list)
{
  list->lh_Tail = 0;
  list->lh_TailPred = (struct Node *)list;
  list->lh_Head = (struct Node *)&list->lh_Tail;
}
#endif
#undef BASE_EXT_DECL
#undef BASE_PAR_DECL
#undef BASE_PAR_DECL0
#undef BASE_NAME

#endif /* _INLINE_EXEC_H */