DEFINITION Exec;

CONST
  deadEnd = 080000000H;
  recovery = 000000000H;
  noMemory = 000010000H;
  makeLib = 000020000H;
  openLib = 000030000H;
  openDev = 000040000H;
  openRes = 000050000H;
  ioError = 000060000H;
  noSignal = 000070000H;
  badParm = 000080000H;
  closeLib = 000090000H;
  closeDev = 0000A0000H;
  procCreate = 0000B0000H;
  execLib = 000008001H;
  graphicsLib = 000008002H;
  layersLib = 000008003H;
  intuition = 000008004H;
  mathLib = 000008005H;
  dosLib = 000008007H;
  ramLib = 000008008H;
  iconLib = 000008009H;
  expansionLib = 00000800AH;
  diskfontLib = 00000800BH;
  utilityLib = 00000800CH;
  audioDev = 000008010H;
  consoleDev = 000008011H;
  gamePortDev = 000008012H;
  keyboardDev = 000008013H;
  trackDiskDev = 000008014H;
  timerDev = 000008015H;
  ciaRsrc = 000008020H;
  diskRsrc = 000008021H;
  miscRsrc = 000008022H;
  bootStrap = 000008030H;
  workbench = 000008031H;
  diskCopy = 000008032H;
  gadTools = 000008033H;
  atUnknown = 000008035H;
  anExecLib = 001000000H;
  excptVect = 001000001H;
  baseChkSum = 001000002H;
  libChkSum = 001000003H;
  memCorrupt = 081000005H;
  intrMem = 081000006H;
  initAPtr = 001000007H;
  semCorrupt = 001000008H;
  freeTwice = 001000009H;
  bogusExcpt = 08100000AH;
  ioUsedTwice = 00100000BH;
  memoryInsane = 00100000CH;
  ioAfterClose = 00100000DH;
  stackProbe = 00100000EH;
  badFreeAddr = 00100000FH;
  anGraphicsLib = 002000000H;
  gfxNoMem = 082010000H;
  gfxNoMemMspc = 082010001H;
  longFrame = 082010006H;
  shortFrame = 082010007H;
  textTmpRas = 002010009H;
  bltBitMap = 08201000AH;
  regionMemory = 08201000BH;
  makeVPort = 082010030H;
  gfxNewError = 00200000CH;
  gfxFreeError = 00200000DH;
  gfxNoLCM = 082011234H;
  obsoleteFont = 002000401H;
  anLayersLib = 003000000H;
  layersNoMem = 083010000H;
  anIntuition = 004000000H;
  gadgetType = 084000001H;
  badGadget = 004000001H;
  createPort = 084010002H;
  itemAlloc = 004010003H;
  subAlloc = 004010004H;
  planeAlloc = 084010005H;
  itemBoxTop = 084000006H;
  openScreen = 084010007H;
  openScrnRast = 084010008H;
  sysScrnType = 084000009H;
  addSWGadget = 08401000AH;
  openWindow = 08401000BH;
  badState = 08400000CH;
  badMessage = 08400000DH;
  weirdEcho = 08400000EH;
  noConsole = 08400000FH;
  anMathLib = 005000000H;
  anDosLib = 007000000H;
  startMem = 007010001H;
  endTask = 007000002H;
  qPktFail = 007000003H;
  asyncPkt = 007000004H;
  freeVec = 007000005H;
  diskBlkSeq = 007000006H;
  bitMap = 007000007H;
  keyFree = 007000008H;
  badChkSum = 007000009H;
  diskError = 00700000AH;
  keyRange = 00700000BH;
  badOverlay = 00700000CH;
  badInitFunc = 00700000DH;
  fileReclosed = 00700000EH;
  anRAMLib = 008000000H;
  badSegList = 008000001H;
  anIconLib = 009000000H;
  anExpansionLib = 00A000000H;
  badExpansionFree = 00A000001H;
  anDiskfontLib = 00B000000H;
  anAudioDev = 010000000H;
  anConsoleDev = 011000000H;
  noWindow = 011000001H;
  anGamePortDev = 012000000H;
  anKeyboardDev = 013000000H;
  anTrackDiskDev = 014000000H;
  tdCalibSeek = 014000001H;
  tdDelay = 014000002H;
  anTimerDev = 015000000H;
  tmBadReq = 015000001H;
  tmBadSupply = 015000002H;
  anCIARsrc = 020000000H;
  anDiskRsrc = 021000000H;
  drHasDisk = 021000001H;
  drIntNoAct = 021000002H;
  anMiscRsrc = 022000000H;
  anBootStrap = 030000000H;
  bootError = 030000001H;
  anWorkbench = 031000000H;
  noFonts = 0B1000001H;
  wbBadStartupMsg1 = 031000001H;
  wbBadStartupMsg2 = 031000002H;
  wbBadIOMsg = 031000003H;
  wbInitPotionAllocDrawer = 0B1010004H;
  wbCreateWBMenusCreateMenus1 = 0B1010005H;
  wbCreateWBMenusCreateMenus2 = 0B1010006H;
  wbLayoutWBMenusLayoutMenus = 0B1010007H;
  wbAddToolMenuItem = 0B1010008H;
  wbReLayoutToolMenu = 0B1010009H;
  wbinitTimer = 0B101000AH;
  wbInitLayerDemon = 0B101000BH;
  wbinitWbGels = 0B101000CH;
  wbInitScreenAndWindows1 = 0B101000DH;
  wbInitScreenAndWindows2 = 0B101000EH;
  wbInitScreenAndWindows3 = 0B101000FH;
  wbMAlloc = 0B1010010H;
  anDiskCopy = 032000000H;
  anGadTools = 033000000H;
  anUtilityLib = 034000000H;
  anUnknown = 035000000H;

CONST
  includeVersion = 36;

TYPE
  ADDRESS = SYSTEM.ADDRESS;
  APTR = ADDRESS;
  BPTR = BPOINTER TO LONGINT;
  LONG = LONGINT;
  ULONG = LONGINT;
  LONGBITS = LONGSET;
  WORD = INTEGER;
  UWORD = INTEGER;
  WORDBITS = SET;
  BYTE = SYSTEM.BYTE;
  SBYTE = SHORTINT;
  UBYTE = BYTE;
  BYTEBITS = SHORTSET;
  RPTR = INTEGER;
  STRING = ARRAY 256 OF CHAR;
  STRPTR = UNTRACED POINTER TO STRING;
  PROC = PROCEDURE;
  FLOAT = REAL;
  DOUBLE = LONGREAL;
  SINGLE = LONGINT;
  BOOL = INTEGER;
  TEXT = CHAR;

CONST
  true = 1;
  false = 0;
  null = NIL;
  byteMask = 255;
  libraryMinimum = 33;

TYPE
  NodePtr = UNTRACED POINTER TO Node;
  MinNodePtr = UNTRACED POINTER TO MinNode;
  ListPtr = UNTRACED POINTER TO List;
  MinListPtr = UNTRACED POINTER TO MinList;
  TaskPtr = UNTRACED POINTER TO Task;
  MsgPortPtr = UNTRACED POINTER TO MsgPort;
  MsgPortSoftIntPtr = UNTRACED POINTER TO MsgPortSoftInt;
  MessagePtr = UNTRACED POINTER TO Message;
  InterruptPtr = UNTRACED POINTER TO Interrupt;
  LibraryPtr = UNTRACED POINTER TO Library;
  DevicePtr = UNTRACED POINTER TO Device;
  UnitPtr = UNTRACED POINTER TO Unit;
  IntVectorPtr = UNTRACED POINTER TO IntVector;
  SoftIntListPtr = UNTRACED POINTER TO SoftIntList;
  ExecBasePtr = UNTRACED POINTER TO ExecBase;
  IORequestPtr = UNTRACED POINTER TO IORequest;
  IOStdReqPtr = UNTRACED POINTER TO IOStdReq;
  MemChunkPtr = UNTRACED POINTER TO MemChunk;
  MemHeaderPtr = UNTRACED POINTER TO MemHeader;
  MemEntryPtr = UNTRACED POINTER TO MemEntry;
  MemListPtr = UNTRACED POINTER TO MemList;
  ResidentPtr = UNTRACED POINTER TO Resident;
  SemaphoreRequestPtr = UNTRACED POINTER TO SemaphoreRequest;
  SignalSemaphorePtr = UNTRACED POINTER TO SignalSemaphore;
  SemaphorePtr = UNTRACED POINTER TO Semaphore;

TYPE
  CommonNode = STRUCT 
  END;
  CommonNodePtr = UNTRACED POINTER TO CommonNode;
  Node = STRUCT 
    succ : NodePtr;
    pred : NodePtr;
    type : SHORTINT;
    pri : SHORTINT;
    name : STRPTR;
  END;
  MinNode = STRUCT 
    succ : MinNodePtr;
    pred : MinNodePtr;
  END;

CONST
  unknown = 0;
  task = 1;
  interrupt = 2;
  device = 3;
  msgPort = 4;
  message = 5;
  freeMsg = 6;
  replyMsg = 7;
  resource = 8;
  library = 9;
  memory = 10;
  softInt = 11;
  font = 12;
  process = 13;
  semaphore = 14;
  signalSem = 15;
  bootNode = 16;
  kickMem = 17;
  graphics = 18;
  deathMessage = 19;
  user = 254;
  extended = 255;

TYPE
  CommonList = STRUCT 
  END;
  CommonListPtr = UNTRACED POINTER TO CommonList;
  List = STRUCT 
    head : NodePtr;
    tail : NodePtr;
    tailPred : NodePtr;
    type : SHORTINT;
    pad : BYTE;
  END;
  MinList = STRUCT 
    head,tail,tailPred : MinNodePtr;
  END;
  Task = STRUCT (node : Node) 
    flags : SHORTSET;
    state : SHORTSET;
    idNestCnt : SHORTINT;
    tdNestCnt : SHORTINT;
    sigAlloc : LONGSET;
    sigWait : LONGSET;
    sigRecvd : LONGSET;
    sigExcept : LONGSET;
    trapAlloc : SET;
    trapAble : SET;
    exceptData : APTR;
    exceptCode : PROC;
    trapData : APTR;
    trapCode : PROC;
    spReg : APTR;
    spLower : APTR;
    spUpper : APTR;
    switch : PROC;
    launch : PROC;
    memEntry : List;
    userData : APTR;
  END;

CONST
  procTime = 0;
  eTask = 3;
  stackChk = 4;
  exception = 5;
  switch = 6;
  launch = 7;
  inval = 0;
  added = 1;
  run = 2;
  ready = 3;
  wait = 4;
  except = 5;
  removed = 6;
  sigAbort = 0;
  sigChild = 1;
  sigBlit = 4;
  sigSingle = 4;
  sigIntuition = 5;
  sigDos = 8;

TYPE
  MsgPort = STRUCT (node : Node) 
    flags : SHORTINT;
    sigBit : SHORTINT;
    sigTask : TaskPtr;
    msgList : List;
  END;
  MsgPortSoftInt = STRUCT (node : Node) 
    flags : SHORTINT;
    sigBit : SHORTINT;
    softInt : InterruptPtr;
    msgList : List;
  END;

CONST
  signal = 0;
  softint = 1;
  ignore = 2;

TYPE
  Message = STRUCT (node : Node) 
    replyPort : MsgPortPtr;
    length : INTEGER;
  END;

CONST
  vectSize = 6;
  reserved = 4;
  base = -vectSize;
  userDef = base - reserved * vectSize;
  nonStd = userDef;
  open = -6;
  close = -12;
  expunge = -18;
  extFunc = -24;

TYPE
  Library = STRUCT (node : Node) 
    flags : SHORTSET;
    pad : BYTE;
    negSize : INTEGER;
    posSize : INTEGER;
    version : INTEGER;
    revision : INTEGER;
    idString : STRPTR;
    sum : LONGINT;
    openCnt : INTEGER;
  END;

CONST
  summing = 0;
  changed = 1;
  sumUsed = 2;
  delExp = 3;

TYPE
  Device = STRUCT (library : Library) 
  END;
  Unit = STRUCT (msgPort : MsgPort) 
    flags : SHORTSET;
    pad : BYTE;
    openCnt : INTEGER;
  END;

CONST
  active = 0;
  inTask = 1;
  openFail = -1;
  aborted = -2;
  noCmd = -3;
  badLength = -4;
  badAddress = -5;
  unitBusy = -6;
  selfTest = -7;

TYPE
  Interrupt = STRUCT (node : Node) 
    data : APTR;
    code : PROC;
  END;
  IntVector = STRUCT 
    data : APTR;
    code : PROC;
    node : NodePtr;
  END;
  SoftIntList = STRUCT (list : List) 
    pad : INTEGER;
  END;

CONST
  nmi = 15;

TYPE
  ExecBase = STRUCT (libNode : Library) 
    softVer : INTEGER;
    lowMemChkSum : INTEGER;
    chkBase : LONGINT;
    coldCapture : APTR;
    coolCapture : APTR;
    warmCapture : APTR;
    sysStkUpper : APTR;
    sysStkLower : APTR;
    maxLocMem : APTR;
    debugEntry : APTR;
    debugData : APTR;
    alertData : APTR;
    maxExtMem : APTR;
    chkSum : INTEGER;
    intVects : ARRAY 16 OF IntVector;
    thisTask : TaskPtr;
    idleCount : LONGINT;
    dispCount : LONGINT;
    quantum : INTEGER;
    elapsed : INTEGER;
    sysFlags : SET;
    idNestCnt : SHORTINT;
    tdNestCnt : SHORTINT;
    attnFlags : SET;
    attnResched : INTEGER;
    resModules : APTR;
    taskTrapCode : PROC;
    taskExceptCode : PROC;
    taskExitCode : PROC;
    taskSigAlloc : LONGSET;
    taskTrapAlloc : SET;
    memList : List;
    resourceList : List;
    deviceList : List;
    intrList : List;
    libList : List;
    portList : List;
    taskReady : List;
    taskWait : List;
    softInts : ARRAY 5 OF SoftIntList;
    lastAlert : ARRAY 4 OF LONGINT;
    vblankFrequency : SHORTINT;
    powerSupplyFrequency : SHORTINT;
    semaphoreList : List;
    kickMemPtr : APTR;
    kickTagPtr : APTR;
    kickCheckSum : APTR;
    pad0 : INTEGER;
    reserved0 : LONGINT;
    ramLibPrivate : APTR;
    eClockFrequency : LONGINT;
    cacheControl : APTR;
    taskID : LONGINT;
    puddleSize : LONGINT;
    poolThreshold : LONGINT;
    publicPool : MinList;
    mmuLock : APTR;
    reserved : ARRAY 12 OF BYTE;
  END;

CONST
  m68010 = 0;
  m68020 = 1;
  m68030 = 2;
  m68040 = 3;
  m68881 = 4;
  m68882 = 5;
  enableI = 0;
  freezeI = 1;
  clearI = 3;
  ibe = 4;
  enableD = 8;
  freezeD = 9;
  clearD = 11;
  dbe = 12;
  writeAllocate = 13;
  copyBack = 31;

TYPE
  IORequest = STRUCT (message : Message) 
    device : DevicePtr;
    unit : UnitPtr;
    command : INTEGER;
    flags : SHORTSET;
    error : SHORTINT;
  END;
  IOStdReq = STRUCT (message : Message) 
    device : DevicePtr;
    unit : UnitPtr;
    command : INTEGER;
    flags : SHORTSET;
    error : SHORTINT;
    actual : LONGINT;
    length : LONGINT;
    data : APTR;
    offset : LONGINT;
  END;

CONST
  beginIO = -30;
  abortIO = -36;
  quick = 0;
  invalid = 0;
  reset = 1;
  read = 2;
  write = 3;
  update = 4;
  clear = 5;
  stop = 6;
  start = 7;
  flush = 8;
  nonstd = 9;

TYPE
  MemChunk = STRUCT 
    next : MemChunkPtr;
    bytes : LONGINT;
  END;
  MemHeader = STRUCT (node : Node) 
    attributes : SET;
    first : MemChunkPtr;
    lower : APTR;
    upper : APTR;
    free : LONGINT;
  END;
  MemEntry = STRUCT 
    addr : APTR;
    length : LONGINT
  END;
  MemList = STRUCT (node : Node) 
    numEntries : INTEGER;
  END;

CONST
  any = LONGSET{};
  public = 0;
  chip = 1;
  fast = 2;
  local = 8;
  mem24BitDMA = 9;
  memClear = 16;
  largest = 17;
  reverse = 18;
  total = 19;
  blockSize = 8;
  blockMask = blockSize - 1;

TYPE
  Resident = STRUCT 
    matchWord : INTEGER;
    matchTag : ResidentPtr;
    endSkip : APTR;
    flags : SHORTSET;
    version : SHORTINT;
    type : SHORTINT;
    pri : SHORTINT;
    name : STRPTR;
    idString : STRPTR;
    init : APTR;
  END;

CONST
  matchWord = 4AFCH;
  autoinit = 7;
  afterDos = 2;
  singleTask = 1;
  coldStart = 0;

TYPE
  SemaphoreRequest = STRUCT (link : MinNode) 
    waiter : TaskPtr;
  END;
  SignalSemaphore = STRUCT (link : Node) 
    nestCount : INTEGER;
    waitQueue : MinList;
    multipleLink : SemaphoreRequest;
    owner : TaskPtr;
    queueCount : INTEGER;
  END;
  Semaphore = STRUCT (msgPort : MsgPort) 
    bids : INTEGER;
  END;

VAR
  exec : ExecBasePtr;

PROCEDURE Supervisor(userFunction: PROC): APTR;
PROCEDURE ExitIntr;
PROCEDURE Schedule;
PROCEDURE Reschedule;
PROCEDURE Switch;
PROCEDURE Dispatch;
PROCEDURE Exception;
PROCEDURE InitCode(startClass: SHORTSET; version: LONGINT);
PROCEDURE InitStruct(initTable: APTR; memory: APTR; size: LONGINT);
PROCEDURE MakeLibrary(funcInit: APTR; structInit: APTR; libInit: PROC; dataSize: LONGINT; segList: BPTR): LibraryPtr;
PROCEDURE MakeFunctions(target: APTR; funcArray: APTR; funcDisplBase: APTR);
PROCEDURE FindResident(name: ARRAY OF CHAR): ResidentPtr;
PROCEDURE InitResident(resident: ResidentPtr; segList: BPTR);
PROCEDURE Alert(alertNum: LONGINT);
PROCEDURE Debug(flags: LONGSET);
PROCEDURE Disable;
PROCEDURE Enable;
PROCEDURE Forbid;
PROCEDURE Permit;
PROCEDURE SetSR(newSR: SET; mask: SET): SET;
PROCEDURE SuperState;
PROCEDURE UserState(sysStack: APTR);
PROCEDURE SetIntVector(intNumber: LONGINT; interrupt: InterruptPtr): InterruptPtr;
PROCEDURE AddIntServer(intNumber: LONGINT; interrupt: InterruptPtr);
PROCEDURE RemIntServer(intNumber: LONGINT; interrupt: InterruptPtr);
PROCEDURE Cause(interrupt: InterruptPtr);
PROCEDURE Allocate(freeList: MemHeaderPtr; byteSize: LONGINT): APTR;
PROCEDURE Deallocate(freeList: MemHeaderPtr; memoryBlock: APTR; byteSize: LONGINT);
PROCEDURE AllocMem(byteSize: LONGINT; requirements: LONGSET): APTR;
PROCEDURE AllocAbs(byteSize: LONGINT; location: APTR): APTR;
PROCEDURE FreeMem(memoryBlock: APTR; byteSize: LONGINT);
PROCEDURE AvailMem(requirements: LONGSET): LONGINT;
PROCEDURE AllocEntry(memList: APTR): APTR;
PROCEDURE FreeEntry(entry: APTR);
PROCEDURE Insert(VAR list: CommonList; node: CommonNodePtr; pred: CommonNodePtr);
PROCEDURE AddHead(VAR list: CommonList; node: CommonNodePtr);
PROCEDURE AddTail(VAR list: CommonList; node: CommonNodePtr);
PROCEDURE Remove(node: CommonNodePtr);
PROCEDURE RemHead(VAR list: CommonList): CommonNodePtr;
PROCEDURE RemTail(VAR list: CommonList): CommonNodePtr;
PROCEDURE Enqueue(VAR list: CommonList; node: CommonNodePtr);
PROCEDURE FindName(VAR list: CommonList; name: ARRAY OF CHAR): CommonNodePtr;
PROCEDURE AddTask(task: TaskPtr; initPC: PROC; finalPC: APTR);
PROCEDURE RemTask(task: TaskPtr);
PROCEDURE FindTask(name: ARRAY OF CHAR): TaskPtr;
PROCEDURE SetTaskPri(task: TaskPtr; priority: LONGINT): SHORTINT;
PROCEDURE SetSignal(newSignals: LONGSET; signalSet: LONGSET): LONGSET;
PROCEDURE SetExcept(newSignals: LONGSET; signalSet: LONGSET): LONGSET;
PROCEDURE Wait(signalSet: LONGSET): LONGSET;
PROCEDURE Signal(task: TaskPtr; signalSet: LONGSET);
PROCEDURE AllocSignal(signalNum: LONGINT): SHORTINT;
PROCEDURE FreeSignal(signalNum: LONGINT);
PROCEDURE AllocTrap(trapNum: LONGINT): SHORTINT;
PROCEDURE FreeTrap(trapNum: LONGINT);
PROCEDURE AddPort(port: MsgPortPtr);
PROCEDURE RemPort(port: MsgPortPtr);
PROCEDURE PutMsg(port: MsgPortPtr; message: MessagePtr);
PROCEDURE GetMsg(port: MsgPortPtr): MessagePtr;
PROCEDURE ReplyMsg(message: MessagePtr);
PROCEDURE WaitPort(port: MsgPortPtr);
PROCEDURE FindPort(name: ARRAY OF CHAR): MsgPortPtr;
PROCEDURE AddLibrary(library: LibraryPtr);
PROCEDURE RemLibrary(library: LibraryPtr);
PROCEDURE OldOpenLibrary(name: ARRAY OF CHAR): LibraryPtr;
PROCEDURE CloseLibrary(library: LibraryPtr);
PROCEDURE SetFunction(library: LibraryPtr; funcOffset: LONGINT; newFunction: PROC): PROC;
PROCEDURE SumLibrary(library: LibraryPtr);
PROCEDURE AddDevice(device: DevicePtr);
PROCEDURE RemDevice(device: DevicePtr);
PROCEDURE OpenDevice(devName: ARRAY OF CHAR; unit: LONGINT; ioRequest: MessagePtr; flags: LONGSET): SHORTINT;
PROCEDURE CloseDevice(ioRequest: MessagePtr);
PROCEDURE DoIO(ioRequest: MessagePtr): SHORTINT;
PROCEDURE OldDoIO(ioRequest: MessagePtr);
PROCEDURE SendIO(ioRequest: MessagePtr);
PROCEDURE CheckIO(ioRequest: MessagePtr): IORequestPtr;
PROCEDURE WaitIO(ioRequest: MessagePtr): SHORTINT;
PROCEDURE OldWaitIO(ioRequest: MessagePtr);
PROCEDURE AbortIO(ioRequest: MessagePtr);
PROCEDURE AddResource(resource: APTR);
PROCEDURE RemResource(resource: APTR);
PROCEDURE OpenResource(resName: ARRAY OF CHAR): APTR;
PROCEDURE RawIOInit;
PROCEDURE RawMayGetChar;
PROCEDURE RawPutChar;
PROCEDURE RawDoFmt(formatStr: ARRAY OF CHAR; dataStream: APTR; putChProc: PROC; putChData: APTR);
PROCEDURE RawDoFmtL(formatStr: ARRAY OF CHAR; dataStream: ARRAY OF SYSTEM.BYTE; putChProc: PROC; putChData: APTR);
PROCEDURE GetCC(): SET;
PROCEDURE TypeOfMem(address: APTR): LONGSET;
PROCEDURE Procure(VAR semaprt: Semaphore; bidmsg: MessagePtr): BOOLEAN;
PROCEDURE Vacate(VAR semaprt: Semaphore);
PROCEDURE OpenLibrary(libName: ARRAY OF CHAR; version: LONGINT): LibraryPtr;
PROCEDURE InitSemaphore(VAR sigSem: SignalSemaphore);
PROCEDURE ObtainSemaphore(VAR sigSem: SignalSemaphore);
PROCEDURE ReleaseSemaphore(VAR sigSem: SignalSemaphore);
PROCEDURE AttemptSemaphore(VAR sigSem: SignalSemaphore): BOOLEAN;
PROCEDURE ObtainSemaphoreList(VAR sigSem: List);
PROCEDURE ReleaseSemaphoreList(VAR sigSem: List);
PROCEDURE FindSemaphore(sigSem: ARRAY OF CHAR): SignalSemaphorePtr;
PROCEDURE AddSemaphore(VAR sigSem: SignalSemaphore);
PROCEDURE RemSemaphore(VAR sigSem: SignalSemaphore);
PROCEDURE SumKickData(): LONGINT;
PROCEDURE AddMemList(size: LONGINT; attributes: LONGSET; pri: LONGINT; base: APTR; name: ARRAY OF CHAR);
PROCEDURE CopyMem(source: ARRAY OF BYTE; dest: ARRAY OF BYTE; size: LONGINT);
PROCEDURE CopyMemAPTR(source: APTR; dest: APTR; size: LONGINT);
PROCEDURE CopyMemQuick(source: ARRAY OF BYTE; dest: ARRAY OF BYTE; size: LONGINT);
PROCEDURE CopyMemQuickAPTR(source: APTR; dest: APTR; size: LONGINT);
PROCEDURE CacheClearU();
PROCEDURE CacheClearE(address: APTR; length: LONGINT; caches: LONGSET);
PROCEDURE CacheControl(cacheBits: LONGSET; cacheMask: LONGSET): LONGSET;
PROCEDURE CreateIORequest(port: MsgPortPtr; size: LONGINT): MessagePtr;
PROCEDURE DeleteIORequest(iorequest: MessagePtr);
PROCEDURE CreateMsgPort(): MsgPortPtr;
PROCEDURE DeleteMsgPort(port: MsgPortPtr);
PROCEDURE ObtainSemaphoreShared(VAR sigSem: SignalSemaphore);
PROCEDURE AllocVec(byteSize: LONGINT; requirements: LONGSET): APTR;
PROCEDURE FreeVec(memoryBlock: APTR);
PROCEDURE CreatePrivatePool(requirements: LONGSET; puddleSize: LONGINT; puddleThresh: LONGINT): MemHeaderPtr;
PROCEDURE DeletePrivatePool(poolHeader: MemHeaderPtr);
PROCEDURE AllocPooled(memSize: LONGINT; poolHeader: MemHeaderPtr): APTR;
PROCEDURE FreePooled(memory: APTR; poolHeader: MemHeaderPtr);
PROCEDURE SetFunction8(funcOffset: LONGINT; newFunction: PROC; array: APTR; library: APTR);
PROCEDURE ColdReboot;
PROCEDURE StackSwap(newSize: LONGINT; newSP: LONGINT; newStack: APTR);
PROCEDURE ChildFree(tid: APTR);
PROCEDURE ChildOrphan(tid: APTR);
PROCEDURE ChildStatus(tid: APTR);
PROCEDURE ChildWait(tid: APTR);

END Exec.

