rebuilt release with generic object file

- included the binaries (a2.exe and files in obg folder)
- note that the release with generic object file now reads standard config from aosg.ini which again can be overridden by myaos.ini (as before). Now both versions (with old object file format and new object file format) can be started and compared.
- note that there are features that cannot be used with the old object file format (such as the interpreter)

git-svn-id: https://svn.inf.ethz.ch/svn/lecturers/a2/trunk@6680 8c9fc860-2736-0410-a75d-ab315db34111

WinAos/aosg.ini

@@ -0,0 +1,51 @@
+; internal
+
+[Configuration]
+Paths.Search = Work;~/obg;../source;PELinker;../UnixAos;vy.ants/source;vy.ants/documents;E:\ices\trunk\Hardware\ActiveCells;e:/highdim/code;E:/highdim/Hardware/Tensys;c:/windows/fonts;E:/highdim/Hardware
+Paths.Work = Work
+Oberon = Oberon.Text
+Boot  = Traps.Install
+Boot1 = FileTrapWriter.Install
+Boot2 = Display.Install --fullscreen
+Boot3 = WindowManager.Install
+Boot4 = Clipboard.Install
+Boot5 = Autostart.Run
+Boot7 = FSTools.Mount WORK RelativeFileSystem ./
+Boot9 = Kernel.GC
+Trace=File
+TraceModules=0
+TraceCommands=1
+EnableReturnBlocks=0
+EnableFreeLists=0
+ObjectFileExtension= ".GofW"
+
+
+
+; Notes:
+
+; Only the values within the very first configuration section are considered.
+
+; For overriding one ore more values, create a file called myaos.ini in the
+; same directory and provide a configuration section with your overrides.
+
+; the file name of the ini file can be overridden by a command line option -ini <filename>
+
+[Description]
+BootX= <boot command, X empty or between 1 and 9>
+Paths.Search = <search path that is taken by A2 to look for files  >
+Paths.Work = <path that is taken by A2 to store to by default >
+Obeorn = <configuration file taken by the inbuilt Oberon system >
+TraceModules= < 0 or 1: if Trace of module loading is switched on or off>
+Trace= < File or Console >
+TraceFile = <filename for trace file (if Trace = File)
+
+
+configurations with external oberon require a release that was compiled with external oberon files
+[Configuration for starting with A2 but using external Oberon]
+Oberon = OberonExternal.Text
+MB=2
+
+[Configuration for starting with external Oberon]
+Oberon = OberonExternal.Text
+Boot1 = Oberon.Call Oberon.Start
+

WinAos/obg/A2Sequencers.SymW

@@ -0,0 +1,287 @@
+MODULE A2Sequencers;
+	IMPORT Machine, Streams, Objects, Kernel;
+CONST 
+	NoDelay* = 0; 
+	MaxHandlers = 10; 
+TYPE 
+	Property* = OBJECT 
+	VAR 
+		locks: LONGINT; 
+		container*: OBJECT; 
+
+		PROCEDURE ^  & InitProperty; 
+		PROCEDURE ^ AcquireRead; 
+		PROCEDURE ^ ReleaseRead; 
+		PROCEDURE ^ AcquireWrite; 
+		PROCEDURE ^ ReleaseWrite; 
+		PROCEDURE ^ ToStream*(w: Streams.Writer); 
+		PROCEDURE ^ FromStream*(r: Streams.Reader); 
+	END Property; 
+
+	Boolean* = OBJECT (Property)
+	VAR 
+		value: BOOLEAN; 
+		handlers: ARRAY MaxHandlers OF BooleanHandler; 
+
+		PROCEDURE ^  & InitBoolean*(value: BOOLEAN); 
+		PROCEDURE ^ Get*(): BOOLEAN; 
+		PROCEDURE ^ Set*(value: BOOLEAN); 
+		PROCEDURE ^ Changed(value: BOOLEAN); 
+		PROCEDURE ^ AddHandler*(handler: BooleanHandler); 
+	END Boolean; 
+
+	Integer* = OBJECT (Property)
+	VAR 
+		value: LONGINT; 
+		handlers: ARRAY MaxHandlers OF IntegerHandler; 
+
+		PROCEDURE ^  & InitInteger*(value: LONGINT); 
+		PROCEDURE ^ Get*(): LONGINT; 
+		PROCEDURE ^ Set*(value: LONGINT); 
+		PROCEDURE ^ Inc*(step: LONGINT); 
+		PROCEDURE ^ Dec*(step: LONGINT); 
+		PROCEDURE ^ Changed(value: LONGINT); 
+		PROCEDURE ^ AddHandler*(handler: IntegerHandler); 
+	END Integer; 
+
+	Real* = OBJECT (Property)
+	VAR 
+		value: REAL; 
+		handlers: ARRAY MaxHandlers OF RealHandler; 
+
+		PROCEDURE ^  & InitReal*(value: REAL); 
+		PROCEDURE ^ Get*(): REAL; 
+		PROCEDURE ^ Set*(value: REAL); 
+		PROCEDURE ^ Changed(value: REAL); 
+		PROCEDURE ^ AddHandler*(handler: RealHandler); 
+	END Real; 
+
+	Set* = OBJECT (Property)
+	VAR 
+		value: SET; 
+		handlers: ARRAY MaxHandlers OF SetHandler; 
+
+		PROCEDURE ^  & InitSet*(value: SET); 
+		PROCEDURE ^ Get*(): SET; 
+		PROCEDURE ^ Set*(value: SET); 
+		PROCEDURE ^ Incl*(element: LONGINT); 
+		PROCEDURE ^ Excl*(element: LONGINT); 
+		PROCEDURE ^ Changed(value: SET); 
+		PROCEDURE ^ AddHandler*(handler: SetHandler); 
+	END Set; 
+
+	String* = OBJECT (Property)
+	VAR 
+		value: POINTER TO ARRAY OF CHAR; 
+		handlers: ARRAY MaxHandlers OF StringHandler; 
+
+		PROCEDURE ^  & InitString*(CONST value: ARRAY OF CHAR; length: LONGINT); 
+		PROCEDURE ^ Get*(VAR value: ARRAY OF CHAR); 
+		PROCEDURE ^ Set*(CONST value: ARRAY OF CHAR); 
+		PROCEDURE ^ Changed(CONST value: ARRAY OF CHAR); 
+		PROCEDURE ^ AddHandler*(handler: StringHandler); 
+	END String; 
+
+	Message* = OBJECT 
+	VAR 
+		next: Message; 
+		time: LONGINT; 
+
+		PROCEDURE ^  & InitMessage*; 
+		PROCEDURE ^ Handle*; 
+	END Message; 
+
+	ProcedureMessage* = OBJECT (Message)
+	VAR 
+		procedure: Procedure; 
+
+		PROCEDURE ^  & InitProcedureMessage*(procedure: Procedure); 
+		PROCEDURE ^ Handle*; 
+	END ProcedureMessage; 
+
+	BooleanMessage* = OBJECT (Message)
+	VAR 
+		value: BOOLEAN; 
+		procedure: BooleanProcedure; 
+
+		PROCEDURE ^  & InitBooleanMessage*(value: BOOLEAN; procedure: BooleanProcedure); 
+		PROCEDURE ^ Handle*; 
+	END BooleanMessage; 
+
+	IntegerMessage* = OBJECT (Message)
+	VAR 
+		value: LONGINT; 
+		procedure: IntegerProcedure; 
+
+		PROCEDURE ^  & InitIntegerMessage*(value: LONGINT; procedure: IntegerProcedure); 
+		PROCEDURE ^ Handle*; 
+	END IntegerMessage; 
+
+	IntegerIntegerMessage* = OBJECT (Message)
+	VAR 
+		value0, value1: LONGINT; 
+		procedure: IntegerIntegerProcedure; 
+
+		PROCEDURE ^  & InitIntegerIntegerMessage*(value0, value1: LONGINT; procedure: IntegerIntegerProcedure); 
+		PROCEDURE ^ Handle*; 
+	END IntegerIntegerMessage; 
+
+	RealMessage* = OBJECT (Message)
+	VAR 
+		value: REAL; 
+		procedure: RealProcedure; 
+
+		PROCEDURE ^  & InitRealMessage*(value: REAL; procedure: RealProcedure); 
+		PROCEDURE ^ Handle*; 
+	END RealMessage; 
+
+	SetMessage* = OBJECT (Message)
+	VAR 
+		value: SET; 
+		procedure: SetProcedure; 
+
+		PROCEDURE ^  & InitSetMessage*(value: SET; procedure: SetProcedure); 
+		PROCEDURE ^ Handle*; 
+	END SetMessage; 
+
+	StringMessage* = OBJECT (Message)
+	VAR 
+		value: POINTER TO ARRAY OF CHAR; 
+		procedure: StringProcedure; 
+
+		PROCEDURE ^  & InitStringMessage*(CONST value: ARRAY OF CHAR; procedure: StringProcedure); 
+		PROCEDURE ^ Handle*; 
+	END StringMessage; 
+
+	Request* = OBJECT {EXCLUSIVE} (Message)
+	VAR 
+		handled: BOOLEAN; 
+
+		PROCEDURE ^  & InitRequest*; 
+		PROCEDURE ^ Handle*; 
+		PROCEDURE ^ Await; 
+	END Request; 
+
+	IntegerRequest* = OBJECT {EXCLUSIVE} (Request)
+	VAR 
+		value: LONGINT; 
+		procedure: IntegerProcedure; 
+
+		PROCEDURE ^  & InitIntegerRequest*(value: LONGINT; procedure: IntegerProcedure); 
+		PROCEDURE ^ Handle*; 
+	END IntegerRequest; 
+
+	RequestBoolean* = OBJECT {EXCLUSIVE} (Request)
+	VAR 
+		procedure: ProcedureBoolean; 
+		result-: BOOLEAN; 
+
+		PROCEDURE ^  & InitRequestBoolean*(procedure: ProcedureBoolean); 
+		PROCEDURE ^ Handle*; 
+	END RequestBoolean; 
+
+	RequestInteger* = OBJECT {EXCLUSIVE} (Request)
+	VAR 
+		procedure: ProcedureInteger; 
+		result-: LONGINT; 
+
+		PROCEDURE ^  & InitRequestInteger*(procedure: ProcedureInteger); 
+		PROCEDURE ^ Handle*; 
+	END RequestInteger; 
+
+	RequestReal* = OBJECT {EXCLUSIVE} (Request)
+	VAR 
+		procedure: ProcedureReal; 
+		result-: REAL; 
+
+		PROCEDURE ^  & InitRequestReal*(procedure: ProcedureReal); 
+		PROCEDURE ^ Handle*; 
+	END RequestReal; 
+
+	IntegerRequestBoolean* = OBJECT {EXCLUSIVE} (Request)
+	VAR 
+		value: LONGINT; 
+		procedure: IntegerProcedureBoolean; 
+		result-: BOOLEAN; 
+
+		PROCEDURE ^  & InitIntegerRequestBoolean*(value: LONGINT; procedure: IntegerProcedureBoolean); 
+		PROCEDURE ^ Handle*; 
+	END IntegerRequestBoolean; 
+
+	RealRequestInteger* = OBJECT {EXCLUSIVE} (Request)
+	VAR 
+		value: REAL; 
+		procedure: RealProcedureInteger; 
+		result-: LONGINT; 
+
+		PROCEDURE ^  & InitRealRequestInteger*(value: REAL; procedure: RealProcedureInteger); 
+		PROCEDURE ^ Handle*; 
+	END RealRequestInteger; 
+
+	Sequencer* = OBJECT {EXCLUSIVE} 
+	VAR 
+		handling, woken: BOOLEAN; 
+		first: Message; 
+		timer: Objects.Timer; 
+
+		PROCEDURE ^  & InitSequencer*; 
+		PROCEDURE ^ SequencerCalledThis*(): BOOLEAN; 
+		PROCEDURE ^ HandleMessages; 
+		PROCEDURE ^ Add*(message: Message; time: LONGINT); 
+		PROCEDURE ^ AddMessage*(procedure: Procedure); 
+		PROCEDURE ^ AddBooleanMessage*(value: BOOLEAN; procedure: BooleanProcedure); 
+		PROCEDURE ^ AddIntegerMessage*(value: LONGINT; procedure: IntegerProcedure); 
+		PROCEDURE ^ AddRealMessage*(value: REAL; procedure: RealProcedure); 
+		PROCEDURE ^ AddSetMessage*(value: SET; procedure: SetProcedure); 
+		PROCEDURE ^ AddStringMessage*(CONST value: ARRAY OF CHAR; procedure: StringProcedure); 
+		PROCEDURE ^ AddIntegerIntegerMessage*(value0, value1: LONGINT; procedure: IntegerIntegerProcedure); 
+		PROCEDURE ^ AddIntegerRequest*(value: LONGINT; procedure: IntegerProcedure); 
+		PROCEDURE ^ AddRequestBoolean*(procedure: ProcedureBoolean): BOOLEAN; 
+		PROCEDURE ^ AddRequestInteger*(procedure: ProcedureInteger): LONGINT; 
+		PROCEDURE ^ AddRequestReal*(procedure: ProcedureReal): REAL; 
+		PROCEDURE ^ AddIntegerRequestBoolean*(value: LONGINT; procedure: IntegerProcedureBoolean): BOOLEAN; 
+		PROCEDURE ^ AddRealRequestInteger*(value: REAL; procedure: RealProcedureInteger): LONGINT; 
+		PROCEDURE ^ Remove*(message: Message); 
+		PROCEDURE ^ Handle*; 
+		PROCEDURE ^ Wakeup; 
+		PROCEDURE ^ Stop*; 
+	BEGIN{ACTIVE} 
+	END Sequencer; 
+
+	BooleanHandler = PROCEDURE {DELEGATE}(property: Boolean; value: BOOLEAN); 
+
+	IntegerHandler = PROCEDURE {DELEGATE}(property: Integer; value: LONGINT); 
+
+	RealHandler = PROCEDURE {DELEGATE}(property: Real; value: REAL); 
+
+	SetHandler = PROCEDURE {DELEGATE}(property: Set; value: SET); 
+
+	StringHandler = PROCEDURE {DELEGATE}(property: String; CONST value: ARRAY OF CHAR); 
+
+	Procedure = PROCEDURE {DELEGATE}; 
+
+	BooleanProcedure = PROCEDURE {DELEGATE}(value: BOOLEAN); 
+
+	IntegerProcedure = PROCEDURE {DELEGATE}(value: LONGINT); 
+
+	IntegerIntegerProcedure = PROCEDURE {DELEGATE}(value0, value1: LONGINT); 
+
+	RealProcedure = PROCEDURE {DELEGATE}(value: REAL); 
+
+	SetProcedure = PROCEDURE {DELEGATE}(value: SET); 
+
+	StringProcedure = PROCEDURE {DELEGATE}(CONST value: ARRAY OF CHAR); 
+
+	ProcedureBoolean = PROCEDURE {DELEGATE}():BOOLEAN; 
+
+	ProcedureInteger = PROCEDURE {DELEGATE}():LONGINT; 
+
+	ProcedureReal = PROCEDURE {DELEGATE}():REAL; 
+
+	IntegerProcedureBoolean = PROCEDURE {DELEGATE}(value: LONGINT):BOOLEAN; 
+
+	RealProcedureInteger = PROCEDURE {DELEGATE}(value: REAL):LONGINT; 
+
+	PROCEDURE ^ Delay*(delay: LONGINT): LONGINT; 
+BEGIN
+END A2Sequencers.

WinAos/obg/AFM.SymW

@@ -0,0 +1,26 @@
+MODULE AFM;
+	IMPORT Files, KernelLog;
+CONST 
+TYPE 
+	CharInfo = RECORD 
+		w: LONGINT; 
+	END; 
+
+	FontMetrics* = OBJECT 
+	VAR 
+		chars: ARRAY 256 OF CharInfo; 
+		fontName: ARRAY 64 OF CHAR; 
+
+		PROCEDURE ^ AddCharInfo(ucs: LONGINT; ci: CharInfo); 
+		PROCEDURE ^ InternalGetWidth(ucs: LONGINT): LONGINT; 
+		PROCEDURE ^ GetWidth*(size: REAL; ucs: LONGINT): REAL; 
+		PROCEDURE ^ Kerning(ucs0, ucs1: LONGINT): LONGINT; 
+		PROCEDURE ^ GetStringWidth*(size: REAL; str: ARRAY OF CHAR): REAL; 
+		PROCEDURE ^ LoadAFM(filename: ARRAY OF CHAR; VAR res: LONGINT); 
+	END FontMetrics; 
+VAR 
+	times*, helvetica*, helveticaBold*: FontMetrics; 
+	res: LONGINT; 
+
+BEGIN
+END AFM.

WinAos/obg/AMD64Decoder.SymW

@@ -0,0 +1,743 @@
+MODULE AMD64Decoder;
+	IMPORT SYSTEM, Decoder, Streams;
+CONST 
+	objFileSuffix = \"Abx"\; 
+	maxArgs = 3; 
+	prOperand = 0; 
+	prAddress = 1; 
+	prCS = 2; 
+	prDS = 3; 
+	prES = 4; 
+	prFS = 5; 
+	prGS = 6; 
+	prSS = 7; 
+	prLOCK = 8; 
+	prREP = 9; 
+	prREPN = 10; 
+	prF3 = prREP; 
+	pr66 = prOperand; 
+	prF2 = prREPN; 
+	prREX = 11; 
+	prREXW = 12; 
+	prREXR = 13; 
+	prREXX = 14; 
+	prREXB = 15; 
+	opInvalid = 0; 
+	opReserved = 1; 
+	opADC = 2; 
+	opADD = 3; 
+	opADDPD = 4; 
+	opADDPS = 5; 
+	opADDSD = 6; 
+	opADDSS = 7; 
+	opADDSUBPD = 8; 
+	opADDSUBPS = 9; 
+	opAND = 10; 
+	opANDNPD = 11; 
+	opANDNPS = 12; 
+	opANDPD = 13; 
+	opANDPS = 14; 
+	opBSF = 15; 
+	opBSR = 16; 
+	opBSWAP = 17; 
+	opBT = 18; 
+	opBTC = 19; 
+	opBTR = 20; 
+	opBTS = 21; 
+	opCALL = 22; 
+	opCBW = 23; 
+	opCDQ = 24; 
+	opCDQE = 25; 
+	opCLC = 26; 
+	opCLD = 27; 
+	opCLGI = 28; 
+	opCLI = 29; 
+	opCLTS = 30; 
+	opCMC = 31; 
+	opCMP = 32; 
+	opCMPPD = 33; 
+	opCMPPS = 34; 
+	opCMPSB = 35; 
+	opCMPSD = 36; 
+	opCMPSQ = 37; 
+	opCMPSS = 38; 
+	opCMPSW = 39; 
+	opCMPXCHG = 40; 
+	opCMPXCHG16B = 41; 
+	opCMPXCHG8B = 42; 
+	opCOMISD = 43; 
+	opCOMISS = 44; 
+	opCPUID = 45; 
+	opCQO = 46; 
+	opCVTDQ2PD = 47; 
+	opCVTDQ2PS = 48; 
+	opCVTPD2PI = 49; 
+	opCVTPD2PS = 50; 
+	opCVTPI2PD = 51; 
+	opCVTPI2PS = 52; 
+	opCVTPS2DQ = 53; 
+	opCVTPS2PD = 54; 
+	opCVTPS2PI = 55; 
+	opCVTSD2SI = 56; 
+	opCVTSD2SS = 57; 
+	opCVTSI2SD = 58; 
+	opCVTSI2SS = 59; 
+	opCVTSS2SD = 60; 
+	opCVTSS2SI = 61; 
+	opCVTTPD2DQ = 62; 
+	opCVTTPD2PI = 63; 
+	opCVTTPS2DQ = 64; 
+	opCVTTPS2PI = 65; 
+	opCVTTSD2SI = 66; 
+	opCVTTSS2SI = 67; 
+	opCWD = 68; 
+	opCWDE = 69; 
+	opDEC = 70; 
+	opDIV = 71; 
+	opDIVPD = 72; 
+	opDIVPS = 73; 
+	opDIVSD = 74; 
+	opDIVSS = 75; 
+	opEMMS = 76; 
+	opENTER = 77; 
+	opF2XM1 = 78; 
+	opFABS = 79; 
+	opFADD = 80; 
+	opFADDP = 81; 
+	opFBLD = 82; 
+	opFBSTP = 83; 
+	opFCHS = 84; 
+	opFCMOVB = 85; 
+	opFCMOVBE = 86; 
+	opFCMOVE = 87; 
+	opFCMOVNB = 88; 
+	opFCMOVNBE = 89; 
+	opFCMOVNE = 90; 
+	opFCMOVNU = 91; 
+	opFCMOVU = 92; 
+	opFCOM = 93; 
+	opFCOMI = 94; 
+	opFCOMIP = 95; 
+	opFCOMP = 96; 
+	opFCOMPP = 97; 
+	opFCOS = 98; 
+	opFDECSTP = 99; 
+	opFDIV = 100; 
+	opFDIVP = 101; 
+	opFDIVR = 102; 
+	opFDIVRP = 103; 
+	opFEMMS = 104; 
+	opFFREE = 105; 
+	opFIADD = 106; 
+	opFICOM = 107; 
+	opFICOMP = 108; 
+	opFIDIV = 109; 
+	opFIDIVR = 110; 
+	opFILD = 111; 
+	opFIMUL = 112; 
+	opFINCSTP = 113; 
+	opFIST = 114; 
+	opFISTP = 115; 
+	opFISTTP = 116; 
+	opFISUB = 117; 
+	opFISUBR = 118; 
+	opFLD = 119; 
+	opFLD1 = 120; 
+	opFLDCW = 121; 
+	opFLDENV = 122; 
+	opFLDL2E = 123; 
+	opFLDL2T = 124; 
+	opFLDLG2 = 125; 
+	opFLDLN2 = 126; 
+	opFLDPI = 127; 
+	opFLDZ = 128; 
+	opFMUL = 129; 
+	opFMULP = 130; 
+	opFNCLEX = 131; 
+	opFNINIT = 132; 
+	opFNOP = 133; 
+	opFNSAVE = 134; 
+	opFNSTCW = 135; 
+	opFNSTENV = 136; 
+	opFNSTSW = 137; 
+	opFPATAN = 138; 
+	opFPREM = 139; 
+	opFPREM1 = 140; 
+	opFPTAN = 141; 
+	opFRNDINT = 142; 
+	opFRSTOR = 143; 
+	opFSCALE = 144; 
+	opFSIN = 145; 
+	opFSINCOS = 146; 
+	opFSQRT = 147; 
+	opFST = 148; 
+	opFSTP = 149; 
+	opFSUB = 150; 
+	opFSUBP = 151; 
+	opFSUBR = 152; 
+	opFSUBRP = 153; 
+	opFTST = 154; 
+	opFUCOM = 155; 
+	opFUCOMI = 156; 
+	opFUCOMIP = 157; 
+	opFUCOMP = 158; 
+	opFUCOMPP = 159; 
+	opFWAIT = 160; 
+	opFXAM = 161; 
+	opFXCH = 162; 
+	opFXRSTOR = 163; 
+	opFXSAVE = 164; 
+	opFXTRACT = 165; 
+	opFYL2X = 166; 
+	opFYL2XP1 = 167; 
+	opHADDPD = 168; 
+	opHADDPS = 169; 
+	opHLT = 170; 
+	opHSUBPD = 171; 
+	opHSUBPS = 172; 
+	opIDIV = 173; 
+	opIMUL = 174; 
+	opIN = 175; 
+	opINC = 176; 
+	opINSB = 177; 
+	opINSD = 178; 
+	opINSW = 179; 
+	opINT = 180; 
+	opINVD = 181; 
+	opINVLPG = 182; 
+	opINVLPGA = 183; 
+	opIRET = 184; 
+	opIRETD = 185; 
+	opIRETQ = 186; 
+	opJA = 187; 
+	opJB = 188; 
+	opJBE = 189; 
+	opJCXZ = 190; 
+	opJE = 191; 
+	opJECXZ = 192; 
+	opJG = 193; 
+	opJGE = 194; 
+	opJL = 195; 
+	opJLE = 196; 
+	opJMP = 197; 
+	opJNB = 198; 
+	opJNBE = 199; 
+	opJNE = 200; 
+	opJNO = 201; 
+	opJNP = 202; 
+	opJO = 203; 
+	opJP = 204; 
+	opJRCXZ = 205; 
+	opJS = 206; 
+	opLAHF = 207; 
+	opLAR = 208; 
+	opLDDQU = 209; 
+	opLDMXCSR = 210; 
+	opLEA = 211; 
+	opLEAVE = 212; 
+	opLFENCE = 213; 
+	opLFS = 214; 
+	opLGDT = 215; 
+	opLGS = 216; 
+	opLIDT = 217; 
+	opLLDT = 218; 
+	opLMSW = 219; 
+	opLODSB = 220; 
+	opLODSD = 221; 
+	opLODSQ = 222; 
+	opLODSW = 223; 
+	opLOOP = 224; 
+	opLOOPE = 225; 
+	opLOOPNE = 226; 
+	opLSL = 227; 
+	opLSS = 228; 
+	opLTR = 229; 
+	opMASKMOVDQU = 230; 
+	opMASKMOVQ = 231; 
+	opMAXPD = 232; 
+	opMAXPS = 233; 
+	opMAXSD = 234; 
+	opMAXSS = 235; 
+	opMFENCE = 236; 
+	opMINPD = 237; 
+	opMINPS = 238; 
+	opMINSD = 239; 
+	opMINSS = 240; 
+	opMOV = 241; 
+	opMOVA = 242; 
+	opMOVAPD = 243; 
+	opMOVAPS = 244; 
+	opMOVB = 245; 
+	opMOVBE = 246; 
+	opMOVD = 247; 
+	opMOVDDUP = 248; 
+	opMOVDQ2Q = 249; 
+	opMOVDQA = 250; 
+	opMOVDQU = 251; 
+	opMOVE = 252; 
+	opMOVG = 253; 
+	opMOVGE = 254; 
+	opMOVHLPS = 255; 
+	opMOVHPD = 256; 
+	opMOVHPS = 257; 
+	opMOVL = 258; 
+	opMOVLE = 259; 
+	opMOVLHPS = 260; 
+	opMOVLPD = 261; 
+	opMOVLPS = 262; 
+	opMOVMSKPD = 263; 
+	opMOVMSKPS = 264; 
+	opMOVNB = 265; 
+	opMOVNBE = 266; 
+	opMOVNE = 267; 
+	opMOVNO = 268; 
+	opMOVNP = 269; 
+	opMOVNTDQ = 270; 
+	opMOVNTI = 271; 
+	opMOVNTPD = 272; 
+	opMOVNTPS = 273; 
+	opMOVNTQ = 274; 
+	opMOVO = 275; 
+	opMOVP = 276; 
+	opMOVQ = 277; 
+	opMOVQ2DQ = 278; 
+	opMOVS = 279; 
+	opMOVSB = 280; 
+	opMOVSD = 281; 
+	opMOVSHDUP = 282; 
+	opMOVSLDUP = 283; 
+	opMOVSQ = 284; 
+	opMOVSS = 285; 
+	opMOVSW = 286; 
+	opMOVSX = 287; 
+	opMOVSXD = 288; 
+	opMOVUPD = 289; 
+	opMOVUPS = 290; 
+	opMOVZX = 291; 
+	opMUL = 292; 
+	opMULPD = 293; 
+	opMULPS = 294; 
+	opMULSD = 295; 
+	opMULSS = 296; 
+	opNEG = 297; 
+	opNOP = 298; 
+	opNOT = 299; 
+	opOR = 300; 
+	opORPD = 301; 
+	opORPS = 302; 
+	opOUT = 303; 
+	opOUTSB = 304; 
+	opOUTSD = 305; 
+	opOUTSW = 306; 
+	opPACKSSDW = 307; 
+	opPACKSSWB = 308; 
+	opPACKUSWB = 309; 
+	opPADDB = 310; 
+	opPADDD = 311; 
+	opPADDQ = 312; 
+	opPADDSB = 313; 
+	opPADDSW = 314; 
+	opPADDUSB = 315; 
+	opPADDUSW = 316; 
+	opPADDW = 317; 
+	opPAND = 318; 
+	opPANDN = 319; 
+	opPAUSE = 320; 
+	opPAVGB = 321; 
+	opPAVGUSB = 322; 
+	opPAVGW = 323; 
+	opPCMPEQB = 324; 
+	opPCMPEQD = 325; 
+	opPCMPEQW = 326; 
+	opPCMPGTB = 327; 
+	opPCMPGTD = 328; 
+	opPCMPGTW = 329; 
+	opPEXTRW = 330; 
+	opPF2ID = 331; 
+	opPF2IW = 332; 
+	opPFACC = 333; 
+	opPFADD = 334; 
+	opPFCMPEQ = 335; 
+	opPFCMPGE = 336; 
+	opPFCMPGT = 337; 
+	opPFMAX = 338; 
+	opPFMIN = 339; 
+	opPFMUL = 340; 
+	opPFNACC = 341; 
+	opPFPNACC = 342; 
+	opPFRCP = 343; 
+	opPFRCPIT1 = 344; 
+	opPFRSQIT1 = 345; 
+	opPFRSQRT = 346; 
+	opPFSUB = 347; 
+	opPFSUBR = 348; 
+	opPI2FD = 349; 
+	opPI2FW = 350; 
+	opPINSRW = 351; 
+	opPMADDWD = 352; 
+	opPMAXSW = 353; 
+	opPMAXUB = 354; 
+	opPMINSW = 355; 
+	opPMINUB = 356; 
+	opPMOVMSKB = 357; 
+	opPMULHRW = 358; 
+	opPMULHUW = 359; 
+	opPMULHW = 360; 
+	opPMULLW = 361; 
+	opPMULUDQ = 362; 
+	opPOP = 363; 
+	opPOPF = 364; 
+	opPOPFD = 365; 
+	opPOPFQ = 366; 
+	opPOR = 367; 
+	opPREFETCH = 368; 
+	opPREFETCHNTA = 369; 
+	opPREFETCHT0 = 370; 
+	opPREFETCHT1 = 371; 
+	opPREFETCHT2 = 372; 
+	opPREFETCHW = 373; 
+	opPSADBW = 374; 
+	opPSHUFD = 375; 
+	opPSHUFHW = 376; 
+	opPSHUFLW = 377; 
+	opPSHUFW = 378; 
+	opPSLLD = 379; 
+	opPSLLDQ = 380; 
+	opPSLLQ = 381; 
+	opPSLLW = 382; 
+	opPSRAD = 383; 
+	opPSRAW = 384; 
+	opPSRLD = 385; 
+	opPSRLDQ = 386; 
+	opPSRLQ = 387; 
+	opPSRLW = 388; 
+	opPSUBB = 389; 
+	opPSUBD = 390; 
+	opPSUBQ = 391; 
+	opPSUBSB = 392; 
+	opPSUBSW = 393; 
+	opPSUBUSB = 394; 
+	opPSUBUSW = 395; 
+	opPSUBW = 396; 
+	opPSWAPD = 397; 
+	opPUNPCKHBW = 398; 
+	opPUNPCKHDQ = 399; 
+	opPUNPCKHQDQ = 400; 
+	opPUNPCKHWD = 401; 
+	opPUNPCKLBW = 402; 
+	opPUNPCKLDQ = 403; 
+	opPUNPCKLQDQ = 404; 
+	opPUNPCKLWD = 405; 
+	opPUSH = 406; 
+	opPUSHF = 407; 
+	opPUSHFD = 408; 
+	opPUSHFQ = 409; 
+	opPXOR = 410; 
+	opRCL = 411; 
+	opRCPPS = 412; 
+	opRCPSS = 413; 
+	opRCR = 414; 
+	opRDMSR = 415; 
+	opRDPMC = 416; 
+	opRDTSC = 417; 
+	opRDTSCP = 418; 
+	opRET = 419; 
+	opROL = 420; 
+	opROR = 421; 
+	opRSM = 422; 
+	opRSQRTPS = 423; 
+	opRSQRTSS = 424; 
+	opSAHF = 425; 
+	opSAR = 426; 
+	opSBB = 427; 
+	opSCASB = 428; 
+	opSCASD = 429; 
+	opSCASQ = 430; 
+	opSCASW = 431; 
+	opSETA = 432; 
+	opSETB = 433; 
+	opSETBE = 434; 
+	opSETE = 435; 
+	opSETG = 436; 
+	opSETGE = 437; 
+	opSETL = 438; 
+	opSETLE = 439; 
+	opSETNB = 440; 
+	opSETNBE = 441; 
+	opSETNE = 442; 
+	opSETNO = 443; 
+	opSETNP = 444; 
+	opSETO = 445; 
+	opSETP = 446; 
+	opSETS = 447; 
+	opSFENCE = 448; 
+	opSGDT = 449; 
+	opSHL = 450; 
+	opSHLD = 451; 
+	opSHR = 452; 
+	opSHRD = 453; 
+	opSHUFPD = 454; 
+	opSHUFPS = 455; 
+	opSIDT = 456; 
+	opSKINIT = 457; 
+	opSLDT = 458; 
+	opSMSW = 459; 
+	opSQRTPD = 460; 
+	opSQRTPS = 461; 
+	opSQRTSD = 462; 
+	opSQRTSS = 463; 
+	opSTC = 464; 
+	opSTD = 465; 
+	opSTGI = 466; 
+	opSTI = 467; 
+	opSTMXCSR = 468; 
+	opSTOSB = 469; 
+	opSTOSD = 470; 
+	opSTOSQ = 471; 
+	opSTOSW = 472; 
+	opSTR = 473; 
+	opSUB = 474; 
+	opSUBPD = 475; 
+	opSUBPS = 476; 
+	opSUBSD = 477; 
+	opSUBSS = 478; 
+	opSWAPGS = 479; 
+	opSYSCALL = 480; 
+	opSYSRET = 481; 
+	opTEST = 482; 
+	opUCOMISD = 483; 
+	opUCOMISS = 484; 
+	opUD2 = 485; 
+	opUNPCKHPD = 486; 
+	opUNPCKHPS = 487; 
+	opUNPCKLPD = 488; 
+	opUNPCKLPS = 489; 
+	opVERR = 490; 
+	opVERW = 491; 
+	opVMLOAD = 492; 
+	opVMMCALL = 493; 
+	opVMRUN = 494; 
+	opVMSAVE = 495; 
+	opWBINVD = 496; 
+	opWRMSR = 497; 
+	opXADD = 498; 
+	opXCHG = 499; 
+	opXLAT = 500; 
+	opXOR = 501; 
+	opXORPD = 502; 
+	opXORPS = 503; 
+	regNONE = 0; 
+	regrAX = 0; 
+	regrCX = 1; 
+	regrDX = 2; 
+	regrBX = 3; 
+	regrSP = 4; 
+	regrBP = 5; 
+	regrSI = 6; 
+	regrDI = 7; 
+	regr8 = 8; 
+	regr9 = 9; 
+	regr10 = 10; 
+	regr11 = 11; 
+	regr12 = 12; 
+	regr13 = 13; 
+	regr14 = 14; 
+	regr15 = 15; 
+	regAL = 1; 
+	regCL = 2; 
+	regDL = 3; 
+	regBL = 4; 
+	regAH = 5; 
+	regCH = 6; 
+	regDH = 7; 
+	regBH = 8; 
+	regR8B = 9; 
+	regR9B = 10; 
+	regR10B = 11; 
+	regR11B = 12; 
+	regR12B = 13; 
+	regR13B = 14; 
+	regR14B = 15; 
+	regR15B = 16; 
+	regSPL = 17; 
+	regBPL = 18; 
+	regSIL = 19; 
+	regDIL = 20; 
+	regAX = 21; 
+	regCX = 22; 
+	regDX = 23; 
+	regBX = 24; 
+	regSP = 25; 
+	regBP = 26; 
+	regSI = 27; 
+	regDI = 28; 
+	regR8W = 29; 
+	regR9W = 30; 
+	regR10W = 31; 
+	regR11W = 32; 
+	regR12W = 33; 
+	regR13W = 34; 
+	regR14W = 35; 
+	regR15W = 36; 
+	regEAX = 37; 
+	regECX = 38; 
+	regEDX = 39; 
+	regEBX = 40; 
+	regESP = 41; 
+	regEBP = 42; 
+	regESI = 43; 
+	regEDI = 44; 
+	regR8D = 45; 
+	regR9D = 46; 
+	regR10D = 47; 
+	regR11D = 48; 
+	regR12D = 49; 
+	regR13D = 50; 
+	regR14D = 51; 
+	regR15D = 52; 
+	regRAX = 53; 
+	regRCX = 54; 
+	regRDX = 55; 
+	regRBX = 56; 
+	regRSP = 57; 
+	regRBP = 58; 
+	regRSI = 59; 
+	regRDI = 60; 
+	regR8 = 61; 
+	regR9 = 62; 
+	regR10 = 63; 
+	regR11 = 64; 
+	regR12 = 65; 
+	regR13 = 66; 
+	regR14 = 67; 
+	regR15 = 68; 
+	regES = 69; 
+	regCS = 70; 
+	regSS = 71; 
+	regDS = 72; 
+	regFS = 73; 
+	regGS = 74; 
+	regST0 = 75; 
+	regST1 = 76; 
+	regST2 = 77; 
+	regST3 = 78; 
+	regST4 = 79; 
+	regST5 = 80; 
+	regST6 = 81; 
+	regST7 = 82; 
+	regCR0 = 83; 
+	regCR1 = 84; 
+	regCR2 = 85; 
+	regCR3 = 86; 
+	regCR4 = 87; 
+	regCR5 = 88; 
+	regCR6 = 89; 
+	regCR7 = 90; 
+	regCR8 = 91; 
+	regCR9 = 92; 
+	regCR10 = 93; 
+	regCR11 = 94; 
+	regCR12 = 95; 
+	regCR13 = 96; 
+	regCR14 = 97; 
+	regCR15 = 98; 
+	regDR0 = 99; 
+	regDR1 = 100; 
+	regDR2 = 101; 
+	regDR3 = 102; 
+	regDR4 = 103; 
+	regDR5 = 104; 
+	regDR6 = 105; 
+	regDR7 = 106; 
+	regDR8 = 107; 
+	regDR9 = 108; 
+	regDR10 = 109; 
+	regDR11 = 110; 
+	regDR12 = 111; 
+	regDR13 = 112; 
+	regDR14 = 113; 
+	regDR15 = 114; 
+	regXMM0 = 115; 
+	regXMM1 = 116; 
+	regXMM2 = 117; 
+	regXMM3 = 118; 
+	regXMM4 = 119; 
+	regXMM5 = 120; 
+	regXMM6 = 121; 
+	regXMM7 = 122; 
+	regXMM8 = 123; 
+	regXMM9 = 124; 
+	regXMM10 = 125; 
+	regXMM11 = 126; 
+	regXMM12 = 127; 
+	regXMM13 = 128; 
+	regXMM14 = 129; 
+	regXMM15 = 130; 
+	regMMX0 = 131; 
+	regMMX1 = 132; 
+	regMMX2 = 133; 
+	regMMX3 = 134; 
+	regMMX4 = 135; 
+	regMMX5 = 136; 
+	regMMX6 = 137; 
+	regMMX7 = 138; 
+	regIP = 139; 
+	regRIP = 140; 
+TYPE 
+	Arg = OBJECT 
+
+		PROCEDURE ^ Print(w: Streams.Writer); 
+	END Arg; 
+
+	ArgImm = OBJECT (Arg)
+	VAR 
+		imm: HUGEINT; 
+
+		PROCEDURE ^  & New*(imm: HUGEINT); 
+		PROCEDURE ^ Print(w: Streams.Writer); 
+	END ArgImm; 
+
+	ArgReg = OBJECT (Arg)
+	VAR 
+		reg: LONGINT; 
+
+		PROCEDURE ^  & New*(reg: LONGINT); 
+		PROCEDURE ^ Print(w: Streams.Writer); 
+	END ArgReg; 
+
+	ArgMem = OBJECT (Arg)
+	VAR 
+		segment, reg, scale, base: LONGINT; 
+		disp: HUGEINT; 
+
+		PROCEDURE ^  & New*(segment, reg, scale, base: LONGINT; disp: HUGEINT); 
+		PROCEDURE ^ Print(w: Streams.Writer); 
+	END ArgMem; 
+
+	AMD64Opcode = OBJECT (Decoder.Opcode)
+	VAR 
+		prefixCount: LONGINT; 
+		prefixes: SET; 
+		instr: LONGINT; 
+		arg: ARRAY maxArgs OF Arg; 
+		hidePrefixes: BOOLEAN; 
+
+		PROCEDURE ^  & New*(proc: Decoder.ProcedureInfo; stream: Streams.Writer); 
+		PROCEDURE ^ PrintOpcodeBytes*(w: Streams.Writer); 
+		PROCEDURE ^ PrintInstruction*(w: Streams.Writer); 
+		PROCEDURE ^ PrintArguments*(w: Streams.Writer); 
+		PROCEDURE ^ PrintVariables*(w: Streams.Writer); 
+	END AMD64Opcode; 
+
+	AMD64Decoder = OBJECT {EXCLUSIVE} (Decoder.Decoder)
+
+		PROCEDURE ^ NewOpcode*(): Decoder.Opcode; 
+		PROCEDURE ^ DecodeThis*(opcode: Decoder.Opcode); 
+	END AMD64Decoder; 
+
+	PROCEDURE ^ PrintReg(w: Streams.Writer; reg: LONGINT); 
+	PROCEDURE ^ PrintImm(n: HUGEINT; w: Streams.Writer); 
+	PROCEDURE ^ AMD64DecoderFactory(reader: Streams.Reader): Decoder.Decoder; 
+	PROCEDURE ^ Init*; 
+BEGIN
+END AMD64Decoder.

WinAos/obg/ARMDecoder.SymW

@@ -0,0 +1,240 @@
+MODULE ARMDecoder;
+	IMPORT SYSTEM, Decoder, Streams, KernelLog;
+CONST 
+	objFileSuffix = \"Oba"\; 
+	none =  -1; 
+	ArgNone =  -2; 
+	ArgImm = 1; 
+	ArgReg = 2; 
+	ArgShift = 3; 
+	ArgRegImm = 11; 
+	ArgRegReg = 12; 
+	ArgRegShift = 13; 
+	ArgRegMem = 14; 
+	ArgRegRList = 15; 
+	ArgRegRegImm = 21; 
+	ArgRegRegReg = 22; 
+	ArgRegRegShift = 23; 
+	ArgRegRegMem = 24; 
+	ArgRegRegRegReg = 31; 
+	ArgRegRegRegImm = 32; 
+	ArgRegRegRegShift = 33; 
+	ArgCProcRegMem = 41; 
+	ArgCProcImmRegRegRegImm = 42; 
+	FP = 12; 
+	SP = 13; 
+	LR = 14; 
+	PC = 15; 
+	CPSR = 16; 
+	SPSR = 17; 
+	SRegC = 0; 
+	SRegX = 1; 
+	SRegS = 2; 
+	SRegF = 3; 
+	opUNDEFINED =  -2; 
+	opADC = 1; 
+	opADD = 2; 
+	opAND = 3; 
+	opASR = 4; 
+	opB = 5; 
+	opBIC = 6; 
+	opBKPT = 7; 
+	opBL = 8; 
+	opBLX = 9; 
+	opBX = 10; 
+	opCDP = 11; 
+	opCDP2 = 12; 
+	opCLZ = 13; 
+	opCMN = 14; 
+	opCMP = 15; 
+	opEOR = 16; 
+	opLDC = 17; 
+	opLDC2 = 18; 
+	opLDM = 19; 
+	opLDR = 20; 
+	opLDRB = 21; 
+	opLDRBT = 22; 
+	opLDRH = 23; 
+	opLDRSB = 24; 
+	opLDRSH = 25; 
+	opLDRT = 26; 
+	opLSL = 27; 
+	opLSR = 28; 
+	opMCR = 29; 
+	opMCR2 = 30; 
+	opMLA = 31; 
+	opMOV = 32; 
+	opMRC = 33; 
+	opMRC2 = 34; 
+	opMRS = 61; 
+	opMSR = 35; 
+	opMUL = 36; 
+	opMVN = 37; 
+	opORR = 38; 
+	opROR = 39; 
+	opRRX = 40; 
+	opRSB = 41; 
+	opRSC = 42; 
+	opSBC = 43; 
+	opSMLAL = 44; 
+	opSMULL = 45; 
+	opSTC = 46; 
+	opSTC2 = 47; 
+	opSTM = 48; 
+	opSTR = 49; 
+	opSTRB = 50; 
+	opSTRBT = 51; 
+	opSTRH = 52; 
+	opSTRT = 53; 
+	opSUB = 54; 
+	opSWI = 55; 
+	opSWP = 56; 
+	opSWPB = 62; 
+	opTEQ = 57; 
+	opTST = 58; 
+	opUMLAL = 59; 
+	opUMULL = 60; 
+	EQ = 0; 
+	NE = 1; 
+	CSHS = 2; 
+	CCLO = 3; 
+	MI = 4; 
+	PL = 5; 
+	VS = 6; 
+	VC = 7; 
+	HI = 8; 
+	LS = 9; 
+	GE = 10; 
+	LT = 11; 
+	GT = 12; 
+	LE = 13; 
+	AL = 14; 
+	NV = 15; 
+	RepInt = 1; 
+	RepHex = 2; 
+	RepRelJmp = 10; 
+	Lsl = 0; 
+	LSR = 1; 
+	Asr = 2; 
+	Ror = 3; 
+	RRX = 4; 
+	AddrModeReg = 1; 
+	AddrModeRegImm = 2; 
+	AddrModeRegReg = 3; 
+	AddrModeRegRegScale = 4; 
+	AddrModeDA = 5; 
+	AddrModeIA = 6; 
+	AddrModeDB = 7; 
+	AddrModeIB = 8; 
+	RegUpdateNone = 0; 
+	RegUpdatePre = 1; 
+	RegUpdatePost = 2; 
+TYPE 
+	ARMArg = OBJECT 
+	END ARMArg; 
+
+	ARMArgImm = OBJECT (ARMArg)
+	VAR 
+		imm, rep: LONGINT; 
+
+		PROCEDURE ^  & New*(imm, rep: LONGINT); 
+	END ARMArgImm; 
+
+	ARMArgReg = OBJECT (ARMArg)
+	VAR 
+		reg: LONGINT; 
+		isCReg: BOOLEAN; 
+		sregMask: SET; 
+
+		PROCEDURE ^  & New*(reg: LONGINT); 
+	END ARMArgReg; 
+
+	ARMArgRList = OBJECT (ARMArg)
+	VAR 
+		regs: SET; 
+		addrMode: LONGINT; 
+
+		PROCEDURE ^  & New*(regs: SET); 
+	END ARMArgRList; 
+
+	ARMArgMem = OBJECT (ARMArg)
+	VAR 
+		addrMode, reg, regOffs, regScale, shift, immOffs: LONGINT; 
+		width: LONGINT; 
+		signed, translation: BOOLEAN; 
+		regUpdate: LONGINT; 
+
+		PROCEDURE ^  & New*(adrMode, reg: LONGINT); 
+	END ARMArgMem; 
+
+	ARMArgShift = OBJECT (ARMArg)
+	VAR 
+		shiftImmOrReg, operation: LONGINT; 
+		reg: BOOLEAN; 
+
+		PROCEDURE ^  & New*(operation, shiftImmOrReg: LONGINT; reg: BOOLEAN); 
+	END ARMArgShift; 
+
+	ARMArgCProc = OBJECT (ARMArg)
+	VAR 
+		cproc: LONGINT; 
+
+		PROCEDURE ^  & New*(cproc: LONGINT); 
+	END ARMArgCProc; 
+
+	ARMOpcode = OBJECT (Decoder.Opcode)
+	VAR 
+		argStructure: LONGINT; 
+		op, cond: LONGINT; 
+		ccUpdate: BOOLEAN; 
+		arg1, arg2, arg3, arg4, arg5, arg6: ARMArg; 
+
+		PROCEDURE ^  & New*(proc: Decoder.ProcedureInfo; stream: Streams.Writer); 
+		PROCEDURE ^ PrintOpcodeBytes*(w: Streams.Writer); 
+		PROCEDURE ^ PrintInstruction*(w: Streams.Writer); 
+		PROCEDURE ^ PrintCondition(w: Streams.Writer); 
+		PROCEDURE ^ PrintLSMAddrMode(w: Streams.Writer); 
+		PROCEDURE ^ PrintArguments*(w: Streams.Writer); 
+		PROCEDURE ^ WriteImm(immArg: ARMArgImm; w: Streams.Writer); 
+		PROCEDURE ^ WriteReg(regArg: ARMArgReg; w: Streams.Writer); 
+		PROCEDURE ^ WriteRegSymbol(reg: LONGINT; w: Streams.Writer); 
+		PROCEDURE ^ WriteShiftSymbol(op: LONGINT; w: Streams.Writer); 
+		PROCEDURE ^ WriteShift(shiftArg: ARMArgShift; w: Streams.Writer); 
+		PROCEDURE ^ WriteMem(memArg: ARMArgMem; w: Streams.Writer); 
+		PROCEDURE ^ WriteRegRList(regArg: ARMArgReg; rListArg: ARMArgRList; w: Streams.Writer); 
+		PROCEDURE ^ WriteCProc(cProcArg: ARMArgCProc; w: Streams.Writer); 
+	END ARMOpcode; 
+
+	ARMDecoder = OBJECT {EXCLUSIVE} (Decoder.Decoder)
+	VAR 
+		bit24To27, bit20To23, bit16To19, bit12To15, bit8To11, bit4To7, bit0To3: LONGINT; 
+
+		PROCEDURE ^ NewOpcode*(): Decoder.Opcode; 
+		PROCEDURE ^ DecodeThis*(opcode: Decoder.Opcode); 
+		PROCEDURE ^ DecodeShifterOperand(op: LONGINT; VAR argStructure: LONGINT; VAR arg1, arg2: ARMArg); 
+		PROCEDURE ^ DataProcessing(opcode: ARMOpcode); 
+		PROCEDURE ^ Miscellaneous(opcode: ARMOpcode); 
+		PROCEDURE ^ MultipliesExtraLS(opcode: ARMOpcode); 
+		PROCEDURE ^ SRegTransfer(opcode: ARMOpcode); 
+		PROCEDURE ^ LoadStore(opcode: ARMOpcode); 
+		PROCEDURE ^ LoadStoreMultiple(opcode: ARMOpcode); 
+		PROCEDURE ^ Branch(opcode: ARMOpcode); 
+		PROCEDURE ^ BranchToThumb(opcode: ARMOpcode; op: LONGINT); 
+		PROCEDURE ^ CoprocLoadStoreDRegTransfer(opcode: ARMOpcode); 
+		PROCEDURE ^ CoprocDataProcessing(opcode: ARMOpcode); 
+		PROCEDURE ^ CoprocRegTransfer(opcode: ARMOpcode); 
+		PROCEDURE ^ SoftwareInterrupt(opcode: ARMOpcode); 
+		PROCEDURE ^ SignExtension(VAR x: LONGINT; length: LONGINT); 
+	END ARMDecoder; 
+VAR 
+	bigEndian: BOOLEAN; 
+
+	PROCEDURE ^ SetBigEndian*; 
+	PROCEDURE ^ SetLittleEndian*; 
+	PROCEDURE ^ Hex(n: LONGINT; w: Streams.Writer); 
+	PROCEDURE ^ SwapBytes(VAR code: LONGINT); 
+	PROCEDURE ^ ARMDecoderFactory(reader: Streams.Reader): Decoder.Decoder; 
+	PROCEDURE ^ CodeScaleCallback(VAR codeSize: LONGINT); 
+	PROCEDURE ^ Init*; 
+BEGIN
+END ARMDecoder.

WinAos/obg/ASMAMD64.SymW

@@ -0,0 +1,751 @@
+MODULE ASMAMD64;
+CONST 
+	maxMnemonicNameLength = 12; 
+	maxMnemonics = 600; 
+	maxInstructions = 1400; 
+	maxRegisters = 150; 
+	maxCPUs = 30; 
+	maxOperands* = 3; 
+	none* =  -1; 
+	cpu8086* = 0; 
+	cpu186* = 1; 
+	cpu286* = 2; 
+	cpu386* = 3; 
+	cpu486* = 4; 
+	cpuPentium* = 5; 
+	cpuP6* = 6; 
+	cpuKatmai* = 7; 
+	cpuWillamette* = 8; 
+	cpuPrescott* = 9; 
+	cpuAMD64* = 10; 
+	cpuPrivileged* = 20; 
+	cpuProtected* = 21; 
+	cpuSSE* = 22; 
+	cpuSSE2* = 23; 
+	cpuSSE3* = 24; 
+	cpu3DNow* = 25; 
+	cpuMMX* = 26; 
+	cpuFPU* = 27; 
+	cpuOptions* = {cpuPrivileged .. cpuFPU}; 
+	optO16* = 0; 
+	optO32* = 1; 
+	optO64* = 2; 
+	optD64* = 3; 
+	optI64* = 4; 
+	optA16* = 5; 
+	optA32* = 6; 
+	optPOP* = 7; 
+	optPLOCK* = 8; 
+	optPREP* = 9; 
+	optPREPN* = 10; 
+	AL* = 0; 
+	AX* = 1; 
+	CL* = 2; 
+	CR8* = 3; 
+	CRn* = 4; 
+	CS* = 5; 
+	DRn* = 6; 
+	DS* = 7; 
+	DX* = 8; 
+	EAX* = 9; 
+	ECX* = 10; 
+	ES* = 11; 
+	FS* = 12; 
+	GS* = 13; 
+	RAX* = 14; 
+	SS* = 15; 
+	imm16* = 16; 
+	imm32* = 17; 
+	imm64* = 18; 
+	imm8* = 19; 
+	mem* = 20; 
+	mem128* = 21; 
+	mem16* = 22; 
+	mem32* = 23; 
+	mem64* = 24; 
+	mem8* = 25; 
+	mmx* = 26; 
+	mmxmem32* = 27; 
+	mmxmem64* = 28; 
+	moffset16* = 29; 
+	moffset32* = 30; 
+	moffset64* = 31; 
+	moffset8* = 32; 
+	one* = 33; 
+	pntr1616* = 34; 
+	pntr1632* = 35; 
+	rAX* = 36; 
+	reg16* = 37; 
+	reg32* = 38; 
+	reg64* = 39; 
+	reg8* = 40; 
+	regmem16* = 41; 
+	regmem32* = 42; 
+	regmem64* = 43; 
+	regmem8* = 44; 
+	rel16off* = 45; 
+	rel32off* = 46; 
+	rel8off* = 47; 
+	segReg* = 48; 
+	simm16* = 49; 
+	simm32* = 50; 
+	simm8* = 51; 
+	st0* = 52; 
+	sti* = 53; 
+	three* = 54; 
+	uimm16* = 55; 
+	uimm32* = 56; 
+	uimm8* = 57; 
+	xmm* = 58; 
+	xmmmem128* = 59; 
+	xmmmem32* = 60; 
+	xmmmem64* = 61; 
+	prfOP* = 102; 
+	prfADR* = 103; 
+	prfCS* = 46; 
+	prfDS* = 62; 
+	prfES* = 38; 
+	prfFS* = 100; 
+	prfGS* = 101; 
+	prfSS* = 54; 
+	prfLOCK* = 240; 
+	prfREP* = 243; 
+	prfREPE* = 243; 
+	prfREPZ* = 243; 
+	prfREPNE* = 242; 
+	prfREPNZ* = 242; 
+	opAAA = 0; 
+	opAAD = 1; 
+	opAAM = 2; 
+	opAAS = 3; 
+	opADC = 4; 
+	opADD* = 5; 
+	opADDPD = 6; 
+	opADDPS = 7; 
+	opADDSD* = 8; 
+	opADDSS* = 9; 
+	opADDSUBPD = 10; 
+	opADDSUBPS = 11; 
+	opAND* = 12; 
+	opANDNPD = 13; 
+	opANDNPS = 14; 
+	opANDPD* = 15; 
+	opANDPS* = 16; 
+	opARPL = 17; 
+	opBOUND = 18; 
+	opBSF = 19; 
+	opBSR = 20; 
+	opBSWAP = 21; 
+	opBT* = 22; 
+	opBTC = 23; 
+	opBTR* = 24; 
+	opBTS* = 25; 
+	opCALL* = 26; 
+	opCBW* = 27; 
+	opCDQ* = 28; 
+	opCDQE = 29; 
+	opCFLUSH = 30; 
+	opCLC = 31; 
+	opCLD* = 32; 
+	opCLGI = 33; 
+	opCLI = 34; 
+	opCLTS = 35; 
+	opCMC = 36; 
+	opCMOVA = 37; 
+	opCMOVAE = 38; 
+	opCMOVB = 39; 
+	opCMOVBE = 40; 
+	opCMOVC = 41; 
+	opCMOVE = 42; 
+	opCMOVG = 43; 
+	opCMOVGE = 44; 
+	opCMOVL = 45; 
+	opCMOVLE = 46; 
+	opCMOVNA = 47; 
+	opCMOVNAE = 48; 
+	opCMOVNB = 49; 
+	opCMOVNBE = 50; 
+	opCMOVNC = 51; 
+	opCMOVNE = 52; 
+	opCMOVNG = 53; 
+	opCMOVNGE = 54; 
+	opCMOVNL = 55; 
+	opCMOVNLE = 56; 
+	opCMOVNO = 57; 
+	opCMOVNP = 58; 
+	opCMOVNS = 59; 
+	opCMOVNZ = 60; 
+	opCMOVO = 61; 
+	opCMOVP = 62; 
+	opCMOVPE = 63; 
+	opCMOVPO = 64; 
+	opCMOVS = 65; 
+	opCMOVZ = 66; 
+	opCMP* = 67; 
+	opCMPPD = 68; 
+	opCMPPS = 69; 
+	opCMPS = 70; 
+	opCMPSB = 71; 
+	opCMPSD = 72; 
+	opCMPSQ = 73; 
+	opCMPSS = 74; 
+	opCMPSW = 75; 
+	opCMPXCHG = 76; 
+	opCMPXCHG16B = 77; 
+	opCMPXCHG8B = 78; 
+	opCOMISD* = 79; 
+	opCOMISS* = 80; 
+	opCPUID = 81; 
+	opCQO* = 82; 
+	opCVTDQ2PD = 83; 
+	opCVTDQ2PS = 84; 
+	opCVTPD2DQ = 85; 
+	opCVTPD2PI = 86; 
+	opCVTPD2PS = 87; 
+	opCVTPI2PD = 88; 
+	opCVTPI2PS = 89; 
+	opCVTPS2DQ = 90; 
+	opCVTPS2PD = 91; 
+	opCVTPS2PI = 92; 
+	opCVTSD2SI* = 93; 
+	opCVTSD2SS* = 94; 
+	opCVTSI2SD* = 95; 
+	opCVTSI2SS* = 96; 
+	opCVTSS2SD* = 97; 
+	opCVTSS2SI* = 98; 
+	opCVTTPD2DQ = 99; 
+	opCVTTPD2PI = 100; 
+	opCVTTPS2DQ = 101; 
+	opCVTTPS2PI = 102; 
+	opCVTTSD2SI = 103; 
+	opCVTTSS2SI = 104; 
+	opCWD* = 105; 
+	opCWDE = 106; 
+	opDAA = 107; 
+	opDAS = 108; 
+	opDEC* = 109; 
+	opDIV = 110; 
+	opDIVPD = 111; 
+	opDIVPS = 112; 
+	opDIVSD* = 113; 
+	opDIVSS* = 114; 
+	opEMMS = 115; 
+	opENTER* = 116; 
+	opF2XM1 = 117; 
+	opFABS = 118; 
+	opFADD = 119; 
+	opFADDP = 120; 
+	opFBLD = 121; 
+	opFBSTP = 122; 
+	opFCHS = 123; 
+	opFCLEX = 124; 
+	opFCMOVB = 125; 
+	opFCMOVBE = 126; 
+	opFCMOVE = 127; 
+	opFCMOVNB = 128; 
+	opFCMOVNBE = 129; 
+	opFCMOVNE = 130; 
+	opFCMOVNU = 131; 
+	opFCMOVU = 132; 
+	opFCOM = 133; 
+	opFCOMI = 134; 
+	opFCOMIP = 135; 
+	opFCOMP = 136; 
+	opFCOMPP = 137; 
+	opFCOS = 138; 
+	opFDECSTP = 139; 
+	opFDIV = 140; 
+	opFDIVP = 141; 
+	opFDIVR = 142; 
+	opFDIVRP = 143; 
+	opFEMMS = 144; 
+	opFFREE = 145; 
+	opFIADD = 146; 
+	opFICOM = 147; 
+	opFICOMP = 148; 
+	opFIDIV = 149; 
+	opFIDIVR = 150; 
+	opFILD = 151; 
+	opFIMUL = 152; 
+	opFINCSTP = 153; 
+	opFINIT = 154; 
+	opFIST = 155; 
+	opFISTP = 156; 
+	opFISTTP = 157; 
+	opFISUB = 158; 
+	opFISUBR = 159; 
+	opFLD = 160; 
+	opFLD1 = 161; 
+	opFLDCW = 162; 
+	opFLDENV = 163; 
+	opFLDL2E = 164; 
+	opFLDL2T = 165; 
+	opFLDLG2 = 166; 
+	opFLDLN2 = 167; 
+	opFLDPI = 168; 
+	opFLDZ = 169; 
+	opFMUL = 170; 
+	opFMULP = 171; 
+	opFNCLEX = 172; 
+	opFNINIT = 173; 
+	opFNOP = 174; 
+	opFNSAVE = 175; 
+	opFNSTCW = 176; 
+	opFNSTENV = 177; 
+	opFNSTSW = 178; 
+	opFPATAN = 179; 
+	opFPREM = 180; 
+	opFPREM1 = 181; 
+	opFPTAN = 182; 
+	opFRNDINT = 183; 
+	opFRSTOR = 184; 
+	opFSAVE = 185; 
+	opFSCALE = 186; 
+	opFSIN = 187; 
+	opFSINCOS = 188; 
+	opFSQRT = 189; 
+	opFST = 190; 
+	opFSTCW = 191; 
+	opFSTENV = 192; 
+	opFSTP = 193; 
+	opFSTSW = 194; 
+	opFSUB = 195; 
+	opFSUBP = 196; 
+	opFSUBR = 197; 
+	opFSUBRP = 198; 
+	opFTST = 199; 
+	opFUCOM = 200; 
+	opFUCOMI = 201; 
+	opFUCOMIP = 202; 
+	opFUCOMP = 203; 
+	opFUCOMPP = 204; 
+	opFWAIT = 205; 
+	opFXAM = 206; 
+	opFXCH = 207; 
+	opFXRSTOR = 208; 
+	opFXSAVE = 209; 
+	opFXTRACT = 210; 
+	opFYL2X = 211; 
+	opFYL2XP1 = 212; 
+	opHADDPD = 213; 
+	opHADDPS = 214; 
+	opHLT = 215; 
+	opHSUBPD = 216; 
+	opHSUBPS = 217; 
+	opIDIV* = 218; 
+	opIMUL* = 219; 
+	opIN* = 220; 
+	opINC* = 221; 
+	opINS = 222; 
+	opINSB = 223; 
+	opINSD = 224; 
+	opINSW = 225; 
+	opINT* = 226; 
+	opINT3* = 227; 
+	opINTO = 228; 
+	opINVD = 229; 
+	opINVLPG = 230; 
+	opINVLPGA = 231; 
+	opIRET = 232; 
+	opIRETD = 233; 
+	opIRETQ = 234; 
+	opJA* = 235; 
+	opJAE* = 236; 
+	opJB* = 237; 
+	opJBE* = 238; 
+	opJC* = 239; 
+	opJCXZ = 240; 
+	opJE* = 241; 
+	opJECXZ = 242; 
+	opJG* = 243; 
+	opJGE* = 244; 
+	opJL* = 245; 
+	opJLE* = 246; 
+	opJMP* = 247; 
+	opJNA = 248; 
+	opJNAE = 249; 
+	opJNB = 250; 
+	opJNBE = 251; 
+	opJNC* = 252; 
+	opJNE* = 253; 
+	opJNG = 254; 
+	opJNGE = 255; 
+	opJNL = 256; 
+	opJNLE = 257; 
+	opJNO = 258; 
+	opJNP = 259; 
+	opJNS = 260; 
+	opJNZ* = 261; 
+	opJO = 262; 
+	opJP = 263; 
+	opJPE = 264; 
+	opJPO = 265; 
+	opJRCXZ = 266; 
+	opJS = 267; 
+	opJZ = 268; 
+	opLAHF = 269; 
+	opLAR = 270; 
+	opLDDQU = 271; 
+	opLDMXCSR = 272; 
+	opLDS = 273; 
+	opLEA = 274; 
+	opLEAVE* = 275; 
+	opLES = 276; 
+	opLFENCE = 277; 
+	opLFS = 278; 
+	opLGDT = 279; 
+	opLGS = 280; 
+	opLIDT = 281; 
+	opLLDT = 282; 
+	opLMSW = 283; 
+	opLODS = 284; 
+	opLODSB = 285; 
+	opLODSD = 286; 
+	opLODSQ = 287; 
+	opLODSW = 288; 
+	opLOOP = 289; 
+	opLOOPE = 290; 
+	opLOOPNE = 291; 
+	opLOOPNZ = 292; 
+	opLOOPZ = 293; 
+	opLSL = 294; 
+	opLSS = 295; 
+	opLTR = 296; 
+	opMASKMOVDQU = 297; 
+	opMASKMOVQ = 298; 
+	opMAXPD = 299; 
+	opMAXPS = 300; 
+	opMAXSD = 301; 
+	opMAXSS = 302; 
+	opMFENCE = 303; 
+	opMINPD = 304; 
+	opMINPS = 305; 
+	opMINSD = 306; 
+	opMINSS = 307; 
+	opMOV* = 308; 
+	opMOVAPD = 309; 
+	opMOVAPS = 310; 
+	opMOVD* = 311; 
+	opMOVDDUP = 312; 
+	opMOVDQ2Q = 313; 
+	opMOVDQA = 314; 
+	opMOVDQU = 315; 
+	opMOVHLPS = 316; 
+	opMOVHPD = 317; 
+	opMOVHPS = 318; 
+	opMOVLHPS = 319; 
+	opMOVLPD = 320; 
+	opMOVLPS = 321; 
+	opMOVMSKPD = 322; 
+	opMOVMSKPS = 323; 
+	opMOVNTDQ = 324; 
+	opMOVNTI = 325; 
+	opMOVNTPD = 326; 
+	opMOVNTPS = 327; 
+	opMOVNTQ = 328; 
+	opMOVQ = 329; 
+	opMOVQ2DQ = 330; 
+	opMOVS = 331; 
+	opMOVSB* = 332; 
+	opMOVSD* = 333; 
+	opMOVSHDUP = 334; 
+	opMOVSLDUP = 335; 
+	opMOVSQ = 336; 
+	opMOVSS* = 337; 
+	opMOVSW = 338; 
+	opMOVSX* = 339; 
+	opMOVSXD* = 340; 
+	opMOVUPD = 341; 
+	opMOVUPS = 342; 
+	opMOVZX* = 343; 
+	opMUL* = 344; 
+	opMULPD = 345; 
+	opMULPS = 346; 
+	opMULSD* = 347; 
+	opMULSS* = 348; 
+	opNEG* = 349; 
+	opNOP* = 350; 
+	opNOT* = 351; 
+	opOR* = 352; 
+	opORPD = 353; 
+	opORPS = 354; 
+	opOUT* = 355; 
+	opOUTS = 356; 
+	opOUTSB = 357; 
+	opOUTSD = 358; 
+	opOUTSW = 359; 
+	opPACKSSDW = 360; 
+	opPACKSSWB = 361; 
+	opPACKUSWB = 362; 
+	opPADDB = 363; 
+	opPADDD = 364; 
+	opPADDQ = 365; 
+	opPADDSB = 366; 
+	opPADDSW = 367; 
+	opPADDUSB = 368; 
+	opPADDUSW = 369; 
+	opPADDW = 370; 
+	opPAND = 371; 
+	opPANDN = 372; 
+	opPAUSE = 373; 
+	opPAVGB = 374; 
+	opPAVGUSB = 375; 
+	opPAVGW = 376; 
+	opPCMPEQB = 377; 
+	opPCMPEQD = 378; 
+	opPCMPEQW = 379; 
+	opPCMPGTB = 380; 
+	opPCMPGTD = 381; 
+	opPCMPGTW = 382; 
+	opPEXTRW = 383; 
+	opPF2ID = 384; 
+	opPF2IW = 385; 
+	opPFACC = 386; 
+	opPFADD = 387; 
+	opPFCMPEQ = 388; 
+	opPFCMPGE = 389; 
+	opPFCMPGT = 390; 
+	opPFMAX = 391; 
+	opPFMIN = 392; 
+	opPFMUL = 393; 
+	opPFNACC = 394; 
+	opPFPNACC = 395; 
+	opPFRCP = 396; 
+	opPFRCPIT1 = 397; 
+	opPFRCPIT2 = 398; 
+	opPFRSQIT1 = 399; 
+	opPFRSQRT = 400; 
+	opPFSUB = 401; 
+	opPFSUBR = 402; 
+	opPI2FD = 403; 
+	opPI2FW = 404; 
+	opPINSRW = 405; 
+	opPMADDWD = 406; 
+	opPMAXSW = 407; 
+	opPMAXUB = 408; 
+	opPMINSW = 409; 
+	opPMINUB = 410; 
+	opPMOVMSKB = 411; 
+	opPMULHRW = 412; 
+	opPMULHUW = 413; 
+	opPMULHW = 414; 
+	opPMULLW = 415; 
+	opPMULUDQ = 416; 
+	opPOP* = 417; 
+	opPOPA = 418; 
+	opPOPAD = 419; 
+	opPOPAW = 420; 
+	opPOPF = 421; 
+	opPOPFD = 422; 
+	opPOPFQ = 423; 
+	opPOPFW = 424; 
+	opPOR = 425; 
+	opPREFETCH = 426; 
+	opPREFETCHNTA = 427; 
+	opPREFETCHT0 = 428; 
+	opPREFETCHT1 = 429; 
+	opPREFETCHT2 = 430; 
+	opPREFETCHW = 431; 
+	opPSADBW = 432; 
+	opPSHUFD = 433; 
+	opPSHUFHW = 434; 
+	opPSHUFLW = 435; 
+	opPSHUFW = 436; 
+	opPSLLD = 437; 
+	opPSLLDQ = 438; 
+	opPSLLQ = 439; 
+	opPSLLW = 440; 
+	opPSRAD = 441; 
+	opPSRAW = 442; 
+	opPSRLD = 443; 
+	opPSRLDQ = 444; 
+	opPSRLQ = 445; 
+	opPSRLW = 446; 
+	opPSUBB = 447; 
+	opPSUBD = 448; 
+	opPSUBQ = 449; 
+	opPSUBSB = 450; 
+	opPSUBSW = 451; 
+	opPSUBUSB = 452; 
+	opPSUBUSW = 453; 
+	opPSUBW = 454; 
+	opPSWAPD = 455; 
+	opPUNPCKHBW = 456; 
+	opPUNPCKHDQ = 457; 
+	opPUNPCKHQDQ = 458; 
+	opPUNPCKHWD = 459; 
+	opPUNPCKLBW = 460; 
+	opPUNPCKLDQ = 461; 
+	opPUNPCKLQDQ = 462; 
+	opPUNPCKLWD = 463; 
+	opPUSH* = 464; 
+	opPUSHA = 465; 
+	opPUSHAD = 466; 
+	opPUSHF = 467; 
+	opPUSHFD = 468; 
+	opPUSHFQ = 469; 
+	opPUSHFW = 470; 
+	opPXOR = 471; 
+	opRCL = 472; 
+	opRCPPS = 473; 
+	opRCPSS = 474; 
+	opRCR = 475; 
+	opRDMSR = 476; 
+	opRDPMC = 477; 
+	opRDTSC = 478; 
+	opRDTSCP = 479; 
+	opRET* = 480; 
+	opRETF = 481; 
+	opROL* = 482; 
+	opROR* = 483; 
+	opRSM = 484; 
+	opRSQRTPS = 485; 
+	opRSQRTSS = 486; 
+	opSAHF = 487; 
+	opSAL* = 488; 
+	opSAR* = 489; 
+	opSBB* = 490; 
+	opSCAS = 491; 
+	opSCASB = 492; 
+	opSCASD = 493; 
+	opSCASQ = 494; 
+	opSCASW = 495; 
+	opSETA* = 496; 
+	opSETAE* = 497; 
+	opSETB* = 498; 
+	opSETBE* = 499; 
+	opSETC* = 500; 
+	opSETE* = 501; 
+	opSETG* = 502; 
+	opSETGE* = 503; 
+	opSETL* = 504; 
+	opSETLE* = 505; 
+	opSETNA = 506; 
+	opSETNAE = 507; 
+	opSETNB = 508; 
+	opSETNBE = 509; 
+	opSETNC* = 510; 
+	opSETNE* = 511; 
+	opSETNG = 512; 
+	opSETNGE = 513; 
+	opSETNL = 514; 
+	opSETNLE = 515; 
+	opSETNO = 516; 
+	opSETNP = 517; 
+	opSETNS = 518; 
+	opSETNZ = 519; 
+	opSETO = 520; 
+	opSETP = 521; 
+	opSETPE = 522; 
+	opSETPO = 523; 
+	opSETS = 524; 
+	opSETZ = 525; 
+	opSFENCE = 526; 
+	opSGDT = 527; 
+	opSHL* = 528; 
+	opSHLD = 529; 
+	opSHR* = 530; 
+	opSHRD = 531; 
+	opSHUFPD = 532; 
+	opSHUFPS = 533; 
+	opSIDT = 534; 
+	opSKINIT = 535; 
+	opSLDT = 536; 
+	opSMSW = 537; 
+	opSQRTPD = 538; 
+	opSQRTPS = 539; 
+	opSQRTSD = 540; 
+	opSQRTSS = 541; 
+	opSTC = 542; 
+	opSTD* = 543; 
+	opSTGI = 544; 
+	opSTI = 545; 
+	opSTMXCSR = 546; 
+	opSTOS = 547; 
+	opSTOSB = 548; 
+	opSTOSD = 549; 
+	opSTOSQ = 550; 
+	opSTOSW = 551; 
+	opSTR = 552; 
+	opSUB* = 553; 
+	opSUBPD = 554; 
+	opSUBPS = 555; 
+	opSUBSD* = 556; 
+	opSUBSS* = 557; 
+	opSWAPGS = 558; 
+	opSYSCALL = 559; 
+	opSYSENTER = 560; 
+	opSYSEXIT = 561; 
+	opSYSRET = 562; 
+	opTEST = 563; 
+	opUCOMISD = 564; 
+	opUCOMISS = 565; 
+	opUD2 = 566; 
+	opUNPCKHPD = 567; 
+	opUNPCKHPS = 568; 
+	opUNPCKLPD = 569; 
+	opUNPCKLPS = 570; 
+	opVERR = 571; 
+	opVERW = 572; 
+	opVMLOAD = 573; 
+	opVMMCALL = 574; 
+	opVMRUN = 575; 
+	opVMSAVE = 576; 
+	opWBINVD = 577; 
+	opWRMSR = 578; 
+	opXADD = 579; 
+	opXCHG = 580; 
+	opXLAT = 581; 
+	opXLATB = 582; 
+	opXOR* = 583; 
+	opXORPD* = 584; 
+	opXORPS* = 585; 
+TYPE 
+	Name = ARRAY 20 OF CHAR; 
+
+	OperandType* = LONGINT; 
+
+	CPUOptions* = SET; 
+
+	Instruction = RECORD 
+		cpuoptions-: CPUOptions; 
+		options-: SET; 
+		opcode-: ARRAY 9 OF CHAR; 
+		operands-: ARRAY maxOperands OF OperandType; 
+		opCount-: LONGINT; 
+	END; 
+
+	Mnemonic = RECORD 
+		name-: ARRAY maxMnemonicNameLength OF CHAR; 
+		firstInstr-, lastInstr-: LONGINT; 
+	END; 
+
+	CPUType = RECORD 
+		name-: Name; 
+		cpuoptions-: CPUOptions; 
+	END; 
+
+	Register = RECORD 
+		name-: Name; 
+		type-: OperandType; 
+		index-: LONGINT; 
+	END; 
+VAR 
+	mnemonics-: ARRAY maxMnemonics OF Mnemonic; 
+	mnemCount: LONGINT; 
+	instructions-: ARRAY maxInstructions OF Instruction; 
+	instrCount: LONGINT; 
+	registers-: ARRAY maxRegisters OF Register; 
+	regCount: LONGINT; 
+	cpus-: ARRAY maxCPUs OF CPUType; 
+	cpuCount: LONGINT; 
+
+	PROCEDURE ^ FindMnem*(CONST mnem: ARRAY OF CHAR): LONGINT; 
+	PROCEDURE ^ FindReg*(CONST reg: ARRAY OF CHAR): LONGINT; 
+	PROCEDURE ^ FindCPU*(CONST cpu: ARRAY OF CHAR): LONGINT; 
+	PROCEDURE ^ Mnem(CONST name: ARRAY OF CHAR); 
+	PROCEDURE ^ Instr(op1, op2, op3: OperandType; CONST opcode: ARRAY OF CHAR; options: SET; cpuoptions: CPUOptions); 
+	PROCEDURE ^ Reg(CONST name: ARRAY OF CHAR; type: OperandType; index: LONGINT); 
+	PROCEDURE ^ Cpu(CONST name: ARRAY OF CHAR; cpuoptions: SET); 
+BEGIN
+END ASMAMD64.

WinAos/obg/ASN1.SymW

@@ -0,0 +1,52 @@
+MODULE ASN1;
+	IMPORT Streams;
+CONST 
+	Trace = FALSE; 
+	ASN1Universal* = 0; 
+	ASN1Application* = 1; 
+	ASN1Context* = 2; 
+	ASN1Private* = 3; 
+	Boolean* = 1; 
+	Integer* = 2; 
+	BitString* = 3; 
+	String* = 4; 
+	Null* = 5; 
+	Oid* = 6; 
+	UTF8* = 12; 
+	PrintableString* = 19; 
+	TeletexString* = 20; 
+	IA5String* = 22; 
+	UTCTime* = 23; 
+	BMPString* = 30; 
+	Sequence* = 48; 
+	Set* = 49; 
+TYPE 
+	CharString* = POINTER TO ARRAY OF CHAR; 
+
+	Triplet* = OBJECT 
+	VAR 
+		tag*: LONGINT; 
+		class*: LONGINT; 
+		length*: LONGINT; 
+		unusedbits*: LONGINT; 
+		constructed*: BOOLEAN; 
+		definite*: BOOLEAN; 
+		bvalue*: BOOLEAN; 
+		ivalue*: LONGINT; 
+		svalue*: POINTER TO ARRAY OF CHAR; 
+		child*, curchild: Triplet; 
+		next*: Triplet; 
+		level*: LONGINT; 
+
+		PROCEDURE ^ AppendChild*(t: Triplet); 
+		PROCEDURE ^ Print*(w: Streams.Writer); 
+	END Triplet; 
+VAR 
+	log*: Streams.Writer; 
+
+	PROCEDURE ^ PrintHexString*(w: Streams.Writer; CONST s: ARRAY OF CHAR); 
+	PROCEDURE ^ PrintNumericString*(w: Streams.Writer; CONST s: ARRAY OF CHAR); 
+	PROCEDURE ^ PrintString*(w: Streams.Writer; CONST s: ARRAY OF CHAR); 
+	PROCEDURE ^ Decode*(reader: Streams.Reader; level: LONGINT; VAR len: LONGINT): Triplet; 
+BEGIN
+END ASN1.

WinAos/obg/AVI.SymW

@@ -0,0 +1,170 @@
+MODULE AVI;
+	IMPORT SYSTEM, Machine, Streams, KernelLog, AOC := Codecs;
+CONST 
+	Debug = FALSE; 
+	DefaultReaderSize = 4096; 
+	WriteError = 2907; 
+TYPE 
+	MainAVIHeaderDesc* = OBJECT 
+	VAR 
+		microSecsPerFrame*: LONGINT; 
+		maxBytesPerSec*: LONGINT; 
+		reserved1*: LONGINT; 
+		flags*: LONGINT; 
+		totalFrames*: LONGINT; 
+		initialFrames*: LONGINT; 
+		streams*: LONGINT; 
+		suggestedBufferSize*: LONGINT; 
+		width*: LONGINT; 
+		height*: LONGINT; 
+		reserved*: ARRAY 4 OF LONGINT; 
+	END MainAVIHeaderDesc; 
+
+	AVIStreamHeader* = OBJECT 
+	VAR 
+		fccType*: ARRAY 4 OF CHAR; 
+		fccHandler*: ARRAY 4 OF CHAR; 
+		flags*: LONGINT; 
+		priority*: LONGINT; 
+		initialFrames*: LONGINT; 
+		scale*: LONGINT; 
+		rate*: LONGINT; 
+		start*: LONGINT; 
+		length*: LONGINT; 
+		suggestedBufferSize*: LONGINT; 
+		quality*: LONGINT; 
+		sampleSize*: LONGINT; 
+		left*: LONGINT; 
+		top*: LONGINT; 
+		right*: LONGINT; 
+		bottom*: LONGINT; 
+		streamIdentifier*: ARRAY 4 OF CHAR; 
+		bitMapInfo*: BitMapInfo; 
+		waveFormatEx*: WAVEFormatEx; 
+	END AVIStreamHeader; 
+
+	BitMapInfo = OBJECT 
+	VAR 
+		size*: LONGINT; 
+		width*: LONGINT; 
+		height*: LONGINT; 
+		planes*: LONGINT; 
+		bitCount*: LONGINT; 
+		compression*: LONGINT; 
+		sizeImage*: LONGINT; 
+		xPelsPerMeter*: LONGINT; 
+		yPelsPerMeter*: LONGINT; 
+		clrUsed*: LONGINT; 
+		clrImportant*: LONGINT; 
+	END BitMapInfo; 
+
+	WAVEFormatEx* = OBJECT 
+	VAR 
+		formatTag*: LONGINT; 
+		channels*: LONGINT; 
+		samplesPerSec*: LONGINT; 
+		avgBytesPerSec*: LONGINT; 
+		blockAlign*: LONGINT; 
+		bitsPerSample*: LONGINT; 
+		cbSize*: LONGINT; 
+	END WAVEFormatEx; 
+
+	AVIIndexEntry* = RECORD 
+		ckid*: LONGINT; 
+		flags*: LONGINT; 
+		offset*: LONGINT; 
+		length*: LONGINT; 
+		tot*: LONGINT; 
+	END; 
+
+	IndexArrayPointer* = POINTER TO ARRAY OF AVIIndexEntry; 
+
+	AVIStream* = OBJECT (AOC.DemuxStream)
+	VAR 
+		bufAdr: LONGINT; 
+		r: Streams.Reader; 
+		chunkSize*: LONGINT; 
+		streamHeader: AVIStreamHeader; 
+		stuffByte*: LONGINT; 
+		eof*: BOOLEAN; 
+
+		PROCEDURE ^  & Init*(r: Streams.Reader; streamHdr: AVIStreamHeader); 
+		PROCEDURE ^ CanSetPos*(): BOOLEAN; 
+		PROCEDURE ^ CompareCharArrays(ar1, ar2: ARRAY OF CHAR; len: LONGINT): BOOLEAN; 
+		PROCEDURE ^ ReadNextChunk(VAR buf: ARRAY OF CHAR); 
+		PROCEDURE ^ Resynch*(VAR buf: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ Pos*(): LONGINT; 
+		PROCEDURE ^ SetAVIPos*(pos: LONGINT; VAR retPos: LONGINT); 
+		PROCEDURE ^ Bytes*(VAR x: ARRAY OF CHAR; ofs, size: LONGINT; VAR len: LONGINT); 
+		PROCEDURE ^ SetPos*(pos: LONGINT); 
+	END AVIStream; 
+
+	AVIDemux* = OBJECT (AOC.AVDemultiplexer)
+	VAR 
+		r: Streams.Reader; 
+		filename*: ARRAY 256 OF CHAR; 
+		aviHeader: MainAVIHeaderDesc; 
+		audioStreamHeader: AVIStreamHeader; 
+		videoStreamHeader: AVIStreamHeader; 
+		riffLength: LONGINT; 
+		movieBeginPos: LONGINT; 
+		indexStart: LONGINT; 
+		videoFrames: LONGINT; 
+		audioChunks: LONGINT; 
+		videoIndex: IndexArrayPointer; 
+		audioIndex: IndexArrayPointer; 
+		audioBytes: LONGINT; 
+		videoBufferIndex: LONGINT; 
+		audioChunkSize: LONGINT; 
+		audioStream: AVIStream; 
+		videoStream: AVIStream; 
+		videoFramePos: LONGINT; 
+		audioFramePos: LONGINT; 
+
+		PROCEDURE ^ Open*(in: Streams.Reader; VAR res: LONGINT); 
+		PROCEDURE ^ GetAVIHeader*(): MainAVIHeaderDesc; 
+		PROCEDURE ^ CompareCharArrays(ar1, ar2: ARRAY OF CHAR; len: LONGINT): BOOLEAN; 
+		PROCEDURE ^ ReadHeader*(): BOOLEAN; 
+		PROCEDURE ^ ReadIndex*; 
+		PROCEDURE ^ SkipHeader*; 
+		PROCEDURE ^ ReadMainAVIHeader(): MainAVIHeaderDesc; 
+		PROCEDURE ^ ReadAVIStreamHeader(): AVIStreamHeader; 
+		PROCEDURE ^ ReadBitMapInfo(): BitMapInfo; 
+		PROCEDURE ^ ReadWaveFormatEx(): WAVEFormatEx; 
+		PROCEDURE ^ DumpHeaders*; 
+		PROCEDURE ^ DumpVideoIndex*; 
+		PROCEDURE ^ DumpAudioIndex*; 
+		PROCEDURE ^ GetAudioStreamHeader*(): AVIStreamHeader; 
+		PROCEDURE ^ GetVideoStreamHeader*(): AVIStreamHeader; 
+		PROCEDURE ^ GetStream*(streamNr: LONGINT): AOC.DemuxStream; 
+		PROCEDURE ^ GetMilliSecondsPerFrame*(): LONGINT; 
+		PROCEDURE ^ GetNofChannels*(): LONGINT; 
+		PROCEDURE ^ GetSamplesPerSecond*(): LONGINT; 
+		PROCEDURE ^ GetBitsPerSample*(): LONGINT; 
+		PROCEDURE ^ GetVideoIndex*(): IndexArrayPointer; 
+		PROCEDURE ^ GetAudioIndex*(): IndexArrayPointer; 
+		PROCEDURE ^ GetAudioChunks*(): LONGINT; 
+		PROCEDURE ^ GetAudioBytes*(): LONGINT; 
+		PROCEDURE ^ GetVideoFrames*(): LONGINT; 
+		PROCEDURE ^ GetNumberOfStreams*(): LONGINT; 
+		PROCEDURE ^ GetStreamInfo*(streamNr: LONGINT): AOC.AVStreamInfo; 
+		PROCEDURE ^ GetStreamType*(streamNr: LONGINT): LONGINT; 
+		PROCEDURE ^ GetInfo*(VAR vl, vf, vr, mspf, al, af, ar: LONGINT); 
+		PROCEDURE ^ GetData*(streamNr: LONGINT; VAR buf: ARRAY OF CHAR; ofs, size, min: LONGINT; VAR len, res: LONGINT); 
+		PROCEDURE ^ SetStreamPos*(streamNr: LONGINT; seekType: LONGINT; pos: LONGINT; VAR itemSize: LONGINT; VAR res: LONGINT); 
+		PROCEDURE ^ GetVideoWidth*(): LONGINT; 
+		PROCEDURE ^ GetVideoHeight*(): LONGINT; 
+		PROCEDURE ^ GetNextFrameSize*(streamNr: LONGINT): LONGINT; 
+		PROCEDURE ^ GetSampleSize*(): LONGINT; 
+	END AVIDemux; 
+
+	PROCEDURE ^ Align*(VAR index: LONGINT); 
+	PROCEDURE ^ IsAligned*(index: LONGINT): BOOLEAN; 
+	PROCEDURE ^ ShowBitsSlow*(n: LONGINT; VAR buf: ARRAY OF CHAR; VAR index: LONGINT): LONGINT; 
+	PROCEDURE ^ ShowBits*(n: LONGINT; VAR buf: ARRAY OF CHAR; VAR index: LONGINT): LONGINT; 
+	PROCEDURE ^ ShowBitsByteAligned*(n: LONGINT; VAR buf: ARRAY OF CHAR; VAR index: LONGINT): LONGINT; 
+	PROCEDURE ^ GetBits*(n: LONGINT; VAR buf: ARRAY OF CHAR; VAR index: LONGINT): LONGINT; 
+	PROCEDURE ^ SkipBits*(n: LONGINT; VAR index: LONGINT); 
+	PROCEDURE ^ Factory*(): AOC.AVDemultiplexer; 
+BEGIN
+END AVI.

WinAos/obg/ActiveTimers.SymW

@@ -0,0 +1,19 @@
+MODULE ActiveTimers;
+	IMPORT Objects;
+TYPE 
+	Timer* = OBJECT {EXCLUSIVE} 
+	VAR 
+		timer: Objects.Timer; 
+		handler: Objects.EventHandler; 
+		timeout, running: BOOLEAN; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ SetTimeout*(h: Objects.EventHandler; ms: LONGINT); 
+		PROCEDURE ^ CancelTimeout*; 
+		PROCEDURE ^ HandleTimeout; 
+		PROCEDURE ^ Finalize*; 
+	BEGIN{ACTIVE} 
+	END Timer; 
+
+BEGIN
+END ActiveTimers.

WinAos/obg/AlmSmtpReceiver.SymW

@@ -0,0 +1,143 @@
+MODULE AlmSmtpReceiver;
+	IMPORT DNS, Files, Streams, IP, Modules, KernelLog, TCP, TCPServices, Dates, Strings;
+CONST 
+	AlmSmtpReceiverPort = 25; 
+	MaxActive = (3 + 1); 
+	ID = \"BlueBottle Receiver "\; 
+	Version = \"MailBottle (0.2.00.16)"\; 
+	Rcp = \".Rcp"\; 
+	Msg = \".Msg"\; 
+	Log = \".Log"\; 
+	ConfigFileName = \"mail.config"\; 
+	ToDisk = TRUE; 
+	DebugMsg = FALSE; 
+	RcptInFileName = TRUE; 
+	MaxUserName = 11; 
+	Prefix = \"In."\; 
+	AlwaysAccept = \"129.132.178.196"\; 
+	EOF = 0X; 
+	maxLexLen = 127; 
+	noSym = 13; 
+	maxP = 13; 
+	maxT = 13; 
+	nrSets = 3; 
+	setSize = 32; 
+	nSets = ((maxT DIV setSize) + 1); 
+	SyEol = 1; 
+	SyCopy = 2; 
+	SyHelo = 3; 
+	SyQuit = 4; 
+	SyNoop = 5; 
+	SyRset = 6; 
+	SyData = 7; 
+	SyDot = 8; 
+	SyRcpt = 9; 
+	SyTo = 10; 
+	SyMail = 11; 
+	SyFrom = 12; 
+	SyTimeout = 14; 
+	Tab = 9X; 
+	LF = 0AX; 
+	CR = 0DX; 
+TYPE 
+	ErrorProc* = PROCEDURE (n: INTEGER); 
+
+	StartTable = ARRAY 128 OF INTEGER; 
+
+	SymbolSet = ARRAY nSets OF SET; 
+
+	String = ARRAY 128 OF CHAR; 
+
+	TokenPtr = POINTER TO Token; 
+
+	Token = RECORD 
+		s: String; 
+		next: TokenPtr; 
+	END; 
+
+	EnvelopePtr = POINTER TO Envelope; 
+
+	Envelope = RECORD 
+		mta, revMta, from: String; 
+		to: TokenPtr; 
+	END; 
+
+	Message* = RECORD 
+		env*: EnvelopePtr; 
+		file*: Files.File; 
+	END; 
+
+	SmtpAgent* = OBJECT {EXCLUSIVE} (TCPServices.Agent)
+	VAR 
+		ch: CHAR; 
+		res: LONGINT; 
+		out: Streams.Writer; 
+		in: Streams.Reader; 
+		log: Files.Writer; 
+		env: Envelope; 
+		thisName, verbSy: String; 
+		finished: BOOLEAN; 
+		sym: INTEGER; 
+		state: INTEGER; 
+		badTokens: LONGINT; 
+		auxString: String; 
+
+		PROCEDURE ^ GetCh(): CHAR; 
+		PROCEDURE ^ ConsumeName; 
+		PROCEDURE ^ AvailableName; 
+		PROCEDURE ^ OpenLog; 
+		PROCEDURE ^ ToMemory*(VAR token: ARRAY OF CHAR); 
+		PROCEDURE ^ DebugMsg1*(msg: ARRAY OF CHAR); 
+		PROCEDURE ^ PutStatus1*(msg: ARRAY OF CHAR); 
+		PROCEDURE ^ ChangeStatus1*(newsym: INTEGER; msg: ARRAY OF CHAR); 
+		PROCEDURE ^ PutStatus2*(msg0, msg1: ARRAY OF CHAR); 
+		PROCEDURE ^ ChangeStatus2*(newsym: INTEGER; msg0, msg1: ARRAY OF CHAR); 
+		PROCEDURE ^ AddExt*(VAR name: String; ext: ARRAY OF CHAR); 
+		PROCEDURE ^ PutBareName(name: String; VAR wr: Files.Writer); 
+		PROCEDURE ^ PutEnvelope(name: String); 
+		PROCEDURE ^ UpdateName(VAR s: String); 
+		PROCEDURE ^ HELO*; 
+		PROCEDURE ^ RSET*; 
+		PROCEDURE ^ NOOP*; 
+		PROCEDURE ^ QUIT*; 
+		PROCEDURE ^ RCPT*; 
+		PROCEDURE ^ Test; 
+		PROCEDURE ^ ToFile(name: String); 
+		PROCEDURE ^ DATA*(name: String); 
+		PROCEDURE ^ AddUserToName(VAR thisName: String); 
+		PROCEDURE ^ MAIL*; 
+		PROCEDURE ^ reset; 
+		PROCEDURE ^ Get; 
+		PROCEDURE ^ ErrMsg(msg: String); 
+		PROCEDURE ^ Error1(n: INTEGER); 
+		PROCEDURE ^ Error2(n, sym: INTEGER); 
+		PROCEDURE ^ Confirm(n: INTEGER); 
+		PROCEDURE ^ Expect(n: INTEGER); 
+		PROCEDURE ^ StartOf(s: INTEGER): BOOLEAN; 
+		PROCEDURE ^ Who; 
+		PROCEDURE ^ BackStagePass(pass: String): BOOLEAN; 
+	BEGIN{ACTIVE} 
+	END SmtpAgent; 
+VAR 
+	errors*: INTEGER; 
+	lasterror*: INTEGER; 
+	charcount: LONGINT; 
+	getCalls: LONGINT; 
+	start: StartTable; 
+	Pattern, Ack: ARRAY 6 OF CHAR; 
+	active: LONGINT; 
+	symSet: ARRAY nrSets OF SymbolSet; 
+	smtp: TCPServices.Service; 
+	nextName: String; 
+
+	PROCEDURE ^ ToLog0(msg: String); 
+	PROCEDURE ^ InitSmtpSTable; 
+	PROCEDURE ^ NewSmtpAgent(c: TCP.Connection; s: TCPServices.Service): TCPServices.Agent; 
+	PROCEDURE ^ GetRegistry(VAR filename: String); 
+	PROCEDURE ^ PutRegistry(VAR filename: String); 
+	PROCEDURE ^ Announce(VAR out: Streams.Writer); 
+	PROCEDURE ^ Open*; 
+	PROCEDURE ^ Close*; 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END AlmSmtpReceiver.

WinAos/obg/AnimationCodec.SymW

@@ -0,0 +1,51 @@
+MODULE AnimationCodec;
+	IMPORT Streams, KernelLog, Strings, Files, Codecs, XML, XMLScanner, XMLParser, WMGraphics;
+CONST 
+	Version = \"ANI09a"\; 
+	HeaderMissing* = 20001; 
+	HeaderError* = 20002; 
+	WrongVersion* = 20003; 
+	FormatError* = 20004; 
+	ImageNotFound* = 20010; 
+	XmlHeader = \"Header"\; 
+	XmlVersion = \"version"\; 
+	XmlWidth = \"width"\; 
+	XmlHeight = \"height"\; 
+	XmlBackgroundColor = \"bgcolor"\; 
+	XmlFrames = \"Frames"\; 
+	XmlFrame = \"Frame"\; 
+	XmlImageName = \"image"\; 
+	XmlLeft = \"x"\; 
+	XmlTop = \"y"\; 
+	XmlDelayTime = \"time"\; 
+	XmlDisposeMode = \"mode"\; 
+	XmlFrom = \"from"\; 
+	XmlTo = \"to"\; 
+	Debug = TRUE; 
+TYPE 
+	Settings = RECORD 
+		x, y: LONGINT; 
+		time, mode: LONGINT; 
+	END; 
+
+	Decoder* = OBJECT (Codecs.AnimationDecoder)
+	VAR 
+		animation: XML.Element; 
+		width, height, bgcolor: LONGINT; 
+		default: Settings; 
+		error: BOOLEAN; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ RestoreDefaultSettings; 
+		PROCEDURE ^ ReportError(pos, line, col: LONGINT; CONST msg: ARRAY OF CHAR); 
+		PROCEDURE ^ Open*(in: Streams.Reader; VAR res: LONGINT); 
+		PROCEDURE ^ ProcessFrame(frame: XML.Element; VAR desc: Codecs.ImageDescriptor; VAR res: LONGINT); 
+		PROCEDURE ^ ProcessFrames(frames: XML.Element; VAR sequence: Codecs.ImageSequence; VAR res: LONGINT); 
+		PROCEDURE ^ GetImageSequence*(VAR sequence: Codecs.ImageSequence; VAR res: LONGINT); 
+	END Decoder; 
+
+	PROCEDURE ^ GenerateFilename(CONST base: ARRAY OF CHAR; VAR filename: ARRAY OF CHAR; suffix, minDigits: LONGINT); 
+	PROCEDURE ^ GetInteger(element: XML.Element; CONST attributeName: ARRAY OF CHAR; VAR value: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GenDecoder*(): Codecs.AnimationDecoder; 
+BEGIN
+END AnimationCodec.

WinAos/obg/Archives.SymW

@@ -0,0 +1,42 @@
+MODULE Archives;
+	IMPORT Configuration, Strings, Streams;
+CONST 
+	ArchiveNameSize = 128; 
+TYPE 
+	StringObject* = OBJECT 
+	VAR 
+		value-: ARRAY 256 OF CHAR; 
+
+		PROCEDURE ^  & Init*(CONST name: ARRAY OF CHAR); 
+	END StringObject; 
+
+	EntryInfo* = OBJECT 
+
+		PROCEDURE ^ GetName*(): Strings.String; 
+		PROCEDURE ^ GetSize*(): LONGINT; 
+		PROCEDURE ^ GetInfoString*(): Strings.String; 
+	END EntryInfo; 
+
+	Index* = POINTER TO ARRAY OF EntryInfo; 
+
+	Archive* = OBJECT 
+	VAR 
+		name*: ARRAY ArchiveNameSize OF CHAR; 
+
+		PROCEDURE ^ Acquire*; 
+		PROCEDURE ^ Release*; 
+		PROCEDURE ^ GetIndex*(): Index; 
+		PROCEDURE ^ GetEntryInfo*(CONST name: ARRAY OF CHAR): EntryInfo; 
+		PROCEDURE ^ RemoveEntry*(CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ RenameEntry*(CONST from, to: ARRAY OF CHAR): EntryInfo; 
+		PROCEDURE ^ OpenSender*(CONST name: ARRAY OF CHAR): Streams.Sender; 
+		PROCEDURE ^ OpenReceiver*(CONST name: ARRAY OF CHAR): Streams.Receiver; 
+		PROCEDURE ^ Copy*(CONST name: ARRAY OF CHAR): Archive; 
+	END Archive; 
+
+	FactoryProcedure = PROCEDURE (name: StringObject):Archive; 
+
+	PROCEDURE ^ Old*(CONST name, type: ARRAY OF CHAR): Archive; 
+	PROCEDURE ^ New*(CONST name, type: ARRAY OF CHAR): Archive; 
+BEGIN
+END Archives.

WinAos/obg/Array1dBytes.SymW

@@ -0,0 +1,188 @@
+MODULE Array1dBytes;
+	IMPORT SYSTEM;
+TYPE 
+	Bytes* = POINTER TO ARRAY OF SYSTEM.BYTE; 
+
+	Byte* = SYSTEM.BYTE; 
+
+	Word* = ARRAY 2 OF SYSTEM.BYTE; 
+
+	DWord* = ARRAY 4 OF SYSTEM.BYTE; 
+
+	QWord* = ARRAY 8 OF SYSTEM.BYTE; 
+
+	PROCEDURE  - AdrCheck*(adr, lower, size: LONGINT);
+	CODE {SYSTEM.i386}
+		MOV	ECX, [ESP]	;  upper
+		MOV	EBX, [ESP+4]	;  lower
+		MOV	EAX, [ESP+8]	;  adr
+		CMP	EAX, EBX
+		JAE	lowerok	;  offset >= adr?
+		PUSH	7
+		INT	3
+		lowerok: ;  offset >= adr
+		ADD	ECX, EBX
+		CMP	EAX, ECX
+		JB	upperok	;  offset < upper?
+		PUSH	7
+		INT	3
+		upperok: ;  offset < upper
+		ADD	ESP, 12	;  adjust stack pointer(inline procedure!)
+	
+	END AdrCheck; 
+	PROCEDURE  - RangeCheck*(offset, len, upper: LONGINT);
+	CODE {SYSTEM.i386}
+		MOV	ECX, [ESP]	;  upper
+		MOV	EBX, [ESP+4]	;  len
+		MOV	EAX, [ESP+8]	;  offset
+		CMP	EAX, 0
+		JAE	lowerok	;  offset >= 0?
+		PUSH	7
+		INT	3
+		lowerok: ;  offset >= 0
+		CMP	EBX, 0
+		JAE	lenok	;  len >= 0?
+		PUSH	7
+		INT	3
+		lenok: ;  len >= 0
+		ADD	EAX, EBX
+		CMP	EAX, ECX
+		JBE	upperok	;  offset+len <= upper?
+		PUSH	7
+		INT	3
+		upperok: ;  offset+len <= upper
+		ADD	ESP, 12	;  adjust stack pointer(inline procedure!)
+	
+	END RangeCheck; 
+	PROCEDURE  - RangeCheck2*(x, y, w, h, width, height: LONGINT);
+	CODE {SYSTEM.i386}
+		MOV	ECX, [ESP]	;  upper = height
+		MOV	EBX, [ESP+8]	;  len = h
+		MOV	EAX, [ESP+16]	;  offset = y
+		CMP	EAX, 0
+		JAE	lowerok	;  offset >= 0?
+		PUSH	7
+		INT	3
+		lowerok: ;  offset >= 0
+		CMP	EBX, 0
+		JAE	lenok	;  len >= 0?
+		PUSH	7
+		INT	3
+		lenok: ;  len >= 0
+		ADD	EAX, EBX
+		CMP	EAX, ECX
+		JBE	upperok	;  offset+len <= upper?
+		PUSH	7
+		INT	3
+		upperok: ;  offset+len <= upper
+		MOV	ECX, [ESP+4]	;  upper = width
+		MOV	EBX, [ESP+12]	;  len = w
+		MOV	EAX, [ESP+20]	;  offset = x
+		CMP	EAX, 0
+		JAE	lowerok2	;  offset >= 0?
+		PUSH	7
+		INT	3
+		lowerok2: ;  offset >= 0
+		CMP	EBX, 0
+		JAE	lenok2	;  len >= 0?
+		PUSH	7
+		INT	3
+		lenok2: ;  len >= 0
+		ADD	EAX, EBX
+		CMP	EAX, ECX
+		JBE	upperok2	;  offset+len <= upper?
+		PUSH	7
+		INT	3
+		upperok2: ;  offset+len <= upper
+		ADD	ESP, 24	;  adjust stack pointer(inline procedure!)
+	
+	END RangeCheck2; 
+	PROCEDURE  - PatRangeCheck*(offset, step, piecelen, pieces, upper: LONGINT);
+	CODE {SYSTEM.i386}
+		MOV	EDI, [ESP]	;  upper
+		MOV	EDX, [ESP+4]	;  pieces
+		MOV	ECX, [ESP+8]	;  piecelen
+		MOV	EBX, [ESP+12]	;  step
+		MOV	EAX, [ESP+16]	;  offset
+		CMP	EBX, 0
+		JAE	piecesok	;  pieces >= 0?
+		PUSH	7
+		INT	3
+		piecesok: ;  pieces >= 0
+		CMP	ECX, 0
+		JA	piecelenok	;  piecelen > 0?
+		PUSH	7
+		INT	3
+		piecelenok: ;  piecelen > 0
+		CMP	EBX, ECX
+		JAE	stepok	;  step >= piecelen?
+		PUSH	7
+		INT	3
+		stepok: ;  step >= piecelen > 0
+		CMP	EAX, 0
+		JAE	lowerok	;  offset >= 0?
+		PUSH	7
+		INT	3
+		lowerok: ;  offset >= 0
+		CMP	EDX, 0
+		JE	nocalc	;  pieces = 0?
+		DEC	EDX
+		IMUL	EDX, EBX	;  EDX := (pieces-1)*step	;
+		ADD	EDX, ECX	;  INC(EDX, piecelen)
+		ADD	EDX, EAX	;  INC(EDX, offset)
+		nocalc:
+		CMP	EDX, EDI
+		JBE	upperok	;  offset+(pieces-1)*step+piecelen <= upper?
+		PUSH	7
+		INT	3
+		upperok:
+		ADD	ESP, 20	;  adjust stack pointer(inline procedure!)
+	
+	END PatRangeCheck; 
+	PROCEDURE  - MoveB*(srcadr, destadr, len: LONGINT);
+	CODE {SYSTEM.i386}
+		MOV	ECX, [ESP]	;  len
+		MOV	EDI, [ESP+4]	;  destadr
+		MOV	ESI, [ESP+8]	;  srcadr
+		CMP	ESI, EDI
+		JAE	moveup	;  src adr greater then dest adr, no problem with moving up
+		MOV	EAX, ESI
+		ADD	EAX, ECX
+		CMP	EAX, EDI
+		JBE	moveup	;  no overlap, no problem, move up
+		MOV	ESI, EAX
+		ADD	EDI, ECX
+		DEC	ESI
+		DEC	EDI
+		STD	;  move down since overlap occured
+		REP
+		MOVSB
+		JMP	done
+		moveup:
+		CLD
+		MOV	BL, CL
+		SHR	ECX, 2
+		AND	BL, 00000003H	;  rest to move after 4 byte move
+		REP
+		MOVSD	;  move 4 bytes each step
+		MOV	CL, BL
+		REP
+		MOVSB	;  move rest in one byte steps
+		done:
+		ADD	ESP, 12	;  adjust stack pointer(inline procedure!)
+	
+	END MoveB; 
+	PROCEDURE ^ MoveBPat*(srcadr, destadr, srcstep, deststep, piecelen, pieces: LONGINT); 
+	PROCEDURE ^ FillB*(adr: LONGINT; byte: SYSTEM.BYTE; count: LONGINT); 
+	PROCEDURE ^ FillBPat*(adr: LONGINT; byte: SYSTEM.BYTE; step, piecelen, pieces: LONGINT); 
+	PROCEDURE ^ FillW*(adr: LONGINT; word: Word; count: LONGINT); 
+	PROCEDURE ^ FillWPat*(adr: LONGINT; word: Word; step, piecelen, pieces: LONGINT); 
+	PROCEDURE ^ FillD*(adr: LONGINT; dword: DWord; count: LONGINT); 
+	PROCEDURE ^ FillDPat*(adr: LONGINT; dword: DWord; step, piecelen, pieces: LONGINT); 
+	PROCEDURE ^ FillQ*(adr: LONGINT; qword: QWord; count: LONGINT); 
+	PROCEDURE ^ FillG*(adr: LONGINT; VAR data: ARRAY OF SYSTEM.BYTE; count: LONGINT); 
+	PROCEDURE ^ FillGPat*(adr: LONGINT; VAR data: ARRAY OF SYSTEM.BYTE; step, piecelen, pieces: LONGINT); 
+	PROCEDURE ^ Fill*(adr: LONGINT; VAR data: ARRAY OF SYSTEM.BYTE; len: LONGINT); 
+	PROCEDURE ^ FillPat*(adr: LONGINT; VAR data: ARRAY OF SYSTEM.BYTE; step, piecelen, pieces: LONGINT); 
+BEGIN
+END Array1dBytes.

WinAos/obg/Array1dCplx.SymW

@@ -0,0 +1,125 @@
+MODULE Array1dCplx;
+	IMPORT SYSTEM, Array1dBytes, NbrCplx, NbrRe, NbrRat, NbrInt, DataErrors, Array1dInt, Array1dRat, Array1dRe;
+CONST 
+	assertSrcIndexCheck* = 1000; 
+	assertDestIndexCheck* = 1001; 
+	sz = SIZEOF(Value); 
+TYPE 
+	Value* = NbrCplx.Complex; 
+
+	RealValue* = NbrRe.Real; 
+
+	Array* = POINTER TO ARRAY OF Value; 
+
+	Index* = LONGINT; 
+
+	Map* = PROCEDURE {DELEGATE}(VAR i: Value); 
+
+	PROCEDURE ^ Copy*(VAR x: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CreateCopy*(VAR x: ARRAY OF Value): Array; 
+	PROCEDURE ^ CopyPat*(VAR x: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ CreateCopyPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Array; 
+	PROCEDURE ^ Fill*(x: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ FillPat*(x: Value; VAR res: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Negate*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ NegatePat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Abs*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ AbsPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ AddAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ MultAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ScalarProduct*(VAR x, y: ARRAY OF Value; VAR res: Value; offset, len: Index); 
+	PROCEDURE ^ DivAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ EqualsAA*(VAR x, y: ARRAY OF Value; offset, len: Index): BOOLEAN; 
+	PROCEDURE ^ AddAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ AddAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ SubtractAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ SubtractVA*(VAR x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ MultAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ MultAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivVA*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ ApplyMap*(map: Map; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ApplyMapPat*(map: Map; VAR res: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ MeanSsq*(VAR x: ARRAY OF Value; offset, len: Index; VAR mean: Value; VAR ssq: RealValue); 
+	PROCEDURE ^ HammingWeight*(VAR x: ARRAY OF Value; offset, len: Index): Index; 
+	PROCEDURE ^ HammingWeightPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Index; 
+	PROCEDURE ^ HammingDist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Index; 
+	PROCEDURE ^ L1Norm*(VAR x: ARRAY OF Value; offset, len: Index): RealValue; 
+	PROCEDURE ^ L1NormPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): RealValue; 
+	PROCEDURE ^ L1Dist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): RealValue; 
+	PROCEDURE ^ L2NormSq*(VAR x: ARRAY OF Value; offset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2Norm*(VAR x: ARRAY OF Value; offset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2NormPatSq*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): NbrRe.Real; 
+	PROCEDURE ^ L2NormPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): NbrRe.Real; 
+	PROCEDURE ^ L2DistSq*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2Dist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ LInftyNorm*(VAR x: ARRAY OF Value; offset, len: Index): RealValue; 
+	PROCEDURE ^ LInftyNormPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): RealValue; 
+	PROCEDURE ^ LInftyDist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): RealValue; 
+	PROCEDURE ^ MinIndex(x, y: Index): Index; 
+	PROCEDURE ^ SetLen*(VAR a: Array; len: Index); 
+	PROCEDURE ^ RemoveBlock*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ InsertBlock*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ShiftBlock*(VAR x: ARRAY OF Value; from, to, len: Index); 
+	PROCEDURE ^ RemovePat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: LONGINT): Array; 
+	PROCEDURE ^ Remove*(VAR x: ARRAY OF Value; offset, len: LONGINT): Array; 
+	PROCEDURE ^ InsertPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: LONGINT): Array; 
+	PROCEDURE ^ Insert*(VAR x: ARRAY OF Value; offset, len: LONGINT): Array; 
+	PROCEDURE ^ GetPieces*(VAR a: ARRAY OF Value; offset, step, piecelen: LONGINT): LONGINT; 
+	PROCEDURE ^ SortByIndex*(VAR x: ARRAY OF Value; VAR index: ARRAY OF Index; offset, len: Index); 
+	OPERATOR ^ "-"-(x: Array): Array; 
+	OPERATOR ^ "~"-(x: Array): Array; 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array1dRe.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array1dRat.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array1dInt.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF NbrRe.Real); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF NbrRat.Rational); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF NbrInt.Integer); 
+	OPERATOR ^ "="-(l: Array; VAR r: ARRAY OF Value): BOOLEAN; 
+	OPERATOR ^ "="-(VAR l: ARRAY OF Value; r: Array): BOOLEAN; 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array1dRe.Array): Array; 
+	OPERATOR ^ "+"-(l: Array1dRe.Array; r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array1dRat.Array): Array; 
+	OPERATOR ^ "+"-(l: Array1dRat.Array; r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array1dInt.Array): Array; 
+	OPERATOR ^ "+"-(l: Array1dInt.Array; r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "+"-(r: Value; l: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "-"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array1dRe.Array): Array; 
+	OPERATOR ^ "-"-(l: Array1dRe.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array1dRat.Array): Array; 
+	OPERATOR ^ "-"-(l: Array1dRat.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array1dInt.Array): Array; 
+	OPERATOR ^ "-"-(l: Array1dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l, r: Array): Value; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dRe.Array): NbrCplx.Complex; 
+	OPERATOR ^ "*"-(l: Array1dRe.Array; r: Array): NbrCplx.Complex; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dRat.Array): NbrCplx.Complex; 
+	OPERATOR ^ "*"-(l: Array1dRat.Array; r: Array): NbrCplx.Complex; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dInt.Array): NbrCplx.Complex; 
+	OPERATOR ^ "*"-(l: Array1dInt.Array; r: Array): NbrCplx.Complex; 
+	OPERATOR ^ "*"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "*"-(l: NbrRe.Real; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrRe.Real): Array; 
+	OPERATOR ^ "*"-(l: NbrRat.Rational; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrRat.Rational): Array; 
+	OPERATOR ^ "*"-(l: NbrInt.Integer; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrInt.Integer): Array; 
+	OPERATOR ^ "/"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrRe.Real): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrRat.Rational): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrInt.Integer): Array; 
+BEGIN
+END Array1dCplx.

WinAos/obg/Array1dInt.SymW

@@ -0,0 +1,113 @@
+MODULE Array1dInt;
+	IMPORT SYSTEM, Array1dBytes, DataErrors, NbrInt, NbrInt64, NbrRe;
+CONST 
+	sz = SIZEOF(Value); 
+TYPE 
+	Value* = NbrInt.Integer; 
+
+	LongerValue* = NbrInt64.Integer; 
+
+	ShorterValue* = INTEGER; 
+
+	RealValue* = NbrRe.Real; 
+
+	Array* = POINTER TO ARRAY OF Value; 
+
+	Index* = LONGINT; 
+
+	Map* = PROCEDURE {DELEGATE}(VAR i: Value); 
+
+	PROCEDURE ^ Copy*(VAR x: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CreateCopy*(VAR x: ARRAY OF Value): Array; 
+	PROCEDURE ^ CopyPat*(VAR x: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ CreateCopyPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Array; 
+	PROCEDURE ^ Fill*(x: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ FillPat*(x: Value; VAR res: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Negate*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ NegatePat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Abs*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ AbsPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ AddAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ MultAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ScalarProduct*(VAR x, y: ARRAY OF Value; VAR res: Value; xoffset, yoffset, len: Index); 
+	PROCEDURE ^ ScalarProductPat*(VAR x, y: ARRAY OF Value; VAR res: Value; xoffset, yoffset, xstep, ystep, piecelen, pieces: Index); 
+	PROCEDURE ^ ModAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ EqualsAA*(VAR x, y: ARRAY OF Value; offset, len: Index): BOOLEAN; 
+	PROCEDURE ^ AddAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ AddAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ SubtractAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ SubtractVA*(VAR x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ MultAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ MultAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivVA*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ ModAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ModAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ ModVA*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ModVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ ApplyMap*(map: Map; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ApplyMapPat*(map: Map; VAR res: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Min*(VAR x: ARRAY OF Value; offset, len: Index; VAR minpos: Index): Value; 
+	PROCEDURE ^ Max*(VAR x: ARRAY OF Value; offset, len: Index; VAR maxpos: Index): Value; 
+	PROCEDURE ^ MinMax*(VAR x: ARRAY OF Value; offset, len: Index; VAR min, max: Value; minpos, maxpos: Index); 
+	PROCEDURE ^ MinMaxPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index; VAR min, max: Value; minpos, maxpos: Index); 
+	PROCEDURE ^ MeanSsq*(VAR x: ARRAY OF Value; offset, len: Index; VAR mean, ssq: RealValue); 
+	PROCEDURE ^ kSmallestModify*(k: Index; VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ kSmallest*(k: Index; VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ Median*(VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ HammingWeight*(VAR x: ARRAY OF Value; offset, len: Index): Index; 
+	PROCEDURE ^ HammingWeightPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Index; 
+	PROCEDURE ^ HammingDist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Index; 
+	PROCEDURE ^ L1Norm*(VAR x: ARRAY OF Value; offset, len: Index): Value; 
+	PROCEDURE ^ L1NormPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Value; 
+	PROCEDURE ^ L1Dist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Value; 
+	PROCEDURE ^ L2NormSq*(VAR x: ARRAY OF Value; offset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2Norm*(VAR x: ARRAY OF Value; offset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2NormPatSq*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): NbrRe.Real; 
+	PROCEDURE ^ L2NormPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): NbrRe.Real; 
+	PROCEDURE ^ L2DistSq*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2Dist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ LInftyNorm*(VAR x: ARRAY OF Value; offset, len: Index): Value; 
+	PROCEDURE ^ LInftyNormPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Value; 
+	PROCEDURE ^ LInftyDist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Value; 
+	PROCEDURE ^ MinIndex(x, y: Index): Index; 
+	PROCEDURE ^ SetLen*(VAR a: Array; len: Index); 
+	PROCEDURE ^ RemoveBlock*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ InsertBlock*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ShiftBlock*(VAR x: ARRAY OF Value; from, to, len: Index); 
+	PROCEDURE ^ RemovePat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: LONGINT): Array; 
+	PROCEDURE ^ Remove*(VAR x: ARRAY OF Value; offset, len: LONGINT): Array; 
+	PROCEDURE ^ InsertPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: LONGINT): Array; 
+	PROCEDURE ^ Insert*(VAR x: ARRAY OF Value; offset, len: LONGINT): Array; 
+	PROCEDURE ^ GetPieces*(VAR a: ARRAY OF Value; offset, step, piecelen: LONGINT): LONGINT; 
+	PROCEDURE ^ Long*(VAR x: ARRAY OF Value; res: ARRAY OF LongerValue; len: Index); 
+	PROCEDURE ^ Short*(VAR x: ARRAY OF Value; res: ARRAY OF ShorterValue; len: Index); 
+	PROCEDURE ^ Sort*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SortWithIndex*(VAR x: ARRAY OF Value; VAR index: ARRAY OF Index; offset, len: Index); 
+	PROCEDURE ^ SortByIndex*(VAR x: ARRAY OF Value; VAR index: ARRAY OF Index; offset, len: Index); 
+	OPERATOR ^ "-"-(x: Array): Array; 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF Value); 
+	OPERATOR ^ "="-(l: Array; VAR r: ARRAY OF Value): BOOLEAN; 
+	OPERATOR ^ "="-(VAR l: ARRAY OF Value; r: Array): BOOLEAN; 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "+"-(r: Value; l: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "-"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	OPERATOR ^ "*"-(l, r: Array): Value; 
+	OPERATOR ^ "*"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "DIV"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "DIV"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "MOD"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "MOD"-(l: Value; r: Array): Array; 
+BEGIN
+END Array1dInt.

WinAos/obg/Array1dRat.SymW

@@ -0,0 +1,108 @@
+MODULE Array1dRat;
+	IMPORT SYSTEM, Array1dBytes, NbrRat, DataErrors, NbrInt, Array1dInt, NbrRe;
+CONST 
+	sz = SIZEOF(Value); 
+TYPE 
+	Value* = NbrRat.Rational; 
+
+	Array* = POINTER TO ARRAY OF Value; 
+
+	Index* = LONGINT; 
+
+	Map* = PROCEDURE {DELEGATE}(VAR i: Value); 
+
+	PROCEDURE ^ Copy*(VAR x: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CreateCopy*(VAR x: ARRAY OF Value): Array; 
+	PROCEDURE ^ CopyPat*(VAR x: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ CreateCopyPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Array; 
+	PROCEDURE ^ Fill*(x: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ FillPat*(x: Value; VAR res: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Negate*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ NegatePat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Abs*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ AbsPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ AddAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ MultAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ScalarProduct*(VAR x, y: ARRAY OF Value; VAR res: Value; xoffset, yoffset, len: Index); 
+	PROCEDURE ^ ScalarProductPat*(VAR x, y: ARRAY OF Value; VAR res: Value; xoffset, yoffset, xstep, ystep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ EqualsAA*(VAR x, y: ARRAY OF Value; offset, len: Index): BOOLEAN; 
+	PROCEDURE ^ AddAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ AddAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ SubtractAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ SubtractVA*(VAR x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ MultAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ MultAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivVA*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ ApplyMap*(map: Map; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ApplyMapPat*(map: Map; VAR res: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Min*(VAR x: ARRAY OF Value; offset, len: Index; VAR minpos: Index): Value; 
+	PROCEDURE ^ Max*(VAR x: ARRAY OF Value; offset, len: Index; VAR maxpos: Index): Value; 
+	PROCEDURE ^ MinMax*(VAR x: ARRAY OF Value; offset, len: Index; VAR min, max: Value; minpos, maxpos: Index); 
+	PROCEDURE ^ MinMaxPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index; VAR min, max: Value; minpos, maxpos: Index); 
+	PROCEDURE ^ MeanSsq*(VAR x: ARRAY OF Value; offset, len: Index; VAR mean, ssq: Value); 
+	PROCEDURE ^ kSmallestModify*(k: Index; VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ kSmallest*(k: Index; VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ Median*(VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ HammingWeight*(VAR x: ARRAY OF Value; offset, len: Index): Index; 
+	PROCEDURE ^ HammingWeightPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Index; 
+	PROCEDURE ^ HammingDist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Index; 
+	PROCEDURE ^ L1Norm*(VAR x: ARRAY OF Value; offset, len: Index): Value; 
+	PROCEDURE ^ L1NormPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Value; 
+	PROCEDURE ^ L1Dist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Value; 
+	PROCEDURE ^ L2NormSq*(VAR x: ARRAY OF Value; offset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2Norm*(VAR x: ARRAY OF Value; offset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2NormPatSq*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): NbrRe.Real; 
+	PROCEDURE ^ L2NormPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): NbrRe.Real; 
+	PROCEDURE ^ L2DistSq*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2Dist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ LInftyNorm*(VAR x: ARRAY OF Value; offset, len: Index): Value; 
+	PROCEDURE ^ LInftyNormPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Value; 
+	PROCEDURE ^ LInftyDist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Value; 
+	PROCEDURE ^ MinIndex(x, y: Index): Index; 
+	PROCEDURE ^ SetLen*(VAR a: Array; len: Index); 
+	PROCEDURE ^ RemoveBlock*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ InsertBlock*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ShiftBlock*(VAR x: ARRAY OF Value; from, to, len: Index); 
+	PROCEDURE ^ RemovePat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: LONGINT): Array; 
+	PROCEDURE ^ Remove*(VAR x: ARRAY OF Value; offset, len: LONGINT): Array; 
+	PROCEDURE ^ InsertPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: LONGINT): Array; 
+	PROCEDURE ^ Insert*(VAR x: ARRAY OF Value; offset, len: LONGINT): Array; 
+	PROCEDURE ^ GetPieces*(VAR a: ARRAY OF Value; offset, step, piecelen: LONGINT): LONGINT; 
+	PROCEDURE ^ Sort*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SortWithIndex*(VAR x: ARRAY OF Value; VAR index: ARRAY OF Index; offset, len: Index); 
+	PROCEDURE ^ SortByIndex*(VAR x: ARRAY OF Value; VAR index: ARRAY OF Index; offset, len: Index); 
+	OPERATOR ^ "-"-(x: Array): Array; 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array1dInt.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF NbrInt.Integer); 
+	OPERATOR ^ "="-(l: Array; VAR r: ARRAY OF Value): BOOLEAN; 
+	OPERATOR ^ "="-(VAR l: ARRAY OF Value; r: Array): BOOLEAN; 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "+"-(r: Value; l: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array1dInt.Array): Array; 
+	OPERATOR ^ "+"-(l: Array1dInt.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "-"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array1dInt.Array): Array; 
+	OPERATOR ^ "-"-(l: Array1dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l, r: Array): Value; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dInt.Array): NbrRat.Rational; 
+	OPERATOR ^ "*"-(l: Array1dInt.Array; r: Array): NbrRat.Rational; 
+	OPERATOR ^ "*"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "*"-(l: NbrInt.Integer; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrInt.Integer): Array; 
+	OPERATOR ^ "/"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrInt.Integer): Array; 
+BEGIN
+END Array1dRat.

WinAos/obg/Array1dRe.SymW

@@ -0,0 +1,124 @@
+MODULE Array1dRe;
+	IMPORT SYSTEM, Array1dBytes, NbrRe, DataErrors, Array1dInt, Array1dRat, NbrInt, NbrRat;
+CONST 
+	sz = SIZEOF(Value); 
+TYPE 
+	Value* = NbrRe.Real; 
+
+	LongerValue* = LONGREAL; 
+
+	RealValue* = NbrRe.Real; 
+
+	Array* = POINTER TO ARRAY OF Value; 
+
+	Index* = LONGINT; 
+
+	Map* = PROCEDURE {DELEGATE}(VAR i: Value); 
+
+	PROCEDURE ^ Copy*(VAR x: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CreateCopy*(VAR x: ARRAY OF Value): Array; 
+	PROCEDURE ^ CopyPat*(VAR x: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ CreateCopyPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Array; 
+	PROCEDURE ^ Fill*(x: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ FillPat*(x: Value; VAR res: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Negate*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ NegatePat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Abs*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ AbsPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ AddAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ MultAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ScalarProduct*(VAR x, y: ARRAY OF Value; VAR res: Value; xoffset, yoffset, len: Index); 
+	PROCEDURE ^ ScalarProductPat*(VAR x, y: ARRAY OF Value; VAR res: Value; xoffset, yoffset, xstep, ystep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivAA*(VAR x, y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ EqualsAA*(VAR x, y: ARRAY OF Value; offset, len: Index): BOOLEAN; 
+	PROCEDURE ^ AddAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ AddAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ SubtractAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ SubtractVA*(VAR x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SubtractVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ MultAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ MultAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivAV*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivAVPat*(VAR x: ARRAY OF Value; y: Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ DivVA*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ DivVAPat*(x: Value; VAR y: ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, srcstep, destoffset, deststep, piecelen, pieces: Index); 
+	PROCEDURE ^ ApplyMap*(map: Map; VAR res: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ApplyMapPat*(map: Map; VAR res: ARRAY OF Value; offset, step, piecelen, pieces: Index); 
+	PROCEDURE ^ Min*(VAR x: ARRAY OF Value; offset, len: Index; VAR minpos: Index): Value; 
+	PROCEDURE ^ Max*(VAR x: ARRAY OF Value; offset, len: Index; VAR maxpos: Index): Value; 
+	PROCEDURE ^ MinMax*(VAR x: ARRAY OF Value; offset, len: Index; VAR min, max: Value; minpos, maxpos: Index); 
+	PROCEDURE ^ MinMaxPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index; VAR min, max: Value; minpos, maxpos: Index); 
+	PROCEDURE ^ MeanSsq*(VAR x: ARRAY OF Value; offset, len: Index; VAR mean, ssq: Value); 
+	PROCEDURE ^ kSmallestModify*(k: Index; VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ kSmallest*(k: Index; VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ Median*(VAR a: ARRAY OF Value; len: LONGINT): Value; 
+	PROCEDURE ^ HammingWeight*(VAR x: ARRAY OF Value; offset, len: Index): Index; 
+	PROCEDURE ^ HammingWeightPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Index; 
+	PROCEDURE ^ HammingDist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Index; 
+	PROCEDURE ^ L1Norm*(VAR x: ARRAY OF Value; offset, len: Index): Value; 
+	PROCEDURE ^ L1NormPat*(map: Map; VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Value; 
+	PROCEDURE ^ L1Dist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Value; 
+	PROCEDURE ^ L2NormSq*(VAR x: ARRAY OF Value; offset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2Norm*(VAR x: ARRAY OF Value; offset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2NormPatSq*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): NbrRe.Real; 
+	PROCEDURE ^ L2NormPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): NbrRe.Real; 
+	PROCEDURE ^ L2DistSq*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ L2Dist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): NbrRe.Real; 
+	PROCEDURE ^ LInftyNorm*(VAR x: ARRAY OF Value; offset, len: Index): Value; 
+	PROCEDURE ^ LInftyNormPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: Index): Value; 
+	PROCEDURE ^ LInftyDist*(VAR x, y: ARRAY OF Value; xoffset, yoffset, len: Index): Value; 
+	PROCEDURE ^ MinIndex(x, y: Index): Index; 
+	PROCEDURE ^ SetLen*(VAR a: Array; len: Index); 
+	PROCEDURE ^ RemoveBlock*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ InsertBlock*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ ShiftBlock*(VAR x: ARRAY OF Value; from, to, len: Index); 
+	PROCEDURE ^ RemovePat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: LONGINT): Array; 
+	PROCEDURE ^ Remove*(VAR x: ARRAY OF Value; offset, len: LONGINT): Array; 
+	PROCEDURE ^ InsertPat*(VAR x: ARRAY OF Value; offset, step, piecelen, pieces: LONGINT): Array; 
+	PROCEDURE ^ Insert*(VAR x: ARRAY OF Value; offset, len: LONGINT): Array; 
+	PROCEDURE ^ GetPieces*(VAR a: ARRAY OF Value; offset, step, piecelen: LONGINT): LONGINT; 
+	PROCEDURE ^ Long*(VAR x: ARRAY OF Value; res: ARRAY OF LongerValue; len: Index); 
+	PROCEDURE ^ Sort*(VAR x: ARRAY OF Value; offset, len: Index); 
+	PROCEDURE ^ SortWithIndex*(VAR x: ARRAY OF Value; VAR index: ARRAY OF Index; offset, len: Index); 
+	PROCEDURE ^ SortByIndex*(VAR x: ARRAY OF Value; VAR index: ARRAY OF Index; offset, len: Index); 
+	OPERATOR ^ "-"-(x: Array): Array; 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array1dRat.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array1dInt.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF NbrRat.Rational); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF NbrInt.Integer); 
+	OPERATOR ^ "="-(l: Array; VAR r: ARRAY OF Value): BOOLEAN; 
+	OPERATOR ^ "="-(VAR l: ARRAY OF Value; r: Array): BOOLEAN; 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array1dRat.Array): Array; 
+	OPERATOR ^ "+"-(l: Array1dRat.Array; r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array1dInt.Array): Array; 
+	OPERATOR ^ "+"-(l: Array1dInt.Array; r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "+"-(r: Value; l: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "-"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array1dRat.Array): Array; 
+	OPERATOR ^ "-"-(l: Array1dRat.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array1dInt.Array): Array; 
+	OPERATOR ^ "-"-(l: Array1dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l, r: Array): Value; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dRat.Array): NbrRe.Real; 
+	OPERATOR ^ "*"-(l: Array1dRat.Array; r: Array): NbrRe.Real; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dInt.Array): NbrRe.Real; 
+	OPERATOR ^ "*"-(l: Array1dInt.Array; r: Array): NbrRe.Real; 
+	OPERATOR ^ "*"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "*"-(l: NbrRat.Rational; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrRat.Rational): Array; 
+	OPERATOR ^ "*"-(l: NbrInt.Integer; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrInt.Integer): Array; 
+	OPERATOR ^ "/"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrRat.Rational): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrInt.Integer): Array; 
+BEGIN
+END Array1dRe.

WinAos/obg/Array2dCplx.SymW

@@ -0,0 +1,77 @@
+MODULE Array2dCplx;
+	IMPORT SYSTEM, Array1dBytes, NbrInt, NbrRat, NbrRe, NbrCplx, Array1dRe, Array1d := Array1dCplx, Array1dInt, Array2dInt, Array1dRat, Array2dRat, Array2dRe, Array1dCplx, ArrayXd := ArrayXdCplx, DataErrors;
+CONST 
+TYPE 
+	Value* = Array1d.Value; 
+
+	RealValue* = NbrRe.Real; 
+
+	Array* = ArrayXd.Array2; 
+
+	Index* = NbrInt.Integer; 
+
+	PROCEDURE ^ Copy*(VAR src: ARRAY OF ARRAY OF Value; VAR dest: ARRAY OF ARRAY OF Value; srcx, srcy, destx, desty, w, h: Index); 
+	PROCEDURE ^ Fill*(val: Value; VAR res: ARRAY OF ARRAY OF Value; x, y, w, h: Index); 
+	PROCEDURE ^ MeanSsq*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index; VAR mean: Value; VAR ssq: RealValue); 
+	PROCEDURE ^ CopyRow*(y: Index; VAR s: ARRAY OF ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyCol*(x: Index; VAR s: ARRAY OF ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyToRow*(VAR s: ARRAY OF Value; y: Index; VAR res: ARRAY OF ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyToCol*(VAR s: ARRAY OF Value; x: Index; VAR res: ARRAY OF ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ Row*(y: Index; VAR s: ARRAY OF ARRAY OF Value): Array1d.Array; 
+	PROCEDURE ^ Col*(x: Index; VAR s: ARRAY OF ARRAY OF Value): Array1d.Array; 
+	PROCEDURE ^ Transposed*(VAR s: ARRAY OF ARRAY OF Value): Array; 
+	PROCEDURE ^ SwapRows*(VAR s: ARRAY OF ARRAY OF Value; y1, y2: Index); 
+	PROCEDURE ^ SwapCols*(VAR s: ARRAY OF ARRAY OF Value; x1, x2: Index); 
+	OPERATOR ^ "-"-(x: Array): Array; 
+	OPERATOR ^ "~"-(x: Array): Array; 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array2dRe.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array2dRat.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array2dInt.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF NbrCplx.Complex); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF NbrRe.Real); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF NbrRat.Rational); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF NbrInt.Integer); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array2dRe.Array): Array; 
+	OPERATOR ^ "+"-(l: Array2dRe.Array; r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array2dRat.Array): Array; 
+	OPERATOR ^ "+"-(l: Array2dRat.Array; r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "+"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array2dRe.Array): Array; 
+	OPERATOR ^ "-"-(l: Array2dRe.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array2dRat.Array): Array; 
+	OPERATOR ^ "-"-(l: Array2dRat.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "-"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l, r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array2dRe.Array): Array; 
+	OPERATOR ^ "*"-(l: Array2dRe.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array2dRat.Array): Array; 
+	OPERATOR ^ "*"-(l: Array2dRat.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "*"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dCplx.Array): Array1dCplx.Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dRe.Array): Array1dCplx.Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dRat.Array): Array1dCplx.Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dInt.Array): Array1dCplx.Array; 
+	OPERATOR ^ "*"-(l: Array1dCplx.Array; r: Array): Array1dCplx.Array; 
+	OPERATOR ^ "*"-(l: Array1dRe.Array; r: Array): Array1dCplx.Array; 
+	OPERATOR ^ "*"-(l: Array1dRat.Array; r: Array): Array1dCplx.Array; 
+	OPERATOR ^ "*"-(l: Array1dInt.Array; r: Array): Array1dCplx.Array; 
+	OPERATOR ^ "*"-(l: NbrCplx.Complex; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrCplx.Complex): Array; 
+	OPERATOR ^ "*"-(l: NbrRe.Real; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrRe.Real): Array; 
+	OPERATOR ^ "*"-(l: NbrRat.Rational; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrRat.Rational): Array; 
+	OPERATOR ^ "*"-(l: NbrInt.Integer; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrInt.Integer): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrCplx.Complex): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrRe.Real): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrRat.Rational): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrInt.Integer): Array; 
+BEGIN
+END Array2dCplx.

WinAos/obg/Array2dInt.SymW

@@ -0,0 +1,41 @@
+MODULE Array2dInt;
+	IMPORT SYSTEM, Array1dBytes, NbrInt, NbrRe, ArrayXd := ArrayXdInt, Array1d := Array1dInt, DataErrors;
+CONST 
+TYPE 
+	Value* = ArrayXd.Value; 
+
+	RealValue* = NbrRe.Real; 
+
+	Array* = POINTER TO ARRAY OF ARRAY OF Value; 
+
+	Index* = NbrInt.Integer; 
+
+	PROCEDURE ^ Copy*(VAR src: ARRAY OF ARRAY OF Value; VAR dest: ARRAY OF ARRAY OF Value; srcx, srcy, destx, desty, w, h: Index); 
+	PROCEDURE ^ Fill*(val: Value; VAR res: ARRAY OF ARRAY OF Value; x, y, w, h: Index); 
+	PROCEDURE ^ MinMax*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index; VAR min, max: Value; VAR minx, miny, maxx, maxy: Index); 
+	PROCEDURE ^ kSmallest*(k: Index; VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index): Value; 
+	PROCEDURE ^ Median*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index): Value; 
+	PROCEDURE ^ MeanSsq*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index; VAR mean, ssq: RealValue); 
+	PROCEDURE ^ CopyRow*(y: Index; VAR s: ARRAY OF ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyCol*(x: Index; VAR s: ARRAY OF ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyToRow*(VAR s: ARRAY OF Value; y: Index; VAR res: ARRAY OF ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyToCol*(VAR s: ARRAY OF Value; x: Index; VAR res: ARRAY OF ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ Row*(y: Index; VAR s: ARRAY OF ARRAY OF Value): ArrayXd.Array1; 
+	PROCEDURE ^ Col*(x: Index; VAR s: ARRAY OF ARRAY OF Value): ArrayXd.Array1; 
+	PROCEDURE ^ Transposed*(VAR s: ARRAY OF ARRAY OF Value): Array; 
+	PROCEDURE ^ SwapRows*(VAR s: ARRAY OF ARRAY OF Value; y1, y2: Index); 
+	PROCEDURE ^ SwapCols*(VAR s: ARRAY OF ARRAY OF Value; x1, x2: Index); 
+	OPERATOR ^ "-"-(x: Array): Array; 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF Value); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	OPERATOR ^ "*"-(l, r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: ArrayXd.Array1): ArrayXd.Array1; 
+	OPERATOR ^ "*"-(l: ArrayXd.Array1; r: Array): ArrayXd.Array1; 
+	OPERATOR ^ "*"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "DIV"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "MOD"-(l: Array; r: Value): Array; 
+BEGIN
+END Array2dInt.

WinAos/obg/Array2dRat.SymW

@@ -0,0 +1,53 @@
+MODULE Array2dRat;
+	IMPORT SYSTEM, Array1dBytes, NbrInt, NbrRat, NbrRe, Array1d := Array1dRat, ArrayXd := ArrayXdRat, Array1dInt, Array2dInt, DataErrors;
+CONST 
+TYPE 
+	Value* = Array1d.Value; 
+
+	RealValue* = NbrRe.Real; 
+
+	Array* = ArrayXd.Array2; 
+
+	Index* = NbrInt.Integer; 
+
+	PROCEDURE ^ Copy*(VAR src: ARRAY OF ARRAY OF Value; VAR dest: ARRAY OF ARRAY OF Value; srcx, srcy, destx, desty, w, h: Index); 
+	PROCEDURE ^ Fill*(val: Value; VAR res: ARRAY OF ARRAY OF Value; x, y, w, h: Index); 
+	PROCEDURE ^ MinMax*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index; VAR min, max: Value; VAR minx, miny, maxx, maxy: Index); 
+	PROCEDURE ^ kSmallest*(k: Index; VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index): Value; 
+	PROCEDURE ^ Median*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index): Value; 
+	PROCEDURE ^ MeanSsq*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index; VAR mean, ssq: RealValue); 
+	PROCEDURE ^ CopyRow*(y: Index; VAR s: ARRAY OF ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyCol*(x: Index; VAR s: ARRAY OF ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyToRow*(VAR s: ARRAY OF Value; y: Index; VAR res: ARRAY OF ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyToCol*(VAR s: ARRAY OF Value; x: Index; VAR res: ARRAY OF ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ Row*(y: Index; VAR s: ARRAY OF ARRAY OF Value): Array1d.Array; 
+	PROCEDURE ^ Col*(x: Index; VAR s: ARRAY OF ARRAY OF Value): Array1d.Array; 
+	PROCEDURE ^ Transposed*(VAR s: ARRAY OF ARRAY OF Value): Array; 
+	PROCEDURE ^ SwapRows*(VAR s: ARRAY OF ARRAY OF Value; y1, y2: Index); 
+	PROCEDURE ^ SwapCols*(VAR s: ARRAY OF ARRAY OF Value; x1, x2: Index); 
+	OPERATOR ^ "-"-(x: Array): Array; 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array2dInt.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF NbrInt.Integer); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "+"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "-"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l, r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "*"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1d.Array): Array1d.Array; 
+	OPERATOR ^ "*"-(l: Array1d.Array; r: Array): Array1d.Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dInt.Array): Array1d.Array; 
+	OPERATOR ^ "*"-(l: Array1dInt.Array; r: Array): Array1d.Array; 
+	OPERATOR ^ "*"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "*"-(l: NbrInt.Integer; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrInt.Integer): Array; 
+	OPERATOR ^ "/"-(l: Array; r: Value): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrInt.Integer): Array; 
+BEGIN
+END Array2dRat.

WinAos/obg/Array2dRe.SymW

@@ -0,0 +1,64 @@
+MODULE Array2dRe;
+	IMPORT SYSTEM, Array1dBytes, NbrInt, NbrRat, NbrRe, Array1d := Array1dRe, ArrayXd := ArrayXdRe, Array1dInt, Array2dInt, Array1dRat, Array2dRat, Array1dRe, DataErrors;
+CONST 
+TYPE 
+	Value* = Array1d.Value; 
+
+	Array* = ArrayXd.Array2; 
+
+	Index* = NbrInt.Integer; 
+
+	PROCEDURE ^ Copy*(VAR src: ARRAY OF ARRAY OF Value; VAR dest: ARRAY OF ARRAY OF Value; srcx, srcy, destx, desty, w, h: Index); 
+	PROCEDURE ^ Fill*(val: Value; VAR res: ARRAY OF ARRAY OF Value; x, y, w, h: Index); 
+	PROCEDURE ^ MinMax*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index; VAR min, max: Value; VAR minx, miny, maxx, maxy: Index); 
+	PROCEDURE ^ kSmallest*(k: Index; VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index): Value; 
+	PROCEDURE ^ Median*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index): Value; 
+	PROCEDURE ^ MeanSsq*(VAR s: ARRAY OF ARRAY OF Value; x, y, w, h: Index; VAR mean, ssq: Value); 
+	PROCEDURE ^ CopyRow*(y: Index; VAR s: ARRAY OF ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyCol*(x: Index; VAR s: ARRAY OF ARRAY OF Value; VAR res: ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyToRow*(VAR s: ARRAY OF Value; y: Index; VAR res: ARRAY OF ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ CopyToCol*(VAR s: ARRAY OF Value; x: Index; VAR res: ARRAY OF ARRAY OF Value; srcoffset, destoffset, len: Index); 
+	PROCEDURE ^ Row*(y: Index; VAR s: ARRAY OF ARRAY OF Value): Array1d.Array; 
+	PROCEDURE ^ Col*(x: Index; VAR s: ARRAY OF ARRAY OF Value): Array1d.Array; 
+	PROCEDURE ^ Transposed*(VAR s: ARRAY OF ARRAY OF Value): Array; 
+	PROCEDURE ^ SwapRows*(VAR s: ARRAY OF ARRAY OF Value; y1, y2: Index); 
+	PROCEDURE ^ SwapCols*(VAR s: ARRAY OF ARRAY OF Value; x1, x2: Index); 
+	OPERATOR ^ "-"-(x: Array): Array; 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array2dRat.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Array2dInt.Array); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF NbrRe.Real); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF NbrRat.Rational); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF NbrInt.Integer); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array2dRat.Array): Array; 
+	OPERATOR ^ "+"-(l: Array2dRat.Array; r: Array): Array; 
+	OPERATOR ^ "+"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "+"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array2dRat.Array): Array; 
+	OPERATOR ^ "-"-(l: Array2dRat.Array; r: Array): Array; 
+	OPERATOR ^ "-"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "-"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l, r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array2dRat.Array): Array; 
+	OPERATOR ^ "*"-(l: Array2dRat.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array2dInt.Array): Array; 
+	OPERATOR ^ "*"-(l: Array2dInt.Array; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dRe.Array): Array1dRe.Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dRat.Array): Array1dRe.Array; 
+	OPERATOR ^ "*"-(l: Array; r: Array1dInt.Array): Array1dRe.Array; 
+	OPERATOR ^ "*"-(l: Array1dRe.Array; r: Array): Array1dRe.Array; 
+	OPERATOR ^ "*"-(l: Array1dRat.Array; r: Array): Array1dRe.Array; 
+	OPERATOR ^ "*"-(l: Array1dInt.Array; r: Array): Array1dRe.Array; 
+	OPERATOR ^ "*"-(l: NbrRe.Real; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrRe.Real): Array; 
+	OPERATOR ^ "*"-(l: NbrRat.Rational; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrRat.Rational): Array; 
+	OPERATOR ^ "*"-(l: NbrInt.Integer; r: Array): Array; 
+	OPERATOR ^ "*"-(l: Array; r: NbrInt.Integer): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrRe.Real): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrRat.Rational): Array; 
+	OPERATOR ^ "/"-(l: Array; r: NbrInt.Integer): Array; 
+BEGIN
+END Array2dRe.

WinAos/obg/ArrayBase.SymW

@@ -0,0 +1,1038 @@
+MODULE ArrayBase;
+	IMPORT KernelLog, SYSTEM, Heaps;
+CONST 
+	debug = FALSE; 
+	conservative = FALSE; 
+	statistics = TRUE; 
+	ptroffs = 0; 
+	adroffs = 4; 
+	flagoffs = 8; 
+	dimoffs = 12; 
+	sizeoffs = 16; 
+	lenoffs = 20; 
+	incoffs = 24; 
+	GeometryMismatch = 400; 
+	DimensionMismatch = 401; 
+	AllocationForbidden = 402; 
+	TensorFlag = 0; 
+	RangeFlag = 1; 
+	TemporaryFlag = 2; 
+	down = 0; 
+	up = 1; 
+	SmallMatrixFlag = 3; 
+	SmallVectorFlag = 3; 
+	Size2Flag = 4; 
+	Size3Flag = 5; 
+	Size4Flag = 6; 
+	Size5Flag = 7; 
+	Size6Flag = 8; 
+	Size7Flag = 9; 
+	Size8Flag = 10; 
+	Mat2x2 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, Size2Flag}); 
+	Mat3x3 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, Size3Flag}); 
+	Mat4x4 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, Size4Flag}); 
+	Mat5x5 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, Size5Flag}); 
+	Mat6x6 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, Size6Flag}); 
+	Mat7x7 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, Size7Flag}); 
+	Mat8x8 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, Size8Flag}); 
+	Vec2 = SYSTEM.VAL(LONGINT, {SmallVectorFlag, Size2Flag}); 
+	Vec3 = SYSTEM.VAL(LONGINT, {SmallVectorFlag, Size3Flag}); 
+	Vec4 = SYSTEM.VAL(LONGINT, {SmallVectorFlag, Size4Flag}); 
+	Vec5 = SYSTEM.VAL(LONGINT, {SmallVectorFlag, Size5Flag}); 
+	Vec6 = SYSTEM.VAL(LONGINT, {SmallVectorFlag, Size6Flag}); 
+	Vec7 = SYSTEM.VAL(LONGINT, {SmallVectorFlag, Size7Flag}); 
+	Vec8 = SYSTEM.VAL(LONGINT, {SmallVectorFlag, Size8Flag}); 
+	MatVec2x2 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, SmallVectorFlag, Size2Flag}); 
+	MatVec3x3 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, SmallVectorFlag, Size3Flag}); 
+	MatVec4x4 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, SmallVectorFlag, Size4Flag}); 
+	MatVec5x5 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, SmallVectorFlag, Size5Flag}); 
+	MatVec6x6 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, SmallVectorFlag, Size6Flag}); 
+	MatVec7x7 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, SmallVectorFlag, Size7Flag}); 
+	MatVec8x8 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, SmallVectorFlag, Size8Flag}); 
+TYPE 
+	Address = LONGINT; 
+
+	UnaryAALoop = PROCEDURE (ladr, dadr, linc, dinc, len: Address); 
+
+	UnaryASLoop = PROCEDURE (ladr, dadr, linc, len: Address); 
+
+	BinaryAAALoop = PROCEDURE (ladr, radr, dadr, linc, rinc, dinc, len: Address); 
+
+	BinaryASALoop = PROCEDURE (ladr, radr, dadr, linc, dinc, len: Address); 
+
+	BinaryAASLoop = PROCEDURE (ladr, radr, dadr, linc, rinc, len: Address); 
+
+	BinaryAABLoop = PROCEDURE (ladr, radr, linc, rinc, len: Address):BOOLEAN; 
+
+	BinaryASBLoop = PROCEDURE (ladr, radr, linc, len: Address):BOOLEAN; 
+
+	FastMatMul* = PROCEDURE (matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT):BOOLEAN; 
+
+	TransposeP* = PROCEDURE (ladr, dadr, lstride, linc, dstride, dinc, rows, cols: LONGINT); 
+
+	T0 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (0 * 8)) OF CHAR; 
+	END; 
+
+	T1 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (1 * 8)) OF CHAR; 
+	END; 
+
+	T2 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (2 * 8)) OF CHAR; 
+	END; 
+
+	T3 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (3 * 8)) OF CHAR; 
+	END; 
+
+	T4 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (4 * 8)) OF CHAR; 
+	END; 
+
+	T5 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (5 * 8)) OF CHAR; 
+	END; 
+
+	T6 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (6 * 8)) OF CHAR; 
+	END; 
+
+	T7 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (7 * 8)) OF CHAR; 
+	END; 
+
+	T8 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (8 * 8)) OF CHAR; 
+	END; 
+
+	T9 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (9 * 8)) OF CHAR; 
+	END; 
+
+	T10 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (10 * 8)) OF CHAR; 
+	END; 
+
+	T11 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (11 * 8)) OF CHAR; 
+	END; 
+
+	T12 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (12 * 8)) OF CHAR; 
+	END; 
+
+	T13 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (13 * 8)) OF CHAR; 
+	END; 
+
+	T14 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (14 * 8)) OF CHAR; 
+	END; 
+
+	T15 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (15 * 8)) OF CHAR; 
+	END; 
+
+	T16 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (16 * 8)) OF CHAR; 
+	END; 
+
+	T17 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (17 * 8)) OF CHAR; 
+	END; 
+
+	T18 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (18 * 8)) OF CHAR; 
+	END; 
+
+	T19 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (19 * 8)) OF CHAR; 
+	END; 
+
+	T20 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (20 * 8)) OF CHAR; 
+	END; 
+
+	T21 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (21 * 8)) OF CHAR; 
+	END; 
+
+	T22 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (22 * 8)) OF CHAR; 
+	END; 
+
+	T23 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (23 * 8)) OF CHAR; 
+	END; 
+
+	T24 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (24 * 8)) OF CHAR; 
+	END; 
+
+	T25 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (25 * 8)) OF CHAR; 
+	END; 
+
+	T26 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (26 * 8)) OF CHAR; 
+	END; 
+
+	T27 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (27 * 8)) OF CHAR; 
+	END; 
+
+	T28 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (28 * 8)) OF CHAR; 
+	END; 
+
+	T29 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (29 * 8)) OF CHAR; 
+	END; 
+
+	T30 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (30 * 8)) OF CHAR; 
+	END; 
+
+	T31 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (31 * 8)) OF CHAR; 
+	END; 
+
+	T32 = POINTER TO RECORD 
+		ptr: ANY; 
+		a: ARRAY (lenoffs + (32 * 8)) OF CHAR; 
+	END; 
+
+	SmallMatMul* = PROCEDURE (dadr, ladr, radr: LONGINT); 
+VAR 
+	alloc*: LONGINT; 
+	allocTemp*: LONGINT; 
+	loopSPAXAX*, loopSPARAR*: BinaryAASLoop; 
+	loopAddAXAX*, loopAddARAR*: BinaryAAALoop; 
+	loopMatMulAXAX*, loopMatMulARAR*: BinaryAASLoop; 
+	loopMatMulIncAXAX*, loopMatMulIncARAR*: BinaryAASLoop; 
+	loopMulAXSX*, loopMulARSR*: BinaryASALoop; 
+	loopIncMulAXSX*, loopIncMulARSR*: BinaryASALoop; 
+	matMulX*, matMulR*: FastMatMul; 
+	matMulIncX*, matMulIncR*: FastMatMul; 
+	transpose4*: TransposeP; 
+	transpose8*: TransposeP; 
+	matMulR2x2*: SmallMatMul; 
+	matMulR3x3*: SmallMatMul; 
+	matMulR4x4*: SmallMatMul; 
+	matVecMulR2x2*: SmallMatMul; 
+	matVecMulR3x3*: SmallMatMul; 
+	matVecMulR4x4*: SmallMatMul; 
+	matMulLR2x2*: SmallMatMul; 
+	matMulLR3x3*: SmallMatMul; 
+	matMulLR4x4*: SmallMatMul; 
+	matVecMulLR2x2*: SmallMatMul; 
+	matVecMulLR3x3*: SmallMatMul; 
+	matVecMulLR4x4*: SmallMatMul; 
+
+	PROCEDURE ^ SetDefaults*; 
+	PROCEDURE ^ Err(CONST s: ARRAY OF CHAR); 
+	PROCEDURE ^ GetArrayDesc(dim: LONGINT): ANY; 
+	PROCEDURE ^ GetInc(base, dim: Address): LONGINT; 
+	PROCEDURE ^ PutInc(base, dim, val: Address); 
+	PROCEDURE ^ GetLen(base, dim: Address): LONGINT; 
+	PROCEDURE ^ PutLen(base, dim, val: Address); 
+	PROCEDURE ^ GetAdr(base: Address): Address; 
+	PROCEDURE ^ PutAdr(base, value: Address); 
+	PROCEDURE ^ GetPtr(base: Address): Address; 
+	PROCEDURE ^ PutPtr(base, value: Address); 
+	PROCEDURE ^ GetSize(base: Address): LONGINT; 
+	PROCEDURE ^ PutSize(base: Address; dim: LONGINT); 
+	PROCEDURE ^ GetDim(base: Address): LONGINT; 
+	PROCEDURE ^ GetFlags(base: Address): SET; 
+	PROCEDURE ^ PutDim(base: Address; dim: LONGINT); 
+	PROCEDURE ^ PutFlags(base: Address; flags: SET); 
+	PROCEDURE ^ Halt(code: LONGINT; left, right, dest: LONGINT); 
+	PROCEDURE ^ FindPattern1(left, dim: Address; VAR d, len, linc: LONGINT); 
+	PROCEDURE ^ FindPattern2(left, right: Address; dim: LONGINT; VAR d, len, linc, ri: LONGINT); 
+	PROCEDURE ^ FindPattern3(left, right, dest: Address; dim: LONGINT; VAR d, len, linc, ri, di: LONGINT); 
+	PROCEDURE ^ Reverse(src: Address; dim: LONGINT); 
+	PROCEDURE ^ CopyUpCompatible(dest, src: Address; VAR modes: SET); 
+	PROCEDURE ^ AllocateTemp(VAR dest: Address; src: Address; Size: LONGINT): ANY; 
+	PROCEDURE ^ ApplyUnaryAAOp(d, l: Address; elementSize: LONGINT; Loop: UnaryAALoop); 
+	PROCEDURE ^ ApplyUnaryASOp(dest, l: Address; Loop: UnaryASLoop); 
+	PROCEDURE ^ ApplyBinaryAAAOp(d, l, r: Address; elementSize: LONGINT; Loop: BinaryAAALoop); 
+	PROCEDURE ^ ApplyBinaryASAOp(d, l, right: Address; elementSize: LONGINT; Loop: BinaryASALoop); 
+	PROCEDURE ^ ApplyBinaryAASOp(dest, l, r: Address; Loop: BinaryAASLoop); 
+	PROCEDURE ^ ApplyBinaryAABOp(l, r: Address; Loop: BinaryAABLoop): BOOLEAN; 
+	PROCEDURE ^ ApplyBinaryASBOp(l, right: Address; Loop: BinaryASBLoop): BOOLEAN; 
+	PROCEDURE ^ Copy4(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ Copy2(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ Copy1(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ Copy8(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE  - MoveB*(srcadr, destadr, len: LONGINT);
+	CODE {SYSTEM.i386}
+		MOV	ECX, [ESP]	;  len
+		MOV	EDI, [ESP+4]	;  destadr
+		MOV	ESI, [ESP+8]	;  srcadr
+		CMP	ESI, EDI
+		JAE	moveup	;  src adr greater then dest adr, no problem with moving up
+		MOV	EAX, ESI
+		ADD	EAX, ECX
+		CMP	EAX, EDI
+		JBE	moveup	;  no overlap, no problem, move up
+		MOV	ESI, EAX
+		ADD	EDI, ECX
+		DEC	ESI
+		DEC	EDI
+		STD	;  move down since overlap occured
+		REP
+		MOVSB
+		JMP	done
+		moveup:
+		CLD
+		MOV	BL, CL
+		SHR	ECX, 2
+		AND	BL, 00000003H	;  rest to move after 4 byte move
+		REP
+		MOVSD	;  move 4 bytes each step
+		MOV	CL, BL
+		REP
+		MOVSB	;  move rest in one byte steps
+		done:
+		ADD	ESP, 12	;  adjust stack pointer(inline procedure!)
+	
+	END MoveB; 
+	PROCEDURE ^ CopyContent(dest, src, elementSize: LONGINT); 
+	PROCEDURE ^ AllocateSame(VAR dest: LONGINT; src: LONGINT; elementsize: LONGINT): ANY; 
+	PROCEDURE ^ TempDescCopy(src: Address): ANY; 
+	PROCEDURE ^ CopyArraySelf*(dest, src: Address; elementsize: LONGINT); 
+	PROCEDURE ^ CopyArray*(dest: Address; src: Address; elementsize: LONGINT); 
+	PROCEDURE ^ CopyTensorSelf*(VAR dest: Address; src: Address; elementsize: LONGINT); 
+	PROCEDURE ^ CopyTensor*(VAR dest: Address; src: Address; elementsize: LONGINT); 
+	PROCEDURE ^ ShallowCopy*(VAR dest: Address; src: Address); 
+	PROCEDURE ^ DescriptorCopy(src, dest: LONGINT); 
+	PROCEDURE ^ ZeroCopyArray*(dest: Address; src: Address; elementsize: LONGINT); 
+	PROCEDURE ^ ZeroCopyTensor*(VAR dest: Address; src: Address; elementsize: LONGINT); 
+	PROCEDURE ^ SameShape(l, r: LONGINT): BOOLEAN; 
+	PROCEDURE ^ Report(CONST name: ARRAY OF CHAR; s: LONGINT); 
+	PROCEDURE ^ ZeroCopy*(left, elementSize, dest, dim: LONGINT); 
+	PROCEDURE ^ ConvertASAILoop(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ConvertASAI*(VAR dest: ARRAY [?] OF INTEGER; CONST src: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ ConvertLoopSL(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ConvertASAL*(VAR dest: ARRAY [?] OF LONGINT; CONST src: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ ConvertLoopSR(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ConvertASAR*(VAR dest: ARRAY [?] OF REAL; CONST src: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ ConvertLoopSX(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ConvertASAX*(VAR dest: ARRAY [?] OF LONGREAL; CONST src: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ ConvertLoopIS(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ConvertAIAS*(VAR dest: ARRAY [?] OF SHORTINT; CONST src: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ ConvertLoopIL(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ConvertAIAL*(VAR dest: ARRAY [?] OF LONGINT; CONST src: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ ConvertLoopIR(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ConvertAIAR*(VAR dest: ARRAY [?] OF REAL; CONST src: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ ConvertLoopIX(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ConvertAIAX*(VAR dest: ARRAY [?] OF LONGREAL; CONST src: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ ConvertLoopLI(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ConvertALAI*(VAR dest: ARRAY [?] OF INTEGER; CONST src: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ ConvertLoopLR(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ConvertALAR*(VAR dest: ARRAY [?] OF REAL; CONST src: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ ConvertLoopLX(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ConvertALAX*(VAR dest: ARRAY [?] OF LONGREAL; CONST src: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ ConvertLoopRL(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ConvertARAL*(VAR dest: ARRAY [?] OF LONGINT; CONST src: ARRAY [?] OF REAL); 
+	PROCEDURE ^ ConvertLoopRX(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ConvertARAX*(VAR dest: ARRAY [?] OF LONGREAL; CONST src: ARRAY [?] OF REAL); 
+	PROCEDURE ^ ConvertLoopXR(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ConvertAXAR*(VAR dest: ARRAY [?] OF REAL; CONST src: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ ConvertLoopXL(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ConvertAXAL*(VAR dest: ARRAY [?] OF LONGINT; CONST src: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ NotLoopAB(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ NotAB*(VAR dest: ARRAY [?] OF BOOLEAN; CONST src: ARRAY [?] OF BOOLEAN); 
+	PROCEDURE ^ MinusLoopS(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ MinusAS*(VAR dest: ARRAY [?] OF SHORTINT; CONST src: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ MinusLoopI(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ MinusAI*(VAR dest: ARRAY [?] OF INTEGER; CONST src: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ MinusLoopL(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ MinusAL*(VAR dest: ARRAY [?] OF LONGINT; CONST src: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ MinusLoopR(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ MinusAR*(VAR dest: ARRAY [?] OF REAL; CONST src: ARRAY [?] OF REAL); 
+	PROCEDURE ^ MinusLoopX(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ MinusAX*(VAR dest: ARRAY [?] OF LONGREAL; CONST src: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ AddASASLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ AddASAS*(VAR dest: ARRAY [?] OF SHORTINT; CONST left, right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ AddAIAILoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ AddAIAI*(VAR dest: ARRAY [?] OF INTEGER; CONST left, right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ AddALALLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ AddALAL*(VAR dest: ARRAY [?] OF LONGINT; CONST left, right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ AddARARLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ AddARAR*(VAR dest: ARRAY [?] OF REAL; CONST left, right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ AddAXAXLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ AddAXAX*(VAR dest: ARRAY [?] OF LONGREAL; CONST left, right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ AddASSSLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ AddASSS*(VAR dest: ARRAY [?] OF SHORTINT; CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT); 
+	PROCEDURE ^ AddSSAS*(VAR dest: ARRAY [?] OF SHORTINT; left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ AddAISILoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ AddAISI*(VAR dest: ARRAY [?] OF INTEGER; CONST left: ARRAY [?] OF INTEGER; right: INTEGER); 
+	PROCEDURE ^ AddSIAI*(VAR dest: ARRAY [?] OF INTEGER; left: INTEGER; CONST right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ AddALSLLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ AddALSL*(VAR dest: ARRAY [?] OF LONGINT; CONST left: ARRAY [?] OF LONGINT; right: LONGINT); 
+	PROCEDURE ^ AddSLAL*(VAR dest: ARRAY [?] OF LONGINT; left: LONGINT; CONST right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ AddARSRLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ AddARSR*(VAR dest: ARRAY [?] OF REAL; CONST left: ARRAY [?] OF REAL; right: REAL); 
+	PROCEDURE ^ AddSRAR*(VAR dest: ARRAY [?] OF REAL; left: REAL; CONST right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ AddAXSXLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ AddAXSX*(VAR dest: ARRAY [?] OF LONGREAL; CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL); 
+	PROCEDURE ^ AddSXAX*(VAR dest: ARRAY [?] OF LONGREAL; left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ SubASASLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ SubASAS*(VAR dest: ARRAY [?] OF SHORTINT; CONST left, right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ SubAIAILoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ SubAIAI*(VAR dest: ARRAY [?] OF INTEGER; CONST left, right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ SubALALLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ SubALAL*(VAR dest: ARRAY [?] OF LONGINT; CONST left, right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ SubARARLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ SubARAR*(VAR dest: ARRAY [?] OF REAL; CONST left, right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ SubAXAXLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ SubAXAX*(VAR dest: ARRAY [?] OF LONGREAL; CONST left, right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ SubASSS*(VAR dest: ARRAY [?] OF SHORTINT; CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT); 
+	PROCEDURE ^ SubAISI*(VAR dest: ARRAY [?] OF INTEGER; CONST left: ARRAY [?] OF INTEGER; right: INTEGER); 
+	PROCEDURE ^ SubALSL*(VAR dest: ARRAY [?] OF LONGINT; CONST left: ARRAY [?] OF LONGINT; right: LONGINT); 
+	PROCEDURE ^ SubARSR*(VAR dest: ARRAY [?] OF REAL; CONST left: ARRAY [?] OF REAL; right: REAL); 
+	PROCEDURE ^ SubAXSX*(VAR dest: ARRAY [?] OF LONGREAL; CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL); 
+	PROCEDURE ^ SubSSASLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ SubSSAS*(VAR dest: ARRAY [?] OF SHORTINT; left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ SubSIAILoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ SubSIAI*(VAR dest: ARRAY [?] OF INTEGER; left: INTEGER; CONST right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ SubSLALLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ SubSLAL*(VAR dest: ARRAY [?] OF LONGINT; left: LONGINT; CONST right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ SubSRARLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ SubSRAR*(VAR dest: ARRAY [?] OF REAL; left: REAL; CONST right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ SubSXAXLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ SubSXAX*(VAR dest: ARRAY [?] OF LONGREAL; left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ EMulASASLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EMulASAS*(VAR dest: ARRAY [?] OF SHORTINT; CONST left, right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ EMulAIAILoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EMulAIAI*(VAR dest: ARRAY [?] OF INTEGER; CONST left, right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ EMulALALLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EMulALAL*(VAR dest: ARRAY [?] OF LONGINT; CONST left, right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ EMulARARLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EMulARAR*(VAR dest: ARRAY [?] OF REAL; CONST left, right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ EMulAXAXLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EMulAXAX*(VAR dest: ARRAY [?] OF LONGREAL; CONST left, right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ EMulIncASASLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EMulIncASAS*(VAR dest: ARRAY [?] OF SHORTINT; CONST left, right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ EMulIncAIAILoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EMulIncAIAI*(VAR dest: ARRAY [?] OF INTEGER; CONST left, right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ EMulIncALALLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EMulIncALAL*(VAR dest: ARRAY [?] OF LONGINT; CONST left, right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ EMulIncARARLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EMulIncARAR*(VAR dest: ARRAY [?] OF REAL; CONST left, right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ EMulIncAXAXLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EMulIncAXAX*(VAR dest: ARRAY [?] OF LONGREAL; CONST left, right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ MulASSSLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ MulASSS*(VAR dest: ARRAY [?] OF SHORTINT; CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT); 
+	PROCEDURE ^ MulSSAS*(VAR dest: ARRAY [?] OF SHORTINT; left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ MulAISILoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ MulAISI*(VAR dest: ARRAY [?] OF INTEGER; CONST left: ARRAY [?] OF INTEGER; right: INTEGER); 
+	PROCEDURE ^ MulSIAI*(VAR dest: ARRAY [?] OF INTEGER; left: INTEGER; CONST right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ MulALSLLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ MulALSL*(VAR dest: ARRAY [?] OF LONGINT; CONST left: ARRAY [?] OF LONGINT; right: LONGINT); 
+	PROCEDURE ^ MulSLAL*(VAR dest: ARRAY [?] OF LONGINT; left: LONGINT; CONST right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ MulARSRLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ MulARSR*(VAR dest: ARRAY [?] OF REAL; CONST left: ARRAY [?] OF REAL; right: REAL); 
+	PROCEDURE ^ MulSRAR*(VAR dest: ARRAY [?] OF REAL; left: REAL; CONST right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ MulAXSXLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ MulAXSX*(VAR dest: ARRAY [?] OF LONGREAL; CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL); 
+	PROCEDURE ^ MulSXAX*(VAR dest: ARRAY [?] OF LONGREAL; left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ IncMulASSSLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ IncMulASSS*(VAR dest: ARRAY [?] OF SHORTINT; CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT); 
+	PROCEDURE ^ IncMulSSAS*(VAR dest: ARRAY [?] OF SHORTINT; left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ DecMulASSS*(VAR dest: ARRAY [?] OF SHORTINT; CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT); 
+	PROCEDURE ^ DecMulSSAS*(VAR dest: ARRAY [?] OF SHORTINT; left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ IncMulAISILoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ IncMulAISI*(VAR dest: ARRAY [?] OF INTEGER; CONST left: ARRAY [?] OF INTEGER; right: INTEGER); 
+	PROCEDURE ^ IncMulSIAI*(VAR dest: ARRAY [?] OF INTEGER; left: INTEGER; CONST right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ DecMulAISI*(VAR dest: ARRAY [?] OF INTEGER; CONST left: ARRAY [?] OF INTEGER; right: INTEGER); 
+	PROCEDURE ^ DecMulSIAI*(VAR dest: ARRAY [?] OF INTEGER; left: INTEGER; CONST right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ IncMulALSLLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ IncMulALSL*(VAR dest: ARRAY [?] OF LONGINT; CONST left: ARRAY [?] OF LONGINT; right: LONGINT); 
+	PROCEDURE ^ IncMulSLAL*(VAR dest: ARRAY [?] OF LONGINT; left: LONGINT; CONST right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ DecMulALSL*(VAR dest: ARRAY [?] OF LONGINT; CONST left: ARRAY [?] OF LONGINT; right: LONGINT); 
+	PROCEDURE ^ DecMulSLAL*(VAR dest: ARRAY [?] OF LONGINT; left: LONGINT; CONST right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ IncMulARSRLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ IncMulARSR*(VAR dest: ARRAY [?] OF REAL; CONST left: ARRAY [?] OF REAL; right: REAL); 
+	PROCEDURE ^ IncMulSRAR*(VAR dest: ARRAY [?] OF REAL; left: REAL; CONST right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ DecMulARSR*(VAR dest: ARRAY [?] OF REAL; CONST left: ARRAY [?] OF REAL; right: REAL); 
+	PROCEDURE ^ DecMulSRAR*(VAR dest: ARRAY [?] OF REAL; left: REAL; CONST right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ IncMulAXSXLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ IncMulAXSX*(VAR dest: ARRAY [?] OF LONGREAL; CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL); 
+	PROCEDURE ^ IncMulSXAX*(VAR dest: ARRAY [?] OF LONGREAL; left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ DecMulAXSX*(VAR dest: ARRAY [?] OF LONGREAL; CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL); 
+	PROCEDURE ^ DecMulSXAX*(VAR dest: ARRAY [?] OF LONGREAL; left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ EDivideASASLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EDivideASAS*(VAR dest: ARRAY [?] OF REAL; CONST left, right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ EDivideAIAILoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EDivideAIAI*(VAR dest: ARRAY [?] OF REAL; CONST left, right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ EDivideALALLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EDivideALAL*(VAR dest: ARRAY [?] OF REAL; CONST left, right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ EDivideARARLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EDivideARAR*(VAR dest: ARRAY [?] OF REAL; CONST left, right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ EDivideAXAXLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EDivideAXAX*(VAR dest: ARRAY [?] OF LONGREAL; CONST left, right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ DivideASSSLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ DivideASSS*(VAR dest: ARRAY [?] OF REAL; CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT); 
+	PROCEDURE ^ DivideSSASLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ DivideSSAS*(VAR dest: ARRAY [?] OF REAL; left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ DivideAISILoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ DivideAISI*(VAR dest: ARRAY [?] OF REAL; CONST left: ARRAY [?] OF INTEGER; right: INTEGER); 
+	PROCEDURE ^ DivideSIAILoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ DivideSIAI*(VAR dest: ARRAY [?] OF REAL; left: INTEGER; CONST right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ DivideALSLLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ DivideALSL*(VAR dest: ARRAY [?] OF REAL; CONST left: ARRAY [?] OF LONGINT; right: LONGINT); 
+	PROCEDURE ^ DivideSLALLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ DivideSLAL*(VAR dest: ARRAY [?] OF REAL; left: LONGINT; CONST right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ DivideARSRLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ DivideARSR*(VAR dest: ARRAY [?] OF REAL; CONST left: ARRAY [?] OF REAL; right: REAL); 
+	PROCEDURE ^ DivideSRARLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ DivideSRAR*(VAR dest: ARRAY [?] OF REAL; left: REAL; CONST right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ DivideAXSXLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ DivideAXSX*(VAR dest: ARRAY [?] OF LONGREAL; CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL); 
+	PROCEDURE ^ DivideSXAXLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ DivideSXAX*(VAR dest: ARRAY [?] OF LONGREAL; left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ EDivASASLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EDivASAS*(VAR dest: ARRAY [?] OF SHORTINT; CONST left, right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ EDivAIAILoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EDivAIAI*(VAR dest: ARRAY [?] OF INTEGER; CONST left, right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ EDivALALLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EDivALAL*(VAR dest: ARRAY [?] OF LONGINT; CONST left, right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ DivASSSLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ DivASSS*(VAR dest: ARRAY [?] OF SHORTINT; CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT); 
+	PROCEDURE ^ DivSSASLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ DivSSAS*(VAR dest: ARRAY [?] OF SHORTINT; left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ DivAISILoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ DivAISI*(VAR dest: ARRAY [?] OF INTEGER; CONST left: ARRAY [?] OF INTEGER; right: INTEGER); 
+	PROCEDURE ^ DivSIAILoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ DivSIAI*(VAR dest: ARRAY [?] OF INTEGER; left: INTEGER; CONST right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ DivALSLLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ DivALSL*(VAR dest: ARRAY [?] OF LONGINT; CONST left: ARRAY [?] OF LONGINT; right: LONGINT); 
+	PROCEDURE ^ DivSLALLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ DivSLAL*(VAR dest: ARRAY [?] OF LONGINT; left: LONGINT; CONST right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ EModASASLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EModASAS*(VAR dest: ARRAY [?] OF SHORTINT; CONST left, right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ EModAIAILoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EModAIAI*(VAR dest: ARRAY [?] OF INTEGER; CONST left, right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ EModALALLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EModALAL*(VAR dest: ARRAY [?] OF LONGINT; CONST left, right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ ModASSSLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ModASSS*(VAR dest: ARRAY [?] OF SHORTINT; CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT); 
+	PROCEDURE ^ ModSSASLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ModSSAS*(VAR dest: ARRAY [?] OF SHORTINT; left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ ModAISILoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ModAISI*(VAR dest: ARRAY [?] OF INTEGER; CONST left: ARRAY [?] OF INTEGER; right: INTEGER); 
+	PROCEDURE ^ ModSIAILoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ModSIAI*(VAR dest: ARRAY [?] OF INTEGER; left: INTEGER; CONST right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ ModALSLLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ModALSL*(VAR dest: ARRAY [?] OF LONGINT; CONST left: ARRAY [?] OF LONGINT; right: LONGINT); 
+	PROCEDURE ^ ModSLALLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ModSLAL*(VAR dest: ARRAY [?] OF LONGINT; left: LONGINT; CONST right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ SPASASLoop(ladr, radr, dadr, linc, rinc, len: LONGINT); 
+	PROCEDURE ^ SPASAS*(CONST left, right: ARRAY [?] OF SHORTINT): LONGINT; 
+	PROCEDURE ^ SPAIAILoop(ladr, radr, dadr, linc, rinc, len: LONGINT); 
+	PROCEDURE ^ SPAIAI*(CONST left, right: ARRAY [?] OF INTEGER): LONGINT; 
+	PROCEDURE ^ SPALALLoop(ladr, radr, dadr, linc, rinc, len: LONGINT); 
+	PROCEDURE ^ SPALAL*(CONST left, right: ARRAY [?] OF LONGINT): LONGINT; 
+	PROCEDURE ^ SPARARLoop(ladr, radr, dadr, linc, rinc, len: LONGINT); 
+	PROCEDURE ^ SPARAR*(CONST left, right: ARRAY [?] OF REAL): REAL; 
+	PROCEDURE ^ SPAXAXLoop(ladr, radr, dadr, linc, rinc, len: LONGINT); 
+	PROCEDURE ^ SPAXAX*(CONST left, right: ARRAY [?] OF LONGREAL): LONGREAL; 
+	PROCEDURE ^ EEqlABABLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EEqlABAB*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF BOOLEAN); 
+	PROCEDURE ^ EEqlASASLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EEqlASAS*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ EEqlAIAILoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EEqlAIAI*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ EEqlALALLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EEqlALAL*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ EEqlARARLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EEqlARAR*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ EEqlAXAXLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EEqlAXAX*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ EEqlABSBLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ EEqlABSB*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF BOOLEAN; right: BOOLEAN); 
+	PROCEDURE ^ EEqlSBAB*(VAR dest: ARRAY [?] OF BOOLEAN; left: BOOLEAN; CONST right: ARRAY [?] OF BOOLEAN); 
+	PROCEDURE ^ EEqlASSSLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ EEqlASSS*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT); 
+	PROCEDURE ^ EEqlSSAS*(VAR dest: ARRAY [?] OF BOOLEAN; left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ EEqlAISILoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ EEqlAISI*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF INTEGER; right: INTEGER); 
+	PROCEDURE ^ EEqlSIAI*(VAR dest: ARRAY [?] OF BOOLEAN; left: INTEGER; CONST right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ EEqlALSLLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ EEqlALSL*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF LONGINT; right: LONGINT); 
+	PROCEDURE ^ EEqlSLAL*(VAR dest: ARRAY [?] OF BOOLEAN; left: LONGINT; CONST right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ EEqlARSRLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ EEqlARSR*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF REAL; right: REAL); 
+	PROCEDURE ^ EEqlSRAR*(VAR dest: ARRAY [?] OF BOOLEAN; left: REAL; CONST right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ EEqlAXSXLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ EEqlAXSX*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL); 
+	PROCEDURE ^ EEqlSXAX*(VAR dest: ARRAY [?] OF BOOLEAN; left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ ENeqABABLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ENeqABAB*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF BOOLEAN); 
+	PROCEDURE ^ ENeqASASLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ENeqASAS*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ ENeqAIAILoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ENeqAIAI*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ ENeqALALLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ENeqALAL*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ ENeqARARLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ENeqARAR*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ ENeqAXAXLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ENeqAXAX*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ ENeqABSBLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ENeqABSB*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF BOOLEAN; right: BOOLEAN); 
+	PROCEDURE ^ ENeqSBAB*(VAR dest: ARRAY [?] OF BOOLEAN; left: BOOLEAN; CONST right: ARRAY [?] OF BOOLEAN); 
+	PROCEDURE ^ ENeqASSSLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ENeqASSS*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT); 
+	PROCEDURE ^ ENeqSSAS*(VAR dest: ARRAY [?] OF BOOLEAN; left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ ENeqAISILoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ENeqAISI*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF INTEGER; right: INTEGER); 
+	PROCEDURE ^ ENeqSIAI*(VAR dest: ARRAY [?] OF BOOLEAN; left: INTEGER; CONST right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ ENeqALSLLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ENeqALSL*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF LONGINT; right: LONGINT); 
+	PROCEDURE ^ ENeqSLAL*(VAR dest: ARRAY [?] OF BOOLEAN; left: LONGINT; CONST right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ ENeqARSRLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ENeqARSR*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF REAL; right: REAL); 
+	PROCEDURE ^ ENeqSRAR*(VAR dest: ARRAY [?] OF BOOLEAN; left: REAL; CONST right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ ENeqAXSXLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ENeqAXSX*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL); 
+	PROCEDURE ^ ENeqSXAX*(VAR dest: ARRAY [?] OF BOOLEAN; left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ EGtrASASLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGtrASAS*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ EGtrAIAILoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGtrAIAI*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ EGtrALALLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGtrALAL*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ EGtrARARLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGtrARAR*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ EGtrAXAXLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGtrAXAX*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ EGtrASSSLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGtrASSS*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT); 
+	PROCEDURE ^ ELssSSAS*(VAR dest: ARRAY [?] OF BOOLEAN; left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ EGtrAISILoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGtrAISI*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF INTEGER; right: INTEGER); 
+	PROCEDURE ^ ELssSIAI*(VAR dest: ARRAY [?] OF BOOLEAN; left: INTEGER; CONST right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ EGtrALSLLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGtrALSL*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF LONGINT; right: LONGINT); 
+	PROCEDURE ^ ELssSLAL*(VAR dest: ARRAY [?] OF BOOLEAN; left: LONGINT; CONST right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ EGtrARSRLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGtrARSR*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF REAL; right: REAL); 
+	PROCEDURE ^ ELssSRAR*(VAR dest: ARRAY [?] OF BOOLEAN; left: REAL; CONST right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ EGtrAXSXLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGtrAXSX*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL); 
+	PROCEDURE ^ ELssSXAX*(VAR dest: ARRAY [?] OF BOOLEAN; left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ EGeqASASLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGeqASAS*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ EGeqAIAILoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGeqAIAI*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ EGeqALALLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGeqALAL*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ EGeqARARLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGeqARAR*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ EGeqAXAXLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGeqAXAX*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ EGeqASSSLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGeqASSS*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT); 
+	PROCEDURE ^ ELeqSSAS*(VAR dest: ARRAY [?] OF BOOLEAN; left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ EGeqAISILoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGeqAISI*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF INTEGER; right: INTEGER); 
+	PROCEDURE ^ ELeqSIAI*(VAR dest: ARRAY [?] OF BOOLEAN; left: INTEGER; CONST right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ EGeqALSLLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGeqALSL*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF LONGINT; right: LONGINT); 
+	PROCEDURE ^ ELeqSLAL*(VAR dest: ARRAY [?] OF BOOLEAN; left: LONGINT; CONST right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ EGeqARSRLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGeqARSR*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF REAL; right: REAL); 
+	PROCEDURE ^ ELeqSRAR*(VAR dest: ARRAY [?] OF BOOLEAN; left: REAL; CONST right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ EGeqAXSXLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ EGeqAXSX*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL); 
+	PROCEDURE ^ ELeqSXAX*(VAR dest: ARRAY [?] OF BOOLEAN; left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ ELssASASLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELssASAS*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ ELssAIAILoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELssAIAI*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ ELssALALLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELssALAL*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ ELssARARLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELssARAR*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ ELssAXAXLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELssAXAX*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ ELssASSSLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELssASSS*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT); 
+	PROCEDURE ^ EGtrSSAS*(VAR dest: ARRAY [?] OF BOOLEAN; left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ ELssAISILoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELssAISI*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF INTEGER; right: INTEGER); 
+	PROCEDURE ^ EGtrSIAI*(VAR dest: ARRAY [?] OF BOOLEAN; left: INTEGER; CONST right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ ELssALSLLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELssALSL*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF LONGINT; right: LONGINT); 
+	PROCEDURE ^ EGtrSLAL*(VAR dest: ARRAY [?] OF BOOLEAN; left: LONGINT; CONST right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ ELssARSRLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELssARSR*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF REAL; right: REAL); 
+	PROCEDURE ^ EGtrSRAR*(VAR dest: ARRAY [?] OF BOOLEAN; left: REAL; CONST right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ ELssAXSXLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELssAXSX*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL); 
+	PROCEDURE ^ EGtrSXAX*(VAR dest: ARRAY [?] OF BOOLEAN; left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ ELeqASASLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELeqASAS*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ ELeqAIAILoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELeqAIAI*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ ELeqALALLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELeqALAL*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ ELeqARARLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELeqARAR*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ ELeqAXAXLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELeqAXAX*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ ELeqASSSLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELeqASSS*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT); 
+	PROCEDURE ^ EGeqSSAS*(VAR dest: ARRAY [?] OF BOOLEAN; left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ ELeqAISILoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELeqAISI*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF INTEGER; right: INTEGER); 
+	PROCEDURE ^ EGeqSIAI*(VAR dest: ARRAY [?] OF BOOLEAN; left: INTEGER; CONST right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ ELeqALSLLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELeqALSL*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF LONGINT; right: LONGINT); 
+	PROCEDURE ^ EGeqSLAL*(VAR dest: ARRAY [?] OF BOOLEAN; left: LONGINT; CONST right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ ELeqARSRLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELeqARSR*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF REAL; right: REAL); 
+	PROCEDURE ^ EGeqSRAR*(VAR dest: ARRAY [?] OF BOOLEAN; left: REAL; CONST right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ ELeqAXSXLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ELeqAXSX*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL); 
+	PROCEDURE ^ EGeqSXAX*(VAR dest: ARRAY [?] OF BOOLEAN; left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ ElOrABABLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ElOrABAB*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF BOOLEAN); 
+	PROCEDURE ^ ElAndABABLoop(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ ElAndABAB*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left, right: ARRAY [?] OF BOOLEAN); 
+	PROCEDURE ^ ElOrABSBLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ElOrABSB*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF BOOLEAN; right: BOOLEAN); 
+	PROCEDURE ^ ElOrSBAB*(VAR dest: ARRAY [?] OF BOOLEAN; left: BOOLEAN; CONST right: ARRAY [?] OF BOOLEAN); 
+	PROCEDURE ^ ElAndABSBLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ ElAndABSB*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF BOOLEAN; right: BOOLEAN); 
+	PROCEDURE ^ ElAndSBAB*(VAR dest: ARRAY [?] OF BOOLEAN; left: BOOLEAN; CONST right: ARRAY [?] OF BOOLEAN); 
+	PROCEDURE ^ LssASASLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LssASAS*(CONST left, right: ARRAY [?] OF SHORTINT): BOOLEAN; 
+	PROCEDURE ^ GeqASASLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GeqASAS*(CONST left, right: ARRAY [?] OF SHORTINT): BOOLEAN; 
+	PROCEDURE ^ LssAIAILoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LssAIAI*(CONST left, right: ARRAY [?] OF INTEGER): BOOLEAN; 
+	PROCEDURE ^ GeqAIAILoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GeqAIAI*(CONST left, right: ARRAY [?] OF INTEGER): BOOLEAN; 
+	PROCEDURE ^ LssALALLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LssALAL*(CONST left, right: ARRAY [?] OF LONGINT): BOOLEAN; 
+	PROCEDURE ^ GeqALALLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GeqALAL*(CONST left, right: ARRAY [?] OF LONGINT): BOOLEAN; 
+	PROCEDURE ^ LssARARLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LssARAR*(CONST left, right: ARRAY [?] OF REAL): BOOLEAN; 
+	PROCEDURE ^ GeqARARLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GeqARAR*(CONST left, right: ARRAY [?] OF REAL): BOOLEAN; 
+	PROCEDURE ^ LssAXAXLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LssAXAX*(CONST left, right: ARRAY [?] OF LONGREAL): BOOLEAN; 
+	PROCEDURE ^ GeqAXAXLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GeqAXAX*(CONST left, right: ARRAY [?] OF LONGREAL): BOOLEAN; 
+	PROCEDURE ^ GtrASASLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GtrASAS*(CONST left, right: ARRAY [?] OF SHORTINT): BOOLEAN; 
+	PROCEDURE ^ LeqASASLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LeqASAS*(CONST left, right: ARRAY [?] OF SHORTINT): BOOLEAN; 
+	PROCEDURE ^ GtrAIAILoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GtrAIAI*(CONST left, right: ARRAY [?] OF INTEGER): BOOLEAN; 
+	PROCEDURE ^ LeqAIAILoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LeqAIAI*(CONST left, right: ARRAY [?] OF INTEGER): BOOLEAN; 
+	PROCEDURE ^ GtrALALLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GtrALAL*(CONST left, right: ARRAY [?] OF LONGINT): BOOLEAN; 
+	PROCEDURE ^ LeqALALLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LeqALAL*(CONST left, right: ARRAY [?] OF LONGINT): BOOLEAN; 
+	PROCEDURE ^ GtrARARLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GtrARAR*(CONST left, right: ARRAY [?] OF REAL): BOOLEAN; 
+	PROCEDURE ^ LeqARARLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LeqARAR*(CONST left, right: ARRAY [?] OF REAL): BOOLEAN; 
+	PROCEDURE ^ GtrAXAXLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GtrAXAX*(CONST left, right: ARRAY [?] OF LONGREAL): BOOLEAN; 
+	PROCEDURE ^ LeqAXAXLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LeqAXAX*(CONST left, right: ARRAY [?] OF LONGREAL): BOOLEAN; 
+	PROCEDURE ^ EqlABABLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ EqlABAB*(CONST left, right: ARRAY [?] OF BOOLEAN): BOOLEAN; 
+	PROCEDURE ^ NeqABAB*(CONST left, right: ARRAY [?] OF BOOLEAN): BOOLEAN; 
+	PROCEDURE ^ EqlASASLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ EqlASAS*(CONST left, right: ARRAY [?] OF SHORTINT): BOOLEAN; 
+	PROCEDURE ^ NeqASAS*(CONST left, right: ARRAY [?] OF SHORTINT): BOOLEAN; 
+	PROCEDURE ^ EqlAIAILoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ EqlAIAI*(CONST left, right: ARRAY [?] OF INTEGER): BOOLEAN; 
+	PROCEDURE ^ NeqAIAI*(CONST left, right: ARRAY [?] OF INTEGER): BOOLEAN; 
+	PROCEDURE ^ EqlALALLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ EqlALAL*(CONST left, right: ARRAY [?] OF LONGINT): BOOLEAN; 
+	PROCEDURE ^ NeqALAL*(CONST left, right: ARRAY [?] OF LONGINT): BOOLEAN; 
+	PROCEDURE ^ EqlARARLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ EqlARAR*(CONST left, right: ARRAY [?] OF REAL): BOOLEAN; 
+	PROCEDURE ^ NeqARAR*(CONST left, right: ARRAY [?] OF REAL): BOOLEAN; 
+	PROCEDURE ^ EqlAXAXLoop(ladr, radr, linc, rinc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ EqlAXAX*(CONST left, right: ARRAY [?] OF LONGREAL): BOOLEAN; 
+	PROCEDURE ^ NeqAXAX*(CONST left, right: ARRAY [?] OF LONGREAL): BOOLEAN; 
+	PROCEDURE ^ EqlABSBLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ EqlABSB*(CONST left: ARRAY [?] OF BOOLEAN; right: BOOLEAN): BOOLEAN; 
+	PROCEDURE ^ EqlSBAB*(left: BOOLEAN; CONST right: ARRAY [?] OF BOOLEAN): BOOLEAN; 
+	PROCEDURE ^ NeqABSB*(CONST left: ARRAY [?] OF BOOLEAN; right: BOOLEAN): BOOLEAN; 
+	PROCEDURE ^ NeqSBAB*(left: BOOLEAN; CONST right: ARRAY [?] OF BOOLEAN): BOOLEAN; 
+	PROCEDURE ^ EqlASSSLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ EqlASSS*(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): BOOLEAN; 
+	PROCEDURE ^ EqlSSAS*(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): BOOLEAN; 
+	PROCEDURE ^ NeqASSS*(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): BOOLEAN; 
+	PROCEDURE ^ NeqSSAS*(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): BOOLEAN; 
+	PROCEDURE ^ EqlAISILoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ EqlAISI*(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): BOOLEAN; 
+	PROCEDURE ^ EqlSIAI*(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): BOOLEAN; 
+	PROCEDURE ^ NeqAISI*(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): BOOLEAN; 
+	PROCEDURE ^ NeqSIAI*(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): BOOLEAN; 
+	PROCEDURE ^ EqlALSLLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ EqlALSL*(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): BOOLEAN; 
+	PROCEDURE ^ EqlSLAL*(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): BOOLEAN; 
+	PROCEDURE ^ NeqALSL*(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): BOOLEAN; 
+	PROCEDURE ^ NeqSLAL*(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): BOOLEAN; 
+	PROCEDURE ^ EqlARSRLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ EqlARSR*(CONST left: ARRAY [?] OF REAL; right: REAL): BOOLEAN; 
+	PROCEDURE ^ EqlSRAR*(left: REAL; CONST right: ARRAY [?] OF REAL): BOOLEAN; 
+	PROCEDURE ^ NeqARSR*(CONST left: ARRAY [?] OF REAL; right: REAL): BOOLEAN; 
+	PROCEDURE ^ NeqSRAR*(left: REAL; CONST right: ARRAY [?] OF REAL): BOOLEAN; 
+	PROCEDURE ^ EqlAXSXLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ EqlAXSX*(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): BOOLEAN; 
+	PROCEDURE ^ EqlSXAX*(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): BOOLEAN; 
+	PROCEDURE ^ NeqAXSX*(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): BOOLEAN; 
+	PROCEDURE ^ NeqSXAX*(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): BOOLEAN; 
+	PROCEDURE ^ GtrASSSLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GtrASSS*(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): BOOLEAN; 
+	PROCEDURE ^ LssSSAS*(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): BOOLEAN; 
+	PROCEDURE ^ GtrAISILoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GtrAISI*(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): BOOLEAN; 
+	PROCEDURE ^ LssSIAI*(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): BOOLEAN; 
+	PROCEDURE ^ GtrALSLLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GtrALSL*(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LssSLAL*(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): BOOLEAN; 
+	PROCEDURE ^ GtrARSRLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GtrARSR*(CONST left: ARRAY [?] OF REAL; right: REAL): BOOLEAN; 
+	PROCEDURE ^ LssSRAR*(left: REAL; CONST right: ARRAY [?] OF REAL): BOOLEAN; 
+	PROCEDURE ^ GtrAXSXLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GtrAXSX*(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): BOOLEAN; 
+	PROCEDURE ^ LssSXAX*(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): BOOLEAN; 
+	PROCEDURE ^ GeqASSSLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GeqASSS*(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): BOOLEAN; 
+	PROCEDURE ^ LeqSSAS*(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): BOOLEAN; 
+	PROCEDURE ^ GeqAISILoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GeqAISI*(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): BOOLEAN; 
+	PROCEDURE ^ LeqSIAI*(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): BOOLEAN; 
+	PROCEDURE ^ GeqALSLLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GeqALSL*(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LeqSLAL*(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): BOOLEAN; 
+	PROCEDURE ^ GeqARSRLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GeqARSR*(CONST left: ARRAY [?] OF REAL; right: REAL): BOOLEAN; 
+	PROCEDURE ^ LeqSRAR*(left: REAL; CONST right: ARRAY [?] OF REAL): BOOLEAN; 
+	PROCEDURE ^ GeqAXSXLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GeqAXSX*(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): BOOLEAN; 
+	PROCEDURE ^ LeqSXAX*(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): BOOLEAN; 
+	PROCEDURE ^ LeqASSSLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LeqASSS*(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): BOOLEAN; 
+	PROCEDURE ^ GeqSSAS*(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): BOOLEAN; 
+	PROCEDURE ^ LeqAISILoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LeqAISI*(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): BOOLEAN; 
+	PROCEDURE ^ GeqSIAI*(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): BOOLEAN; 
+	PROCEDURE ^ LeqALSLLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LeqALSL*(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GeqSLAL*(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): BOOLEAN; 
+	PROCEDURE ^ LeqARSRLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LeqARSR*(CONST left: ARRAY [?] OF REAL; right: REAL): BOOLEAN; 
+	PROCEDURE ^ GeqSRAR*(left: REAL; CONST right: ARRAY [?] OF REAL): BOOLEAN; 
+	PROCEDURE ^ LeqAXSXLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LeqAXSX*(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): BOOLEAN; 
+	PROCEDURE ^ GeqSXAX*(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): BOOLEAN; 
+	PROCEDURE ^ LssASSSLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LssASSS*(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): BOOLEAN; 
+	PROCEDURE ^ GtrSSAS*(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): BOOLEAN; 
+	PROCEDURE ^ LssAISILoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LssAISI*(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): BOOLEAN; 
+	PROCEDURE ^ GtrSIAI*(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): BOOLEAN; 
+	PROCEDURE ^ LssALSLLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LssALSL*(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): BOOLEAN; 
+	PROCEDURE ^ GtrSLAL*(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): BOOLEAN; 
+	PROCEDURE ^ LssARSRLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LssARSR*(CONST left: ARRAY [?] OF REAL; right: REAL): BOOLEAN; 
+	PROCEDURE ^ GtrSRAR*(left: REAL; CONST right: ARRAY [?] OF REAL): BOOLEAN; 
+	PROCEDURE ^ LssAXSXLoop(ladr, radr, linc, len: LONGINT): BOOLEAN; 
+	PROCEDURE ^ LssAXSX*(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): BOOLEAN; 
+	PROCEDURE ^ GtrSXAX*(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): BOOLEAN; 
+	PROCEDURE ^ MinASLoop(ladr, dadr, linc, len: LONGINT); 
+	PROCEDURE ^ MinAS*(CONST left: ARRAY [?] OF SHORTINT): SHORTINT; 
+	PROCEDURE ^ MinAILoop(ladr, dadr, linc, len: LONGINT); 
+	PROCEDURE ^ MinAI*(CONST left: ARRAY [?] OF INTEGER): INTEGER; 
+	PROCEDURE ^ MinALLoop(ladr, dadr, linc, len: LONGINT); 
+	PROCEDURE ^ MinAL*(CONST left: ARRAY [?] OF LONGINT): LONGINT; 
+	PROCEDURE ^ MinARLoop(ladr, dadr, linc, len: LONGINT); 
+	PROCEDURE ^ MinAR*(CONST left: ARRAY [?] OF REAL): REAL; 
+	PROCEDURE ^ MinAXLoop(ladr, dadr, linc, len: LONGINT); 
+	PROCEDURE ^ MinAX*(CONST left: ARRAY [?] OF LONGREAL): LONGREAL; 
+	PROCEDURE ^ MaxASLoop(ladr, dadr, linc, len: LONGINT); 
+	PROCEDURE ^ MaxAS*(CONST left: ARRAY [?] OF SHORTINT): SHORTINT; 
+	PROCEDURE ^ MaxAILoop(ladr, dadr, linc, len: LONGINT); 
+	PROCEDURE ^ MaxAI*(CONST left: ARRAY [?] OF INTEGER): INTEGER; 
+	PROCEDURE ^ MaxALLoop(ladr, dadr, linc, len: LONGINT); 
+	PROCEDURE ^ MaxAL*(CONST left: ARRAY [?] OF LONGINT): LONGINT; 
+	PROCEDURE ^ MaxARLoop(ladr, dadr, linc, len: LONGINT); 
+	PROCEDURE ^ MaxAR*(CONST left: ARRAY [?] OF REAL): REAL; 
+	PROCEDURE ^ MaxAXLoop(ladr, dadr, linc, len: LONGINT); 
+	PROCEDURE ^ MaxAX*(CONST left: ARRAY [?] OF LONGREAL): LONGREAL; 
+	PROCEDURE ^ SumASLoop(ladr, dadr, linc, len: LONGINT); 
+	PROCEDURE ^ SumAS*(CONST left: ARRAY [?] OF SHORTINT): SHORTINT; 
+	PROCEDURE ^ SumAILoop(ladr, dadr, linc, len: LONGINT); 
+	PROCEDURE ^ SumAI*(CONST left: ARRAY [?] OF INTEGER): INTEGER; 
+	PROCEDURE ^ SumALLoop(ladr, dadr, linc, len: LONGINT); 
+	PROCEDURE ^ SumAL*(CONST left: ARRAY [?] OF LONGINT): LONGINT; 
+	PROCEDURE ^ SumARLoop(ladr, dadr, linc, len: LONGINT); 
+	PROCEDURE ^ SumAR*(CONST left: ARRAY [?] OF REAL): REAL; 
+	PROCEDURE ^ SumAXLoop(ladr, dadr, linc, len: LONGINT); 
+	PROCEDURE ^ SumAX*(CONST left: ARRAY [?] OF LONGREAL): LONGREAL; 
+	PROCEDURE ^ AbsLoopS(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ AbsAS*(VAR dest: ARRAY [?] OF SHORTINT; CONST src: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ AbsLoopI(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ AbsAI*(VAR dest: ARRAY [?] OF INTEGER; CONST src: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ AbsLoopL(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ AbsAL*(VAR dest: ARRAY [?] OF LONGINT; CONST src: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ AbsLoopR(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ AbsAR*(VAR dest: ARRAY [?] OF REAL; CONST src: ARRAY [?] OF REAL); 
+	PROCEDURE ^ AbsLoopX(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ AbsAX*(VAR dest: ARRAY [?] OF LONGREAL; CONST src: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ AssignABSBLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ AssignABSB*(VAR dest: ARRAY [?] OF BOOLEAN; CONST left: ARRAY [?] OF BOOLEAN; right: BOOLEAN); 
+	PROCEDURE ^ AssignASSSLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ AssignASSS*(VAR dest: ARRAY [?] OF SHORTINT; CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT); 
+	PROCEDURE ^ AssignAISILoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ AssignAISI*(VAR dest: ARRAY [?] OF INTEGER; CONST left: ARRAY [?] OF INTEGER; right: INTEGER); 
+	PROCEDURE ^ AssignALSLLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ AssignALSL*(VAR dest: ARRAY [?] OF LONGINT; CONST left: ARRAY [?] OF LONGINT; right: LONGINT); 
+	PROCEDURE ^ AssignARSRLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ AssignARSR*(VAR dest: ARRAY [?] OF REAL; CONST left: ARRAY [?] OF REAL; right: REAL); 
+	PROCEDURE ^ AssignAXSXLoop(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ AssignAXSX*(VAR dest: ARRAY [?] OF LONGREAL; CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL); 
+	PROCEDURE ^ AllocateMatrix(dest: Address; rows, cols, elementsize: LONGINT): ANY; 
+	PROCEDURE ^ AllocateVector(dest: Address; l0, elementsize: LONGINT): ANY; 
+	PROCEDURE ^ ApplyMatMulLoop(dest, left, right: Address; Size: LONGINT; loop: BinaryAASLoop; fast: FastMatMul); 
+	PROCEDURE ^ ApplyMatVecMulLoop(dest, left, right: Address; Size: LONGINT; loop: BinaryAASLoop; fast: FastMatMul); 
+	PROCEDURE ^ ApplyVecMatMulLoop(dest, left, right: Address; Size: LONGINT; loop: BinaryAASLoop; fast: FastMatMul); 
+	PROCEDURE ^ MatMulASASLoop(ladr, radr, dadr, linc, rinc, len: Address); 
+	PROCEDURE ^ MatMulASAS*(VAR dest: ARRAY [*, *] OF SHORTINT; CONST left, right: ARRAY [*, *] OF SHORTINT); 
+	PROCEDURE ^ MatVecMulASAS*(VAR dest: ARRAY [*] OF SHORTINT; CONST left: ARRAY [*, *] OF SHORTINT; CONST right: ARRAY [*] OF SHORTINT); 
+	PROCEDURE ^ VecMatMulASAS*(VAR dest: ARRAY [*] OF SHORTINT; CONST left: ARRAY [*] OF SHORTINT; CONST right: ARRAY [*, *] OF SHORTINT); 
+	PROCEDURE ^ MatMulAIAILoop(ladr, radr, dadr, linc, rinc, len: Address); 
+	PROCEDURE ^ MatMulAIAI*(VAR dest: ARRAY [*, *] OF INTEGER; CONST left, right: ARRAY [*, *] OF INTEGER); 
+	PROCEDURE ^ MatVecMulAIAI*(VAR dest: ARRAY [*] OF INTEGER; CONST left: ARRAY [*, *] OF INTEGER; CONST right: ARRAY [*] OF INTEGER); 
+	PROCEDURE ^ VecMatMulAIAI*(VAR dest: ARRAY [*] OF INTEGER; CONST left: ARRAY [*] OF INTEGER; CONST right: ARRAY [*, *] OF INTEGER); 
+	PROCEDURE ^ MatMulALALLoop(ladr, radr, dadr, linc, rinc, len: Address); 
+	PROCEDURE ^ MatMulALAL*(VAR dest: ARRAY [*, *] OF LONGINT; CONST left, right: ARRAY [*, *] OF LONGINT); 
+	PROCEDURE ^ MatVecMulALAL*(VAR dest: ARRAY [*] OF LONGINT; CONST left: ARRAY [*, *] OF LONGINT; CONST right: ARRAY [*] OF LONGINT); 
+	PROCEDURE ^ VecMatMulALAL*(VAR dest: ARRAY [*] OF LONGINT; CONST left: ARRAY [*] OF LONGINT; CONST right: ARRAY [*, *] OF LONGINT); 
+	PROCEDURE ^ MatMulARARLoop(ladr, radr, dadr, linc, rinc, len: Address); 
+	PROCEDURE ^ MatMulARAR*(VAR dest: ARRAY [*, *] OF REAL; CONST left, right: ARRAY [*, *] OF REAL); 
+	PROCEDURE ^ MatVecMulARAR*(VAR dest: ARRAY [*] OF REAL; CONST left: ARRAY [*, *] OF REAL; CONST right: ARRAY [*] OF REAL); 
+	PROCEDURE ^ VecMatMulARAR*(VAR dest: ARRAY [*] OF REAL; CONST left: ARRAY [*] OF REAL; CONST right: ARRAY [*, *] OF REAL); 
+	PROCEDURE ^ MatMulAXAXLoop(ladr, radr, dadr, linc, rinc, len: Address); 
+	PROCEDURE ^ MatMulAXAX*(VAR dest: ARRAY [*, *] OF LONGREAL; CONST left, right: ARRAY [*, *] OF LONGREAL); 
+	PROCEDURE ^ MatVecMulAXAX*(VAR dest: ARRAY [*] OF LONGREAL; CONST left: ARRAY [*, *] OF LONGREAL; CONST right: ARRAY [*] OF LONGREAL); 
+	PROCEDURE ^ VecMatMulAXAX*(VAR dest: ARRAY [*] OF LONGREAL; CONST left: ARRAY [*] OF LONGREAL; CONST right: ARRAY [*, *] OF LONGREAL); 
+	PROCEDURE ^ MatMulIncASASLoop(ladr, radr, dadr, linc, rinc, len: Address); 
+	PROCEDURE ^ MatMulIncASAS*(VAR dest: ARRAY [*, *] OF SHORTINT; CONST left, right: ARRAY [*, *] OF SHORTINT); 
+	PROCEDURE ^ MatVecMulIncASAS*(VAR dest: ARRAY [*] OF SHORTINT; CONST left: ARRAY [*, *] OF SHORTINT; CONST right: ARRAY [*] OF SHORTINT); 
+	PROCEDURE ^ VecMatMulIncASAS*(VAR dest: ARRAY [*] OF SHORTINT; CONST left: ARRAY [*] OF SHORTINT; CONST right: ARRAY [*, *] OF SHORTINT); 
+	PROCEDURE ^ MatMulDecASAS*(VAR dest: ARRAY [*, *] OF SHORTINT; CONST left, right: ARRAY [*, *] OF SHORTINT); 
+	PROCEDURE ^ MatVecMulDecASAS*(VAR dest: ARRAY [*] OF SHORTINT; CONST left: ARRAY [*, *] OF SHORTINT; CONST right: ARRAY [*] OF SHORTINT); 
+	PROCEDURE ^ VecMatMulDecASAS*(VAR dest: ARRAY [*] OF SHORTINT; CONST left: ARRAY [*] OF SHORTINT; CONST right: ARRAY [*, *] OF SHORTINT); 
+	PROCEDURE ^ MatMulIncAIAILoop(ladr, radr, dadr, linc, rinc, len: Address); 
+	PROCEDURE ^ MatMulIncAIAI*(VAR dest: ARRAY [*, *] OF INTEGER; CONST left, right: ARRAY [*, *] OF INTEGER); 
+	PROCEDURE ^ MatVecMulIncAIAI*(VAR dest: ARRAY [*] OF INTEGER; CONST left: ARRAY [*, *] OF INTEGER; CONST right: ARRAY [*] OF INTEGER); 
+	PROCEDURE ^ VecMatMulIncAIAI*(VAR dest: ARRAY [*] OF INTEGER; CONST left: ARRAY [*] OF INTEGER; CONST right: ARRAY [*, *] OF INTEGER); 
+	PROCEDURE ^ MatMulDecAIAI*(VAR dest: ARRAY [*, *] OF INTEGER; CONST left, right: ARRAY [*, *] OF INTEGER); 
+	PROCEDURE ^ MatVecMulDecAIAI*(VAR dest: ARRAY [*] OF INTEGER; CONST left: ARRAY [*, *] OF INTEGER; CONST right: ARRAY [*] OF INTEGER); 
+	PROCEDURE ^ VecMatMulDecAIAI*(VAR dest: ARRAY [*] OF INTEGER; CONST left: ARRAY [*] OF INTEGER; CONST right: ARRAY [*, *] OF INTEGER); 
+	PROCEDURE ^ MatMulIncALALLoop(ladr, radr, dadr, linc, rinc, len: Address); 
+	PROCEDURE ^ MatMulIncALAL*(VAR dest: ARRAY [*, *] OF LONGINT; CONST left, right: ARRAY [*, *] OF LONGINT); 
+	PROCEDURE ^ MatVecMulIncALAL*(VAR dest: ARRAY [*] OF LONGINT; CONST left: ARRAY [*, *] OF LONGINT; CONST right: ARRAY [*] OF LONGINT); 
+	PROCEDURE ^ VecMatMulIncALAL*(VAR dest: ARRAY [*] OF LONGINT; CONST left: ARRAY [*] OF LONGINT; CONST right: ARRAY [*, *] OF LONGINT); 
+	PROCEDURE ^ MatMulDecALAL*(VAR dest: ARRAY [*, *] OF LONGINT; CONST left, right: ARRAY [*, *] OF LONGINT); 
+	PROCEDURE ^ MatVecMulDecALAL*(VAR dest: ARRAY [*] OF LONGINT; CONST left: ARRAY [*, *] OF LONGINT; CONST right: ARRAY [*] OF LONGINT); 
+	PROCEDURE ^ VecMatMulDecALAL*(VAR dest: ARRAY [*] OF LONGINT; CONST left: ARRAY [*] OF LONGINT; CONST right: ARRAY [*, *] OF LONGINT); 
+	PROCEDURE ^ MatMulIncARARLoop(ladr, radr, dadr, linc, rinc, len: Address); 
+	PROCEDURE ^ MatMulIncARAR*(VAR dest: ARRAY [*, *] OF REAL; CONST left, right: ARRAY [*, *] OF REAL); 
+	PROCEDURE ^ MatVecMulIncARAR*(VAR dest: ARRAY [*] OF REAL; CONST left: ARRAY [*, *] OF REAL; CONST right: ARRAY [*] OF REAL); 
+	PROCEDURE ^ VecMatMulIncARAR*(VAR dest: ARRAY [*] OF REAL; CONST left: ARRAY [*] OF REAL; CONST right: ARRAY [*, *] OF REAL); 
+	PROCEDURE ^ MatMulDecARAR*(VAR dest: ARRAY [*, *] OF REAL; CONST left, right: ARRAY [*, *] OF REAL); 
+	PROCEDURE ^ MatVecMulDecARAR*(VAR dest: ARRAY [*] OF REAL; CONST left: ARRAY [*, *] OF REAL; CONST right: ARRAY [*] OF REAL); 
+	PROCEDURE ^ VecMatMulDecARAR*(VAR dest: ARRAY [*] OF REAL; CONST left: ARRAY [*] OF REAL; CONST right: ARRAY [*, *] OF REAL); 
+	PROCEDURE ^ MatMulIncAXAXLoop(ladr, radr, dadr, linc, rinc, len: Address); 
+	PROCEDURE ^ MatMulIncAXAX*(VAR dest: ARRAY [*, *] OF LONGREAL; CONST left, right: ARRAY [*, *] OF LONGREAL); 
+	PROCEDURE ^ MatVecMulIncAXAX*(VAR dest: ARRAY [*] OF LONGREAL; CONST left: ARRAY [*, *] OF LONGREAL; CONST right: ARRAY [*] OF LONGREAL); 
+	PROCEDURE ^ VecMatMulIncAXAX*(VAR dest: ARRAY [*] OF LONGREAL; CONST left: ARRAY [*] OF LONGREAL; CONST right: ARRAY [*, *] OF LONGREAL); 
+	PROCEDURE ^ MatMulDecAXAX*(VAR dest: ARRAY [*, *] OF LONGREAL; CONST left, right: ARRAY [*, *] OF LONGREAL); 
+	PROCEDURE ^ MatVecMulDecAXAX*(VAR dest: ARRAY [*] OF LONGREAL; CONST left: ARRAY [*, *] OF LONGREAL; CONST right: ARRAY [*] OF LONGREAL); 
+	PROCEDURE ^ VecMatMulDecAXAX*(VAR dest: ARRAY [*] OF LONGREAL; CONST left: ARRAY [*] OF LONGREAL; CONST right: ARRAY [*, *] OF LONGREAL); 
+	PROCEDURE ^ CrossProductASAS*(VAR dest: ARRAY [*] OF SHORTINT; CONST left, right: ARRAY [*] OF SHORTINT); 
+	PROCEDURE ^ CrossProductAIAI*(VAR dest: ARRAY [*] OF INTEGER; CONST left, right: ARRAY [*] OF INTEGER); 
+	PROCEDURE ^ CrossProductALAL*(VAR dest: ARRAY [*] OF LONGINT; CONST left, right: ARRAY [*] OF LONGINT); 
+	PROCEDURE ^ CrossProductARAR*(VAR dest: ARRAY [*] OF REAL; CONST left, right: ARRAY [*] OF REAL); 
+	PROCEDURE ^ CrossProductAXAX*(VAR dest: ARRAY [*] OF LONGREAL; CONST left, right: ARRAY [*] OF LONGREAL); 
+	PROCEDURE ^ Overlap(src1, src2: Address): BOOLEAN; 
+	PROCEDURE ^ Transpose*(dest, left: Address; Size: LONGINT); 
+	PROCEDURE ^ TransposeAS*(VAR dest: ARRAY [*, *] OF SHORTINT; CONST left: ARRAY [*, *] OF SHORTINT); 
+	PROCEDURE ^ TransposeAI*(VAR dest: ARRAY [*, *] OF INTEGER; CONST left: ARRAY [*, *] OF INTEGER); 
+	PROCEDURE ^ TransposeAL*(VAR dest: ARRAY [*, *] OF LONGINT; CONST left: ARRAY [*, *] OF LONGINT); 
+	PROCEDURE ^ TransposeAR*(VAR dest: ARRAY [*, *] OF REAL; CONST left: ARRAY [*, *] OF REAL); 
+	PROCEDURE ^ TransposeAX*(VAR dest: ARRAY [*, *] OF LONGREAL; CONST left: ARRAY [*, *] OF LONGREAL); 
+	PROCEDURE ^ CheckTensorGeometry(left, right, dest: Address; ldim, rdim: LONGINT): BOOLEAN; 
+	PROCEDURE ^ Reshape*(VAR dest: LONGINT; src: LONGINT; CONST shape: ARRAY [*] OF LONGINT); 
+	PROCEDURE ^ AllocateTensorX*(VAR dest: LONGINT; CONST a: ARRAY [*] OF LONGINT; Size: LONGINT); 
+	PROCEDURE ^ LenA*(VAR dest: ARRAY [*] OF LONGINT; src: Address); 
+	PROCEDURE ^ IncrA*(VAR dest: ARRAY [*] OF LONGINT; src: Address); 
+	PROCEDURE ^ Len*(src: Address; d: LONGINT): LONGINT; 
+	PROCEDURE ^ Incr*(src: Address; d: LONGINT): LONGINT; 
+	PROCEDURE ^ AllocateTensor(VAR dest: LONGINT; left, right: Address; Size: LONGINT): ANY; 
+	PROCEDURE ^ FindPatternTensor(left, right: Address; VAR rdim, len, linc, ri: LONGINT); 
+	PROCEDURE ^ ApplyTensorAAAOp(d, l, r: Address; elementSize: LONGINT; Loop: BinaryASALoop); 
+	PROCEDURE ^ TensorProdASAS*(VAR dest: ARRAY [?] OF SHORTINT; CONST left, right: ARRAY [?] OF SHORTINT); 
+	PROCEDURE ^ TensorProdAIAI*(VAR dest: ARRAY [?] OF INTEGER; CONST left, right: ARRAY [?] OF INTEGER); 
+	PROCEDURE ^ TensorProdALAL*(VAR dest: ARRAY [?] OF LONGINT; CONST left, right: ARRAY [?] OF LONGINT); 
+	PROCEDURE ^ TensorProdARAR*(VAR dest: ARRAY [?] OF REAL; CONST left, right: ARRAY [?] OF REAL); 
+	PROCEDURE ^ TensorProdAXAX*(VAR dest: ARRAY [?] OF LONGREAL; CONST left, right: ARRAY [?] OF LONGREAL); 
+	PROCEDURE ^ MinSXSX*(l, r: LONGREAL): LONGREAL; 
+	PROCEDURE ^ MaxSXSX*(l, r: LONGREAL): LONGREAL; 
+	PROCEDURE ^ MinSRSR*(l, r: REAL): REAL; 
+	PROCEDURE ^ MaxSRSR*(l, r: REAL): REAL; 
+	PROCEDURE ^ InitOptimization; 
+BEGIN
+END ArrayBase.

WinAos/obg/ArrayBaseOptimized.SymW

@@ -0,0 +1,242 @@
+MODULE ArrayBaseOptimized;
+	IMPORT SYSTEM, ArrayBase, Machine, KernelLog, Commands;
+CONST 
+	L2CacheSize = (512 * 1024); 
+	L1BlockN = 5; 
+	L2BARatio = 1; 
+	L0BlockKR = 4; 
+	L1MaxBlockKR = 336; 
+	L2BlockSize = 81920; 
+	L0BlockKX = 2; 
+	L1MaxBlockKX = 256; 
+	debug = FALSE; 
+	parallel = TRUE; 
+	SSE = TRUE; 
+	MaxCachePoolSize = 0; 
+	maxProcesses = 32; 
+	cMatMulDynamic* =  -1; 
+	cMatMulScalarProduct* = 0; 
+	cMatMulNaive* = 1; 
+	cMatMulTransposed* = 2; 
+	cMatMulStride* = 3; 
+	cMatMulBlocked* = 4; 
+TYPE 
+	Cache = POINTER TO RECORD 
+		p: ANY; 
+		adr, size: LONGINT; 
+		prev, next: Cache; 
+	END; 
+
+	CachePool = OBJECT {EXCLUSIVE} 
+	VAR 
+		first, last: Cache; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ Acquire(size: LONGINT): Cache; 
+		PROCEDURE ^ Release(c: Cache); 
+	END CachePool; 
+
+	ComputationObj = OBJECT {EXCLUSIVE} 
+	VAR 
+		done: BOOLEAN; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ Compute; 
+		PROCEDURE ^ Wait; 
+	BEGIN{ACTIVE, EXCLUSIVE} 
+	END ComputationObj; 
+
+	MatMulHObjR = OBJECT {EXCLUSIVE} (ComputationObj)
+	VAR 
+		MatrixA, MatrixB, MatrixC, Stride, IncC, StrideC, RowsA, RowsB, Cols: LONGINT; 
+		add: BOOLEAN; 
+
+		PROCEDURE ^  & InitR*(MatrixA, MatrixB, MatrixC, Stride, IncC, StrideC, RowsA, RowsB, Cols: LONGINT; add: BOOLEAN); 
+		PROCEDURE ^ Compute; 
+	END MatMulHObjR; 
+
+	MatMulHObjX = OBJECT {EXCLUSIVE} (ComputationObj)
+	VAR 
+		MatrixA, MatrixB, MatrixC, Stride, IncC, StrideC, RowsA, RowsB, Cols: LONGINT; 
+		add: BOOLEAN; 
+
+		PROCEDURE ^  & InitX*(MatrixA, MatrixB, MatrixC, Stride, IncC, StrideC, RowsA, RowsB, Cols: LONGINT; add: BOOLEAN); 
+		PROCEDURE ^ Compute; 
+	END MatMulHObjX; 
+
+	MultiplyObjectR = OBJECT {EXCLUSIVE} (ComputationObj)
+	VAR 
+		adrA, adrB, C, M, N, K, IncC, StrideC, L2BlockM, L2BlockN, L2BlockK: LONGINT; 
+		start, finished: BOOLEAN; 
+
+		PROCEDURE ^  & InitR*(adrA, adrB, C, M, N, K, IncC, StrideC, L2BlockM, L2BlockN, L2BlockK: LONGINT); 
+		PROCEDURE ^ Compute; 
+	END MultiplyObjectR; 
+
+	MultiplyObjectX = OBJECT {EXCLUSIVE} (ComputationObj)
+	VAR 
+		adrA, adrB, C, M, N, K, IncC, StrideC, L2BlockM, L2BlockN, L2BlockK: LONGINT; 
+		start, finished: BOOLEAN; 
+
+		PROCEDURE ^  & InitX*(adrA, adrB, C, M, N, K, IncC, StrideC, L2BlockM, L2BlockN, L2BlockK: LONGINT); 
+		PROCEDURE ^ Compute; 
+	END MultiplyObjectX; 
+VAR 
+	alignedC*, unalignedC*, singleC*: LONGINT; 
+	rejectMatMul*: LONGINT; 
+	matAllocTime*, matCompTime*: LONGINT; 
+	cBlockSize*: LONGINT; 
+	nrProcesses*: LONGINT; 
+	lastUsedBlockSize*: LONGINT; 
+	allocT-, copyT-, zeroT-, compT-: HUGEINT; 
+	cachePool: CachePool; 
+
+	PROCEDURE  - L1Block1XA(adrA, adrB, adrC, K: LONGINT);
+	CODE
+	END L1Block1XA; 
+	PROCEDURE  - L1Block1XSSE(adrA, adrB, adrC, K: LONGINT);
+	CODE
+	END L1Block1XSSE; 
+	PROCEDURE  - L1Block5XSSE(adrA, adrB, adrC, IncC, K: LONGINT);
+	CODE
+	END L1Block5XSSE; 
+	PROCEDURE  - L1Block1RA(adrA, adrB, adrC, K: LONGINT);
+	CODE
+	END L1Block1RA; 
+	PROCEDURE  - L1Block1RSSE(adrA, adrB, adrC, K: LONGINT);
+	CODE
+	END L1Block1RSSE; 
+	PROCEDURE  - L1Block5RSSE(adrA, adrB, adrC, IncC, K: LONGINT);
+	CODE
+	END L1Block5RSSE; 
+	PROCEDURE  - Align4(adr: LONGINT): LONGINT;
+	CODE
+	END Align4; 
+	PROCEDURE  - Align2(adr: LONGINT): LONGINT;
+	CODE
+	END Align2; 
+	PROCEDURE  - ZeroR(adr: LONGINT; count: LONGINT);
+	CODE
+	END ZeroR; 
+	PROCEDURE  - ZeroX(adr: LONGINT; count: LONGINT);
+	CODE
+	END ZeroX; 
+	PROCEDURE  - ZeroRI(adr, inc: LONGINT; count: LONGINT);
+	CODE
+	END ZeroRI; 
+	PROCEDURE  - ZeroXI(adr, inc: LONGINT; count: LONGINT);
+	CODE
+	END ZeroXI; 
+	PROCEDURE  - MovR(from, to0, frominc, count: LONGINT);
+	CODE
+	END MovR; 
+	PROCEDURE  - MovX(from, to0, frominc, count: LONGINT);
+	CODE
+	END MovX; 
+	PROCEDURE  - MovR5(src, inc, stride, dest, count: LONGINT);
+	CODE
+	END MovR5; 
+	PROCEDURE ^ AddAXAXLoopA(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ AddARARLoopA(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ AddAXAXLoopSSE(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ AddARARLoopSSE(ladr, radr, dadr, linc, rinc, dinc, len: LONGINT); 
+	PROCEDURE ^ SPAXAXLoopA(ladr, radr, dadr, linc, rinc, len: LONGINT); 
+	PROCEDURE ^ SPARARLoopA(ladr, radr, dadr, linc, rinc, len: LONGINT); 
+	PROCEDURE ^ SPAXAXLoopSSE(ladr, radr, dadr, linc, rinc, len: LONGINT); 
+	PROCEDURE ^ SPARARLoopSSE(ladr, radr, dadr, linc, rinc, len: LONGINT); 
+	PROCEDURE ^ MulAXSXLoopA(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ MulARSRLoopA(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ IncMulAXSXLoopA(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ IncMulARSRLoopA(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ MulAXSXLoopSSE(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ MulARSRLoopSSE(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ IncMulAXSXLoopSSE(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ IncMulARSRLoopSSE(ladr, radr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ AlignedSPXSSE(ladr, radr, dadr, len: LONGINT; add: BOOLEAN); 
+	PROCEDURE ^ AlignedSPRSSE(ladr, radr, dadr, len: LONGINT; add: BOOLEAN); 
+	PROCEDURE ^ Copy4(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ Copy8(ladr, dadr, linc, dinc, len: LONGINT); 
+	PROCEDURE ^ Transpose4A(ladr, dadr, lstride, linc, dstride, dinc, rows, cols: LONGINT); 
+	PROCEDURE ^ Transpose4(ladr, dadr, lstride, linc, dstride, dinc, rows, cols: LONGINT); 
+	PROCEDURE ^ Transpose8(ladr, dadr, lstride, linc, dstride, dinc, rows, cols: LONGINT); 
+	PROCEDURE ^ Transpose8A(ladr, dadr, lstride, linc, dstride, dinc, rows, cols: LONGINT); 
+	PROCEDURE ^ SSEMul24BlockR(VAR CbFirst: LONGINT; StrideA, StrideB, StrideC, Ca, Ra, Cb, Rb, matrixA, matrixB, matrixC: LONGINT; add: BOOLEAN); 
+	PROCEDURE ^ SSEMul12BlockX(VAR CbFirst: LONGINT; StrideA, StrideB, StrideC, Ca, Ra, Cb, Rb, matrixA, matrixB, matrixC: LONGINT; add: BOOLEAN); 
+	PROCEDURE ^ SSEMul16BlockR(StrideA, StrideB, StrideC, Ca, Ra, CbFrom, matrixA, matrixB, matrixC: LONGINT; add: BOOLEAN); 
+	PROCEDURE ^ SSEMul8BlockX(StrideA, StrideB, StrideC, Ca, Ra, CbFrom, matrixA, matrixB, matrixC: LONGINT; add: BOOLEAN); 
+	PROCEDURE ^ SSEMul8BlockR(StrideA, StrideB, StrideC, Ca, Ra, CbFrom, matrixA, matrixB, matrixC: LONGINT; add: BOOLEAN); 
+	PROCEDURE ^ SSEMul4BlockX(StrideA, StrideB, StrideC, Ca, Ra, CbFrom, matrixA, matrixB, matrixC: LONGINT; add: BOOLEAN); 
+	PROCEDURE ^ SSEMul4BlockR(StrideA, StrideB, StrideC, Ca, Ra, CbFrom, matrixA, matrixB, matrixC: LONGINT; add: BOOLEAN); 
+	PROCEDURE ^ SSEMul2BlockX(StrideA, StrideB, StrideC, Ca, Ra, CbFrom, matrixA, matrixB, matrixC: LONGINT; add: BOOLEAN); 
+	PROCEDURE ^ MagicBlockR(M, N, K: LONGINT; VAR L2BlockM, L2BlockN, L2BlockK: LONGINT); 
+	PROCEDURE ^ MagicBlockX(M, N, K: LONGINT; VAR L2BlockM, L2BlockN, L2BlockK: LONGINT); 
+	PROCEDURE ^ DispCR(adrM: LONGINT; inc, stride, M, N: LONGINT); 
+	PROCEDURE ^ DispCX(adrM: LONGINT; inc, stride, M, N: LONGINT); 
+	PROCEDURE ^ L3BlockX(matrixA, matrixB, matrixC: LONGINT; M, N, K, incC, strideC, L2BlockM, L2BlockN, L2BlockK: LONGINT); 
+	PROCEDURE ^ L3BlockR(matrixA, matrixB, matrixC: LONGINT; M, N, K, incC, strideC, L2BlockM, L2BlockN, L2BlockK: LONGINT); 
+	PROCEDURE ^ Align(adr: LONGINT; align: LONGINT): LONGINT; 
+	PROCEDURE ^ CopyAX(matrixA, dest: LONGINT; IncA, StrideA: LONGINT; K, M, L2BlockK, L2BlockM: LONGINT); 
+	PROCEDURE ^ CopyAR(matrixA, dest: LONGINT; IncA, StrideA: LONGINT; K, M, L2BlockK, L2BlockM: LONGINT); 
+	PROCEDURE ^ CopyBX(matrixB, dest: LONGINT; IncB, StrideB: LONGINT; N, K, L2BlockN, L2BlockK: LONGINT); 
+	PROCEDURE ^ CopyBR(matrixB, dest: LONGINT; IncB, StrideB: LONGINT; N, K, L2BlockN, L2BlockK: LONGINT); 
+	PROCEDURE  - GetTimer(): HUGEINT;
+	CODE
+	END GetTimer; 
+	PROCEDURE ^ Tic(VAR t: HUGEINT); 
+	PROCEDURE ^ Toc(VAR t, addto: HUGEINT); 
+	PROCEDURE ^ MultiplyX(A, B, C, M, N, K, L2BlockM, L2BlockN, L2BlockK: LONGINT; IncA, StrideA, IncB, StrideB, IncC, StrideC: LONGINT; add: BOOLEAN); 
+	PROCEDURE ^ MultiplyR(A, B, C, M, N, K, L2BlockM, L2BlockN, L2BlockK: LONGINT; IncA, StrideA, IncB, StrideB, IncC, StrideC: LONGINT; add: BOOLEAN); 
+	PROCEDURE ^ MatMulAXAXLoopA(ladr, radr, dadr, linc, rinc, len: LONGINT); 
+	PROCEDURE ^ MatMulAXAXLoopSSE(ladr, radr, dadr, linc, rinc, len: LONGINT); 
+	PROCEDURE ^ MatMulARARLoopA(ladr, radr, dadr, linc, rinc, len: LONGINT); 
+	PROCEDURE ^ MatMulARARLoopSSE(ladr, radr, dadr, linc, rinc, len: LONGINT); 
+	PROCEDURE ^ MatMulIncAXAXLoopA(ladr, radr, dadr, linc, rinc, len: LONGINT); 
+	PROCEDURE ^ MatMulIncAXAXLoopSSE(ladr, radr, dadr, linc, rinc, len: LONGINT); 
+	PROCEDURE ^ MatMulIncARARLoopA(ladr, radr, dadr, linc, rinc, len: LONGINT); 
+	PROCEDURE ^ MatMulIncARARLoopSSE(ladr, radr, dadr, linc, rinc, len: LONGINT); 
+	PROCEDURE ^ MatMulHBlockR(MatrixA, MatrixB, MatrixC, Stride, IncC, StrideC, RowsA, RowsB, Cols: LONGINT; add: BOOLEAN); 
+	PROCEDURE ^ MatMulHBlockX(MatrixA, MatrixB, MatrixC, Stride, IncC, StrideC, RowsA, RowsB, Cols: LONGINT; add: BOOLEAN); 
+	PROCEDURE ^ CopyDataR(src, dest, incSrc, strideSrc, incDest, strideDest, rows, cols: LONGINT); 
+	PROCEDURE ^ CopyDataX(src, dest, incSrc, strideSrc, incDest, strideDest, rows, cols: LONGINT); 
+	PROCEDURE ^ MatMulARARTransposed(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT; add: BOOLEAN): BOOLEAN; 
+	PROCEDURE ^ MatMulAXAXTransposed(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT; add: BOOLEAN): BOOLEAN; 
+	PROCEDURE ^ MatMulARARSSEStride(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT; add: BOOLEAN): BOOLEAN; 
+	PROCEDURE ^ MatMulAXAXSSEStride(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT; add: BOOLEAN): BOOLEAN; 
+	PROCEDURE ^ MatMulARARNaiive(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, M, N, K: LONGINT; add: BOOLEAN); 
+	PROCEDURE ^ MatMulAXAXNaiive(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, M, N, K: LONGINT; add: BOOLEAN); 
+	PROCEDURE ^ BestMethod(M, N, K: LONGINT): LONGINT; 
+	PROCEDURE ^ MatMulR(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulX(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulIncR(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulIncX(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulARARBlocked(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT; add: BOOLEAN): BOOLEAN; 
+	PROCEDURE ^ MatMulAXAXBlocked(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT; add: BOOLEAN): BOOLEAN; 
+	PROCEDURE ^ MatMulRNaive(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulXNaive(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulIncRNaive(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulIncXNaive(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulXTransposed(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulIncXTransposed(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulRTransposed(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulIncRTransposed(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulXSSEStride(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulIncXSSEStride(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulRSSEStride(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulIncRSSEStride(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulRBlocked(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulIncRBlocked(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulXBlocked(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ MatMulIncXBlocked(matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT): BOOLEAN; 
+	PROCEDURE ^ SetMatMulMethod*(i: LONGINT); 
+	PROCEDURE ^ MatMulR2x2(dadr, ladr, radr: LONGINT); 
+	PROCEDURE ^ MatMulR3x3(dadr, ladr, radr: LONGINT); 
+	PROCEDURE ^ MatMulR4x4(dadr, ladr, radr: LONGINT); 
+	PROCEDURE ^ MatVecMulR2x2(dadr, ladr, radr: LONGINT); 
+	PROCEDURE ^ InstallMatMul*(context: Commands.Context); 
+	PROCEDURE ^ InstallAsm*; 
+	PROCEDURE ^ InstallSSE*; 
+	PROCEDURE ^ InstallSSE2*; 
+	PROCEDURE ^ Install*; 
+	PROCEDURE ^ SetParameters*(context: Commands.Context); 
+BEGIN
+END ArrayBaseOptimized.

WinAos/obg/ArrayXdBytes.SymW

@@ -0,0 +1,231 @@
+MODULE ArrayXdBytes;
+	IMPORT SYSTEM, Array1dBytes, dbgOut := KernelLog, DataIO;
+CONST 
+	strongIndexChecking = TRUE; 
+	debug = FALSE; 
+TYPE 
+	Index* = LONGINT; 
+
+	IndexArray* = POINTER TO ARRAY OF Index; 
+
+	Address* = LONGINT; 
+
+	ArrayMemoryStructure* = OBJECT 
+	VAR 
+		baseadr: Index; 
+		bytes-: Index; 
+		dim-: Index; 
+		len-: IndexArray; 
+		diminc-: IndexArray; 
+		elementsize: Index; 
+		origin-: IndexArray; 
+		adrwoffset: Index; 
+	END ArrayMemoryStructure; 
+
+	Enumerator* = OBJECT 
+	VAR 
+		dim: LONGINT; 
+		mem: ArrayMemoryStructure; 
+		adr-, size-: LONGINT; 
+		lncdim: LONGINT; 
+		pos-, origin, len: IndexArray; 
+
+		PROCEDURE ^  & Init*(mem: ArrayMemoryStructure; enumorigin, enumlen: IndexArray; block: BOOLEAN); 
+		PROCEDURE ^ Next*(): BOOLEAN; 
+	END Enumerator; 
+
+	Array* = OBJECT (ArrayMemoryStructure)
+	VAR 
+		protector: ANY; 
+		permutation-: IndexArray; 
+		bc-: SHORTINT; 
+		f0, f1, f2, f3: Index; 
+		o0-, o1-, o2-, o3-, l0-, l1-, l2-, l3-: Index; 
+
+		PROCEDURE ^ dbgWriteInfo*; 
+		PROCEDURE ^ GetInfo*(VAR elementsize: LONGINT); 
+		PROCEDURE ^ SetBoundaryCondition*(c: SHORTINT); 
+		PROCEDURE ^ Allocate*(size: LONGINT; VAR baseadr: LONGINT; VAR protector: ANY); 
+		PROCEDURE ^ ValidateCache*; 
+		PROCEDURE ^ Init(newdim: LONGINT); 
+		PROCEDURE ^  & NewXdB*(neworigin, newlen: IndexArray); 
+		PROCEDURE ^ AlikeX*(): Array; 
+		PROCEDURE ^ CopyX*(): Array; 
+		PROCEDURE ^ NewRangeX*(neworigin, newlen: IndexArray; preservedata: BOOLEAN); 
+		PROCEDURE ^ OptimizeForAccess*(order: ARRAY OF Index; preservedata: BOOLEAN); 
+		PROCEDURE ^ PermuteDimensions*(permutation: IndexArray; rearrangeMemory: BOOLEAN); 
+		PROCEDURE ^ DeleteElements*(dimension, first, length: Index); 
+		PROCEDURE ^ InsertElements*(dimension, first, length: Index); 
+		PROCEDURE ^ ToggleElements*(dimension: Index; pos1, pos2: Index); 
+		PROCEDURE ^ PermuteElements*(dimension: Index; permutation: ARRAY OF Index); 
+		PROCEDURE ^ MirrorDimension*(dimension: Index); 
+		PROCEDURE ^ BlockCopy*(dimension, from, to, length: Index); 
+		PROCEDURE ^ BlockMove*(dimension, from, to, length: Index); 
+		PROCEDURE ^ LoadXd*(VAR R: DataIO.Reader); 
+		PROCEDURE ^ StoreXd*(VAR W: DataIO.Writer; storeRawData: BOOLEAN); 
+	END Array; 
+
+	Rectangle = OBJECT 
+	VAR 
+		origin, len, destpos, destlen: IndexArray; 
+		next: Rectangle; 
+	END Rectangle; 
+
+	BoundaryEnum* = OBJECT 
+	VAR 
+		root: Rectangle; 
+
+		PROCEDURE ^  & Init*(a: Array; origin, len: IndexArray); 
+		PROCEDURE ^ Get*(VAR origin, len: IndexArray): BOOLEAN; 
+	END BoundaryEnum; 
+
+	PROCEDURE ^ StoreMemory(W: DataIO.Writer; baseadr: LONGINT; len: LONGINT); 
+	PROCEDURE ^ ReadMemory(R: DataIO.Reader; baseadr: LONGINT; size: LONGINT; VAR len: LONGINT); 
+	PROCEDURE ^ Min(l, r: LONGINT): LONGINT; 
+	PROCEDURE ^ CheckIndexArray(dim: Index; VAR a: IndexArray); 
+	PROCEDURE ^ CopyIndexArray(src: ARRAY OF Index; dest: IndexArray); 
+	PROCEDURE ^ Intersect*(org1, len1, org2, len2: IndexArray; VAR org, len: IndexArray): BOOLEAN; 
+	PROCEDURE  - CheckLEQ*(lesseq, than: LONGINT);
+	CODE {SYSTEM.i386}
+		MOV	ECX, [ESP]	;  than
+		MOV	EBX, [ESP+4]	;  less
+		CMP	EBX, ECX
+		JLE	ok
+		PUSH	7
+		INT	3
+		ok:
+		ADD	ESP, 8
+	
+	END CheckLEQ; 
+	PROCEDURE  - CheckLE*(lesseq, than: LONGINT);
+	CODE {SYSTEM.i386}
+		MOV	ECX, [ESP]	;  than
+		MOV	EBX, [ESP+4]	;  less
+		CMP	EBX, ECX
+		JL	ok
+		PUSH	7
+		INT	3
+		ok:
+		ADD	ESP, 8
+	
+	END CheckLE; 
+	PROCEDURE  - CheckEQ*(equals, this: LONGINT);
+	CODE {SYSTEM.i386}
+		MOV	ECX, [ESP]	;  this
+		MOV	EBX, [ESP+4]	;  equals
+		CMP	EBX, ECX
+		JE	ok
+		PUSH	7
+		INT	3
+		ok:
+		ADD	ESP, 8
+	
+	END CheckEQ; 
+	PROCEDURE ^ CheckPermutation(dim: LONGINT; VAR permutation: ARRAY OF LONGINT): BOOLEAN; 
+	PROCEDURE ^ CompletePermutation(beginning: ARRAY OF LONGINT; full: ARRAY OF LONGINT): BOOLEAN; 
+	PROCEDURE ^ ApplyPermutation(permutation: ARRAY OF Index; VAR array: ARRAY OF Index); 
+	PROCEDURE ^ IdentityPermutation(dim: LONGINT): IndexArray; 
+	PROCEDURE ^ ComputeIncrease(len: IndexArray; permutation: IndexArray; elementsize: LONGINT; diminc: IndexArray); 
+	PROCEDURE ^ AMSCopyDescr(src: ArrayMemoryStructure; dest: ArrayMemoryStructure); 
+	PROCEDURE ^ EnumArrayPart(mem: ArrayMemoryStructure; pos, len: IndexArray; chunks: BOOLEAN): Enumerator; 
+	PROCEDURE ^ TraverseMemory*(proc: Address; mem: ArrayMemoryStructure); 
+	PROCEDURE ^ TraverseMemory2*(proc: Address; srcmem, destmem: ArrayMemoryStructure); 
+	PROCEDURE ^ TraverseMemory3*(proc: Address; leftmem, rightmem, destmem: ArrayMemoryStructure); 
+	PROCEDURE ^ TraverseAndCopy(src, dest: Enumerator); 
+	PROCEDURE ^ CopyDataByCoordinateTraversal*(srcmem, destmem: ArrayMemoryStructure); 
+	PROCEDURE ^ CopyDataRaw*(srcmem, destmem: ArrayMemoryStructure); 
+	PROCEDURE ^ CopyDataPositionPreserving*(srcmem, destmem: ArrayMemoryStructure); 
+	PROCEDURE ^ MakeMemoryStructure*(dim: LONGINT; origin, len: IndexArray; elementsize: Index; baseadr: Address): ArrayMemoryStructure; 
+	PROCEDURE ^ MakeContinuousMemStruct*(adr, elements, elementsize: LONGINT; VAR memory: ArrayMemoryStructure); 
+	PROCEDURE ^ CheckEqDimensions*(l, r: Array); 
+	PROCEDURE ^ ToggleDimensions*(a: Array; d1, d2: LONGINT; rearrangeMemory: BOOLEAN); 
+	PROCEDURE ^ dbgS(s: ARRAY OF CHAR); 
+	PROCEDURE ^ dbgSI(s: ARRAY OF CHAR; i: LONGINT); 
+	PROCEDURE ^ dbgSISI(s: ARRAY OF CHAR; i: LONGINT; s2: ARRAY OF CHAR; i2: LONGINT); 
+	PROCEDURE ^ dbgSISISI(s: ARRAY OF CHAR; i: LONGINT; s2: ARRAY OF CHAR; i2: LONGINT; s3: ARRAY OF CHAR; i3: LONGINT); 
+	PROCEDURE ^ dbgWriteMemoryInfo*(a: ArrayMemoryStructure); 
+	PROCEDURE ^ Adr1*(a: Array; x: Index): Index; 
+	PROCEDURE ^ Adr2*(a: Array; x, y: Index): Index; 
+	PROCEDURE ^ Adr3*(a: Array; x, y, z: Index): Index; 
+	PROCEDURE ^ Adr4*(a: Array; x, y, z, t: Index): Index; 
+	PROCEDURE ^ AdrX*(a: ArrayMemoryStructure; VAR b: ARRAY OF Index; dim: Index): Index; 
+	PROCEDURE ^ Index1*(x: LONGINT): IndexArray; 
+	PROCEDURE ^ Array1*(x: LONGINT): IndexArray; 
+	PROCEDURE ^ Index2*(x, y: LONGINT): IndexArray; 
+	PROCEDURE ^ Array2*(x, y: LONGINT): IndexArray; 
+	PROCEDURE ^ Array3*(x, y, z: LONGINT): IndexArray; 
+	PROCEDURE ^ Index3*(x, y, z: LONGINT): IndexArray; 
+	PROCEDURE ^ Index4*(x, y, z, t: LONGINT): IndexArray; 
+	PROCEDURE ^ Array4*(x, y, z, t: LONGINT): IndexArray; 
+	PROCEDURE ^ IndexX*(VAR a: ARRAY OF LONGINT): IndexArray; 
+	PROCEDURE ^ IndexCpy*(src: IndexArray): IndexArray; 
+	PROCEDURE ^ Get1*(a: Array; x: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ Get2*(a: Array; x, y: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ Get3*(a: Array; x, y, z: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ Get4*(a: Array; x, y, z, t: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ GetX*(a: Array; VAR b: ARRAY OF Index; dim: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ Set1*(a: Array; x: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ Set2*(a: Array; x, y: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ Set3*(a: Array; x, y, z: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ Set4*(a: Array; x, y, z, t: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ SetX*(a: Array; VAR b: ARRAY OF Index; dim: Index; VAR v: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ CopyArrayPartToArrayPart*(srcmem, destmem: ArrayMemoryStructure; srcpos, srclen, destpos, destlen: IndexArray); 
+	PROCEDURE ^ FillArrayPart*(mem: ArrayMemoryStructure; pos, len: IndexArray; val: ARRAY OF SYSTEM.BYTE); 
+	PROCEDURE ^ CopyArrayToMemory*(srcmem: ArrayMemoryStructure; destadr: Index; nrelems: Index); 
+	PROCEDURE ^ CopyMemoryToArray*(srcadr: Index; destmem: ArrayMemoryStructure; nrelems: Index); 
+	PROCEDURE ^ CopyArrayPartToMemory*(srcmem: ArrayMemoryStructure; destadr: Index; srcpos, srclen: IndexArray; destlen: Index); 
+	PROCEDURE ^ CopyMemoryToArrayPart*(srcadr: Index; destmem: ArrayMemoryStructure; srclen: Index; destpos, destlen: IndexArray); 
+	PROCEDURE  - InBounds*(origin, len: Index; idx: Index): BOOLEAN;
+	CODE {SYSTEM.i386}
+		; if (idx < origin) or (idx-origin >= len) then return false end;
+		; return true;
+		; AL=1 : TRUE; AL=0: FALSE
+		MOV	EAX, [ESP]	;  EAX := idx
+		MOV	EBX, [ESP+4]	;  EBX := len
+		MOV	ECX, [ESP+8]	;  ECX := origin
+		CMP	EAX, ECX	;
+		JL	outbound	;  idx < origin: outbound
+		SUB	EAX, ECX
+		CMP	EAX, EBX
+		JGE	outbound	;  (idx-origin) >= len
+		MOV	AL, 1
+		JMP	done	;
+		outbound:
+		MOV	AL, 0
+		done:
+		ADD	ESP, 12
+	
+	END InBounds; 
+	PROCEDURE  - PeriodicBounds*(origin, len: Index; idx: Index): Index;
+	CODE {SYSTEM.i386}
+		; DEC( idx, origin );  idx := idx MOD len;  INC( idx, origin );
+
+		; modulus:
+		; a := b MOD c; 	c -> EBX	; b -> EAX
+
+		; CDQ
+		; IDIV EBX
+		; CMP     EDX,0
+		; JNL     2
+		; ADD     EDX,EBX
+
+		; EDX -> a
+
+		MOV	EAX, [ESP]	;  EAX := idx
+		SUB	EAX, [ESP+8]	;  EAX := EAX-origin
+		MOV	EBX, [ESP+4]	;  EBX := len
+		CDQ
+		IDIV	EBX
+		CMP	EDX, 0
+		JNL	2
+		ADD	EDX, EBX
+		MOV	EAX, EDX
+		ADD	EAX, [ESP+8]
+		ADD	ESP, 12
+	
+	END PeriodicBounds; 
+	PROCEDURE ^ MirrorOnB*(origin, len: Index; idx: Index): Index; 
+	PROCEDURE ^ MirrorOffB*(origin, len: Index; idx: Index): Index; 
+	PROCEDURE ^ TestB*; 
+BEGIN
+END ArrayXdBytes.

WinAos/obg/ArrayXdCplx.SymW

@@ -0,0 +1,157 @@
+MODULE ArrayXdCplx;
+	IMPORT SYSTEM, NbrInt, ArrayXdBytes, Array1d := Array1dCplx, NbrCplx, dbgOut := KernelLog, DataErrors, Array1dInt, ArrayXdRat, ArrayXdRe, DataIO;
+CONST 
+	generic* = 0; 
+	vector* = 1; 
+	matrix* = 2; 
+	cube* = 3; 
+	hcube* = 4; 
+	VERSION* = 1; 
+	StrictBoundaryC* = 0; 
+	AbsorbingBoundaryC* = 1; 
+	PeriodicBoundaryC* = 2; 
+	SymmetricOnBoundaryC* = 3; 
+	SymmetricOffBoundaryC* = 4; 
+	AntisymmetricOnBoundaryC* = 5; 
+	AntisymmetricOffBoundaryC* = 6; 
+TYPE 
+	Value* = Array1d.Value; 
+
+	Index* = LONGINT; 
+
+	Array1* = Array1d.Array; 
+
+	IntValue* = Array1dInt.Value; 
+
+	Array2* = POINTER TO ARRAY OF ARRAY OF Value; 
+
+	Array3* = POINTER TO ARRAY OF ARRAY OF ARRAY OF Value; 
+
+	Array4* = POINTER TO ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; 
+
+	Map* = Array1d.Map; 
+
+	Array* = OBJECT {EXCLUSIVE} (ArrayXdBytes.Array)
+	VAR 
+		data-: Array1; 
+
+		PROCEDURE ^ Allocate*(size: LONGINT; VAR adr: Index; VAR ptr: ANY); 
+		PROCEDURE ^ GetInfo*(VAR elementsize: Index); 
+		PROCEDURE ^ AlikeX*(): ArrayXdBytes.Array; 
+		PROCEDURE ^ Read*(R: DataIO.Reader); 
+		PROCEDURE ^ Write*(W: DataIO.Writer); 
+		PROCEDURE ^ Type*(): SHORTINT; 
+		PROCEDURE ^ Get1*(x: Index): Value; 
+		PROCEDURE ^ Set1*(x: Index; v: Value); 
+		PROCEDURE ^ Get2*(x, y: Index): Value; 
+		PROCEDURE ^ Set2*(x, y: Index; v: Value); 
+		PROCEDURE ^ Get3*(x, y, z: Index): Value; 
+		PROCEDURE ^ Set3*(x, y, z: Index; v: Value); 
+		PROCEDURE ^ Get4*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ Set4*(x, y, z, t: Index; v: Value); 
+		PROCEDURE ^ GetX*(VAR x: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ SetX*(VAR x: ARRAY OF Index; dim: Index; v: Value); 
+		PROCEDURE ^ Get1BAbsorbing*(x: Index): Value; 
+		PROCEDURE ^ Get2BAbsorbing*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAbsorbing*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAbsorbing*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAbsorbing*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BPeriodic*(x: Index): Value; 
+		PROCEDURE ^ Get2BPeriodic*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BPeriodic*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BPeriodic*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBPeriodic*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BSymmetricOffB*(x: Index): Value; 
+		PROCEDURE ^ Get2BSymmetricOffB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BSymmetricOffB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BSymmetricOffB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBSymmetricOffB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BSymmetricOnB*(x: Index): Value; 
+		PROCEDURE ^ Get2BSymmetricOnB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BSymmetricOnB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BSymmetricOnB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBSymmetricOnB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BAntisymmetricOffB*(x: Index): Value; 
+		PROCEDURE ^ Get2BAntisymmetricOffB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAntisymmetricOffB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAntisymmetricOffB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAntisymmetricOffB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BAntisymmetricOnB*(x: Index): Value; 
+		PROCEDURE ^ Get2BAntisymmetricOnB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAntisymmetricOnB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAntisymmetricOnB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAntisymmetricOnB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ CopyToArray*(dest: Array; srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray); 
+		PROCEDURE ^ MapAll*(m: Array1d.Map); 
+		PROCEDURE ^ Negate*; 
+		PROCEDURE ^ Add*(x: Array); 
+		PROCEDURE ^ Subtract*(x: Array); 
+		PROCEDURE ^ Multiply*(a: Value); 
+		PROCEDURE ^ Divide*(a: Value); 
+		PROCEDURE ^ dbgWrite*; 
+	END Array; 
+VAR 
+	zero: Value; 
+
+	PROCEDURE ^ New1d*(ox, w: Index): Array; 
+	PROCEDURE ^ New2d*(ox, w, oy, h: Index): Array; 
+	PROCEDURE ^ New3d*(ox, w, oy, h, oz, d: Index): Array; 
+	PROCEDURE ^ New4d*(ox, w, oy, h, oz, d, ot, dt: Index): Array; 
+	PROCEDURE ^ CopyVecToVec*(src, dest: Array; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyMtxToVec*(src, dest: Array; dim: Index; srcx, srcy, destx, len: Index); 
+	PROCEDURE ^ CopyVecToMtx*(src, dest: Array; dim: Index; srcx, destx, desty, len: Index); 
+	PROCEDURE ^ CopyCubeToVec*(src, dest: Array; dim: Index; srcx, srcy, srcz, destx, len: Index); 
+	PROCEDURE ^ CopyVecToCube*(src, dest: Array; dim: Index; srcx, destx, desty, destz, len: Index); 
+	PROCEDURE ^ CopyHCubeToVec*(src, dest: Array; dim: Index; srcx, srcy, srcz, srct, destx, len: Index); 
+	PROCEDURE ^ CopyVecToHCube*(src, dest: Array; dim: Index; srcx, destx, desty, destz, destt, len: Index); 
+	PROCEDURE ^ CopyMtxToMtx*(src, dest: Array; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyCubeToMtx*(src, dest: Array; dimx, dimy: Index; srcx, srcy, srcz, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToCube*(src, dest: Array; dimx, dimy: Index; srcx, srcy, destx, desty, destz, lenx, leny: Index); 
+	PROCEDURE ^ CopyHCubeToMtx*(src, dest: Array; dimx, dimy: Index; srcx, srcy, srcz, srct, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToHCube*(src, dest: Array; dimx, dimy: Index; srcx, srcy, destx, desty, destz, destt, lenx, leny: Index); 
+	PROCEDURE ^ CopyCubeToCube*(src, dest: Array; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyHCubeToCube*(src, dest: Array; dimx, dimy, dimz: Index; srcx, srcy, srcz, srct, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyCubeToHCube*(src, dest: Array; dimx, dimy, dimz: Index; srcx, srcy, srcz, destx, desty, destz, destt, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyHCubeToHCube*(src, dest: Array; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyArrayToVec*(VAR src: ARRAY OF Value; dest: Array; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyVecToArray*(src: Array; VAR dest: ARRAY OF Value; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyArrayToMtx*(VAR src: ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF Value; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyArrayToCube*(VAR src: ARRAY OF ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyCubeToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF ARRAY OF Value; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyArrayToHCube*(VAR src: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyHCubeToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyArrayToArrayPartB*(src: Array; dest: ArrayXdBytes.ArrayMemoryStructure; boundaryCondition: SHORTINT; srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray); 
+	OPERATOR ^ ":="-(VAR l: Array1; r: Array); 
+	OPERATOR ^ ":="-(VAR l: Array2; r: Array); 
+	OPERATOR ^ ":="-(VAR l: Array3; r: Array); 
+	PROCEDURE ^ Fill*(l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: ArrayXdRe.Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: ArrayXdRat.Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: IntValue); 
+	PROCEDURE ^ Add*(l, r, res: Array); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	PROCEDURE ^ Sub*(l, r, res: Array); 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	PROCEDURE ^ Mul*(l, r, res: Array); 
+	PROCEDURE ^ Div*(l, r, res: Array); 
+	PROCEDURE ^ AddAV*(l: Array; r: Value; res: Array); 
+	OPERATOR ^ "+"(l: Array; r: IntValue): Array; 
+	OPERATOR ^ "+"(l: IntValue; r: Array): Array; 
+	PROCEDURE ^ MulAV*(l: Array; r: Value; res: Array); 
+	OPERATOR ^ "*"(l: Array; r: IntValue): Array; 
+	OPERATOR ^ "*"(l: IntValue; r: Array): Array; 
+	PROCEDURE ^ DivAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ DivVA*(l: Value; r: Array; res: Array); 
+	PROCEDURE ^ SubAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ SubVA*(l: Value; r: Array; res: Array); 
+	OPERATOR ^ "-"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "-"-(l: IntValue; r: Array): Array; 
+	PROCEDURE ^ LoadArray(R: DataIO.Reader; VAR obj: OBJECT); 
+	PROCEDURE ^ StoreArray(W: DataIO.Writer; obj: OBJECT); 
+	PROCEDURE ^ Register; 
+	PROCEDURE ^ Load*(R: DataIO.Reader; VAR obj: Array); 
+	PROCEDURE ^ Store*(W: DataIO.Writer; obj: Array); 
+BEGIN
+END ArrayXdCplx.

WinAos/obg/ArrayXdInt.SymW

@@ -0,0 +1,155 @@
+MODULE ArrayXdInt;
+	IMPORT SYSTEM, NbrInt, ArrayXdBytes, Array1d := Array1dInt, dbgOut := KernelLog, DataErrors, DataIO;
+CONST 
+	generic* = 0; 
+	vector* = 1; 
+	matrix* = 2; 
+	cube* = 3; 
+	hcube* = 4; 
+	VERSION* = 1; 
+	StrictBoundaryC* = 0; 
+	AbsorbingBoundaryC* = 1; 
+	PeriodicBoundaryC* = 2; 
+	SymmetricOnBoundaryC* = 3; 
+	SymmetricOffBoundaryC* = 4; 
+	AntisymmetricOnBoundaryC* = 5; 
+	AntisymmetricOffBoundaryC* = 6; 
+TYPE 
+	Value* = Array1d.Value; 
+
+	Index* = LONGINT; 
+
+	Array1* = Array1d.Array; 
+
+	Array2* = POINTER TO ARRAY OF ARRAY OF Value; 
+
+	Array3* = POINTER TO ARRAY OF ARRAY OF ARRAY OF Value; 
+
+	Array4* = POINTER TO ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; 
+
+	Map* = Array1d.Map; 
+
+	Array* = OBJECT {EXCLUSIVE} (ArrayXdBytes.Array)
+	VAR 
+		data-: Array1; 
+
+		PROCEDURE ^ Allocate*(size: LONGINT; VAR adr: Index; VAR ptr: ANY); 
+		PROCEDURE ^ GetInfo*(VAR elementsize: Index); 
+		PROCEDURE ^ AlikeX*(): ArrayXdBytes.Array; 
+		PROCEDURE ^ Read*(R: DataIO.Reader); 
+		PROCEDURE ^ Write*(W: DataIO.Writer); 
+		PROCEDURE ^ Type*(): SHORTINT; 
+		PROCEDURE ^ Get1*(x: Index): Value; 
+		PROCEDURE ^ Set1*(x: Index; v: Value); 
+		PROCEDURE ^ Get2*(x, y: Index): Value; 
+		PROCEDURE ^ Set2*(x, y: Index; v: Value); 
+		PROCEDURE ^ Get3*(x, y, z: Index): Value; 
+		PROCEDURE ^ Set3*(x, y, z: Index; v: Value); 
+		PROCEDURE ^ Get4*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ Set4*(x, y, z, t: Index; v: Value); 
+		PROCEDURE ^ GetX*(VAR x: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ SetX*(VAR x: ARRAY OF Index; dim: Index; v: Value); 
+		PROCEDURE ^ Get1BAbsorbing*(x: Index): Value; 
+		PROCEDURE ^ Get2BAbsorbing*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAbsorbing*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAbsorbing*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAbsorbing*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BPeriodic*(x: Index): Value; 
+		PROCEDURE ^ Get2BPeriodic*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BPeriodic*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BPeriodic*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBPeriodic*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BSymmetricOffB*(x: Index): Value; 
+		PROCEDURE ^ Get2BSymmetricOffB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BSymmetricOffB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BSymmetricOffB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBSymmetricOffB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BSymmetricOnB*(x: Index): Value; 
+		PROCEDURE ^ Get2BSymmetricOnB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BSymmetricOnB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BSymmetricOnB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBSymmetricOnB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BAntisymmetricOffB*(x: Index): Value; 
+		PROCEDURE ^ Get2BAntisymmetricOffB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAntisymmetricOffB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAntisymmetricOffB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAntisymmetricOffB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BAntisymmetricOnB*(x: Index): Value; 
+		PROCEDURE ^ Get2BAntisymmetricOnB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAntisymmetricOnB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAntisymmetricOnB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAntisymmetricOnB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ CopyToArray*(dest: Array; srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray); 
+		PROCEDURE ^ MapAll*(m: Array1d.Map); 
+		PROCEDURE ^ Negate*; 
+		PROCEDURE ^ Add*(x: Array); 
+		PROCEDURE ^ Subtract*(x: Array); 
+		PROCEDURE ^ Multiply*(a: Value); 
+		PROCEDURE ^ Divide*(a: Value); 
+		PROCEDURE ^ Modulus*(a: Value); 
+		PROCEDURE ^ dbgWrite*; 
+	END Array; 
+
+	PROCEDURE ^ New1d*(ox, w: Index): Array; 
+	PROCEDURE ^ New2d*(ox, w, oy, h: Index): Array; 
+	PROCEDURE ^ New3d*(ox, w, oy, h, oz, d: Index): Array; 
+	PROCEDURE ^ New4d*(ox, w, oy, h, oz, d, ot, dt: Index): Array; 
+	PROCEDURE ^ CopyVecToVec*(src, dest: Array; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyMtxToVec*(src, dest: Array; dim: Index; srcx, srcy, destx, len: Index); 
+	PROCEDURE ^ CopyVecToMtx*(src, dest: Array; dim: Index; srcx, destx, desty, len: Index); 
+	PROCEDURE ^ CopyCubeToVec*(src, dest: Array; dim: Index; srcx, srcy, srcz, destx, len: Index); 
+	PROCEDURE ^ CopyVecToCube*(src, dest: Array; dim: Index; srcx, destx, desty, destz, len: Index); 
+	PROCEDURE ^ CopyHCubeToVec*(src, dest: Array; dim: Index; srcx, srcy, srcz, srct, destx, len: Index); 
+	PROCEDURE ^ CopyVecToHCube*(src, dest: Array; dim: Index; srcx, destx, desty, destz, destt, len: Index); 
+	PROCEDURE ^ CopyMtxToMtx*(src, dest: Array; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyCubeToMtx*(src, dest: Array; dimx, dimy: Index; srcx, srcy, srcz, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToCube*(src, dest: Array; dimx, dimy: Index; srcx, srcy, destx, desty, destz, lenx, leny: Index); 
+	PROCEDURE ^ CopyHCubeToMtx*(src, dest: Array; dimx, dimy: Index; srcx, srcy, srcz, srct, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToHCube*(src, dest: Array; dimx, dimy: Index; srcx, srcy, destx, desty, destz, destt, lenx, leny: Index); 
+	PROCEDURE ^ CopyCubeToCube*(src, dest: Array; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyHCubeToCube*(src, dest: Array; dimx, dimy, dimz: Index; srcx, srcy, srcz, srct, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyCubeToHCube*(src, dest: Array; dimx, dimy, dimz: Index; srcx, srcy, srcz, destx, desty, destz, destt, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyHCubeToHCube*(src, dest: Array; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyArrayToVec*(VAR src: ARRAY OF Value; dest: Array; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyVecToArray*(src: Array; VAR dest: ARRAY OF Value; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyArrayToMtx*(VAR src: ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF Value; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyArrayToCube*(VAR src: ARRAY OF ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyCubeToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF ARRAY OF Value; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyArrayToHCube*(VAR src: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyHCubeToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyArrayToArrayPartB*(src: Array; dest: ArrayXdBytes.ArrayMemoryStructure; boundaryCondition: SHORTINT; srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF ARRAY OF Value); 
+	OPERATOR ^ ":="-(VAR l: Array1; r: Array); 
+	OPERATOR ^ ":="-(VAR l: Array2; r: Array); 
+	OPERATOR ^ ":="-(VAR l: Array3; r: Array); 
+	PROCEDURE ^ Fill*(l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	PROCEDURE ^ Add*(l, r, res: Array); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	PROCEDURE ^ Sub*(l, r, res: Array); 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	PROCEDURE ^ Mul*(l, r, res: Array); 
+	PROCEDURE ^ Div*(l, r, res: Array); 
+	PROCEDURE ^ Mod*(l, r, res: Array); 
+	PROCEDURE ^ AddAV*(l: Array; r: Value; res: Array); 
+	OPERATOR ^ "+"(l: Array; r: Value): Array; 
+	OPERATOR ^ "+"(l: Value; r: Array): Array; 
+	PROCEDURE ^ MulAV*(l: Array; r: Value; res: Array); 
+	OPERATOR ^ "*"(l: Array; r: Value): Array; 
+	OPERATOR ^ "*"(l: Value; r: Array): Array; 
+	PROCEDURE ^ DivAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ DivVA*(l: Value; r: Array; res: Array); 
+	PROCEDURE ^ ModAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ ModVA*(l: Value; r: Array; res: Array); 
+	PROCEDURE ^ SubAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ SubVA*(l: Value; r: Array; res: Array); 
+	OPERATOR ^ "-"-(l: Value; r: Array): Array; 
+	PROCEDURE ^ LoadArray(R: DataIO.Reader; VAR obj: OBJECT); 
+	PROCEDURE ^ StoreArray(W: DataIO.Writer; obj: OBJECT); 
+	PROCEDURE ^ Register; 
+	PROCEDURE ^ Load*(R: DataIO.Reader; VAR obj: Array); 
+	PROCEDURE ^ Store*(W: DataIO.Writer; obj: Array); 
+BEGIN
+END ArrayXdInt.

WinAos/obg/ArrayXdRat.SymW

@@ -0,0 +1,154 @@
+MODULE ArrayXdRat;
+	IMPORT SYSTEM, NbrInt, ArrayXdBytes, Array1d := Array1dRat, dbgOut := KernelLog, NbrRat, DataErrors, Array1dInt, DataIO;
+CONST 
+	generic* = 0; 
+	vector* = 1; 
+	matrix* = 2; 
+	cube* = 3; 
+	hcube* = 4; 
+	VERSION* = 1; 
+	StrictBoundaryC* = 0; 
+	AbsorbingBoundaryC* = 1; 
+	PeriodicBoundaryC* = 2; 
+	SymmetricOnBoundaryC* = 3; 
+	SymmetricOffBoundaryC* = 4; 
+	AntisymmetricOnBoundaryC* = 5; 
+	AntisymmetricOffBoundaryC* = 6; 
+TYPE 
+	Value* = Array1d.Value; 
+
+	Index* = LONGINT; 
+
+	Array1* = Array1d.Array; 
+
+	IntValue* = Array1dInt.Value; 
+
+	Array2* = POINTER TO ARRAY OF ARRAY OF Value; 
+
+	Array3* = POINTER TO ARRAY OF ARRAY OF ARRAY OF Value; 
+
+	Array4* = POINTER TO ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; 
+
+	Map* = Array1d.Map; 
+
+	Array* = OBJECT {EXCLUSIVE} (ArrayXdBytes.Array)
+	VAR 
+		data-: Array1; 
+
+		PROCEDURE ^ Allocate*(size: LONGINT; VAR adr: Index; VAR ptr: ANY); 
+		PROCEDURE ^ GetInfo*(VAR elementsize: Index); 
+		PROCEDURE ^ AlikeX*(): ArrayXdBytes.Array; 
+		PROCEDURE ^ Read*(R: DataIO.Reader); 
+		PROCEDURE ^ Write*(W: DataIO.Writer); 
+		PROCEDURE ^ Type*(): SHORTINT; 
+		PROCEDURE ^ Get1*(x: Index): Value; 
+		PROCEDURE ^ Set1*(x: Index; v: Value); 
+		PROCEDURE ^ Get2*(x, y: Index): Value; 
+		PROCEDURE ^ Set2*(x, y: Index; v: Value); 
+		PROCEDURE ^ Get3*(x, y, z: Index): Value; 
+		PROCEDURE ^ Set3*(x, y, z: Index; v: Value); 
+		PROCEDURE ^ Get4*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ Set4*(x, y, z, t: Index; v: Value); 
+		PROCEDURE ^ GetX*(VAR x: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ SetX*(VAR x: ARRAY OF Index; dim: Index; v: Value); 
+		PROCEDURE ^ Get1BAbsorbing*(x: Index): Value; 
+		PROCEDURE ^ Get2BAbsorbing*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAbsorbing*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAbsorbing*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAbsorbing*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BPeriodic*(x: Index): Value; 
+		PROCEDURE ^ Get2BPeriodic*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BPeriodic*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BPeriodic*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBPeriodic*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BSymmetricOffB*(x: Index): Value; 
+		PROCEDURE ^ Get2BSymmetricOffB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BSymmetricOffB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BSymmetricOffB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBSymmetricOffB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BSymmetricOnB*(x: Index): Value; 
+		PROCEDURE ^ Get2BSymmetricOnB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BSymmetricOnB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BSymmetricOnB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBSymmetricOnB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BAntisymmetricOffB*(x: Index): Value; 
+		PROCEDURE ^ Get2BAntisymmetricOffB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAntisymmetricOffB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAntisymmetricOffB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAntisymmetricOffB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BAntisymmetricOnB*(x: Index): Value; 
+		PROCEDURE ^ Get2BAntisymmetricOnB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAntisymmetricOnB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAntisymmetricOnB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAntisymmetricOnB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ CopyToArray*(dest: Array; srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray); 
+		PROCEDURE ^ MapAll*(m: Array1d.Map); 
+		PROCEDURE ^ Negate*; 
+		PROCEDURE ^ Add*(x: Array); 
+		PROCEDURE ^ Subtract*(x: Array); 
+		PROCEDURE ^ Multiply*(a: Value); 
+		PROCEDURE ^ Divide*(a: Value); 
+		PROCEDURE ^ dbgWrite*; 
+	END Array; 
+VAR 
+	zero: Value; 
+
+	PROCEDURE ^ New1d*(ox, w: Index): Array; 
+	PROCEDURE ^ New2d*(ox, w, oy, h: Index): Array; 
+	PROCEDURE ^ New3d*(ox, w, oy, h, oz, d: Index): Array; 
+	PROCEDURE ^ New4d*(ox, w, oy, h, oz, d, ot, dt: Index): Array; 
+	PROCEDURE ^ CopyVecToVec*(src, dest: Array; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyMtxToVec*(src, dest: Array; dim: Index; srcx, srcy, destx, len: Index); 
+	PROCEDURE ^ CopyVecToMtx*(src, dest: Array; dim: Index; srcx, destx, desty, len: Index); 
+	PROCEDURE ^ CopyCubeToVec*(src, dest: Array; dim: Index; srcx, srcy, srcz, destx, len: Index); 
+	PROCEDURE ^ CopyVecToCube*(src, dest: Array; dim: Index; srcx, destx, desty, destz, len: Index); 
+	PROCEDURE ^ CopyHCubeToVec*(src, dest: Array; dim: Index; srcx, srcy, srcz, srct, destx, len: Index); 
+	PROCEDURE ^ CopyVecToHCube*(src, dest: Array; dim: Index; srcx, destx, desty, destz, destt, len: Index); 
+	PROCEDURE ^ CopyMtxToMtx*(src, dest: Array; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyCubeToMtx*(src, dest: Array; dimx, dimy: Index; srcx, srcy, srcz, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToCube*(src, dest: Array; dimx, dimy: Index; srcx, srcy, destx, desty, destz, lenx, leny: Index); 
+	PROCEDURE ^ CopyHCubeToMtx*(src, dest: Array; dimx, dimy: Index; srcx, srcy, srcz, srct, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToHCube*(src, dest: Array; dimx, dimy: Index; srcx, srcy, destx, desty, destz, destt, lenx, leny: Index); 
+	PROCEDURE ^ CopyCubeToCube*(src, dest: Array; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyHCubeToCube*(src, dest: Array; dimx, dimy, dimz: Index; srcx, srcy, srcz, srct, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyCubeToHCube*(src, dest: Array; dimx, dimy, dimz: Index; srcx, srcy, srcz, destx, desty, destz, destt, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyHCubeToHCube*(src, dest: Array; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyArrayToVec*(VAR src: ARRAY OF Value; dest: Array; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyVecToArray*(src: Array; VAR dest: ARRAY OF Value; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyArrayToMtx*(VAR src: ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF Value; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyArrayToCube*(VAR src: ARRAY OF ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyCubeToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF ARRAY OF Value; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyArrayToHCube*(VAR src: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyHCubeToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyArrayToArrayPartB*(src: Array; dest: ArrayXdBytes.ArrayMemoryStructure; boundaryCondition: SHORTINT; srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray); 
+	OPERATOR ^ ":="-(VAR l: Array1; r: Array); 
+	OPERATOR ^ ":="-(VAR l: Array2; r: Array); 
+	OPERATOR ^ ":="-(VAR l: Array3; r: Array); 
+	PROCEDURE ^ Fill*(l: Array; r: Value); 
+	PROCEDURE ^ Add*(l, r, res: Array); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	PROCEDURE ^ Sub*(l, r, res: Array); 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	PROCEDURE ^ Mul*(l, r, res: Array); 
+	PROCEDURE ^ Div*(l, r, res: Array); 
+	PROCEDURE ^ AddAV*(l: Array; r: Value; res: Array); 
+	OPERATOR ^ "+"(l: Array; r: IntValue): Array; 
+	OPERATOR ^ "+"(l: IntValue; r: Array): Array; 
+	PROCEDURE ^ MulAV*(l: Array; r: Value; res: Array); 
+	OPERATOR ^ "*"(l: Array; r: IntValue): Array; 
+	OPERATOR ^ "*"(l: IntValue; r: Array): Array; 
+	PROCEDURE ^ DivAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ DivVA*(l: Value; r: Array; res: Array); 
+	OPERATOR ^ "/"(l: IntValue; r: Array): Array; 
+	PROCEDURE ^ SubAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ SubVA*(l: Value; r: Array; res: Array); 
+	OPERATOR ^ "-"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "-"-(l: IntValue; r: Array): Array; 
+	PROCEDURE ^ LoadArray(R: DataIO.Reader; VAR obj: OBJECT); 
+	PROCEDURE ^ StoreArray(W: DataIO.Writer; obj: OBJECT); 
+	PROCEDURE ^ Register; 
+	PROCEDURE ^ Load*(R: DataIO.Reader; VAR obj: Array); 
+	PROCEDURE ^ Store*(W: DataIO.Writer; obj: Array); 
+BEGIN
+END ArrayXdRat.

WinAos/obg/ArrayXdRe.SymW

@@ -0,0 +1,156 @@
+MODULE ArrayXdRe;
+	IMPORT SYSTEM, NbrInt, NbrRe, ArrayXdBytes, Array1d := Array1dRe, dbgOut := KernelLog, DataErrors, Array1dInt, ArrayXdRat, DataIO;
+CONST 
+	generic* = 0; 
+	vector* = 1; 
+	matrix* = 2; 
+	cube* = 3; 
+	hcube* = 4; 
+	VERSION* = 1; 
+	StrictBoundaryC* = 0; 
+	AbsorbingBoundaryC* = 1; 
+	PeriodicBoundaryC* = 2; 
+	SymmetricOnBoundaryC* = 3; 
+	SymmetricOffBoundaryC* = 4; 
+	AntisymmetricOnBoundaryC* = 5; 
+	AntisymmetricOffBoundaryC* = 6; 
+TYPE 
+	Value* = Array1d.Value; 
+
+	Index* = LONGINT; 
+
+	Array1* = Array1d.Array; 
+
+	IntValue* = Array1dInt.Value; 
+
+	Array2* = POINTER TO ARRAY OF ARRAY OF Value; 
+
+	Array3* = POINTER TO ARRAY OF ARRAY OF ARRAY OF Value; 
+
+	Array4* = POINTER TO ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; 
+
+	Map* = Array1d.Map; 
+
+	Array* = OBJECT {EXCLUSIVE} (ArrayXdBytes.Array)
+	VAR 
+		data-: Array1; 
+
+		PROCEDURE ^ Allocate*(size: LONGINT; VAR adr: Index; VAR ptr: ANY); 
+		PROCEDURE ^ GetInfo*(VAR elementsize: Index); 
+		PROCEDURE ^ AlikeX*(): ArrayXdBytes.Array; 
+		PROCEDURE ^ Read*(R: DataIO.Reader); 
+		PROCEDURE ^ Write*(W: DataIO.Writer); 
+		PROCEDURE ^ Type*(): SHORTINT; 
+		PROCEDURE ^ Get1*(x: Index): Value; 
+		PROCEDURE ^ Set1*(x: Index; v: Value); 
+		PROCEDURE ^ Get2*(x, y: Index): Value; 
+		PROCEDURE ^ Set2*(x, y: Index; v: Value); 
+		PROCEDURE ^ Get3*(x, y, z: Index): Value; 
+		PROCEDURE ^ Set3*(x, y, z: Index; v: Value); 
+		PROCEDURE ^ Get4*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ Set4*(x, y, z, t: Index; v: Value); 
+		PROCEDURE ^ GetX*(VAR x: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ SetX*(VAR x: ARRAY OF Index; dim: Index; v: Value); 
+		PROCEDURE ^ Get1BAbsorbing*(x: Index): Value; 
+		PROCEDURE ^ Get2BAbsorbing*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAbsorbing*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAbsorbing*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAbsorbing*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BPeriodic*(x: Index): Value; 
+		PROCEDURE ^ Get2BPeriodic*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BPeriodic*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BPeriodic*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBPeriodic*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BSymmetricOffB*(x: Index): Value; 
+		PROCEDURE ^ Get2BSymmetricOffB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BSymmetricOffB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BSymmetricOffB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBSymmetricOffB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BSymmetricOnB*(x: Index): Value; 
+		PROCEDURE ^ Get2BSymmetricOnB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BSymmetricOnB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BSymmetricOnB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBSymmetricOnB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BAntisymmetricOffB*(x: Index): Value; 
+		PROCEDURE ^ Get2BAntisymmetricOffB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAntisymmetricOffB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAntisymmetricOffB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAntisymmetricOffB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ Get1BAntisymmetricOnB*(x: Index): Value; 
+		PROCEDURE ^ Get2BAntisymmetricOnB*(x, y: Index): Value; 
+		PROCEDURE ^ Get3BAntisymmetricOnB*(x, y, z: Index): Value; 
+		PROCEDURE ^ Get4BAntisymmetricOnB*(x, y, z, t: Index): Value; 
+		PROCEDURE ^ GetXBAntisymmetricOnB*(b: ARRAY OF Index; dim: Index): Value; 
+		PROCEDURE ^ CopyToArray*(dest: Array; srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray); 
+		PROCEDURE ^ MapAll*(m: Array1d.Map); 
+		PROCEDURE ^ Negate*; 
+		PROCEDURE ^ Add*(x: Array); 
+		PROCEDURE ^ Subtract*(x: Array); 
+		PROCEDURE ^ Multiply*(a: Value); 
+		PROCEDURE ^ Divide*(a: Value); 
+		PROCEDURE ^ dbgWrite*; 
+	END Array; 
+
+	PROCEDURE ^ New1d*(ox, w: Index): Array; 
+	PROCEDURE ^ New2d*(ox, w, oy, h: Index): Array; 
+	PROCEDURE ^ New3d*(ox, w, oy, h, oz, d: Index): Array; 
+	PROCEDURE ^ New4d*(ox, w, oy, h, oz, d, ot, dt: Index): Array; 
+	PROCEDURE ^ CopyVecToVec*(src, dest: Array; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyMtxToVec*(src, dest: Array; dim: Index; srcx, srcy, destx, len: Index); 
+	PROCEDURE ^ CopyVecToMtx*(src, dest: Array; dim: Index; srcx, destx, desty, len: Index); 
+	PROCEDURE ^ CopyCubeToVec*(src, dest: Array; dim: Index; srcx, srcy, srcz, destx, len: Index); 
+	PROCEDURE ^ CopyVecToCube*(src, dest: Array; dim: Index; srcx, destx, desty, destz, len: Index); 
+	PROCEDURE ^ CopyHCubeToVec*(src, dest: Array; dim: Index; srcx, srcy, srcz, srct, destx, len: Index); 
+	PROCEDURE ^ CopyVecToHCube*(src, dest: Array; dim: Index; srcx, destx, desty, destz, destt, len: Index); 
+	PROCEDURE ^ CopyMtxToMtx*(src, dest: Array; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyCubeToMtx*(src, dest: Array; dimx, dimy: Index; srcx, srcy, srcz, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToCube*(src, dest: Array; dimx, dimy: Index; srcx, srcy, destx, desty, destz, lenx, leny: Index); 
+	PROCEDURE ^ CopyHCubeToMtx*(src, dest: Array; dimx, dimy: Index; srcx, srcy, srcz, srct, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToHCube*(src, dest: Array; dimx, dimy: Index; srcx, srcy, destx, desty, destz, destt, lenx, leny: Index); 
+	PROCEDURE ^ CopyCubeToCube*(src, dest: Array; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyHCubeToCube*(src, dest: Array; dimx, dimy, dimz: Index; srcx, srcy, srcz, srct, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyCubeToHCube*(src, dest: Array; dimx, dimy, dimz: Index; srcx, srcy, srcz, destx, desty, destz, destt, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyHCubeToHCube*(src, dest: Array; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyArrayToVec*(VAR src: ARRAY OF Value; dest: Array; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyVecToArray*(src: Array; VAR dest: ARRAY OF Value; srcx, destx, len: Index); 
+	PROCEDURE ^ CopyArrayToMtx*(VAR src: ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyMtxToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF Value; srcx, srcy, destx, desty, lenx, leny: Index); 
+	PROCEDURE ^ CopyArrayToCube*(VAR src: ARRAY OF ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyCubeToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF ARRAY OF Value; srcx, srcy, srcz, destx, desty, destz, lenx, leny, lenz: Index); 
+	PROCEDURE ^ CopyArrayToHCube*(VAR src: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; dest: Array; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyHCubeToArray*(src: Array; VAR dest: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value; srcx, srcy, srcz, srct, destx, desty, destz, destt, lenx, leny, lenz, lent: Index); 
+	PROCEDURE ^ CopyArrayToArrayPartB*(src: Array; dest: ArrayXdBytes.ArrayMemoryStructure; boundaryCondition: SHORTINT; srcpos, srclen, destpos, destlen: ArrayXdBytes.IndexArray); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value); 
+	OPERATOR ^ ":="-(VAR l: Array; VAR r: ARRAY OF ARRAY OF ARRAY OF Value); 
+	OPERATOR ^ ":="-(VAR l: Array1; r: Array); 
+	OPERATOR ^ ":="-(VAR l: Array2; r: Array); 
+	OPERATOR ^ ":="-(VAR l: Array3; r: Array); 
+	PROCEDURE ^ Fill*(l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: ArrayXdRat.Value); 
+	OPERATOR ^ ":="-(VAR l: Array; r: IntValue); 
+	PROCEDURE ^ Add*(l, r, res: Array); 
+	OPERATOR ^ "+"-(l, r: Array): Array; 
+	PROCEDURE ^ Sub*(l, r, res: Array); 
+	OPERATOR ^ "-"-(l, r: Array): Array; 
+	PROCEDURE ^ Mul*(l, r, res: Array); 
+	PROCEDURE ^ Div*(l, r, res: Array); 
+	PROCEDURE ^ AddAV*(l: Array; r: Value; res: Array); 
+	OPERATOR ^ "+"(l: Array; r: Value): Array; 
+	OPERATOR ^ "+"(l: Value; r: Array): Array; 
+	PROCEDURE ^ MulAV*(l: Array; r: Value; res: Array); 
+	OPERATOR ^ "*"(l: Array; r: Value): Array; 
+	OPERATOR ^ "*"(l: Value; r: Array): Array; 
+	PROCEDURE ^ DivAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ DivVA*(l: Value; r: Array; res: Array); 
+	PROCEDURE ^ SubAV*(l: Array; r: Value; res: Array); 
+	PROCEDURE ^ SubVA*(l: Value; r: Array; res: Array); 
+	OPERATOR ^ "-"-(l: Value; r: Array): Array; 
+	OPERATOR ^ "-"-(l: IntValue; r: Array): Array; 
+	PROCEDURE ^ LoadArray(R: DataIO.Reader; VAR obj: OBJECT); 
+	PROCEDURE ^ StoreArray(W: DataIO.Writer; obj: OBJECT); 
+	PROCEDURE ^ Register; 
+	PROCEDURE ^ Load*(R: DataIO.Reader; VAR obj: Array); 
+	PROCEDURE ^ Store*(W: DataIO.Writer; obj: Array); 
+BEGIN
+END ArrayXdRe.

WinAos/obg/Attributes.SymW

@@ -0,0 +1,36 @@
+MODULE Attributes;
+CONST 
+	Invalid =  -1; 
+	InitialAttributeArraySize = 16; 
+TYPE 
+	Attribute* = RECORD 
+		object: ANY; 
+		flags-: SET; 
+		data-: ANY; 
+	END; 
+
+	AttributeArray = POINTER TO ARRAY OF Attribute; 
+
+	Attributes* = OBJECT 
+	VAR 
+		attributes: AttributeArray; 
+		nofAttributes: LONGINT; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ ResizeArrayIfNecessary; 
+		PROCEDURE ^ AddObject(object: ANY; flags: SET; data: ANY); 
+		PROCEDURE ^ RemoveObject(object: ANY; hint: LONGINT); 
+		PROCEDURE ^ GetIndexOf(object: ANY): LONGINT; 
+		PROCEDURE ^ Get*(object: ANY): Attribute; 
+		PROCEDURE ^ Set*(object: ANY; flags: SET; data: ANY); 
+		PROCEDURE ^ GetFlags*(object: ANY): SET; 
+		PROCEDURE ^ SetFlags*(object: ANY; flags: SET); 
+		PROCEDURE ^ Include*(object: ANY; flag: LONGINT); 
+		PROCEDURE ^ Exclude*(object: ANY; flag: LONGINT); 
+		PROCEDURE ^ GetData*(object: ANY): ANY; 
+		PROCEDURE ^ SetData*(object, data: ANY); 
+		PROCEDURE ^ Clear*; 
+	END Attributes; 
+
+BEGIN
+END Attributes.

WinAos/obg/Autostart.SymW

@@ -0,0 +1,8 @@
+MODULE Autostart;
+	IMPORT XML, XMLObjects, Commands, Configuration, KernelLog;
+CONST 
+	Trace = TRUE; 
+
+	PROCEDURE ^ Run*; 
+BEGIN
+END Autostart.

WinAos/obg/BIT.SymW

@@ -0,0 +1,55 @@
+MODULE BIT;
+	IMPORT S := SYSTEM;
+CONST 
+	rbo = FALSE; 
+	risc = FALSE; 
+TYPE 
+	SHORTCARD* = SHORTINT; 
+
+	CARDINAL* = INTEGER; 
+
+	LONGCARD* = LONGINT; 
+
+	PROCEDURE ^ CXOR*(x, y: CHAR): CHAR; 
+	PROCEDURE ^ SXOR*(x, y: SHORTINT): SHORTINT; 
+	PROCEDURE ^ IXOR*(x, y: INTEGER): INTEGER; 
+	PROCEDURE ^ LXOR*(x, y: LONGINT): LONGINT; 
+	PROCEDURE ^ COR*(x, y: CHAR): CHAR; 
+	PROCEDURE ^ SOR*(x, y: SHORTINT): SHORTINT; 
+	PROCEDURE ^ IOR*(x, y: INTEGER): INTEGER; 
+	PROCEDURE ^ LOR*(x, y: LONGINT): LONGINT; 
+	PROCEDURE ^ CAND*(x, y: CHAR): CHAR; 
+	PROCEDURE ^ SAND*(x, y: SHORTINT): SHORTINT; 
+	PROCEDURE ^ IAND*(x, y: INTEGER): INTEGER; 
+	PROCEDURE ^ LAND*(x, y: LONGINT): LONGINT; 
+	PROCEDURE ^ CLSH*(x: CHAR; n: SHORTINT): CHAR; 
+	PROCEDURE ^ SLSH*(x: SHORTINT; n: SHORTINT): SHORTINT; 
+	PROCEDURE ^ ILSH*(x: INTEGER; n: SHORTINT): INTEGER; 
+	PROCEDURE ^ LLSH*(x: LONGINT; n: SHORTINT): LONGINT; 
+	PROCEDURE ^ CROT*(x: CHAR; n: SHORTINT): CHAR; 
+	PROCEDURE ^ SROT*(x: SHORTINT; n: SHORTINT): SHORTINT; 
+	PROCEDURE ^ IROT*(x: INTEGER; n: SHORTINT): INTEGER; 
+	PROCEDURE ^ LROT*(x: LONGINT; n: SHORTINT): LONGINT; 
+	PROCEDURE ^ ISWAP*(x: INTEGER): INTEGER; 
+	PROCEDURE ^ LSWAP*(x: LONGINT): LONGINT; 
+	PROCEDURE ^ CBIT*(x: CHAR; n: SHORTINT): BOOLEAN; 
+	PROCEDURE ^ BIT*(x: LONGINT; n: SHORTINT): BOOLEAN; 
+	PROCEDURE ^ CSETBIT*(VAR x: CHAR; n: SHORTINT); 
+	PROCEDURE ^ SSETBIT*(VAR x: SHORTINT; n: SHORTINT); 
+	PROCEDURE ^ ISETBIT*(VAR x: INTEGER; n: SHORTINT); 
+	PROCEDURE ^ LSETBIT*(VAR x: LONGINT; n: SHORTINT); 
+	PROCEDURE ^ CCLRBIT*(VAR x: CHAR; n: SHORTINT); 
+	PROCEDURE ^ SCLRBIT*(VAR x: SHORTINT; n: SHORTINT); 
+	PROCEDURE ^ ICLRBIT*(VAR x: INTEGER; n: SHORTINT); 
+	PROCEDURE ^ LCLRBIT*(VAR x: LONGINT; n: SHORTINT); 
+	PROCEDURE ^ SLESS*(x, y: SHORTCARD): BOOLEAN; 
+	PROCEDURE ^ ILESS*(x, y: CARDINAL): BOOLEAN; 
+	PROCEDURE ^ LLESS*(x, y: LONGCARD): BOOLEAN; 
+	PROCEDURE ^ SLESSEQ*(x, y: SHORTCARD): BOOLEAN; 
+	PROCEDURE ^ ILESSEQ*(x, y: CARDINAL): BOOLEAN; 
+	PROCEDURE ^ LLESSEQ*(x, y: LONGCARD): BOOLEAN; 
+	PROCEDURE ^ SDIV*(x, y: SHORTCARD): SHORTCARD; 
+	PROCEDURE ^ IDIV*(x, y: CARDINAL): CARDINAL; 
+	PROCEDURE ^ LDIV*(x, y: LONGCARD): LONGCARD; 
+BEGIN
+END BIT.

WinAos/obg/BMPCodec.SymW

@@ -0,0 +1,54 @@
+MODULE BMPCodec;
+	IMPORT Codecs, KernelLog, Streams, WMGraphics, Raster, Strings;
+CONST 
+	FileHeaderSize = 14; 
+	RGB = 0; 
+	RLE8 = 1; 
+	RLE4 = 2; 
+	BITFIELDS = 3; 
+TYPE 
+	BMPDecoder = OBJECT (Codecs.ImageDecoder)
+	VAR 
+		errors: BOOLEAN; 
+		in: Streams.Reader; 
+		size, reserved, offset, width, height, compression, colors, importantColors, col, redMask, greenMask, blueMask: LONGINT; 
+		planes, bpp: INTEGER; 
+		pal: Raster.Palette; 
+		img: Raster.Image; 
+		decoded: BOOLEAN; 
+
+		PROCEDURE ^ Error(x: ARRAY OF CHAR); 
+		PROCEDURE ^ Log(x: ARRAY OF CHAR); 
+		PROCEDURE ^ Open*(in: Streams.Reader; VAR res: LONGINT); 
+		PROCEDURE ^ GetImageInfo*(VAR width, height, format, maxProgressionLevel: LONGINT); 
+		PROCEDURE ^ SetProgressionLevel*(progressionLevel: LONGINT); 
+		PROCEDURE ^ GetNativeImage*(VAR img: Raster.Image); 
+		PROCEDURE ^ Render*(img: Raster.Image); 
+	END BMPDecoder; 
+
+	BMPEncoder* = OBJECT (Codecs.ImageEncoder)
+	VAR 
+		out: Streams.Writer; 
+
+		PROCEDURE ^ Open*(out: Streams.Writer); 
+		PROCEDURE ^ SetQuality*(quality: LONGINT); 
+		PROCEDURE ^ WriteImage*(img: Raster.Image; VAR res: LONGINT); 
+	END BMPEncoder; 
+
+	PROCEDURE ^ Unmask(val, mask, nbits: LONGINT): LONGINT; 
+	PROCEDURE ^ Load1(img: Raster.Image; w, h: LONGINT; VAR pal: Raster.Palette; r: Streams.Reader); 
+	PROCEDURE ^ Load4(img: Raster.Image; w, h, compression: LONGINT; pal: Raster.Palette; r: Streams.Reader); 
+	PROCEDURE ^ Load8(img: Raster.Image; w, h, compression: LONGINT; pal: Raster.Palette; r: Streams.Reader); 
+	PROCEDURE ^ Load16(img: Raster.Image; w, h, compression, rMask, gMask, bMask: LONGINT; r: Streams.Reader); 
+	PROCEDURE ^ Load24(img: Raster.Image; w, h: LONGINT; r: Streams.Reader); 
+	PROCEDURE ^ Load32(img: Raster.Image; w, h, compression, rMask, gMask, bMask: LONGINT; r: Streams.Reader); 
+	PROCEDURE ^ Store1(img: Raster.Image; w, h: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ Store4(img: Raster.Image; w, h: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ Store8(img: Raster.Image; w, h: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ Store16(img: Raster.Image; w, h, rMask, gMask, bMask: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ Store24(img: Raster.Image; w, h: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ Store32(img: Raster.Image; w, h, rMask, gMask, bMask: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ DecoderFactory*(): Codecs.ImageDecoder; 
+	PROCEDURE ^ EncoderFactory*(): Codecs.ImageEncoder; 
+BEGIN
+END BMPCodec.

WinAos/obg/Base64.SymW

@@ -0,0 +1,11 @@
+MODULE Base64;
+	IMPORT Streams, KernelLog;
+VAR 
+	encTable: ARRAY 64 OF CHAR; 
+	decTable: ARRAY 128 OF INTEGER; 
+
+	PROCEDURE ^ Decode*(R: Streams.Reader; W: Streams.Writer); 
+	PROCEDURE ^ Encode*(R: Streams.Reader; W: Streams.Writer); 
+	PROCEDURE ^ InitTables; 
+BEGIN
+END Base64.

WinAos/obg/Beep.SymW

@@ -0,0 +1,23 @@
+MODULE Beep;
+	IMPORT Kernel32, Kernel;
+TYPE 
+	Beeper = OBJECT {EXCLUSIVE} 
+	VAR 
+		hz: LONGINT; 
+		beep: BOOLEAN; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ On(hz: LONGINT); 
+		PROCEDURE ^ Off; 
+		PROCEDURE ^ Beep; 
+	BEGIN{ACTIVE} 
+	END Beeper; 
+VAR 
+	beep: Beeper; 
+
+	PROCEDURE ^ Beep*(hz: LONGINT); 
+	PROCEDURE ^ Test*; 
+	PROCEDURE ^ TestOn*; 
+	PROCEDURE ^ TestOff*; 
+BEGIN
+END Beep.

WinAos/obg/BeepTest.SymW

@@ -0,0 +1,10 @@
+MODULE BeepTest;
+	IMPORT Beep, Kernel, KernelLog;
+CONST 
+VAR 
+	busy: BOOLEAN; 
+	timer: Kernel.Timer; 
+
+	PROCEDURE ^ Go*; 
+BEGIN
+END BeepTest.

WinAos/obg/BenchSyntaxHighlighter.SymW

@@ -0,0 +1,16 @@
+MODULE BenchSyntaxHighlighter;
+	IMPORT Streams, Commands, Options, Dates, Strings, Files, Random, Texts, TextUtilities, SyntaxHighlighter;
+CONST 
+	DefaultHighlighterName = \"Oberon"\; 
+	DefaultNofIterations = 1000; 
+
+	PROCEDURE ^ Reader(reader: Texts.TextReader; nofIterations: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ Words(reader: Texts.TextReader; highlighter: SyntaxHighlighter.Highlighter; nofIterations: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ RebuildRegions(reader: Texts.TextReader; highlighter: SyntaxHighlighter.Highlighter; nofIterations: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ RegionLookup(reader: Texts.TextReader; highlighter: SyntaxHighlighter.Highlighter; nofIterations: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ Full(reader: Texts.TextReader; highlighter: SyntaxHighlighter.Highlighter; nofIterations: LONGINT; out: Streams.Writer); 
+	PROCEDURE ^ Indent(writer: Streams.Writer; width: LONGINT); 
+	PROCEDURE ^ Bench*(context: Commands.Context); 
+	PROCEDURE ^ TestScanner*(context: Commands.Context); 
+BEGIN
+END BenchSyntaxHighlighter.

WinAos/obg/BenchTCP.SymW

@@ -0,0 +1,47 @@
+MODULE BenchTCP;
+	IMPORT Kernel, IP, KernelLog, TCP, DNS, Strings, Commands;
+CONST 
+	BufSize = 32768; 
+	CloseTimeout = 10000; 
+	EchoPort = 7; 
+	DiscardPort = 9; 
+	TimePort = 37; 
+	Header = \"BenchTCP: "\; 
+TYPE 
+	Bytes = POINTER TO ARRAY OF CHAR; 
+
+	Sender = OBJECT {EXCLUSIVE} 
+	VAR 
+		c: TCP.Connection; 
+		num, num0, res: LONGINT; 
+		buf: Bytes; 
+		done: BOOLEAN; 
+
+		PROCEDURE ^  & Init*(c: TCP.Connection; buf: Bytes; num: LONGINT); 
+		PROCEDURE ^ Join(): LONGINT; 
+	BEGIN{ACTIVE} 
+	END Sender; 
+
+	Tester = OBJECT {EXCLUSIVE} 
+	VAR 
+		c: TCP.Connection; 
+		num, num0, res, port, total, len: LONGINT; 
+		fip: IP.Adr; 
+		timer: Kernel.MilliTimer; 
+		sender: Sender; 
+		server: ARRAY 64 OF CHAR; 
+		time: HUGEINT; 
+
+		PROCEDURE ^  & Init*(CONST server: ARRAY OF CHAR; num, port: LONGINT); 
+	BEGIN{ACTIVE} 
+	END Tester; 
+VAR 
+	buf: Bytes; 
+
+	PROCEDURE ^ Message(CONST msg1, msg2: ARRAY OF CHAR; res: LONGINT); 
+	PROCEDURE ^ Report(ms, port, total: LONGINT; CONST msg: ARRAY OF CHAR); 
+	PROCEDURE ^ Discard*(context: Commands.Context); 
+	PROCEDURE ^ Echo*(context: Commands.Context); 
+	PROCEDURE ^ Time*(context: Commands.Context); 
+BEGIN
+END BenchTCP.

WinAos/obg/BenchXML.SymW

@@ -0,0 +1,37 @@
+MODULE BenchXML;
+	IMPORT KernelLog, Streams, Modules, Commands, Options, Dates, Strings, Files, XML, XMLScanner, XMLParser;
+CONST 
+	DefaultNofTimes = 1000; 
+	DefaultNofWorkers = 1; 
+	Waiting = 0; 
+	Working = 1; 
+	Terminating = 2; 
+	Terminated = 3; 
+TYPE 
+	Worker = OBJECT {EXCLUSIVE} 
+	VAR 
+		file: Files.File; 
+		pooling: SET; 
+		nofTimes: LONGINT; 
+		state: LONGINT; 
+
+		PROCEDURE ^  & Init*(file: Files.File; nofTimes: LONGINT; pooling: SET); 
+		PROCEDURE ^ Start; 
+		PROCEDURE ^ Terminate; 
+		PROCEDURE ^ Parse; 
+	BEGIN{ACTIVE} 
+	END Worker; 
+VAR 
+	error: BOOLEAN; 
+	workers: POINTER TO ARRAY OF Worker; 
+	nofActiveWorkers: LONGINT; 
+
+	PROCEDURE ^ DecrementNofActiveWorkers; 
+	PROCEDURE ^ ParseFile(file: Files.File; pooling: SET): XML.Document; 
+	PROCEDURE ^ BenchParser*(context: Commands.Context); 
+	PROCEDURE ^ ToSeconds(nofDays, nofHours, nofMinutes, nofSeconds: LONGINT): LONGINT; 
+	PROCEDURE ^ DefaultReportError(pos, line, col: LONGINT; CONST msg: ARRAY OF CHAR); 
+	PROCEDURE ^ ShowUsage(out: Streams.Writer); 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END BenchXML.

WinAos/obg/BimboMail.SymW

@@ -0,0 +1,31 @@
+MODULE BimboMail;
+	IMPORT Modules, WMGrids, WMStringGrids, MailStorage, WMGraphics, WMMessages, WMStandardComponents, WMComponents, WMEditors, Strings, TextUtilities, Texts, WM := WMWindowManager;
+CONST 
+	TempFilename = \"BimboMail.Temp"\; 
+TYPE 
+	KillerMsg = OBJECT 
+	END KillerMsg; 
+
+	Window* = OBJECT {EXCLUSIVE} (WMComponents.FormWindow)
+	VAR 
+		currentMailbox: MailStorage.Storage; 
+		messageList: WMStringGrids.StringGrid; 
+		messageText: WMEditors.Editor; 
+
+		PROCEDURE ^ CreateForm(): WMComponents.VisualComponent; 
+		PROCEDURE ^ SetMailbox(mb: MailStorage.Storage); 
+		PROCEDURE ^  & New*; 
+		PROCEDURE ^ GetTitleStr(col: LONGINT; VAR x: ARRAY OF CHAR); 
+		PROCEDURE ^ Close*; 
+		PROCEDURE ^ Handle*(VAR x: WMMessages.Message); 
+		PROCEDURE ^ MessageClick(sender, data: ANY); 
+	END Window; 
+VAR 
+	nofWindows: LONGINT; 
+
+	PROCEDURE ^ Open*; 
+	PROCEDURE ^ IncCount; 
+	PROCEDURE ^ DecCount; 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END BimboMail.

WinAos/obg/BimboScanner.SymW

@@ -0,0 +1,145 @@
+MODULE BimboScanner;
+	IMPORT Trace, Texts, Streams, UTF8Strings, Strings;
+CONST 
+	Eot* = 0X; 
+	ObjectMarker = 20X; 
+	LF = 0AX; 
+	char* = 1; 
+	integer* = 2; 
+	longinteger* = 3; 
+	real* = 4; 
+	longreal* = 5; 
+	MaxHDig* = 8; 
+	MaxHHDig* = 16; 
+	MaxRExp* = 38; 
+	MaxLExp* = 308; 
+	null* = 0; 
+	times* = 1; 
+	slash* = 2; 
+	div* = 3; 
+	mod* = 4; 
+	and* = 5; 
+	plus* = 6; 
+	minus* = 7; 
+	or* = 8; 
+	eql* = 9; 
+	neq* = 10; 
+	lss* = 11; 
+	leq* = 12; 
+	gtr* = 13; 
+	geq* = 14; 
+	in* = 15; 
+	is* = 16; 
+	arrow* = 17; 
+	period* = 18; 
+	comma* = 19; 
+	colon* = 20; 
+	upto* = 21; 
+	rparen* = 22; 
+	rbrak* = 23; 
+	rbrace* = 24; 
+	of* = 25; 
+	then* = 26; 
+	do* = 27; 
+	to* = 28; 
+	by* = 29; 
+	lparen* = 30; 
+	lbrak* = 31; 
+	lbrace* = 32; 
+	not* = 33; 
+	becomes* = 34; 
+	number* = 35; 
+	nil* = 36; 
+	true* = 37; 
+	false* = 38; 
+	string* = 39; 
+	ident* = 40; 
+	semicolon* = 41; 
+	bar* = 42; 
+	end* = 43; 
+	else* = 44; 
+	elsif* = 45; 
+	until* = 46; 
+	if* = 47; 
+	case* = 48; 
+	while* = 49; 
+	repeat* = 50; 
+	for* = 51; 
+	loop* = 52; 
+	with* = 53; 
+	exit* = 54; 
+	passivate* = 55; 
+	return* = 56; 
+	refines* = 57; 
+	implements* = 58; 
+	array* = 59; 
+	definition* = 60; 
+	object* = 61; 
+	record* = 62; 
+	pointer* = 63; 
+	begin* = 64; 
+	code* = 65; 
+	const* = 66; 
+	type* = 67; 
+	var* = 68; 
+	procedure* = 69; 
+	import* = 70; 
+	module* = 71; 
+	eof* = 72; 
+	comment* = 73; 
+	newLine* = 74; 
+	question* = 75; 
+	finally* = 76; 
+TYPE 
+	StringMaker = OBJECT 
+	VAR 
+		length: LONGINT; 
+		data: Strings.String; 
+
+		PROCEDURE ^  & Init(initialSize: LONGINT); 
+		PROCEDURE ^ Add*(CONST buf: ARRAY OF CHAR; ofs, len: LONGINT; propagate: BOOLEAN; VAR res: LONGINT); 
+		PROCEDURE ^ Shorten(n: LONGINT); 
+		PROCEDURE ^ Clear*; 
+		PROCEDURE ^ GetWriter*(): Streams.Writer; 
+		PROCEDURE ^ GetLength*(): LONGINT; 
+		PROCEDURE ^ GetString*(): Strings.String; 
+	END StringMaker; 
+
+	Scanner* = OBJECT 
+	VAR 
+		buffer: Strings.String; 
+		pos-: LONGINT; 
+		ch-: CHAR; 
+		str-: ARRAY 1024 OF CHAR; 
+		sym-: LONGINT; 
+		numtyp-: INTEGER; 
+		intval-: LONGINT; 
+		longintval-: HUGEINT; 
+		realval-: REAL; 
+		lrlval-: LONGREAL; 
+		numStartPos, numEndPos: LONGINT; 
+		lastpos-, curpos-, errpos-: LONGINT; 
+		isNummer: BOOLEAN; 
+		commentStr-: StringMaker; 
+		cw: Streams.Writer; 
+
+		PROCEDURE ^  & Init; 
+		PROCEDURE ^ err(n: INTEGER); 
+		PROCEDURE ^ NextChar*; 
+		PROCEDURE ^ Str(VAR sym: LONGINT); 
+		PROCEDURE ^ Identifier(VAR sym: LONGINT); 
+		PROCEDURE ^ Number; 
+		PROCEDURE ^ GetNumAsString*(VAR val: ARRAY OF CHAR); 
+		PROCEDURE ^ Get(VAR s: LONGINT); 
+		PROCEDURE ^ Next*; 
+	END Scanner; 
+VAR 
+	reservedChar-, ignoredChar, newChar-: ARRAY 256 OF BOOLEAN; 
+
+	PROCEDURE ^ InitWithText*(t: Texts.Text; pos: LONGINT): Scanner; 
+	PROCEDURE ^ ExpandBuf(VAR oldBuf: Strings.String; newSize: LONGINT); 
+	PROCEDURE ^ InitReservedChars; 
+	PROCEDURE ^ InitNewChar; 
+	PROCEDURE ^ InitIgnoredChar; 
+BEGIN
+END BimboScanner.

WinAos/obg/Bimso.SymW

@@ -0,0 +1,45 @@
+MODULE Bimso;
+	IMPORT Strings, WMGraphics, WMMessages, WMComponents, WMStandardComponents, Modules, KernelLog, WMRectangles, WMGraphicUtilities, Random, Kernel, WMDialogs, WM := WMWindowManager;
+CONST 
+	MaxLevel = 1000; 
+TYPE 
+	KillerMsg = OBJECT 
+	END KillerMsg; 
+
+	Window* = OBJECT {EXCLUSIVE} (WMComponents.FormWindow)
+	VAR 
+		b: ARRAY 4 OF WMStandardComponents.Button; 
+		startButton: WMStandardComponents.Button; 
+		start, alive: BOOLEAN; 
+		c, cflash: ARRAY 4 OF WMGraphics.Color; 
+		random: Random.Generator; 
+		game: ARRAY MaxLevel OF SHORTINT; 
+		level: LONGINT; 
+		step: LONGINT; 
+		error: BOOLEAN; 
+		timer: Kernel.Timer; 
+		s, levelStr: ARRAY 32 OF CHAR; 
+
+		PROCEDURE ^ CreateForm(): WMComponents.VisualComponent; 
+		PROCEDURE ^  & New*; 
+		PROCEDURE ^ Close*; 
+		PROCEDURE ^ Handle*(VAR x: WMMessages.Message); 
+		PROCEDURE ^ CreateLevel; 
+		PROCEDURE ^ ShowLevel; 
+		PROCEDURE ^ EnableInput; 
+		PROCEDURE ^ DisableInput; 
+		PROCEDURE ^ Evaluate(sender, data: ANY); 
+		PROCEDURE ^ Start(sender, data: ANY); 
+		PROCEDURE ^ Started; 
+		PROCEDURE ^ Play; 
+	BEGIN{ACTIVE} 
+	END Window; 
+VAR 
+	nofWindows: LONGINT; 
+
+	PROCEDURE ^ Open*; 
+	PROCEDURE ^ IncCount; 
+	PROCEDURE ^ DecCount; 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END Bimso.

WinAos/obg/Bin2Hex.SymW

@@ -0,0 +1,12 @@
+MODULE Bin2Hex;
+	IMPORT Streams, Files, Commands;
+CONST 
+
+	PROCEDURE ^ Byte(VAR w: Streams.Writer; val: LONGINT); 
+	PROCEDURE ^ ExtendedAddressRecord*(VAR w: Streams.Writer; extadr: LONGINT); 
+	PROCEDURE ^ DataRecord*(VAR w: Streams.Writer; CONST data: ARRAY OF CHAR; len, offset: LONGINT); 
+	PROCEDURE ^ EndOfFileRecord*(VAR w: Streams.Writer); 
+	PROCEDURE ^ ConvertFile*(r: Streams.Reader; w: Streams.Writer; offset, maxlen: LONGINT); 
+	PROCEDURE ^ Convert*(context: Commands.Context); 
+BEGIN
+END Bin2Hex.

WinAos/obg/BinToCode.SymW

@@ -0,0 +1,14 @@
+MODULE BinToCode;
+	IMPORT Files, Commands, Streams;
+CONST 
+	BufferAddressName = \"a"\; 
+	MaxBufferSize = 4; 
+TYPE 
+	Buffer = ARRAY MaxBufferSize OF CHAR; 
+VAR 
+	hexdigit: ARRAY 17 OF CHAR; 
+
+	PROCEDURE ^ WriteBuffer(w: Streams.Writer; CONST buffer: Buffer; offset, size: LONGINT); 
+	PROCEDURE ^ Convert*(context: Commands.Context); 
+BEGIN
+END BinToCode.

WinAos/obg/BitSets.SymW

@@ -0,0 +1,27 @@
+MODULE BitSets;
+	IMPORT SYSTEM;
+CONST 
+	Elements = ((MAX(SET) - MIN(SET)) + 1); 
+TYPE 
+	Data = POINTER TO ARRAY OF SET; 
+
+	BitSet* = OBJECT 
+	VAR 
+		size: SIZE; 
+		data: Data; 
+
+		PROCEDURE ^  & InitBitSet*(size: LONGINT); 
+		PROCEDURE ^ Zero*; 
+		PROCEDURE ^ Resize*(size: SIZE); 
+		PROCEDURE ^ GetSize*(): SIZE; 
+		PROCEDURE ^ SetBit*(pos: SIZE; value: BOOLEAN); 
+		PROCEDURE ^ GetBit*(pos: SIZE): BOOLEAN; 
+		PROCEDURE ^ SetBits*(startPos: SIZE; bits, value: LONGINT); 
+		PROCEDURE ^ SetBytes*(startPos: SIZE; bytes: LONGINT; CONST values: ARRAY OF CHAR); 
+		PROCEDURE ^ GetBits*(startPos: SIZE; bits: LONGINT): LONGINT; 
+		PROCEDURE ^ CopyTo*(address: ADDRESS; bits: SIZE); 
+	END BitSet; 
+
+	PROCEDURE ^ CopyBits*(source: BitSet; sourcePos: LONGINT; dest: BitSet; destPos, count: LONGINT); 
+BEGIN
+END BitSets.

WinAos/obg/BootConsole.SymW

@@ -0,0 +1,14 @@
+MODULE BootConsole;
+	IMPORT Machine, Trace, KernelLog, Modules, Streams, Objects, Files, Commands;
+CONST 
+	ModuleName = \"Console"\; 
+	TraceBoot = FALSE; 
+
+	PROCEDURE ^ BootCommand(CONST config: ARRAY OF CHAR; flags: SET); 
+	PROCEDURE ^ GetString(VAR i: LONGINT; CONST r: ARRAY OF CHAR; VAR s: ARRAY OF CHAR): BOOLEAN; 
+	PROCEDURE ^ Error(CONST config, val: ARRAY OF CHAR; i: LONGINT); 
+	PROCEDURE ^ Generate(CONST name: ARRAY OF CHAR; par: Files.Parameters): BOOLEAN; 
+	PROCEDURE ^ OpenVolume(CONST config: ARRAY OF CHAR); 
+	PROCEDURE ^ OpenVolumes; 
+BEGIN
+END BootConsole.

WinAos/obg/BootManager.SymW

@@ -0,0 +1,7 @@
+MODULE BootManager;
+	IMPORT Commands, Files;
+CONST 
+
+	PROCEDURE ^ Split*(context: Commands.Context); 
+BEGIN
+END BootManager.

WinAos/obg/BootShell.SymW

@@ -0,0 +1,121 @@
+MODULE BootShell;
+	IMPORT SYSTEM, KernelLog, Machine, Modules, Streams, Commands, Inputs, Strings, Locks;
+CONST 
+	Version = \"A2 Bootshell v1.0"\; 
+	LineWidth = 80; 
+	TraceHeight = 25; 
+	TraceBase = 753664; 
+	BufferHeight = 2048; 
+	BufferSize = (BufferHeight * LineWidth); 
+	TAB = 9X; 
+	CR = 0DX; 
+	LF = 0AX; 
+	SPACE = \" "\; 
+	Mode_Insert = 0; 
+	Mode_Overwrite = 1; 
+	Black = 0; 
+	Blue = 1; 
+	Green = 2; 
+	Cyan = 3; 
+	Red = 4; 
+	Magenta = 5; 
+	Brown = 6; 
+	White = 7; 
+	Gray = 8; 
+	LightBlue = 9; 
+	LightGreen = 10; 
+	LightCyan = 11; 
+	LightRed = 12; 
+	LightMagenta = 13; 
+	Yellow = 14; 
+	BrightWhite = 15; 
+TYPE 
+	CommandsString = POINTER TO RECORD 
+		prev, next: CommandsString; 
+		string: Strings.String; 
+	END; 
+
+	CommandHistoryObject = OBJECT 
+	VAR 
+		first, current: CommandsString; 
+
+		PROCEDURE ^ GetNextCommand(): Strings.String; 
+		PROCEDURE ^ GetPreviousCommand(): Strings.String; 
+		PROCEDURE ^ AddCommand(string: Strings.String); 
+		PROCEDURE ^  & Init*; 
+	END CommandHistoryObject; 
+
+	Character = RECORD 
+		ch: CHAR; 
+		color: SHORTINT; 
+	END; 
+
+	Line = ARRAY LineWidth OF Character; 
+
+	TextBuffer = OBJECT 
+	VAR 
+		defaultColor: SHORTINT; 
+		currentColor: SHORTINT; 
+		lines: ARRAY BufferHeight OF Line; 
+		firstLine, lastLine: LONGINT; 
+		firstLineShown: LONGINT; 
+		editStartPosition, editEndPosition: LONGINT; 
+		cursorPosition: LONGINT; 
+		mode: LONGINT; 
+		lock: Locks.RecursiveLock; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ Clear; 
+		PROCEDURE ^ SetColor(foreground, background: SHORTINT); 
+		PROCEDURE ^ SetEditStart; 
+		PROCEDURE ^ Send(CONST data: ARRAY OF CHAR; ofs, len: LONGINT; propagate: BOOLEAN; VAR res: LONGINT); 
+		PROCEDURE ^ String(CONST string: ARRAY OF CHAR); 
+		PROCEDURE ^ Char(ch: CHAR); 
+		PROCEDURE ^ CheckVisibility; 
+		PROCEDURE ^ NextLine; 
+		PROCEDURE ^ MoveCharactersToRight; 
+		PROCEDURE ^ MoveCharactersToLeft; 
+		PROCEDURE ^ CharInternal(ch: CHAR); 
+		PROCEDURE ^ DeleteCurrentLine; 
+		PROCEDURE ^ GetCurrentLine(): Strings.String; 
+		PROCEDURE ^ Home; 
+		PROCEDURE ^ End; 
+		PROCEDURE ^ Backspace; 
+		PROCEDURE ^ Delete; 
+		PROCEDURE ^ ScrollUp(nofLines: LONGINT); 
+		PROCEDURE ^ ScrollDown(nofLines: LONGINT); 
+		PROCEDURE ^ CursorLeft; 
+		PROCEDURE ^ CursorRight; 
+		PROCEDURE ^ Dump(out: Streams.Writer); 
+	END TextBuffer; 
+
+	Shell = OBJECT (Inputs.Sink)
+	VAR 
+		textBuffer: TextBuffer; 
+		history: CommandHistoryObject; 
+
+		PROCEDURE ^  & Init; 
+		PROCEDURE ^ Handle*(VAR msg: Inputs.Message); 
+		PROCEDURE ^ CommandHistory(next: BOOLEAN); 
+		PROCEDURE ^ Prompt; 
+		PROCEDURE ^ Execute; 
+		PROCEDURE ^ Quit; 
+	END Shell; 
+VAR 
+	shell: Shell; 
+
+	PROCEDURE ^ Subtract(position, value, bufferSize: LONGINT): LONGINT; 
+	PROCEDURE ^ Add(position, value, bufferSize: LONGINT): LONGINT; 
+	PROCEDURE ^ Difference(end, start, bufferSize: LONGINT): LONGINT; 
+	PROCEDURE ^ ClearLine(VAR line: Line; from, to: LONGINT; color: SHORTINT); 
+	PROCEDURE ^ IsWhitespace(ch: CHAR): BOOLEAN; 
+	PROCEDURE ^ Min(a, b: LONGINT): LONGINT; 
+	PROCEDURE ^ Invalidate(textBuffer: TextBuffer); 
+	PROCEDURE ^ Open*; 
+	PROCEDURE ^ Close*; 
+	PROCEDURE ^ Dump*(context: Commands.Context); 
+	PROCEDURE ^ UpdateCursor(textBuffer: TextBuffer); 
+	PROCEDURE ^ Cleanup; 
+	PROCEDURE ^ Init; 
+BEGIN
+END BootShell.

WinAos/obg/CATServer.SymW

@@ -0,0 +1,24 @@
+MODULE CATServer;
+	IMPORT Modules, Streams, TCP, TCPServices, AosLog := TFLog, Performance;
+CONST 
+	CATPort = 9999; 
+TYPE 
+	CATAgent = OBJECT {EXCLUSIVE} (TCPServices.Agent)
+	VAR 
+		in: Streams.Reader; 
+		out: Streams.Writer; 
+		token: ARRAY 16 OF CHAR; 
+		x: LONGINT; 
+
+	BEGIN{ACTIVE} 
+	END CATAgent; 
+VAR 
+	cat: TCPServices.Service; 
+	log: AosLog.Log; 
+
+	PROCEDURE ^ NewCATAgent(c: TCP.Connection; s: TCPServices.Service): TCPServices.Agent; 
+	PROCEDURE ^ Start*; 
+	PROCEDURE ^ Stop*; 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END CATServer.

WinAos/obg/CLUTs.SymW

@@ -0,0 +1,21 @@
+MODULE CLUTs;
+	IMPORT Streams;
+CONST 
+	colors* = 256; 
+TYPE 
+	CLUT* = RECORD 
+		col*: ARRAY colors OF LONGINT; 
+		size*: INTEGER; 
+		bits: INTEGER; 
+		cube: POINTER TO ARRAY OF CHAR; 
+	END; 
+
+	PROCEDURE ^ Set*(VAR clut: CLUT; n, col: LONGINT); 
+	PROCEDURE ^ Get*(VAR clut: CLUT; n: LONGINT; VAR col: LONGINT); 
+	PROCEDURE ^ Init*(VAR clut: CLUT; size, bits: LONGINT); 
+	PROCEDURE ^ Match*(VAR clut: CLUT; col: LONGINT): LONGINT; 
+	PROCEDURE ^ Copy*(from, to: CLUT); 
+	PROCEDURE ^ Write*(VAR w: Streams.Writer; VAR clut: CLUT); 
+	PROCEDURE ^ Read*(r: Streams.Reader; VAR clut: CLUT; size: LONGINT); 
+BEGIN
+END CLUTs.

WinAos/obg/CPUID.SymW

@@ -0,0 +1,162 @@
+MODULE CPUID;
+	IMPORT SYSTEM, Streams, Commands, Options;
+CONST 
+	Intel* = 0; 
+	Amd* = 1; 
+	Other* = 2; 
+	PBE* = 31; 
+	IA64* = 30; 
+	TM* = 29; 
+	HTT* = 28; 
+	SS* = 27; 
+	SSE2* = 26; 
+	SSE* = 25; 
+	FXSR* = 24; 
+	MMX* = 23; 
+	ACPI* = 22; 
+	DS* = 21; 
+	CLFLUSH* = 19; 
+	PSN* = 18; 
+	PSE36* = 17; 
+	PAT* = 16; 
+	CMOV* = 15; 
+	MCA* = 14; 
+	PGE* = 13; 
+	MTRR* = 12; 
+	SysEnterSysExit* = 11; 
+	APIC* = 9; 
+	CMPXCH8B* = 8; 
+	MCE* = 7; 
+	PAE* = 6; 
+	MSR* = 5; 
+	TSC* = 4; 
+	PSE* = 3; 
+	DE* = 2; 
+	VME* = 1; 
+	FPU* = 0; 
+	SSE4_2* = 20; 
+	SSE4_1* = 19; 
+	DCA* = 18; 
+	PDCM* = 15; 
+	XTPR* = 14; 
+	CMPXCHG16B* = 13; 
+	CID* = 10; 
+	SSSE3* = 9; 
+	TM2* = 8; 
+	EST* = 7; 
+	SMX* = 6; 
+	VMX* = 5; 
+	DS_CPL* = 4; 
+	MONITOR* = 3; 
+	DTES64* = 2; 
+	SSE3* = 0; 
+	Amd3DNow* = 31; 
+	Amd3DNowExt* = 32; 
+	LM* = 29; 
+	RDTSCP* = 27; 
+	FFXSR* = 25; 
+	MmxExt* = 22; 
+	NX* = 20; 
+	SysCallSysRet* = 11; 
+	AltMovCr8* = 4; 
+	SVM* = 2; 
+	CmpLegacy* = 1; 
+	LahfSahf* = 0; 
+	AMD7_TscInvariant* = 8; 
+	AMD7_STC* = 5; 
+	AMD7_TM* = 4; 
+	AMD7_TTP* = 3; 
+	AMD7_VID* = 2; 
+	AMD7_FID* = 1; 
+	AMD7_TS* = 0; 
+TYPE 
+	CpuInformation* = RECORD 
+		cputype-: LONGINT; 
+		largestStandardFunction-: LONGINT; 
+		vendor-: ARRAY 13 OF CHAR; 
+		family-, model-, stepping-: LONGINT; 
+		type-: LONGINT; 
+		features-, features2-: SET; 
+		localApicId-, logicalProcessorCount-: LONGINT; 
+		clflushSize-: LONGINT; 
+		brandId-: LONGINT; 
+		largestExtendedFunction-: LONGINT; 
+		extFeatures-, extFeatures2-: SET; 
+		processorName-: ARRAY 48 OF CHAR; 
+		l1DataTlbAssociativity2M4M-: LONGINT; 
+		l1DataTlbSize2M4M-: LONGINT; 
+		l1InstrTlbAssociativity2M4M-: LONGINT; 
+		l1InstrTlbSize2M4M-: LONGINT; 
+		l1DataTlbAssociativity4K-: LONGINT; 
+		l1DataTlbSize4K-: LONGINT; 
+		l1InstrTlbAssociativity4K-: LONGINT; 
+		l1InstrTlbSize4K-: LONGINT; 
+		l1DcSize-: LONGINT; 
+		l1DcAssociativity-: LONGINT; 
+		l1DcLinesPerTag-: LONGINT; 
+		l1DcLineSize-: LONGINT; 
+		l1IcSize-: LONGINT; 
+		l1IcAssociativity-: LONGINT; 
+		l1IcLinesPerTag-: LONGINT; 
+		l1IcLineSize-: LONGINT; 
+		unifiedTlb-: BOOLEAN; 
+		l2DataTlbAssociativity2M4M-: LONGINT; 
+		l2DataTlbSize2M4M-: LONGINT; 
+		l2InstrTlbAssociativity2M4M-: LONGINT; 
+		l2InstrTlbSize2M4M-: LONGINT; 
+		l2DataTlbAssociativity4K-: LONGINT; 
+		l2DataTlbSize4K-: LONGINT; 
+		l2InstrTlbAssociativity4K-: LONGINT; 
+		l2InstrTlbSize4K-: LONGINT; 
+		l2CacheSize-: LONGINT; 
+		l2Associativity-: LONGINT; 
+		l2LinesPerTag-: LONGINT; 
+		l2LineSize-: LONGINT; 
+		powerManagement-: SET; 
+		linAddrSize-: LONGINT; 
+		physAddrSize-: LONGINT; 
+		apicIdCoreIdSize-: LONGINT; 
+		numberOfCores-: LONGINT; 
+		svmRev-: LONGINT; 
+		nasid-: LONGINT; 
+	END; 
+
+	PROCEDURE ^ CPUID(function: LONGINT; VAR eax, ebx, ecx, edx: SET); 
+	PROCEDURE ^ CpuIdSupported(): BOOLEAN; 
+	PROCEDURE ^ StandardFunction0(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ StandardFunction1(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ IntelStandardFunction4(wr: Streams.Writer); 
+	PROCEDURE ^ IntelStandardFunction5(w: Streams.Writer); 
+	PROCEDURE ^ IntelStandardFunction6(w: Streams.Writer); 
+	PROCEDURE ^ IntelStandardFunction9(w: Streams.Writer); 
+	PROCEDURE ^ IntelStandardFunction0A(w: Streams.Writer); 
+	PROCEDURE ^ ExtendedFunction0(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ ExtendedFunction1(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ ExtendedFunction2to4(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ AmdExtendedFunction5(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ AmdExtendedFunction6(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ IntelExtendedFunction6(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ AmdExtendedFunction7(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ ExtendedFunction8(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ AmdExtendedFunctionA(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ GetString(VAR string: ARRAY OF CHAR; offset: LONGINT; register: SET); 
+	PROCEDURE ^ GetCpuInformation(VAR cpuInfo: CpuInformation); 
+	PROCEDURE ^ ShowExtFeatures2Amd(w: Streams.Writer; register: SET); 
+	PROCEDURE ^ ShowExtFeaturesAmd(w: Streams.Writer; register: SET); 
+	PROCEDURE ^ ShowPowerManagementAmd(w: Streams.Writer; register: SET); 
+	PROCEDURE ^ ShowLongModeAS(w: Streams.Writer; cpuInfo: CpuInformation); 
+	PROCEDURE ^ ShowFeatures2(w: Streams.Writer; register: SET); 
+	PROCEDURE ^ ShowFeatures(w: Streams.Writer; register: SET); 
+	PROCEDURE ^ ShowL1Associativity(w: Streams.Writer; value: LONGINT); 
+	PROCEDURE ^ ShowL2Associativity(w: Streams.Writer; value: LONGINT); 
+	PROCEDURE ^ AmdShowL1TlbAndCache(w: Streams.Writer; cpuInfo: CpuInformation); 
+	PROCEDURE ^ AmdShowL2TlbAndCache(w: Streams.Writer; cpuInfo: CpuInformation); 
+	PROCEDURE ^ AmdShowSVM(w: Streams.Writer; cpuInfo: CpuInformation); 
+	PROCEDURE ^ IntelShowCacheDescriptors(w: Streams.Writer); 
+	PROCEDURE ^ GetCacheIntel*(w: Streams.Writer; value: LONGINT; VAR s: ARRAY OF CHAR); 
+	PROCEDURE ^ IntelShowL2TlbAndCache(w: Streams.Writer; cpuInfo: CpuInformation); 
+	PROCEDURE ^ ShowDetailedCpuInformation(w: Streams.Writer; cpuInfo: CpuInformation); 
+	PROCEDURE ^ ShowCpuInformation(w: Streams.Writer; cpuInfo: CpuInformation); 
+	PROCEDURE ^ Show*(context: Commands.Context); 
+BEGIN
+END CPUID.