first experimental win64 version

oberon starts as a shell and bootup configuration is entirely formulated as a sequence commands
start a2 using oberon64 run a2.txt (or simplex double click a2.bat)

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

win64/a2.bat

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

win64/a2.txt

@@ -0,0 +1,11 @@
+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 ~
+Autostart.Run~

win64/bin/A2Sequencers.SymWw

@@ -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.

win64/bin/ADVAPI32.SymWw

@@ -0,0 +1,103 @@
+MODULE ADVAPI32;
+	IMPORT SYSTEM, Kernel32, Modules, KernelLog;
+CONST 
+	HKEYClassesRoot* = LONGINT(80000000H); 
+	HKEYCurrentUser* = LONGINT(80000001H); 
+	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.

win64/bin/AFM.SymWw

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

win64/bin/AMD64Decoder.SymWw

@@ -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.

win64/bin/ARMDecoder.SymWw

@@ -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.

win64/bin/ASMAMD64.SymWw

@@ -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.

win64/bin/ASN1.SymWw

@@ -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.

win64/bin/ActiveCellsRunner.SymWw

@@ -0,0 +1,64 @@
+module ActiveCellsRunner;
+	import system, ActiveCellsRuntime, Commands, Modules, D := Diagnostics;
+const 
+	DefaultChanDepth* = 2048; 
+	EnableTrace* = false; 
+type 
+	Cell = object 
+	var 
+		isCellnet: boolean; 
+	end Cell; 
+
+	Fifo = object {EXCLUSIVE} 
+	var 
+		data: pointer to array of system.byte; 
+		length: longint; 
+		rdPos, numEle: longint; 
+		inPort: Port; 
+		outPort: Port; 
+
+		procedure ^  & Init(outP: Port; inP: Port; length: longint); 
+		procedure ^ Put(value: longint); 
+		procedure ^ Get(var value: longint); 
+		procedure ^ BulkPut(const value: array of system.byte); 
+		procedure ^ BulkGet(var value: array of system.byte); 
+		procedure ^ BulkGetNonBlocking(var value: array of system.byte): boolean; 
+	end Fifo; 
+
+	Port = object 
+	var 
+		fifo-: Fifo; 
+		delegatedTo-: Port; 
+		inout-: set; 
+		owner: Cell; 
+
+		procedure ^  & InitPort(inout: set; width: longint); 
+		procedure ^ Delegate(toPort: Port); 
+		procedure ^ SetFifo(f: Fifo); 
+		procedure ^ Send(value: longint); 
+		procedure ^ BulkSend(const value: array of system.byte); 
+		procedure ^ Receive(var value: longint); 
+		procedure ^ ReceiveNonBlocking(var value: longint): boolean; 
+		procedure ^ BulkReceive(var value: array of system.byte); 
+	end Port; 
+
+	Context* = object {EXCLUSIVE} (ActiveCellsRuntime.Context)
+
+		procedure ^ Allocate*(scope: any; var c: any; t: Modules.TypeDesc; const name: array of char; isCellnet, isEngine: boolean); 
+		procedure ^ AddPort*(c: any; var p: any; const name: array of char; inout: set; width: longint); 
+		procedure ^ AddPortArray*(c: any; var ports: any; const name: array of char; inout: set; width: longint; const lens: array of longint); 
+		procedure ^ AddStaticPortArray*(c: any; var ports: array of any; const name: array of char; inout: set; width: longint); 
+		procedure ^ Connect*(outPort, inPort: any; depth: longint); 
+		procedure ^ Delegate*(netPort: any; cellPort: any); 
+		procedure ^ Start*(c: any; proc: procedure {DELEGATE}); 
+		procedure ^ Send*(p: any; value: longint); 
+		procedure ^ BulkSend*(p: any; const value: array of system.byte); 
+		procedure ^ Receive*(p: any; var value: longint); 
+		procedure ^ ReceiveNonBlocking*(p: any; var value: longint): boolean; 
+		procedure ^ BulkReceive*(p: any; var value: array of system.byte); 
+	end Context; 
+
+	procedure ^ Execute*(context: Commands.Context); 
+	procedure ^ Stop*(context: Commands.Context); 
+begin
+end ActiveCellsRunner.

win64/bin/ActiveCellsRuntime.SymWw

@@ -0,0 +1,108 @@
+module ActiveCellsRuntime;
+	import system, Heaps, Modules, Diagnostics, Strings, Objects, Reflection, Commands;
+const 
+	EnableTrace* = false; 
+type 
+	Cell* = object 
+	var 
+		c: any; 
+	end Cell; 
+
+	Context* = object {EXCLUSIVE} 
+	var 
+		topNet-: any; 
+		finishedAssembly-: boolean; 
+		res*: longint; 
+
+		procedure ^ Allocate*(scope: any; var c: any; t: Modules.TypeDesc; const name: array of char; isCellNet, isEngine: boolean); 
+		procedure ^ AddPort*(c: any; var p: any; const name: array of char; inout: set; width: longint); 
+		procedure ^ AddPortArray*(c: any; var ports: any; const name: array of char; inout: set; width: longint; const lens: array of longint); 
+		procedure ^ AddStaticPortArray*(c: any; var ports: array of any; const name: array of char; inout: set; width: longint); 
+		procedure ^ AddPortIntegerProperty*(p: any; const name: array of char; value: longint); 
+		procedure ^ AddFlagProperty*(c: any; const name: array of char); 
+		procedure ^ AddStringProperty*(c: any; const name: array of char; const value: array of char); 
+		procedure ^ AddIntegerProperty*(c: any; const name: array of char; value: longint); 
+		procedure ^ AddBooleanProperty*(c: any; const name: array of char; value: boolean); 
+		procedure ^ AddRealProperty*(c: any; const name: array of char; value: longreal); 
+		procedure ^ AddSetProperty*(c: any; const name: array of char; s: set); 
+		procedure ^ FinishedProperties*(var c: any); 
+		procedure ^ Connect*(outPort, inPort: any; depth: longint); 
+		procedure ^ Delegate*(netPort: any; cellPort: any); 
+		procedure ^ Start*(c: any; proc: procedure {DELEGATE}); 
+		procedure ^ Send*(p: any; value: longint); 
+		procedure ^ BulkSend*(p: any; const value: array of system.byte); 
+		procedure ^ SendNonBlocking*(p: any; value: longint): boolean; 
+		procedure ^ Receive*(p: any; var value: longint); 
+		procedure ^ BulkReceive*(p: any; var value: array of system.byte); 
+		procedure ^ ReceiveNonBlocking*(p: any; var value: longint): boolean; 
+		procedure ^ FinishedAssembly; 
+		procedure ^ WaitUntilFinishedAssembly; 
+	end Context; 
+
+	Launcher* = object {EXCLUSIVE} 
+	var 
+		proc: procedure {DELEGATE}; 
+		context: Context; 
+		finished, delayedStart: boolean; 
+		error-: boolean; 
+
+		procedure ^  & Init*(context: Context); 
+		procedure ^ Start*(p: procedure {DELEGATE}; doWait: boolean); 
+	begin{ACTIVE} 
+	end Launcher; 
+
+	Module = pointer to record 
+		next: Module; 
+		checked, imports: boolean; 
+		m: Modules.Module; 
+	end; 
+
+	bytearray = array of system.byte; 
+
+	longintSpecial = longint; 
+
+	realSpecial = real; 
+
+	Pin = port in; 
+
+	Pout = port out; 
+
+	procedure ^ GetContext(): Context; 
+	procedure ^ AllocateOnContext(context: Context; scope: Cell; var c: Cell; tag: address; const name: array of char; isCellnet, isEngine: boolean); 
+	procedure ^ Allocate*(scope: Cell; var c: Cell; tag: address; const name: array of char; isCellnet, isEngine: boolean); 
+	procedure ^ AddPort*(c: Cell; var p: any; const name: array of char; inout: set; width: longint); 
+	procedure ^ AddPortArray*(c: Cell; var ports: any; const name: array of char; inout: set; width: longint; const lens: array of longint); 
+	procedure ^ AddStaticPortArray*(c: Cell; var ports: array of any; const name: array of char; inout: set; width: longint); 
+	procedure ^ AddPortIntegerProperty*(p: any; const name: array of char; value: longint); 
+	procedure ^ AddFlagProperty*(c: Cell; const name: array of char); 
+	procedure ^ AddStringProperty*(c: Cell; const name: array of char; var newValue: array of char; const value: array of char); 
+	procedure ^ AddIntegerProperty*(c: Cell; const name: array of char; var newValue: longint; value: longint); 
+	procedure ^ AddBooleanProperty*(c: Cell; const name: array of char; var newValue: boolean; value: boolean); 
+	procedure ^ AddRealProperty*(c: Cell; const name: array of char; var newValue: longreal; value: longreal); 
+	procedure ^ AddSetProperty*(c: Cell; const name: array of char; var newValue: set; value: set); 
+	procedure ^ FinishedProperties*(c: Cell); 
+	procedure ^ Connect*(outPort, inPort: any; depth: longint); 
+	procedure ^ Delegate*(netPort: any; cellPort: any); 
+	procedure ^ Start*(c: Cell; proc: procedure {DELEGATE}); 
+	procedure ^ Send*(p: any; value: longint); 
+	procedure ^ BulkSend*(p: any; const value: array of system.byte); 
+	procedure ^ SendNonBlocking*(p: any; value: longint): boolean; 
+	procedure ^ Receive*(p: any; var value: longint); 
+	procedure ^ BulkReceive*(p: any; var value: array of system.byte); 
+	procedure ^ ReceiveNonBlocking*(p: any; var value: longint): boolean; 
+	procedure ^ Find(root: Module; m: Modules.Module): Module; 
+	procedure ^ Imports(root, m: Module; const name: array of char): boolean; 
+	procedure ^ CopyModules(): Module; 
+	procedure ^ FreeDownTo(const modulename: array of char): longint; 
+	procedure ^ Execute*(const cellNet: array of char; context: Context; diagnostics: Diagnostics.Diagnostics); 
+	operator ^ "<<"-(p: port out; const a: bytearray); 
+	operator ^ "<<"-(var a: bytearray; p: port in); 
+	operator ^ "<<"-(p: port out; a: longintSpecial); 
+	operator ^ "<<"-(var a: longintSpecial; p: port in); 
+	operator ^ "<<"-(p: port out; a: realSpecial); 
+	operator ^ "<<"-(var a: realSpecial; p: port in); 
+	operator ^ ">>"-(pout: Pout; pin: Pin); 
+	operator ^ ">>"-(cellPort: Pout; netPort: Pout); 
+	operator ^ ">>"-(netPort: Pin; cellPort: Pin); 
+begin
+end ActiveCellsRuntime.

win64/bin/ActiveTimers.SymWw

@@ -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.

win64/bin/AlmSmtpReceiver.SymWw

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

win64/bin/AnimationCodec.SymWw

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

win64/bin/Archives.SymWw

@@ -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.

win64/bin/Array1dBytes.SymWw

@@ -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(-1917569187)}  - 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(-195154503)}  - 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(-1234722257)}  - 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(1324527634)}  - 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.

win64/bin/Attributes.SymWw

@@ -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.

win64/bin/Autostart.SymWw

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

win64/bin/B.SymWw

@@ -0,0 +1,3 @@
+MODULE B;
+BEGIN
+END B.

win64/bin/BIT.SymWw

@@ -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.

win64/bin/BMPCodec.SymWw

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

win64/bin/Base64.SymWw

@@ -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.

win64/bin/Beep.SymWw

@@ -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.

win64/bin/BeepTest.SymWw

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

win64/bin/BenchSyntaxHighlighter.SymWw

@@ -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.

win64/bin/BenchTCP.SymWw

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

win64/bin/BenchXML.SymWw

@@ -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.

win64/bin/BimboMail.SymWw

@@ -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.

win64/bin/BimboScanner.SymWw

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

win64/bin/Bimso.SymWw

@@ -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.

win64/bin/Bin2Hex.SymWw

@@ -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.

win64/bin/BinToCode.SymWw

@@ -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.

win64/bin/BitSets.SymWw

@@ -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.

win64/bin/BootConsole.SymWw

@@ -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.

win64/bin/BootManager.SymWw

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

win64/bin/BootShell.SymWw

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

win64/bin/CATServer.SymWw

@@ -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.

win64/bin/CLUTs.SymWw

@@ -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.

win64/bin/CPUID.SymWw

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

win64/bin/CRC.SymWw

@@ -0,0 +1,44 @@
+MODULE CRC;
+	IMPORT SYSTEM, Streams;
+CONST 
+	Init16 =  -1; 
+	Init32 = LONGINT(0FFFFFFFFH); 
+TYPE 
+	CRC16Stream* = OBJECT (Streams.Writer)
+	VAR 
+		crc*: INTEGER; 
+
+		PROCEDURE ^  & InitStream*; 
+		PROCEDURE ^ Send*(CONST buf: ARRAY OF CHAR; ofs, len: LONGINT; propagate: BOOLEAN; VAR res: LONGINT); 
+		PROCEDURE ^ SetCRC*(crc: INTEGER); 
+		PROCEDURE ^ GetCRC*(): INTEGER; 
+	END CRC16Stream; 
+
+	CRC32Stream* = OBJECT (Streams.Writer)
+	VAR 
+		crc: LONGINT; 
+
+		PROCEDURE ^  & InitStream*; 
+		PROCEDURE ^ Reset*; 
+		PROCEDURE ^ Send*(CONST buf: ARRAY OF CHAR; ofs, len: LONGINT; propagate: BOOLEAN; VAR res: LONGINT); 
+		PROCEDURE ^ SetCRC*(crc: LONGINT); 
+		PROCEDURE ^ GetCRC*(): LONGINT; 
+		PROCEDURE ^ GetUninvertedCRC*(): LONGINT; 
+	END CRC32Stream; 
+
+	CRC32* = OBJECT 
+	VAR 
+		crc: LONGINT; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ Char*(c: CHAR); 
+		PROCEDURE ^ Add*(i: LONGINT); 
+		PROCEDURE ^ Get*(): LONGINT; 
+	END CRC32; 
+VAR 
+	CRC16Table, CRC32Table: ARRAY 256 OF SET; 
+
+	PROCEDURE ^ InitTable16; 
+	PROCEDURE ^ InitTable32; 
+BEGIN
+END CRC.

win64/bin/CSS2.SymWw

@@ -0,0 +1,248 @@
+MODULE CSS2;
+	IMPORT Strings, Objects := XMLObjects;
+CONST 
+	Undefined* = 0; 
+	All* = 0; 
+	Aural* = 1; 
+	Braille* = 2; 
+	Embossed* = 3; 
+	Handheld* = 4; 
+	Print* = 5; 
+	Projection* = 6; 
+	Screen* = 7; 
+	TTY* = 8; 
+	TV* = 9; 
+	Descendant* = 1; 
+	Child* = 2; 
+	Sibling* = 3; 
+	Equal* = 1; 
+	Includes* = 2; 
+	Dashmatch* = 3; 
+	Slash* = 1; 
+	Comma* = 2; 
+	Minus* =  -1; 
+	Plus* = 1; 
+	IntNumber* = 1; 
+	RealNumber* = 2; 
+	Percent* = 3; 
+	IntDimension* = 4; 
+	RealDimension* = 5; 
+	Function* = 6; 
+	StringVal* = 7; 
+	StringIdent* = 8; 
+	URI* = 9; 
+	Color* = 10; 
+	Ident* = 11; 
+	UnicodeRange* = 12; 
+	em* = 1; 
+	ex* = 2; 
+	px* = 3; 
+	in* = 4; 
+	cm* = 5; 
+	mm* = 6; 
+	pt* = 7; 
+	pc* = 8; 
+	deg* = 9; 
+	grad* = 10; 
+	rad* = 11; 
+	ms* = 12; 
+	s* = 13; 
+	Hz* = 14; 
+	kHz* = 15; 
+	Left* = 1; 
+	Right* = 2; 
+	First* = 3; 
+TYPE 
+	String* = Strings.String; 
+
+	StyleSheet* = OBJECT 
+	VAR 
+		charSet: String; 
+		rulesets, pages, fontFaces: Objects.Collection; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetCharSet*(): String; 
+		PROCEDURE ^ SetCharSet*(VAR charSet: ARRAY OF CHAR); 
+		PROCEDURE ^ GetRuleSets*(): Objects.Enumerator; 
+		PROCEDURE ^ AddRuleSet*(rs: RuleSet); 
+		PROCEDURE ^ GetPages*(): Objects.Enumerator; 
+		PROCEDURE ^ AddPage*(page: Page); 
+		PROCEDURE ^ GetFontFaces*(): Objects.Enumerator; 
+		PROCEDURE ^ AddFontFace*(fontFace: FontFace); 
+	END StyleSheet; 
+
+	RuleSet* = OBJECT 
+	VAR 
+		selectors, declarations: Objects.Collection; 
+		hasImportantDeclarations, hasNotImportantDeclarations: BOOLEAN; 
+		media: SET; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetMedia*(): SET; 
+		PROCEDURE ^ IsMediumSupported*(medium: SHORTINT): BOOLEAN; 
+		PROCEDURE ^ AddMedium*(medium: SHORTINT); 
+		PROCEDURE ^ SetMedia*(media: SET); 
+		PROCEDURE ^ GetSelectors*(): Objects.Enumerator; 
+		PROCEDURE ^ AddSelector*(selector: Selector); 
+		PROCEDURE ^ GetDeclarations*(): Objects.Enumerator; 
+		PROCEDURE ^ AddDeclaration*(declaration: Declaration); 
+		PROCEDURE ^ HasImportantDeclarations*(): BOOLEAN; 
+		PROCEDURE ^ HasNotImportantDeclarations*(): BOOLEAN; 
+	END RuleSet; 
+
+	Selector* = OBJECT 
+	VAR 
+		a, b, c: LONGINT; 
+		simpleSelectors: Objects.Collection; 
+		lastSimpleSel: SimpleSelector; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetSpecifity*(VAR a, b, c: LONGINT); 
+		PROCEDURE ^ GetSimpleSelectors*(): Objects.Enumerator; 
+		PROCEDURE ^ AddSimpleSelector*(simpleSelector: SimpleSelector); 
+	END Selector; 
+
+	SimpleSelector* = OBJECT 
+	VAR 
+		next: SimpleSelector; 
+		combinator: SHORTINT; 
+		elementName: String; 
+		subSelectors: Objects.Collection; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetNext*(): SimpleSelector; 
+		PROCEDURE ^ GetCombinator*(): SHORTINT; 
+		PROCEDURE ^ SetCombinator*(combinator: SHORTINT); 
+		PROCEDURE ^ GetElementName*(): String; 
+		PROCEDURE ^ SetElementName*(VAR elementName: ARRAY OF CHAR); 
+		PROCEDURE ^ GetSubSelectors*(): Objects.Enumerator; 
+		PROCEDURE ^ AddSubSelector*(subSelector: SubSelector); 
+	END SimpleSelector; 
+
+	SubSelector* = OBJECT 
+	END SubSelector; 
+
+	Id* = OBJECT (SubSelector)
+	VAR 
+		value: String; 
+
+		PROCEDURE ^ GetValue*(): String; 
+		PROCEDURE ^ SetValue*(VAR value: ARRAY OF CHAR); 
+	END Id; 
+
+	Class* = OBJECT (SubSelector)
+	VAR 
+		value: String; 
+
+		PROCEDURE ^ GetValue*(): String; 
+		PROCEDURE ^ SetValue*(VAR value: ARRAY OF CHAR); 
+	END Class; 
+
+	Attribute* = OBJECT (SubSelector)
+	VAR 
+		name, value: String; 
+		relation: SHORTINT; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetName*(): String; 
+		PROCEDURE ^ SetName*(VAR name: ARRAY OF CHAR); 
+		PROCEDURE ^ GetRelation*(): SHORTINT; 
+		PROCEDURE ^ SetRelation*(relation: SHORTINT); 
+		PROCEDURE ^ GetValue*(): String; 
+		PROCEDURE ^ SetValue*(VAR value: ARRAY OF CHAR); 
+	END Attribute; 
+
+	Pseudo* = OBJECT (SubSelector)
+	VAR 
+		isLanguage: BOOLEAN; 
+		type: String; 
+
+		PROCEDURE ^ GetType*(): String; 
+		PROCEDURE ^ SetType*(VAR type: ARRAY OF CHAR); 
+		PROCEDURE ^ GetLanguage*(): String; 
+		PROCEDURE ^ IsLanguage*(): BOOLEAN; 
+		PROCEDURE ^ SetLanguage*(VAR language: ARRAY OF CHAR); 
+	END Pseudo; 
+
+	Declaration* = OBJECT 
+	VAR 
+		property: String; 
+		expr: Objects.Collection; 
+		important: BOOLEAN; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetProperty*(): String; 
+		PROCEDURE ^ SetProperty*(VAR property: ARRAY OF CHAR); 
+		PROCEDURE ^ GetTerms*(): Objects.Enumerator; 
+		PROCEDURE ^ AddTerm*(term: Term); 
+		PROCEDURE ^ RemoveTerm*(term: Term); 
+		PROCEDURE ^ IsImportant*(): BOOLEAN; 
+		PROCEDURE ^ SetImportant*(important: BOOLEAN); 
+	END Declaration; 
+
+	Term* = OBJECT 
+	VAR 
+		operator, unaryOperator: SHORTINT; 
+		type: SHORTINT; 
+		intVal: LONGINT; 
+		realVal: LONGREAL; 
+		stringVal: String; 
+		unit: SHORTINT; 
+		expr: Objects.Collection; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetOperator*(): SHORTINT; 
+		PROCEDURE ^ SetOperator*(operator: SHORTINT); 
+		PROCEDURE ^ GetUnaryOperator*(): SHORTINT; 
+		PROCEDURE ^ SetUnaryOperator*(unaryOperator: SHORTINT); 
+		PROCEDURE ^ GetType*(): SHORTINT; 
+		PROCEDURE ^ SetType*(type: SHORTINT); 
+		PROCEDURE ^ GetIntVal*(): LONGINT; 
+		PROCEDURE ^ SetIntVal*(intVal: LONGINT); 
+		PROCEDURE ^ GetRealVal*(): LONGREAL; 
+		PROCEDURE ^ SetRealVal*(realVal: LONGREAL); 
+		PROCEDURE ^ GetStringVal*(): String; 
+		PROCEDURE ^ SetStringVal*(VAR stringVal: ARRAY OF CHAR); 
+		PROCEDURE ^ IsStringIdent*(ident: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ IsIdent*(ident: LONGINT): BOOLEAN; 
+		PROCEDURE ^ GetUnit*(): SHORTINT; 
+		PROCEDURE ^ SetUnit*(unit: SHORTINT); 
+		PROCEDURE ^ IsLength*(): BOOLEAN; 
+		PROCEDURE ^ IsAngle*(): BOOLEAN; 
+		PROCEDURE ^ IsTime*(): BOOLEAN; 
+		PROCEDURE ^ IsFrequency*(): BOOLEAN; 
+		PROCEDURE ^ GetColor*(VAR r, g, b, a: CHAR); 
+		PROCEDURE ^ SetColor*(r, g, b, a: CHAR); 
+		PROCEDURE ^ GetTerms*(): Objects.Enumerator; 
+		PROCEDURE ^ AddTerm*(term: Term); 
+	END Term; 
+
+	Page* = OBJECT 
+	VAR 
+		selector: String; 
+		pseudoPage: SHORTINT; 
+		declarations: Objects.Collection; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetSelector*(): String; 
+		PROCEDURE ^ SetSelector*(VAR selector: ARRAY OF CHAR); 
+		PROCEDURE ^ GetPseudoPage*(): SHORTINT; 
+		PROCEDURE ^ SetPseudoPage*(pseudoPage: SHORTINT); 
+		PROCEDURE ^ GetDeclarations*(): Objects.Enumerator; 
+		PROCEDURE ^ AddDeclaration*(declaration: Declaration); 
+	END Page; 
+
+	FontFace* = OBJECT 
+	VAR 
+		declarations: Objects.Collection; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ GetDeclarations*(): Objects.Enumerator; 
+		PROCEDURE ^ AddDeclaration*(declaration: Declaration); 
+	END FontFace; 
+
+	PROCEDURE ^ IntToRGBA*(color: LONGINT; VAR r, g, b, a: CHAR); 
+	PROCEDURE ^ RGBAToInt*(r, g, b, a: CHAR; VAR color: LONGINT); 
+	PROCEDURE ^ NewString(VAR value: ARRAY OF CHAR): String; 
+BEGIN
+END CSS2.

win64/bin/CSS2Parser.SymWw

@@ -0,0 +1,40 @@
+MODULE CSS2Parser;
+	IMPORT KernelLog, Strings, Scanner := CSS2Scanner, XMLObjects, CSS2, Files;
+CONST 
+TYPE 
+	String = CSS2.String; 
+
+	Parser* = OBJECT 
+	VAR 
+		reportError*: PROCEDURE (pos, line, row: LONGINT; msg: ARRAY OF CHAR); 
+		scanner: Scanner.Scanner; 
+
+		PROCEDURE ^  & Init*(scanner: Scanner.Scanner); 
+		PROCEDURE ^ CheckSymbol(expectedSymbols: SET; errormsg: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ Error(msg: ARRAY OF CHAR); 
+		PROCEDURE ^ Parse*(): CSS2.StyleSheet; 
+		PROCEDURE ^ ParseImport(styleSheet: CSS2.StyleSheet); 
+		PROCEDURE ^ ParseMedia(styleSheet: CSS2.StyleSheet); 
+		PROCEDURE ^ ParsePage(): CSS2.Page; 
+		PROCEDURE ^ ParseFontFace(): CSS2.FontFace; 
+		PROCEDURE ^ ParseRuleSet(): CSS2.RuleSet; 
+		PROCEDURE ^ ParseSelector(): CSS2.Selector; 
+		PROCEDURE ^ ParseSimpleSelector(): CSS2.SimpleSelector; 
+		PROCEDURE ^ ParseId(): CSS2.Id; 
+		PROCEDURE ^ ParseClass(): CSS2.Class; 
+		PROCEDURE ^ ParseAttribute(): CSS2.Attribute; 
+		PROCEDURE ^ ParsePseudo(): CSS2.Pseudo; 
+		PROCEDURE ^ ParseDeclaration(): CSS2.Declaration; 
+		PROCEDURE ^ ParseTerm(): CSS2.Term; 
+		PROCEDURE ^ ParseRGB(hasAlpha: BOOLEAN): LONGINT; 
+		PROCEDURE ^ IgnoreKeyword; 
+	END Parser; 
+
+	PROCEDURE ^ GetMedium(mediumStr: ARRAY OF CHAR): SHORTINT; 
+	PROCEDURE ^ GetPseudoPage(pseudoPageStr: ARRAY OF CHAR): SHORTINT; 
+	PROCEDURE ^ GetTermUnit(unitStr: ARRAY OF CHAR): SHORTINT; 
+	PROCEDURE ^ ComputeRGB(VAR s: ARRAY OF CHAR): LONGINT; 
+	PROCEDURE ^ HexStrToInt(VAR str: ARRAY OF CHAR; VAR val: LONGINT); 
+	PROCEDURE ^ DefaultReportError(pos, line, row: LONGINT; msg: ARRAY OF CHAR); 
+BEGIN
+END CSS2Parser.

win64/bin/CSS2Properties.SymWw

@@ -0,0 +1,382 @@
+MODULE CSS2Properties;
+	IMPORT DynamicStrings, XMLObjects, CSS2, WMWindowManager, WMGraphics, Raster, GfxImages, GfxFonts, Gfx;
+CONST 
+	Aqua* = LONGINT(0FF00FFFFH); 
+	Black* = LONGINT(0FF000000H); 
+	Blue* = LONGINT(0FF0000FFH); 
+	Fuchsia* = LONGINT(0FFFF00FFH); 
+	Gray* = LONGINT(0FF808080H); 
+	Green* = LONGINT(0FF008000H); 
+	Lime* = LONGINT(0FF00FF00H); 
+	Maroon* = LONGINT(0FF800000H); 
+	Navy* = LONGINT(0FF000080H); 
+	Olive* = LONGINT(0FF808000H); 
+	Purple* = LONGINT(0FF800080H); 
+	Red* = LONGINT(0FFFF0000H); 
+	Silver* = LONGINT(0FFC0C0C0H); 
+	Teal* = LONGINT(0FF008080H); 
+	White* = LONGINT(0FFFFFFFFH); 
+	Yellow* = LONGINT(0FFFFFF00H); 
+	Transparent* = 0; 
+	XXSmall* = 0; 
+	XSmall* = 1; 
+	Small* = 2; 
+	Medium* = 3; 
+	Large* = 4; 
+	XLarge* = 5; 
+	XXLarge* = 6; 
+	Larger* = 7; 
+	Smaller* = 8; 
+	None* = 1; 
+	Inherit* = 2; 
+	Normal* = 3; 
+	Auto* = 4; 
+	Top* = 5; 
+	Center* = 6; 
+	Bottom* = 7; 
+	Left* = 8; 
+	Right* = 9; 
+	Repeat* = 5; 
+	NoRepeat* = 6; 
+	Collapse* = 5; 
+	Separate* = 6; 
+	Hidden* = 6; 
+	Dotted* = 7; 
+	Dashed* = 8; 
+	Solid* = 9; 
+	Double* = 10; 
+	Groove* = 11; 
+	Ridge* = 12; 
+	Inset* = 13; 
+	Outset* = 14; 
+	Thin* = 5; 
+	Thick* = 7; 
+	StaticPosition* = 5; 
+	Clear* = 5; 
+	OpenQuote* = 5; 
+	CloseQuote* = 6; 
+	NoOpenQuote* = 7; 
+	NoCloseQuote* = 8; 
+	Crosshair* = 5; 
+	Default* = 6; 
+	Pointer* = 7; 
+	Move* = 8; 
+	EResize* = 9; 
+	NEResize* = 10; 
+	NWResize* = 11; 
+	NResize* = 12; 
+	SEResize* = 13; 
+	SWResize* = 14; 
+	SResize* = 15; 
+	WResize* = 16; 
+	Text* = 17; 
+	Wait* = 18; 
+	Help* = 19; 
+	Ltr* = 5; 
+	Rtl* = 6; 
+	Inline* = 3; 
+	Block* = 4; 
+	ListItem* = 5; 
+	RunIn* = 6; 
+	Compact* = 7; 
+	Marker* = 8; 
+	Table* = 9; 
+	InlineTable* = 10; 
+	TableRowGroup* = 11; 
+	TableHeaderGroup* = 12; 
+	TableFooterGroup* = 13; 
+	TableRow* = 14; 
+	TableColumnGroup* = 15; 
+	TableColumn* = 16; 
+	TableCell* = 17; 
+	TableCaption* = 18; 
+	Show* = 5; 
+	Hide* = 6; 
+	Caption* = 5; 
+	Icon* = 6; 
+	Menu* = 7; 
+	MessageBox* = 8; 
+	SmallCaption* = 9; 
+	StatusBar* = 10; 
+	Wider* = 5; 
+	Narrower* = 6; 
+	UltraCondensed* = 7; 
+	ExtraCondensed* = 8; 
+	Condensed* = 9; 
+	SemiCondensed* = 10; 
+	SemiExpanded* = 11; 
+	Expanded* = 12; 
+	ExtraExpanded* = 13; 
+	UltraExpanded* = 14; 
+	Italic* = 5; 
+	Oblique* = 6; 
+	SmallCaps* = 5; 
+	Bold* = 5; 
+	Bolder* = 6; 
+	Lighter* = 7; 
+	Inside* = 5; 
+	Outside* = 6; 
+	Disc* = 5; 
+	Circle* = 6; 
+	Square* = 7; 
+	Decimal* = 8; 
+	DecimalLeadingZero* = 9; 
+	LowerRoman* = 10; 
+	UpperRoman* = 11; 
+	LowerGreek* = 12; 
+	LowerAlpha* = 13; 
+	LowerLatin* = 14; 
+	UpperAlpha* = 15; 
+	UpperLatin* = 16; 
+	Hebrew* = 17; 
+	Armenian* = 18; 
+	Georgian* = 19; 
+	CjkIdeographic* = 20; 
+	Hiragana* = 21; 
+	Katakana* = 22; 
+	HiraganaIroha* = 23; 
+	KatakanaIroha* = 24; 
+	Invert* = 122; 
+	Visible* = 7; 
+	Static* = 5; 
+	Relative* = 6; 
+	Absolute* = 7; 
+	Fixed* = 8; 
+	Scroll* = 9; 
+	Justify* = 10; 
+	Underline* = 5; 
+	Overline* = 6; 
+	LineThrough* = 7; 
+	Blink* = 8; 
+	Capitalize* = 5; 
+	Uppercase* = 6; 
+	Lowercase* = 7; 
+	Embed* = 5; 
+	BidiOverride* = 6; 
+	Baseline* = 8; 
+	Sub* = 9; 
+	Super* = 10; 
+	TextTop* = 11; 
+	Middle* = 12; 
+	TextBottom* = 13; 
+	Pre* = 5; 
+	Nowrap* = 6; 
+	DummyAuto = 0; 
+TYPE 
+	String = CSS2.String; 
+
+	Value* = RECORD 
+		specified: CSS2.Term; 
+	END; 
+
+	Color* = RECORD (Value)
+		computed*: RECORD 
+			r*, g*, b*, a*: CHAR; 
+		END; 
+	END; 
+
+	TRBLColor* = RECORD 
+		top*, right*, bottom*, left*: Color; 
+	END; 
+
+	Ident* = RECORD (Value)
+		computed*: SHORTINT; 
+	END; 
+
+	TRBLIdent* = RECORD 
+		top*, right*, bottom*, left*: Ident; 
+	END; 
+
+	Dim* = RECORD (Value)
+		computed*: LONGREAL; 
+	END; 
+
+	OrientDim* = RECORD 
+		horizontal*, vertical*: Dim; 
+	END; 
+
+	TRBLDim* = RECORD 
+		top*, right*, bottom*, left*: Dim; 
+	END; 
+
+	Bool* = RECORD (Value)
+		computed*: BOOLEAN; 
+	END; 
+
+	Img* = RECORD (Value)
+		computed*: GfxImages.Image; 
+	END; 
+
+	Cursor* = RECORD 
+		specified: XMLObjects.Collection; 
+		computed*: WMWindowManager.PointerInfo; 
+	END; 
+
+	Font* = RECORD (Value)
+		computed*: GfxFonts.Font; 
+	END; 
+
+	ImgTerm = OBJECT (CSS2.Term)
+	VAR 
+		img: GfxImages.Image; 
+	END ImgTerm; 
+
+	AllMediaProperties* = OBJECT 
+	VAR 
+		parent: AllMediaProperties; 
+		replaced, generated: BOOLEAN; 
+		counterIncrement*, counterReset*, display*: Ident; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ SetParent*(parent: AllMediaProperties); 
+		PROCEDURE ^ GetValue*(name: ARRAY OF CHAR): CSS2.Declaration; 
+		PROCEDURE ^ SetValue*(declaration: CSS2.Declaration); 
+		PROCEDURE ^ Initialize*; 
+		PROCEDURE ^ ComputeValues*; 
+		PROCEDURE ^ IsBlockLevelElement*(): BOOLEAN; 
+		PROCEDURE ^ IsInlineLevelElement*(): BOOLEAN; 
+	END AllMediaProperties; 
+
+	VisualProperties* = OBJECT (AllMediaProperties)
+	TYPE 
+		; 
+
+		; 
+
+		; 
+
+		; 
+
+		; 
+
+		; 
+
+		; 
+
+		; 
+	VAR 
+		dimensionChanged-: BOOLEAN; 
+		containingBlock: RECORD 
+			width, height: LONGREAL; 
+		END; 
+		ppi*: LONGREAL; 
+		backgroundAttachment*: Bool; 
+		backgroundColor*: Color; 
+		backgroundImage*: Img; 
+		backgroundPosition*: OrientDim; 
+		backgroundRepeat*: RECORD 
+			horizontal*, vertical*: Bool; 
+		END; 
+		borderCollapse*: Bool; 
+		borderSpacing*: OrientDim; 
+		borderColor*: TRBLColor; 
+		borderStyle*: TRBLIdent; 
+		borderWidth*, margin*, padding*: TRBLDim; 
+		top*, right*, bottom*, left*: Dim; 
+		height*, width*, maxHeight*, maxWidth*, minHeight*, minWidth*: Dim; 
+		captionSide*: Ident; 
+		clear*: RECORD 
+			left*, right*: Bool; 
+		END; 
+		clip*: TRBLDim; 
+		color*: Color; 
+		cursor*: Cursor; 
+		direction*: Bool; 
+		emptyCells*: Bool; 
+		float*: Ident; 
+		font*: Font; 
+		fontSize*: Dim; 
+		fontFamily*, fontSizeAdjust*, fontStyle*, fontWeight*: CSS2.Term; 
+		fontStretch*: Ident; 
+		fontVariant*: Bool; 
+		letterSpacing*, wordSpacing*: Dim; 
+		lineHeight*: Dim; 
+		listStyleImage*: Img; 
+		listStylePosition*: Bool; 
+		listStyleType*: Ident; 
+		markerOffset*: Dim; 
+		outlineColor*: Color; 
+		outlineStyle*: Ident; 
+		outlineWidth*: Dim; 
+		overflow*: Ident; 
+		position*: Ident; 
+		quotes*: RECORD (Value)
+		END; 
+		tableLayout*: Bool; 
+		textAlign*: Ident; 
+		textDecoration*: RECORD (Value)
+			computed*: SET; 
+		END; 
+		textIndent*: Dim; 
+		textShadow*: RECORD (Value)
+		END; 
+		textTransform*: Ident; 
+		unicodeBidi*: Ident; 
+		verticalAlign*: RECORD (Value)
+			computedLength*: LONGREAL; 
+			computed*: SHORTINT; 
+		END; 
+		visibility*: Ident; 
+		whiteSpace*: Ident; 
+		zIndex*: RECORD (Value)
+			computed*: LONGINT; 
+		END; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ SetParent*(parent: AllMediaProperties); 
+		PROCEDURE ^ GetValue*(name: ARRAY OF CHAR): CSS2.Declaration; 
+		PROCEDURE ^ SetValue*(declaration: CSS2.Declaration); 
+		PROCEDURE ^ Initialize*; 
+		PROCEDURE ^ ComputeValues*; 
+		PROCEDURE ^ ComputeDimensions*; 
+		PROCEDURE ^ ComputeWidthsAndMargins; 
+		PROCEDURE ^ ComputeHeightsAndMargins; 
+		PROCEDURE ^ ComputeFont; 
+		PROCEDURE ^ ComputeContainingBlock; 
+		PROCEDURE ^ IsPositioned(): BOOLEAN; 
+	END VisualProperties; 
+VAR 
+	AbsoluteFontSizes: ARRAY 7 OF SHORTINT; 
+	defaultColor*: LONGINT; 
+	defaultCursor*, crosshairCursor*, pointerCursor*, moveCursor*, eResizeCursor*, neResizeCursor*, nwResizeCursor*, nResizeCursor*, seResizeCursor*, swResizeCursor*, sResizeCursor*, wResizeCursor*, textCursor*, waitCursor*, helpCursor*: WMWindowManager.PointerInfo; 
+	defaultFont*, captionFont*, iconFont*, menuFont*, messageBoxFont*, smallCaptionFont*, statusBarFont*: GfxFonts.Font; 
+	thinBorder*, mediumBorder*, thickBorder*: LONGREAL; 
+	m: WMWindowManager.WindowManager; 
+
+	PROCEDURE ^ IsAutoSize*(size: Dim): BOOLEAN; 
+	PROCEDURE ^ IsAutoMargin*(margin: Dim): BOOLEAN; 
+	PROCEDURE ^ ChangeToIdent(identValue: SHORTINT): CSS2.Term; 
+	PROCEDURE ^ ChangeToStringIdent(VAR term: CSS2.Term; identValue: ARRAY OF CHAR); 
+	PROCEDURE ^ SetNil(VAR property: CSS2.Term; term: CSS2.Term): BOOLEAN; 
+	PROCEDURE ^ SetIdentOrInherit(VAR property: CSS2.Term; term: CSS2.Term): BOOLEAN; 
+	PROCEDURE ^ SetNone(VAR property: CSS2.Term; term: CSS2.Term): BOOLEAN; 
+	PROCEDURE ^ ChangeToIdentCollection(VAR collection: XMLObjects.Collection; identValue: SHORTINT); 
+	PROCEDURE ^ SetNilCollection(VAR collection: XMLObjects.Collection; term: CSS2.Term): BOOLEAN; 
+	PROCEDURE ^ SetIdentOrInheritCollection(VAR collection: XMLObjects.Collection; term: CSS2.Term): BOOLEAN; 
+	PROCEDURE ^ GetPixels(term: CSS2.Term; ppi: LONGREAL; font: GfxFonts.Font): LONGREAL; 
+	PROCEDURE ^ ChangeToPixel(pixelVal: LONGREAL): CSS2.Term; 
+	PROCEDURE ^ SetColor(VAR property: CSS2.Term; term: CSS2.Term; invertAllowed: BOOLEAN); 
+	PROCEDURE ^ IsBorderStyle(term: CSS2.Term): BOOLEAN; 
+	PROCEDURE ^ BorderStyle(VAR position: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ IsBorderWidth(term: CSS2.Term): BOOLEAN; 
+	PROCEDURE ^ BorderWidth(VAR position: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ BoxOffset(VAR position: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ ListStyleImage(VAR listStyleImage: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ ListStylePosition(VAR listStylePosition: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ ListStyleType(VAR listStyleType: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ MarginWidth(VAR position: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ MaxDimension(VAR dimension: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ MinDimension(VAR dimension: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ PaddingWidth(VAR position: CSS2.Term; term: CSS2.Term); 
+	PROCEDURE ^ ComputeBool(VAR property: Bool; parentProperty: Bool; trueIdent: LONGINT); 
+	PROCEDURE ^ ComputeColor(VAR property: Color; parentProperty, initial: Color); 
+	PROCEDURE ^ ComputeImg(VAR property: Img; parentProperty: Img); 
+	PROCEDURE ^ ComputeDim(VAR property: Dim; parentProperty: Dim; ppi, referenceDim: LONGREAL; font: GfxFonts.Font); 
+	PROCEDURE ^ ComputeIdent(VAR property: Ident; parentProperty: Ident); 
+	PROCEDURE ^ ComputeCursor(VAR property: Cursor; parentProperty: Cursor); 
+	PROCEDURE ^ SetZeroIfAutoSize(size: Dim); 
+	PROCEDURE ^ SetZeroIfAutoMargin(size: Dim); 
+	PROCEDURE ^ ToGfxColor*(color: Color): Gfx.Color; 
+	PROCEDURE ^ IntToColor(color: LONGINT): Color; 
+BEGIN
+END CSS2Properties.

win64/bin/CSS2Scanner.SymWw

@@ -0,0 +1,80 @@
+MODULE CSS2Scanner;
+	IMPORT KernelLog, Strings, Streams, Files, DynamicStrings;
+CONST 
+	Null =  -2; 
+	Invalid* =  -1; 
+	Ident* = 0; 
+	AtKeyword* = 1; 
+	String* = 2; 
+	Hash* = 3; 
+	Important* = 4; 
+	Number* = 5; 
+	Percentage* = 6; 
+	Dimension* = 7; 
+	URI* = 8; 
+	Function* = 9; 
+	UnicodeRange* = 10; 
+	Cdo* = 11; 
+	Cdc* = 12; 
+	Slash* = 13; 
+	Comma* = 14; 
+	Greater* = 15; 
+	Plus* = 16; 
+	Minus* = 17; 
+	Asterisk* = 18; 
+	Semicolon* = 19; 
+	Colon* = 20; 
+	Dot* = 21; 
+	BracketOpen* = 22; 
+	BracketClose* = 23; 
+	ParenOpen* = 24; 
+	ParenClose* = 25; 
+	BraceOpen* = 26; 
+	BraceClose* = 27; 
+	Equal* = 28; 
+	Includes* = 29; 
+	Dashmatch* = 30; 
+	Eof* = 31; 
+	Undefined* = 0; 
+	Integer* = 1; 
+	Real* = 2; 
+TYPE 
+	Scanner* = OBJECT 
+	VAR 
+		sym-: LONGINT; 
+		numberType-: SHORTINT; 
+		intVal-: LONGINT; 
+		realVal-: LONGREAL; 
+		line-, row-, pos: LONGINT; 
+		reportError*: PROCEDURE (pos, line, row: LONGINT; msg: ARRAY OF CHAR); 
+		nextCh: CHAR; 
+		dynstr: DynamicStrings.DynamicString; 
+		f: Files.File; 
+		r: Files.Reader; 
+
+		PROCEDURE ^  & Init*(f: Files.File); 
+		PROCEDURE ^ Error(msg: ARRAY OF CHAR); 
+		PROCEDURE ^ NextCh; 
+		PROCEDURE ^ SkipWhiteSpace; 
+		PROCEDURE ^ ScanComment; 
+		PROCEDURE ^ ScanEscape(isString: BOOLEAN; VAR i: LONGINT); 
+		PROCEDURE ^ ScanIdent; 
+		PROCEDURE ^ ScanName; 
+		PROCEDURE ^ ScanString; 
+		PROCEDURE ^ ScanURL; 
+		PROCEDURE ^ ScanNumber; 
+		PROCEDURE ^ Scan*; 
+		PROCEDURE ^ GetStr*(): Strings.String; 
+		PROCEDURE ^ GetPos*(): LONGINT; 
+	END Scanner; 
+
+	PROCEDURE ^ IsWhiteSpace(ch: CHAR): BOOLEAN; 
+	PROCEDURE ^ IsNonAscii(ch: CHAR): BOOLEAN; 
+	PROCEDURE ^ IsEscape(ch: CHAR): BOOLEAN; 
+	PROCEDURE ^ IsNmStart(ch: CHAR): BOOLEAN; 
+	PROCEDURE ^ IsNmChar(ch: CHAR): BOOLEAN; 
+	PROCEDURE ^ IsDigit(ch: CHAR): BOOLEAN; 
+	PROCEDURE ^ HexStrToInt(VAR str: ARRAY OF CHAR; VAR val: LONGINT); 
+	PROCEDURE ^ DefaultReportError(pos, line, row: LONGINT; msg: ARRAY OF CHAR); 
+BEGIN
+END CSS2Scanner.

win64/bin/CSV.SymWw

@@ -0,0 +1,58 @@
+MODULE CSV;
+	IMPORT Streams, Files, Strings;
+CONST 
+	CR = 0DX; 
+	LF = 0AX; 
+	TAB = 9X; 
+	SP = 20X; 
+TYPE 
+	Field* = OBJECT 
+	VAR 
+		next-: Field; 
+		string*: Strings.String; 
+	END Field; 
+
+	Line* = OBJECT 
+	VAR 
+		next-: Line; 
+		fields-: Field; 
+	END Line; 
+
+	Scanner* = OBJECT 
+	VAR 
+		r: Streams.Reader; 
+		buf: Strings.Buffer; 
+		bufw: Streams.Writer; 
+		csvFile: CSV; 
+
+		PROCEDURE ^  & Init*(file: CSV; r: Streams.Reader); 
+		PROCEDURE ^ Scan*; 
+		PROCEDURE ^ ScanLine*; 
+		PROCEDURE ^ ScanField*; 
+	END Scanner; 
+
+	CSV* = OBJECT 
+	VAR 
+		separator-: CHAR; 
+		escaper-: CHAR; 
+		quoteChars-: Strings.String; 
+		lines-: Line; 
+		curLine: Line; 
+		curField: Field; 
+
+		PROCEDURE ^  & Init*(CONST separator, escaper: CHAR; CONST quotes: ARRAY OF CHAR); 
+		PROCEDURE ^ NewLine*; 
+		PROCEDURE ^ AddField*(CONST str: ARRAY OF CHAR); 
+		PROCEDURE ^ NeedsQuotes*(CONST str: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ GetUnusedQuote*(CONST str: ARRAY OF CHAR): CHAR; 
+		PROCEDURE ^ Write*(out: Streams.Writer); 
+	END CSV; 
+
+	PROCEDURE ^ IsWhiteSpace*(CONST ch: CHAR): BOOLEAN; 
+	PROCEDURE ^ ContainsWhitespace*(CONST str: ARRAY OF CHAR): BOOLEAN; 
+	PROCEDURE ^ GetDefaultCSV*(): CSV; 
+	PROCEDURE ^ ScanFromFileName*(CONST fn: ARRAY OF CHAR; VAR csv: CSV); 
+	PROCEDURE ^ AppendCSVToFileName*(CONST fn: ARRAY OF CHAR; CONST csv: CSV); 
+	PROCEDURE ^ CompareCSVs*(a, b: CSV): BOOLEAN; 
+BEGIN
+END CSV.

win64/bin/Caches.SymWw

@@ -0,0 +1,44 @@
+MODULE Caches;
+	IMPORT KernelLog, Objects, Disks;
+CONST 
+	LockedBit = 0; 
+	DirtyBit = 1; 
+	CacheUpdateTime = (5 * 1000); 
+	Trace = TRUE; 
+TYPE 
+	Buffer* = OBJECT 
+	VAR 
+		data*: POINTER TO ARRAY OF CHAR; 
+		dev*: Disks.Device; 
+		block*: LONGINT; 
+		state: SET; 
+		nextHash, prevHash, nextLRU, prevLRU, nextDirty: Buffer; 
+
+		PROCEDURE ^  & Init*(size: LONGINT); 
+	END Buffer; 
+
+	Cache* = OBJECT {EXCLUSIVE} 
+	VAR 
+		blockSize*: LONGINT; 
+		hashTable: POINTER TO ARRAY OF Buffer; 
+		lru: Buffer; 
+		lruClean: LONGINT; 
+		syncNow: BOOLEAN; 
+		timer: Objects.Timer; 
+
+		PROCEDURE ^ Acquire*(dev: Disks.Device; block: LONGINT; VAR buffer: Buffer; VAR valid: BOOLEAN); 
+		PROCEDURE ^ Release*(buffer: Buffer; modified, written: BOOLEAN); 
+		PROCEDURE ^ Synchronize*; 
+		PROCEDURE ^ AcquireDirty(VAR list: Buffer); 
+		PROCEDURE ^ ReleaseDirty(buffer: Buffer); 
+		PROCEDURE ^ AwaitSync; 
+		PROCEDURE ^ Hash(dev: Disks.Device; block: LONGINT): LONGINT; 
+		PROCEDURE ^ MoveBuffer(buf: Buffer; from, to: LONGINT); 
+		PROCEDURE ^ HandleTimeout; 
+		PROCEDURE ^  & Init*(blockSize, hashSize, cacheSize: LONGINT); 
+	BEGIN{ACTIVE, SAFE} 
+	END Cache; 
+
+	PROCEDURE ^ ReportError(dev: Disks.Device; block, num, res: LONGINT); 
+BEGIN
+END Caches.

win64/bin/CalcConvolution.SymWw

@@ -0,0 +1,9 @@
+MODULE CalcConvolution;
+	IMPORT NbrInt, NbrRe, DataErrors, MathInt, MathRe, CalcFn;
+CONST 
+
+	PROCEDURE ^ LogP(p, x: NbrRe.Real): NbrRe.Real; 
+	PROCEDURE ^ GetArrayDimension*(x, t: NbrRe.Real; n: NbrInt.Integer): NbrInt.Integer; 
+	PROCEDURE ^ Solve*(k: CalcFn.ReArg; f: CalcFn.Re2Arg; x, t: NbrRe.Real; n, p: NbrInt.Integer; VAR soln: ARRAY OF ARRAY OF NbrRe.Real); 
+BEGIN
+END CalcConvolution.

win64/bin/CalcD1.SymWw

@@ -0,0 +1,19 @@
+MODULE CalcD1;
+	IMPORT NbrInt, NbrRe, NbrCplx, MathRe, CalcFn;
+CONST 
+	Forward* = 9; 
+	Central* = 10; 
+	Backward* = 11; 
+VAR 
+	epsilon, zero: NbrRe.Real; 
+
+	PROCEDURE ^ DoNothing(x: NbrRe.Real); 
+	PROCEDURE ^ DoCplxNothing(z: NbrCplx.Complex); 
+	PROCEDURE ^ Solve*(f: CalcFn.ReArg; atX: NbrRe.Real; differencing: NbrInt.Integer): NbrRe.Real; 
+	PROCEDURE ^ SolveCplx*(f: CalcFn.CplxArg; atZ: NbrCplx.Complex; differencing: NbrInt.Integer): NbrCplx.Complex; 
+	PROCEDURE ^ SolveCplxRe*(f: CalcFn.CplxArg; atZ: NbrCplx.Complex; differencing: NbrInt.Integer): NbrCplx.Complex; 
+	PROCEDURE ^ SolveCplxIm*(f: CalcFn.CplxArg; atZ: NbrCplx.Complex; differencing: NbrInt.Integer): NbrCplx.Complex; 
+	PROCEDURE ^ SolveCplxAbs*(f: CalcFn.CplxArg; atZ: NbrCplx.Complex; differencing: NbrInt.Integer): NbrCplx.Complex; 
+	PROCEDURE ^ SolveCplxArg*(f: CalcFn.CplxArg; atZ: NbrCplx.Complex; differencing: NbrInt.Integer): NbrCplx.Complex; 
+BEGIN
+END CalcD1.

win64/bin/CalcD2.SymWw

@@ -0,0 +1,19 @@
+MODULE CalcD2;
+	IMPORT NbrInt, NbrRe, NbrCplx, MathRe, CalcFn;
+CONST 
+	Forward* = 9; 
+	Central* = 10; 
+	Backward* = 11; 
+VAR 
+	epsilon, zero: NbrRe.Real; 
+
+	PROCEDURE ^ DoNothing(x: NbrRe.Real); 
+	PROCEDURE ^ DoCplxNothing(z: NbrCplx.Complex); 
+	PROCEDURE ^ Solve*(f: CalcFn.ReArg; atX: NbrRe.Real; differencing: NbrInt.Integer): NbrRe.Real; 
+	PROCEDURE ^ SolveCplx*(f: CalcFn.CplxArg; atZ: NbrCplx.Complex; differencing: NbrInt.Integer): NbrCplx.Complex; 
+	PROCEDURE ^ SolveCplxRe*(f: CalcFn.CplxArg; atZ: NbrCplx.Complex; differencing: NbrInt.Integer): NbrCplx.Complex; 
+	PROCEDURE ^ SolveCplxIm*(f: CalcFn.CplxArg; atZ: NbrCplx.Complex; differencing: NbrInt.Integer): NbrCplx.Complex; 
+	PROCEDURE ^ SolveCplxAbs*(f: CalcFn.CplxArg; atZ: NbrCplx.Complex; differencing: NbrInt.Integer): NbrCplx.Complex; 
+	PROCEDURE ^ SolveCplxArg*(f: CalcFn.CplxArg; atZ: NbrCplx.Complex; differencing: NbrInt.Integer): NbrCplx.Complex; 
+BEGIN
+END CalcD2.

win64/bin/CalcD3.SymWw

@@ -0,0 +1,19 @@
+MODULE CalcD3;
+	IMPORT NbrInt, NbrRe, NbrCplx, MathRe, CalcFn;
+CONST 
+	Forward* = 9; 
+	Central* = 10; 
+	Backward* = 11; 
+VAR 
+	epsilon, zero: NbrRe.Real; 
+
+	PROCEDURE ^ DoNothing(x: NbrRe.Real); 
+	PROCEDURE ^ DoCplxNothing(z: NbrCplx.Complex); 
+	PROCEDURE ^ Solve*(f: CalcFn.ReArg; atX: NbrRe.Real; differencing: NbrInt.Integer): NbrRe.Real; 
+	PROCEDURE ^ SolveCplx*(f: CalcFn.CplxArg; atZ: NbrCplx.Complex; differencing: NbrInt.Integer): NbrCplx.Complex; 
+	PROCEDURE ^ SolveCplxRe*(f: CalcFn.CplxArg; atZ: NbrCplx.Complex; differencing: NbrInt.Integer): NbrCplx.Complex; 
+	PROCEDURE ^ SolveCplxIm*(f: CalcFn.CplxArg; atZ: NbrCplx.Complex; differencing: NbrInt.Integer): NbrCplx.Complex; 
+	PROCEDURE ^ SolveCplxAbs*(f: CalcFn.CplxArg; atZ: NbrCplx.Complex; differencing: NbrInt.Integer): NbrCplx.Complex; 
+	PROCEDURE ^ SolveCplxArg*(f: CalcFn.CplxArg; atZ: NbrCplx.Complex; differencing: NbrInt.Integer): NbrCplx.Complex; 
+BEGIN
+END CalcD3.