Added Win32 binary

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

Win32/a2.bat

@@ -0,0 +1 @@
+oberon run a2.txt

Win32/a2.txt

@@ -0,0 +1,12 @@
+Heaps.SetMetaData ~
+Traps.Install ~
+Files.AddSearchPath bin~
+Files.AddSearchPath ../source~
+Files.SetWorkPath work~
+Configuration.Init~
+Machine.SetTraceFile~
+FSTools.Mount WORK RelativeFileSystem Work~
+Display.Install ~
+WindowManager.Install ~
+Clipboard.Install ~
+Autostart.Run~

Win32/bin/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.

Win32/bin/ADVAPI32.SymW

@@ -0,0 +1,103 @@
+MODULE ADVAPI32;
+	IMPORT SYSTEM, Kernel32, Modules, KernelLog;
+CONST 
+	HKEYClassesRoot* = LONGINT(2147483648); 
+	HKEYCurrentUser* = LONGINT(2147483649); 
+	RegNone* = 0; 
+	RegSZ* = 1; 
+	KeyQueryValue* = 0; 
+	KeySetValue* = 1; 
+	KeyCreateSubKey* = 2; 
+	KeyEnumerateSubKeys* = 3; 
+	KeyAllAccess* = {19, 18, 17, 16, 5, 4, 3, 2, 1, 0}; 
+	RegOptionNonVolatile* = {}; 
+	Success* = 0; 
+	ErrorMoreData* = 234; 
+	SC_MANAGER_CREATE_SERVICE* = 2; 
+	SC_MANAGER_ALL_ACCESS* = 983103; 
+	SERVICE_ALL_ACCESS* = 983551; 
+	SERVICE_WIN32_OWN_PROCESS* = 16; 
+	SERVICE_AUTO_START* = 2; 
+	SERVICE_ERROR_NORMAL* = 1; 
+	SERVICE_WIN32* = 48; 
+	SERVICE_START_PENDING* = 2; 
+	SERVICE_ACCEPT_STOP* = 1; 
+	SERVICE_ACCEPT_SHUTDOWN* = 4; 
+	SERVICE_RUNNING* = 4; 
+	SERVICE_CONTROL_STOP* = 1; 
+	SERVICE_CONTROL_SHUTDOWN* = 5; 
+	SERVICE_STOPPED* = 1; 
+TYPE 
+	HKEY* = ADDRESS; 
+
+	LPSTR* = ADDRESS; 
+
+	LPCSTR* = ARRAY OF CHAR; 
+
+	HWND* = Kernel32.HANDLE; 
+
+	HINSTANCE* = Kernel32.HINSTANCE; 
+
+	INT* = LONGINT; 
+
+	LPCTSTR* = LPCSTR; 
+
+	SC_HANDLE* = Kernel32.HANDLE; 
+
+	DWORD* = LONGINT; 
+
+	LPDWORD* = ADDRESS; 
+
+	BOOL* = Kernel32.BOOL; 
+
+	LPSERVICE_MAIN_FUNCTIONA = PROCEDURE {WINAPI}(dwNumServicesArgs: DWORD; VAR lpServiceArgVectors: ARRAY OF CHAR):BOOL; 
+
+	LPSERVICE_MAIN_FUNCTION* = LPSERVICE_MAIN_FUNCTIONA; 
+
+	SERVICE_TABLE_ENTRYA = RECORD 
+		lpServiceName*: LPSTR; 
+		lpServiceProc*: LPSERVICE_MAIN_FUNCTIONA; 
+	END; 
+
+	SERVICE_TABLE_ENTRY* = SERVICE_TABLE_ENTRYA; 
+
+	LPHANDLER_FUNCTION* = PROCEDURE {WINAPI}(dwControl: DWORD); 
+
+	SERVICE_STATUS_HANDLE* = Kernel32.HANDLE; 
+
+	SERVICE_STATUS* = RECORD 
+		dwServiceType*, dwCurrentState*, dwControlsAccepted*, dwWin32ExitCode*, dwServiceSpecificExitCode*, dwCheckPoint*, dwWaitHint*: DWORD; 
+	END; 
+VAR 
+	GetUserName-: PROCEDURE {WINAPI}(VAR lpBuffer: ARRAY OF CHAR; VAR nSize: LONGINT):Kernel32.BOOL; 
+	RegCloseKey-: PROCEDURE {WINAPI}(hKey: HKEY):LONGINT; 
+	RegCreateKeyEx-: PROCEDURE {WINAPI}(hKey: HKEY; lpSubKey: ARRAY OF CHAR; Reserved: LONGINT; lpClass: ARRAY OF CHAR; dwOptions, samDesired: SET; lpSecurityAttributes: ANY; VAR phkResult: HKEY; VAR lpdwDisposition: LONGINT):LONGINT; 
+	RegDeleteKey-: PROCEDURE {WINAPI}(hKey: HKEY; lpSubKey: ARRAY OF CHAR):LONGINT; 
+	RegDeleteValue-: PROCEDURE {WINAPI}(hKey: HKEY; lpValueName: ARRAY OF CHAR):LONGINT; 
+	RegEnumKeyEx-: PROCEDURE {WINAPI}(hKey: HKEY; dwIndex: LONGINT; VAR lpName: ARRAY OF CHAR; VAR lpcbName: LONGINT; VAR lpReserved: LONGINT; VAR lpClass: ARRAY OF CHAR; VAR lpcbClass: LONGINT; VAR lpftLastWriteTime: Kernel32.FileTime):LONGINT; 
+	RegEnumValue-: PROCEDURE {WINAPI}(hKey: HKEY; dwIndex: LONGINT; VAR lpValueName: ARRAY OF CHAR; VAR lpcbValueName: LONGINT; VAR lpReserved, type: LONGINT; VAR lpData: ARRAY OF SYSTEM.BYTE; VAR lpcbData: LONGINT):LONGINT; 
+	RegOpenKeyEx-: PROCEDURE {WINAPI}(hKey: HKEY; lpSubKey: ARRAY OF CHAR; ulOptions: LONGINT; samDesired: SET; VAR phkResult: HKEY):LONGINT; 
+	RegQueryValueEx-: PROCEDURE {WINAPI}(hKey: HKEY; lpValueName: ARRAY OF CHAR; VAR lpReserved, lpType: LONGINT; VAR lpData: ARRAY OF SYSTEM.BYTE; VAR lpcbData: LONGINT):LONGINT; 
+	RegSetValueEx-: PROCEDURE {WINAPI}(hKey: HKEY; lpValueName: ARRAY OF CHAR; Reserved, dwType: LONGINT; VAR lpData: ARRAY OF SYSTEM.BYTE; cbData: LONGINT):LONGINT; 
+	GetFileVersionInfo-: PROCEDURE {WINAPI}(lpstrFilename: ARRAY OF CHAR; dwHandle, dwLen: LONGINT; VAR lpDate: ARRAY OF SYSTEM.BYTE):Kernel32.BOOL; 
+	GetFileVersionInfoSize-: PROCEDURE {WINAPI}(lpstrFilename: ARRAY OF CHAR; VAR lpdwHandle: LONGINT):LONGINT; 
+	VerQueryValue-: PROCEDURE {WINAPI}(pBlock: ARRAY OF SYSTEM.BYTE; lpSubBlock: ARRAY OF CHAR; VAR lplpBuffer: ADDRESS; VAR puLen: LONGINT):Kernel32.BOOL; 
+	CloseServiceHandle-: PROCEDURE {WINAPI}(hSCObject: SC_HANDLE):BOOL; 
+	CreateService-: PROCEDURE {WINAPI}(hSCManager: SC_HANDLE; VAR lpServiceName, lpDisplayName: LPCTSTR; dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl: DWORD; VAR lpBinaryPathName, lpLoadOrderGroup: LPCTSTR; lpdwTagId: LPDWORD; VAR lpDependencies, lpServiceStartName, lpPassword: LPCTSTR):SC_HANDLE; 
+	DeleteService-: PROCEDURE {WINAPI}(hService: SC_HANDLE):BOOL; 
+	OpenSCManager-: PROCEDURE {WINAPI}(VAR lpMachineName, lpDatabaseName: LPCTSTR; dwDesiredAccess: DWORD):SC_HANDLE; 
+	OpenService-: PROCEDURE {WINAPI}(hSCManager: SC_HANDLE; VAR lpServiceName: LPCTSTR; dwDesiredAccess: DWORD):SC_HANDLE; 
+	RegisterServiceCtrlHandler-: PROCEDURE {WINAPI}(VAR lpServiceName: ARRAY OF CHAR; lpHandlerProc: LPHANDLER_FUNCTION):SERVICE_STATUS_HANDLE; 
+	SetServiceStatus-: PROCEDURE {WINAPI}(hServiceStatus: SERVICE_STATUS_HANDLE; VAR lpServiceStatus: SERVICE_STATUS):BOOL; 
+	StartService-: PROCEDURE {WINAPI}(hService: SC_HANDLE; dwNumServiceArgs: DWORD; VAR lpServiceArgVectors: LPCTSTR):BOOL; 
+	StartServiceCtrlDispatcher-: PROCEDURE {WINAPI}(VAR lpServiceTable: ARRAY OF SYSTEM.BYTE):BOOL; 
+	advapi32: Kernel32.HMODULE; 
+
+	PROCEDURE ^ InstallService*(srvName, serviceDesc, exeFile: ARRAY OF CHAR): BOOLEAN; 
+	PROCEDURE ^ UninstallService*(srvName: ARRAY OF CHAR): BOOLEAN; 
+	PROCEDURE ^ OutError*(funcName: ARRAY OF CHAR): LONGINT; 
+	PROCEDURE ^ TermMod; 
+	PROCEDURE ^ GetProcAddress(hModule: ADDRESS; VAR adr: ADDRESS; procName: ARRAY OF CHAR); 
+	PROCEDURE ^ Init; 
+BEGIN
+END ADVAPI32.

Win32/bin/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: WORD); 
+	END FontMetrics; 
+VAR 
+	times*, helvetica*, helveticaBold*: FontMetrics; 
+	res: WORD; 
+
+BEGIN
+END AFM.

Win32/bin/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.

Win32/bin/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.

Win32/bin/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.

Win32/bin/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.

Win32/bin/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: WORD); 
+		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: WORD); 
+		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.

Win32/bin/ActiveTimers.SymW

@@ -0,0 +1,18 @@
+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.

Win32/bin/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: WORD; 
+		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.

Win32/bin/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: WORD); 
+		PROCEDURE ^ ProcessFrame(frame: XML.Element; VAR desc: Codecs.ImageDescriptor; VAR res: WORD); 
+		PROCEDURE ^ ProcessFrames(frames: XML.Element; VAR sequence: Codecs.ImageSequence; VAR res: WORD); 
+		PROCEDURE ^ GetImageSequence*(VAR sequence: Codecs.ImageSequence; VAR res: WORD); 
+	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.

Win32/bin/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.

Win32/bin/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 {FingerPrint(-1807882291)}  - 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 {FingerPrint(-712869057)}  - 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 {FingerPrint(1427773561)}  - 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 {FingerPrint(2123246868)}  - 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 {FingerPrint(1857348743)}  - 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.

Win32/bin/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.

Win32/bin/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.

Win32/bin/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.

Win32/bin/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.

Win32/bin/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.

Win32/bin/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.

Win32/bin/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.

Win32/bin/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.

Win32/bin/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 {FingerPrint(1857348743)}  - 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.

Win32/bin/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 {FingerPrint(1567398664)}  - L1Block1XA(adrA, adrB, adrC, K: LONGINT);
+	CODE
+	END L1Block1XA; 
+	PROCEDURE {FingerPrint(-1103416808)}  - L1Block1XSSE(adrA, adrB, adrC, K: LONGINT);
+	CODE
+	END L1Block1XSSE; 
+	PROCEDURE {FingerPrint(-863605617)}  - L1Block5XSSE(adrA, adrB, adrC, IncC, K: LONGINT);
+	CODE
+	END L1Block5XSSE; 
+	PROCEDURE {FingerPrint(-2016777711)}  - L1Block1RA(adrA, adrB, adrC, K: LONGINT);
+	CODE
+	END L1Block1RA; 
+	PROCEDURE {FingerPrint(-1103419880)}  - L1Block1RSSE(adrA, adrB, adrC, K: LONGINT);
+	CODE
+	END L1Block1RSSE; 
+	PROCEDURE {FingerPrint(-913937265)}  - L1Block5RSSE(adrA, adrB, adrC, IncC, K: LONGINT);
+	CODE
+	END L1Block5RSSE; 
+	PROCEDURE {FingerPrint(-410736588)}  - Align4(adr: LONGINT): LONGINT;
+	CODE
+	END Align4; 
+	PROCEDURE {FingerPrint(-410734540)}  - Align2(adr: LONGINT): LONGINT;
+	CODE
+	END Align2; 
+	PROCEDURE {FingerPrint(-1888682025)}  - ZeroR(adr: LONGINT; count: LONGINT);
+	CODE
+	END ZeroR; 
+	PROCEDURE {FingerPrint(-2056454185)}  - ZeroX(adr: LONGINT; count: LONGINT);
+	CODE
+	END ZeroX; 
+	PROCEDURE {FingerPrint(-2043961113)}  - ZeroRI(adr, inc: LONGINT; count: LONGINT);
+	CODE
+	END ZeroRI; 
+	PROCEDURE {FingerPrint(-2044010265)}  - ZeroXI(adr, inc: LONGINT; count: LONGINT);
+	CODE
+	END ZeroXI; 
+	PROCEDURE {FingerPrint(-1528439671)}  - MovR(from, to0, frominc, count: LONGINT);
+	CODE
+	END MovR; 
+	PROCEDURE {FingerPrint(-1538925431)}  - MovX(from, to0, frominc, count: LONGINT);
+	CODE
+	END MovX; 
+	PROCEDURE {FingerPrint(1715167892)}  - 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 {FingerPrint(1951090261)}  - 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.

Win32/bin/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 {FingerPrint(-269175839)}  - 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 {FingerPrint(-238922078)}  - 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 {FingerPrint(-2019807603)}  - 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 {FingerPrint(-677094810)}  - 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 {FingerPrint(1387277801)}  - 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.

Win32/bin/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.

Win32/bin/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.

Win32/bin/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.

Win32/bin/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.

Win32/bin/Attributes.SymW

@@ -0,0 +1,35 @@
+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.

Win32/bin/Autostart.SymW

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

Win32/bin/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.

Win32/bin/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: WORD); 
+		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: WORD); 
+	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.

Win32/bin/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.

Win32/bin/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.

Win32/bin/BeepTest.SymW

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

Win32/bin/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.

Win32/bin/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: WORD); 
+	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.

Win32/bin/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.

Win32/bin/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.

Win32/bin/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: WORD); 
+		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.

Win32/bin/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.

Win32/bin/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.

Win32/bin/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.

Win32/bin/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: LONGINT; 
+		data: Data; 
+
+		PROCEDURE ^  & InitBitSet*(size: LONGINT); 
+		PROCEDURE ^ Zero*; 
+		PROCEDURE ^ Resize*(size: LONGINT); 
+		PROCEDURE ^ GetSize*(): LONGINT; 
+		PROCEDURE ^ SetBit*(pos: SIZE; value: BOOLEAN); 
+		PROCEDURE ^ GetBit*(pos: SIZE): BOOLEAN; 
+		PROCEDURE ^ SetBits*(startPos: SIZE; bits: LONGINT; value: HUGEINT); 
+		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: SIZE; dest: BitSet; destPos, count: SIZE); 
+BEGIN
+END BitSets.

Win32/bin/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.

Win32/bin/BootManager.SymW

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

Win32/bin/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: WORD); 
+		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.

Win32/bin/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.

Win32/bin/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.