A2OS/WinAos/obg/FoxArrayBase.SymW

MODULE FoxArrayBase;
	IMPORT SYSTEM, KernelLog, Heaps, Math, MathL, ComplexNumbers;
CONST 
	debug = FALSE; 
	statistics = FALSE; 
	conservative = TRUE; 
	ArrDataArrayOffset = ADDRESS(16); 
	AddressSize = SIZEOF(ADDRESS); 
	MathPtrOffset = (0 * AddressSize); 
	MathAdrOffset = (1 * AddressSize); 
	MathFlagsOffset = (2 * AddressSize); 
	MathDimOffset = (3 * AddressSize); 
	MathElementSizeOffset = (4 * AddressSize); 
	MathLenOffset = (5 * AddressSize); 
	MathIncrOffset = (6 * AddressSize); 
	GeometryMismatch = 400; 
	DimensionMismatch = 401; 
	AllocationForbidden = 402; 
	TensorFlag = 0; 
	RangeFlag = 1; 
	TemporaryFlag = 2; 
	down = 0; 
	up = 1; 
	SmallMatrixFlag = 3; 
	SmallVectorFlag = 3; 
	Size2Flag = 4; 
	Size3Flag = 5; 
	Size4Flag = 6; 
	Size5Flag = 7; 
	Size6Flag = 8; 
	Size7Flag = 9; 
	Size8Flag = 10; 
	Mat2x2 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, Size2Flag}); 
	Mat3x3 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, Size3Flag}); 
	Mat4x4 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, Size4Flag}); 
	Mat5x5 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, Size5Flag}); 
	Mat6x6 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, Size6Flag}); 
	Mat7x7 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, Size7Flag}); 
	Mat8x8 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, Size8Flag}); 
	Vec2 = SYSTEM.VAL(LONGINT, {SmallVectorFlag, Size2Flag}); 
	Vec3 = SYSTEM.VAL(LONGINT, {SmallVectorFlag, Size3Flag}); 
	Vec4 = SYSTEM.VAL(LONGINT, {SmallVectorFlag, Size4Flag}); 
	Vec5 = SYSTEM.VAL(LONGINT, {SmallVectorFlag, Size5Flag}); 
	Vec6 = SYSTEM.VAL(LONGINT, {SmallVectorFlag, Size6Flag}); 
	Vec7 = SYSTEM.VAL(LONGINT, {SmallVectorFlag, Size7Flag}); 
	Vec8 = SYSTEM.VAL(LONGINT, {SmallVectorFlag, Size8Flag}); 
	MatVec2x2 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, SmallVectorFlag, Size2Flag}); 
	MatVec3x3 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, SmallVectorFlag, Size3Flag}); 
	MatVec4x4 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, SmallVectorFlag, Size4Flag}); 
	MatVec5x5 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, SmallVectorFlag, Size5Flag}); 
	MatVec6x6 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, SmallVectorFlag, Size6Flag}); 
	MatVec7x7 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, SmallVectorFlag, Size7Flag}); 
	MatVec8x8 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, SmallVectorFlag, Size8Flag}); 
	SmallArrayMask = {SmallMatrixFlag, SmallVectorFlag, Size2Flag, Size3Flag, Size4Flag, Size5Flag, Size6Flag, Size7Flag, Size8Flag}; 
TYPE 
	GenericUnaryAALoopS = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: SHORTINT):SHORTINT); 

	GenericUnaryAALoopI = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: INTEGER):INTEGER); 

	GenericUnaryAALoopL = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: LONGINT):LONGINT); 

	GenericUnaryAALoopH = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: HUGEINT):HUGEINT); 

	GenericUnaryAALoopR = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: REAL):REAL); 

	GenericUnaryAALoopX = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: LONGREAL):LONGREAL); 

	GenericUnaryAALoopZ = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: COMPLEX):COMPLEX); 

	GenericUnaryAALoopLZ = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: LONGCOMPLEX):LONGCOMPLEX); 

	UnaryAALoop = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 

	UnaryASLoop = PROCEDURE (ladr, dadr: ADDRESS; linc, len: SIZE); 

	UnarySALoop = PROCEDURE (ladr, dadr: ADDRESS; dinc, len: SIZE); 

	BinaryAAALoop = PROCEDURE (ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 

	BinaryASALoop = PROCEDURE (ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 

	BinaryAASLoop = PROCEDURE (ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 

	BinaryAABLoop = PROCEDURE (ladr, radr: ADDRESS; linc, rinc, len: SIZE):BOOLEAN; 

	BinaryASBLoop = PROCEDURE (ladr, radr: ADDRESS; linc, len: SIZE):BOOLEAN; 

	FastMatMul* = PROCEDURE (matrixA, matrixB, matrixC, IncA, StrideA, IncB, StrideB, IncC, StrideC, RowsA, ColsA, RowsB, ColsB: LONGINT):BOOLEAN; 

	TransposeP* = PROCEDURE (ladr, dadr, lstride, linc, dstride, dinc, rows, cols: LONGINT); 

	LenInc = RECORD 
		len: SIZE; 
		inc: SIZE; 
	END; 

	ArrayDescriptor* = RECORD 
		ptr*: ANY; 
		adr*: ADDRESS; 
		flags*: SET; 
		dim*: SIZE; 
		elementSize*: SIZE; 
	END; 

	Tensor = POINTER TO ArrayDescriptor; 

	UnsafeArray* = POINTER {UNSAFE} TO RECORD (ArrayDescriptor)
		lens*: ARRAY 8 OF LenInc; 
	END; 

	A0 = RECORD (ArrayDescriptor)
	END; 

	A1 = RECORD (ArrayDescriptor)
		lens: ARRAY 1 OF LenInc; 
	END; 

	A2 = RECORD (ArrayDescriptor)
		lens: ARRAY 2 OF LenInc; 
	END; 

	A3 = RECORD (ArrayDescriptor)
		lens: ARRAY 3 OF LenInc; 
	END; 

	A4 = RECORD (ArrayDescriptor)
		lens: ARRAY 4 OF LenInc; 
	END; 

	A5 = RECORD (ArrayDescriptor)
		lens: ARRAY 5 OF LenInc; 
	END; 

	A6 = RECORD (ArrayDescriptor)
		lens: ARRAY 6 OF LenInc; 
	END; 

	A7 = RECORD (ArrayDescriptor)
		lens: ARRAY 7 OF LenInc; 
	END; 

	A8 = RECORD (ArrayDescriptor)
		lens: ARRAY 8 OF LenInc; 
	END; 

	T0 = POINTER TO A0; 

	T1 = POINTER TO A1; 

	T2 = POINTER TO A2; 

	T3 = POINTER TO A3; 

	T4 = POINTER TO A4; 

	T5 = POINTER TO A5; 

	T6 = POINTER TO A6; 

	T7 = POINTER TO A7; 

	T8 = POINTER TO A8; 

	SmallMatMul* = PROCEDURE (dadr, ladr, radr: LONGINT); 

	LongintPtr = POINTER {UNSAFE} TO RECORD 
		val: LONGINT; 
	END; 
VAR 
	temporary*: T0; 
	alloc*: LONGINT; 
	allocTemp*: LONGINT; 
	loopSPAXAX*, loopSPARAR*: BinaryAASLoop; 
	loopSPAZAZ, loopSPALZALZ: BinaryAASLoop; 
	loopAddAXAX*, loopAddARAR*, loopAddAZAZ*, loopAddALZALZ*: BinaryAAALoop; 
	loopMatMulAXAX*, loopMatMulARAR*: BinaryAASLoop; 
	loopMatMulIncAXAX*, loopMatMulIncARAR*: BinaryAASLoop; 
	loopMulAXSX*, loopMulARSR*, loopMulAZSZ*, loopMulALZSLZ*: BinaryASALoop; 
	loopIncMulAXSX*, loopIncMulARSR*: BinaryASALoop; 
	matMulX*, matMulR*: FastMatMul; 
	matMulIncX*, matMulIncR*: FastMatMul; 
	transpose4*: TransposeP; 
	transpose8*: TransposeP; 
	matMulR2x2*: SmallMatMul; 
	matMulR3x3*: SmallMatMul; 
	matMulR4x4*: SmallMatMul; 
	matVecMulR2x2*: SmallMatMul; 
	matVecMulR3x3*: SmallMatMul; 
	matVecMulR4x4*: SmallMatMul; 
	matMulLR2x2*: SmallMatMul; 
	matMulLR3x3*: SmallMatMul; 
	matMulLR4x4*: SmallMatMul; 
	matVecMulLR2x2*: SmallMatMul; 
	matVecMulLR3x3*: SmallMatMul; 
	matVecMulLR4x4*: SmallMatMul; 

	PROCEDURE ^ SetDefaults*; 
	PROCEDURE ^ Err(CONST s: ARRAY OF CHAR); 
	PROCEDURE ^ GetIncr(base: UnsafeArray; dim: SIZE): SIZE; 
	PROCEDURE ^ PutInc(base: UnsafeArray; dim, val: SIZE); 
	PROCEDURE ^ GetLen(base: UnsafeArray; dim: SIZE): LONGINT; 
	PROCEDURE ^ PutLen(base: UnsafeArray; dim, val: SIZE); 
	PROCEDURE ^ GetAdr(base: UnsafeArray): ADDRESS; 
	PROCEDURE ^ PutAdr(base: UnsafeArray; value: ADDRESS); 
	PROCEDURE ^ Align(value: ADDRESS): ADDRESS; 
	PROCEDURE ^ GetPtr(base: UnsafeArray): ANY; 
	PROCEDURE ^ PutPtr(base: UnsafeArray; value: ANY); 
	PROCEDURE ^ GetSize(base: UnsafeArray): LONGINT; 
	PROCEDURE ^ PutSize(base: UnsafeArray; val: SIZE); 
	PROCEDURE ^ GetDim(base: UnsafeArray): SIZE; 
	PROCEDURE ^ GetFlags(base: UnsafeArray): SET; 
	PROCEDURE ^ PutDim(base: UnsafeArray; dim: SIZE); 
	PROCEDURE ^ PutFlags(base: UnsafeArray; flags: SET); 
	PROCEDURE ^ Report(CONST name: ARRAY OF CHAR; s: ADDRESS); 
	PROCEDURE ^ GetArrayDesc(dim: LONGINT): Tensor; 
	PROCEDURE ^ EnsureArrayDesc*(dim: SIZE; VAR d: Tensor); 
	PROCEDURE ^ Halt(code: LONGINT; left, right, dest: LONGINT); 
	PROCEDURE ^ FindPattern1(left, dim: ADDRESS; VAR d, len, linc: LONGINT); 
	PROCEDURE ^ FindPattern2(left, right: ADDRESS; dim: LONGINT; VAR d, len, linc, ri: LONGINT); 
	PROCEDURE ^ FindPattern3(left, right, dest: ADDRESS; dim: LONGINT; VAR d, len, linc, ri, di: LONGINT); 
	PROCEDURE ^ Reverse(src: ADDRESS; dim: LONGINT); 
	PROCEDURE ^ CopyUpCompatible(dest, src: ADDRESS; VAR modes: SET); 
	PROCEDURE ^ AllocateTemp(VAR dest: ADDRESS; src: ADDRESS; Size: LONGINT): ANY; 
	PROCEDURE ^ ApplyGenericUnaryAAOpS(d, l: ADDRESS; elementSize: LONGINT; Loop: GenericUnaryAALoopS; op: PROCEDURE (x: SHORTINT):SHORTINT); 
	PROCEDURE ^ ApplyGenericUnaryAAOpI(d, l: ADDRESS; elementSize: LONGINT; Loop: GenericUnaryAALoopI; op: PROCEDURE (x: INTEGER):INTEGER); 
	PROCEDURE ^ ApplyGenericUnaryAAOpL(d, l: ADDRESS; elementSize: LONGINT; Loop: GenericUnaryAALoopL; op: PROCEDURE (x: LONGINT):LONGINT); 
	PROCEDURE ^ ApplyGenericUnaryAAOpH(d, l: ADDRESS; elementSize: LONGINT; Loop: GenericUnaryAALoopH; op: PROCEDURE (x: HUGEINT):HUGEINT); 
	PROCEDURE ^ ApplyGenericUnaryAAOpR(d, l: ADDRESS; elementSize: LONGINT; Loop: GenericUnaryAALoopR; op: PROCEDURE (x: REAL):REAL); 
	PROCEDURE ^ ApplyGenericUnaryAAOpX(d, l: ADDRESS; elementSize: LONGINT; Loop: GenericUnaryAALoopX; op: PROCEDURE (x: LONGREAL):LONGREAL); 
	PROCEDURE ^ ApplyGenericUnaryAAOpZ(d, l: ADDRESS; elementSize: LONGINT; Loop: GenericUnaryAALoopZ; op: PROCEDURE (x: COMPLEX):COMPLEX); 
	PROCEDURE ^ ApplyGenericUnaryAAOpLZ(d, l: ADDRESS; elementSize: LONGINT; Loop: GenericUnaryAALoopLZ; op: PROCEDURE (x: LONGCOMPLEX):LONGCOMPLEX); 
	PROCEDURE ^ ApplyUnaryAAOp(d, l: ADDRESS; elementSize: LONGINT; Loop: UnaryAALoop); 
	PROCEDURE ^ ApplyUnaryASOp(dest, l: ADDRESS; Loop: UnaryASLoop); 
	PROCEDURE ^ ApplyUnarySAOp(d, right: ADDRESS; Loop: UnarySALoop); 
	PROCEDURE ^ ApplyBinaryAAAOp(d, l, r: ADDRESS; elementSize: LONGINT; Loop: BinaryAAALoop); 
	PROCEDURE ^ ApplyBinaryASAOp(d, l, right: ADDRESS; elementSize: LONGINT; Loop: BinaryASALoop); 
	PROCEDURE ^ ApplyBinaryAASOp(dest, l, r: ADDRESS; Loop: BinaryAASLoop); 
	PROCEDURE ^ ApplyBinaryAABOp(l, r: ADDRESS; Loop: BinaryAABLoop; geometryMismatchDefault: BOOLEAN): BOOLEAN; 
	PROCEDURE ^ ApplyBinaryASBOp(l, right: ADDRESS; Loop: BinaryASBLoop): BOOLEAN; 
	PROCEDURE ^ Copy4(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	PROCEDURE ^ Copy2(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	PROCEDURE ^ Copy1(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	PROCEDURE ^ Copy8(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	PROCEDURE {FingerPrint(1857348743)}  - MoveB*(srcadr, destadr, len: LONGINT);
	CODE {SYSTEM.i386}
		MOV	ECX, [ESP]	;  len
		MOV	EDI, [ESP+4]	;  destadr
		MOV	ESI, [ESP+8]	;  srcadr
		CMP	ESI, EDI
		JAE	moveup	;  src adr greater then dest adr, no problem with moving up
		MOV	EAX, ESI
		ADD	EAX, ECX
		CMP	EAX, EDI
		JBE	moveup	;  no overlap, no problem, move up
		MOV	ESI, EAX
		ADD	EDI, ECX
		DEC	ESI
		DEC	EDI
		STD	;  move down since overlap occured
		REP
		MOVSB
		JMP	done
		moveup:
		CLD
		MOV	BL, CL
		SHR	ECX, 2
		AND	BL, 00000003H	;  rest to move after 4 byte move
		REP
		MOVSD	;  move 4 bytes each step
		MOV	CL, BL
		REP
		MOVSB	;  move rest in one byte steps
		done:
		ADD	ESP, 12	;  adjust stack pointer(inline procedure!)
	
	END MoveB; 
	PROCEDURE ^ CopyContent(dest, src: ADDRESS; elementSize: SIZE); 
	PROCEDURE ^ AllocateSame(VAR dest: ADDRESS; src: ADDRESS; elementsize: LONGINT): ANY; 
	PROCEDURE ^ TempDescCopy(src: ADDRESS): ANY; 
	PROCEDURE ^ CopyArraySelf*(dest, src: ADDRESS; elementsize: LONGINT); 
	PROCEDURE ^ CopyArray*(dest: ADDRESS; src: ADDRESS; elementsize: SIZE); 
	PROCEDURE ^ CopyTensorSelf*(VAR dest: ADDRESS; src: ADDRESS; elementsize: SIZE); 
	PROCEDURE ^ CopyTensor*(VAR dest: ADDRESS; src: ADDRESS; elementsize: SIZE); 
	PROCEDURE ^ ShallowCopy*(VAR dest: ADDRESS; src: ADDRESS); 
	PROCEDURE ^ DescriptorCopy(src, dest: LONGINT); 
	PROCEDURE ^ ZeroCopy*(CONST src: ARRAY [?] ; VAR dest: ARRAY [?] ); 
	OPERATOR ^ "ALIAS"-(CONST src: ARRAY [?] ): ARRAY [?] ; 
	PROCEDURE ^ SameShape(l, r: ADDRESS): BOOLEAN; 
	PROCEDURE ^ ConvertASAILoop(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "@Convert"-(CONST src: ARRAY [?] OF SHORTINT): ARRAY [?] OF INTEGER; 
	OPERATOR ^ "LONG"-(CONST src: ARRAY [?] OF SHORTINT): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ ConvertLoopSL(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "@Convert"-(CONST src: ARRAY [?] OF SHORTINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ ConvertLoopSR(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "@Convert"-(CONST src: ARRAY [?] OF SHORTINT): ARRAY [?] OF REAL; 
	PROCEDURE ^ ConvertLoopSX(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "@Convert"-(CONST src: ARRAY [?] OF SHORTINT): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ ConvertLoopIS(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "@Convert"-(CONST src: ARRAY [?] OF INTEGER): ARRAY [?] OF SHORTINT; 
	OPERATOR ^ "SHORT"-(CONST src: ARRAY [?] OF INTEGER): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ ConvertLoopIL(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "@Convert"-(CONST src: ARRAY [?] OF INTEGER): ARRAY [?] OF LONGINT; 
	OPERATOR ^ "LONG"-(CONST src: ARRAY [?] OF INTEGER): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ ConvertLoopIR(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "@Convert"-(CONST src: ARRAY [?] OF INTEGER): ARRAY [?] OF REAL; 
	PROCEDURE ^ ConvertLoopIX(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "@Convert"-(CONST src: ARRAY [?] OF INTEGER): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ ConvertLoopLI(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "@Convert"-(CONST src: ARRAY [?] OF LONGINT): ARRAY [?] OF INTEGER; 
	OPERATOR ^ "SHORT"-(CONST src: ARRAY [?] OF LONGINT): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ ConvertLoopLR(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "@Convert"-(CONST src: ARRAY [?] OF LONGINT): ARRAY [?] OF REAL; 
	PROCEDURE ^ ConvertLoopLX(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "@Convert"-(CONST src: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ ConvertLoopRL(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "@Convert"-(CONST src: ARRAY [?] OF REAL): ARRAY [?] OF LONGINT; 
	OPERATOR ^ "ENTIER"-(CONST src: ARRAY [?] OF REAL): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ ConvertLoopRX(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "@Convert"-(CONST src: ARRAY [?] OF REAL): ARRAY [?] OF LONGREAL; 
	OPERATOR ^ "LONG"-(CONST src: ARRAY [?] OF REAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ ConvertLoopXR(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "@Convert"-(CONST src: ARRAY [?] OF LONGREAL): ARRAY [?] OF REAL; 
	OPERATOR ^ "SHORT"-(CONST src: ARRAY [?] OF LONGREAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ ConvertLoopXL(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "@Convert"-(CONST src: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGINT; 
	OPERATOR ^ "ENTIER"-(CONST src: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ NotLoopAB(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "~"-(CONST src: ARRAY [?] OF BOOLEAN): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ GenericLoopS(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: SHORTINT):SHORTINT); 
	PROCEDURE ^ GenericLoopI(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: INTEGER):INTEGER); 
	PROCEDURE ^ GenericLoopL(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: LONGINT):LONGINT); 
	PROCEDURE ^ GenericLoopH(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: HUGEINT):HUGEINT); 
	PROCEDURE ^ GenericLoopR(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: REAL):REAL); 
	PROCEDURE ^ GenericLoopX(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: LONGREAL):LONGREAL); 
	PROCEDURE ^ GenericLoopZ(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: COMPLEX):COMPLEX); 
	PROCEDURE ^ GenericLoopLZ(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: LONGCOMPLEX):LONGCOMPLEX); 
	PROCEDURE ^ MinusLoopS(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(CONST src: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ MinusLoopI(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(CONST src: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ MinusLoopL(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(CONST src: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ MinusLoopR(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(CONST src: ARRAY [?] OF REAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ MinusLoopX(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(CONST src: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ AddASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "+"-(CONST left, right: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ AddAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "+"-(CONST left, right: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ AddALALLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "+"-(CONST left, right: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ AddARARLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "+"-(CONST left, right: ARRAY [?] OF REAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ AddAXAXLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "+"-(CONST left, right: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ AddAZAZLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "+"-(CONST left, right: ARRAY [?] OF COMPLEX): ARRAY [?] OF COMPLEX; 
	PROCEDURE ^ AddALZALZLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "+"-(CONST left, right: ARRAY [?] OF LONGCOMPLEX): ARRAY [?] OF LONGCOMPLEX; 
	PROCEDURE ^ AddASSSLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "+"-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): ARRAY [?] OF SHORTINT; 
	OPERATOR ^ "+"-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ AddAISILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "+"-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): ARRAY [?] OF INTEGER; 
	OPERATOR ^ "+"-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ AddALSLLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "+"-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): ARRAY [?] OF LONGINT; 
	OPERATOR ^ "+"-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ AddARSRLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "+"-(CONST left: ARRAY [?] OF REAL; right: REAL): ARRAY [?] OF REAL; 
	OPERATOR ^ "+"-(left: REAL; CONST right: ARRAY [?] OF REAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ AddAXSXLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "+"-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): ARRAY [?] OF LONGREAL; 
	OPERATOR ^ "+"-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ AddAZSZLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "+"-(CONST left: ARRAY [?] OF COMPLEX; right: COMPLEX): ARRAY [?] OF COMPLEX; 
	OPERATOR ^ "+"-(left: COMPLEX; CONST right: ARRAY [?] OF COMPLEX): ARRAY [?] OF COMPLEX; 
	PROCEDURE ^ AddALZSLZLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "+"-(CONST left: ARRAY [?] OF LONGCOMPLEX; right: LONGCOMPLEX): ARRAY [?] OF LONGCOMPLEX; 
	OPERATOR ^ "+"-(left: LONGCOMPLEX; CONST right: ARRAY [?] OF LONGCOMPLEX): ARRAY [?] OF LONGCOMPLEX; 
	PROCEDURE ^ SubASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(CONST left, right: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ SubAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(CONST left, right: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ SubALALLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(CONST left, right: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ SubARARLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(CONST left, right: ARRAY [?] OF REAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ SubAXAXLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(CONST left, right: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ SubAZAZLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(CONST left, right: ARRAY [?] OF COMPLEX): ARRAY [?] OF COMPLEX; 
	PROCEDURE ^ SubALZALZLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(CONST left, right: ARRAY [?] OF LONGCOMPLEX): ARRAY [?] OF LONGCOMPLEX; 
	OPERATOR ^ "-"-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): ARRAY [?] OF SHORTINT; 
	OPERATOR ^ "-"-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): ARRAY [?] OF INTEGER; 
	OPERATOR ^ "-"-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): ARRAY [?] OF LONGINT; 
	OPERATOR ^ "-"-(CONST left: ARRAY [?] OF REAL; right: REAL): ARRAY [?] OF REAL; 
	OPERATOR ^ "-"-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): ARRAY [?] OF LONGREAL; 
	OPERATOR ^ "-"-(CONST left: ARRAY [?] OF COMPLEX; right: COMPLEX): ARRAY [?] OF COMPLEX; 
	OPERATOR ^ "-"-(CONST left: ARRAY [?] OF LONGCOMPLEX; right: LONGCOMPLEX): ARRAY [?] OF LONGCOMPLEX; 
	PROCEDURE ^ SubSSASLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ SubSIAILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ SubSLALLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ SubSRARLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(left: REAL; CONST right: ARRAY [?] OF REAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ SubSXAXLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ SubSZAZLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(left: COMPLEX; CONST right: ARRAY [?] OF COMPLEX): ARRAY [?] OF COMPLEX; 
	PROCEDURE ^ SubSLZALZLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "-"-(left: LONGCOMPLEX; CONST right: ARRAY [?] OF LONGCOMPLEX): ARRAY [?] OF LONGCOMPLEX; 
	PROCEDURE ^ EMulASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".*"-(CONST left, right: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ EMulAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".*"-(CONST left, right: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ EMulALALLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".*"-(CONST left, right: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ EMulARARLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".*"-(CONST left, right: ARRAY [?] OF REAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ EMulAXAXLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".*"-(CONST left, right: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ EMulAZAZLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".*"-(CONST left, right: ARRAY [?] OF COMPLEX): ARRAY [?] OF COMPLEX; 
	PROCEDURE ^ EMulALZALZLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".*"-(CONST left, right: ARRAY [?] OF LONGCOMPLEX): ARRAY [?] OF LONGCOMPLEX; 
	PROCEDURE ^ EMulIncASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".*+"-(CONST left, right: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ EMulIncAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".*+"-(CONST left, right: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ EMulIncALALLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".*+"-(CONST left, right: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ EMulIncARARLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".*+"-(CONST left, right: ARRAY [?] OF REAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ EMulIncAXAXLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".*+"-(CONST left, right: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ MulASSSLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "*"-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): ARRAY [?] OF SHORTINT; 
	OPERATOR ^ "*"-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ MulAISILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "*"-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): ARRAY [?] OF INTEGER; 
	OPERATOR ^ "*"-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ MulALSLLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "*"-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): ARRAY [?] OF LONGINT; 
	OPERATOR ^ "*"-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ MulARSRLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "*"-(CONST left: ARRAY [?] OF REAL; right: REAL): ARRAY [?] OF REAL; 
	OPERATOR ^ "*"-(left: REAL; CONST right: ARRAY [?] OF REAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ MulAXSXLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "*"-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): ARRAY [?] OF LONGREAL; 
	OPERATOR ^ "*"-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ MulAZSZLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "*"-(CONST left: ARRAY [?] OF COMPLEX; right: COMPLEX): ARRAY [?] OF COMPLEX; 
	OPERATOR ^ "*"-(left: COMPLEX; CONST right: ARRAY [?] OF COMPLEX): ARRAY [?] OF COMPLEX; 
	PROCEDURE ^ MulALZSLZLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "*"-(CONST left: ARRAY [?] OF LONGCOMPLEX; right: LONGCOMPLEX): ARRAY [?] OF LONGCOMPLEX; 
	OPERATOR ^ "*"-(left: LONGCOMPLEX; CONST right: ARRAY [?] OF LONGCOMPLEX): ARRAY [?] OF LONGCOMPLEX; 
	PROCEDURE ^ IncMulASSSLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "INCMUL"-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): ARRAY [?] OF SHORTINT; 
	OPERATOR ^ "INCMUL"-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	OPERATOR ^ "DECMUL"-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): ARRAY [?] OF SHORTINT; 
	OPERATOR ^ "DECMUL"-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ IncMulAISILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "INCMUL"-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): ARRAY [?] OF INTEGER; 
	OPERATOR ^ "INCMUL"-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	OPERATOR ^ "DECMUL"-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): ARRAY [?] OF INTEGER; 
	OPERATOR ^ "DECMUL"-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ IncMulALSLLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "INCMUL"-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): ARRAY [?] OF LONGINT; 
	OPERATOR ^ "INCMUL"-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	OPERATOR ^ "DECMUL"-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): ARRAY [?] OF LONGINT; 
	OPERATOR ^ "DECMUL"-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ IncMulARSRLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "INCMUL"-(CONST left: ARRAY [?] OF REAL; right: REAL): ARRAY [?] OF REAL; 
	OPERATOR ^ "INCMUL"-(left: REAL; CONST right: ARRAY [?] OF REAL): ARRAY [?] OF REAL; 
	OPERATOR ^ "DECMUL"-(CONST left: ARRAY [?] OF REAL; right: REAL): ARRAY [?] OF REAL; 
	OPERATOR ^ "DECMUL"-(left: REAL; CONST right: ARRAY [?] OF REAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ IncMulAXSXLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "INCMUL"-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): ARRAY [?] OF LONGREAL; 
	OPERATOR ^ "INCMUL"-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGREAL; 
	OPERATOR ^ "DECMUL"-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): ARRAY [?] OF LONGREAL; 
	OPERATOR ^ "DECMUL"-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ EDivideASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "./"-(CONST left, right: ARRAY [?] OF SHORTINT): ARRAY [?] OF REAL; 
	PROCEDURE ^ EDivideAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "./"-(CONST left, right: ARRAY [?] OF INTEGER): ARRAY [?] OF REAL; 
	PROCEDURE ^ EDivideALALLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "./"-(CONST left, right: ARRAY [?] OF LONGINT): ARRAY [?] OF REAL; 
	PROCEDURE ^ EDivideARARLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "./"-(CONST left, right: ARRAY [?] OF REAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ EDivideAXAXLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "./"-(CONST left, right: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ EDivideAZAZLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "./"-(CONST left, right: ARRAY [?] OF COMPLEX): ARRAY [?] OF COMPLEX; 
	PROCEDURE ^ EDivideALZALZLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "./"-(CONST left, right: ARRAY [?] OF LONGCOMPLEX): ARRAY [?] OF LONGCOMPLEX; 
	PROCEDURE ^ DivideASSSLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "/"-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): ARRAY [?] OF REAL; 
	PROCEDURE ^ DivideSSASLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "/"-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): ARRAY [?] OF REAL; 
	PROCEDURE ^ DivideAISILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "/"-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): ARRAY [?] OF REAL; 
	PROCEDURE ^ DivideSIAILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "/"-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): ARRAY [?] OF REAL; 
	PROCEDURE ^ DivideALSLLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "/"-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): ARRAY [?] OF REAL; 
	PROCEDURE ^ DivideSLALLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "/"-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): ARRAY [?] OF REAL; 
	PROCEDURE ^ DivideARSRLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "/"-(CONST left: ARRAY [?] OF REAL; right: REAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ DivideSRARLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "/"-(left: REAL; CONST right: ARRAY [?] OF REAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ DivideAXSXLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "/"-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ DivideSXAXLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "/"-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ DivideAZSZLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "/"-(CONST left: ARRAY [?] OF COMPLEX; right: COMPLEX): ARRAY [?] OF COMPLEX; 
	PROCEDURE ^ DivideSZAZLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "/"-(left: COMPLEX; CONST right: ARRAY [?] OF COMPLEX): ARRAY [?] OF COMPLEX; 
	PROCEDURE ^ DivideALZSLZLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "/"-(CONST left: ARRAY [?] OF LONGCOMPLEX; right: LONGCOMPLEX): ARRAY [?] OF LONGCOMPLEX; 
	PROCEDURE ^ DivideSLZALZLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "/"-(left: LONGCOMPLEX; CONST right: ARRAY [?] OF LONGCOMPLEX): ARRAY [?] OF LONGCOMPLEX; 
	PROCEDURE ^ EDivASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "DIV"-(CONST left, right: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ EDivAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "DIV"-(CONST left, right: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ EDivALALLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "DIV"-(CONST left, right: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ DivASSSLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "DIV"-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ DivSSASLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "DIV"-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ DivAISILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "DIV"-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ DivSIAILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "DIV"-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ DivALSLLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "DIV"-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ DivSLALLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "DIV"-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ EModASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "MOD"-(CONST left, right: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ EModAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "MOD"-(CONST left, right: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ EModALALLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "MOD"-(CONST left, right: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ ModASSSLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "MOD"-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ ModSSASLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "MOD"-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ ModAISILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "MOD"-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ ModSIAILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "MOD"-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ ModALSLLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "MOD"-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ ModSLALLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "MOD"-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ SPASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 
	OPERATOR ^ "+*"-(CONST left, right: ARRAY [?] OF SHORTINT): LONGINT; 
	PROCEDURE ^ SPAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 
	OPERATOR ^ "+*"-(CONST left, right: ARRAY [?] OF INTEGER): LONGINT; 
	PROCEDURE ^ SPALALLoop(ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 
	OPERATOR ^ "+*"-(CONST left, right: ARRAY [?] OF LONGINT): LONGINT; 
	PROCEDURE ^ SPARARLoop(ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 
	OPERATOR ^ "+*"-(CONST left, right: ARRAY [?] OF REAL): REAL; 
	PROCEDURE ^ SPAXAXLoop(ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 
	OPERATOR ^ "+*"-(CONST left, right: ARRAY [?] OF LONGREAL): LONGREAL; 
	PROCEDURE ^ SPAZAZLoop(ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 
	OPERATOR ^ "+*"-(CONST left, right: ARRAY [?] OF COMPLEX): COMPLEX; 
	PROCEDURE ^ SPALZALZLoop(ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 
	OPERATOR ^ "+*"-(CONST left, right: ARRAY [?] OF LONGCOMPLEX): LONGCOMPLEX; 
	PROCEDURE ^ EEqlABABLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".="-(CONST left, right: ARRAY [?] OF BOOLEAN): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EEqlASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".="-(CONST left, right: ARRAY [?] OF SHORTINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EEqlAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".="-(CONST left, right: ARRAY [?] OF INTEGER): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EEqlALALLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".="-(CONST left, right: ARRAY [?] OF LONGINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EEqlARARLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".="-(CONST left, right: ARRAY [?] OF REAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EEqlAXAXLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".="-(CONST left, right: ARRAY [?] OF LONGREAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EEqlABSBLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".="-(CONST left: ARRAY [?] OF BOOLEAN; right: BOOLEAN): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".="-(left: BOOLEAN; CONST right: ARRAY [?] OF BOOLEAN): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EEqlASSSLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".="-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".="-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EEqlAISILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".="-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".="-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EEqlALSLLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".="-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".="-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EEqlARSRLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".="-(CONST left: ARRAY [?] OF REAL; right: REAL): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".="-(left: REAL; CONST right: ARRAY [?] OF REAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EEqlAXSXLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".="-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".="-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ENeqABABLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".#"-(CONST left, right: ARRAY [?] OF BOOLEAN): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ENeqASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".#"-(CONST left, right: ARRAY [?] OF SHORTINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ENeqAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".#"-(CONST left, right: ARRAY [?] OF INTEGER): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ENeqALALLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".#"-(CONST left, right: ARRAY [?] OF LONGINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ENeqARARLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".#"-(CONST left, right: ARRAY [?] OF REAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ENeqAXAXLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".#"-(CONST left, right: ARRAY [?] OF LONGREAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ENeqABSBLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".#"-(CONST left: ARRAY [?] OF BOOLEAN; right: BOOLEAN): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".#"-(left: BOOLEAN; CONST right: ARRAY [?] OF BOOLEAN): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ENeqASSSLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".#"-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".#"-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ENeqAISILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".#"-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".#"-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ENeqALSLLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".#"-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".#"-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ENeqARSRLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".#"-(CONST left: ARRAY [?] OF REAL; right: REAL): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".#"-(left: REAL; CONST right: ARRAY [?] OF REAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ENeqAXSXLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".#"-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".#"-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGtrASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".>"-(CONST left, right: ARRAY [?] OF SHORTINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGtrAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".>"-(CONST left, right: ARRAY [?] OF INTEGER): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGtrALALLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".>"-(CONST left, right: ARRAY [?] OF LONGINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGtrARARLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".>"-(CONST left, right: ARRAY [?] OF REAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGtrAXAXLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".>"-(CONST left, right: ARRAY [?] OF LONGREAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGtrASSSLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".>"-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".<"-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGtrAISILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".>"-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".<"-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGtrALSLLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".>"-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".<"-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGtrARSRLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".>"-(CONST left: ARRAY [?] OF REAL; right: REAL): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".<"-(left: REAL; CONST right: ARRAY [?] OF REAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGtrAXSXLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".>"-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".<"-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGeqASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".>="-(CONST left, right: ARRAY [?] OF SHORTINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGeqAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".>="-(CONST left, right: ARRAY [?] OF INTEGER): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGeqALALLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".>="-(CONST left, right: ARRAY [?] OF LONGINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGeqARARLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".>="-(CONST left, right: ARRAY [?] OF REAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGeqAXAXLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".>="-(CONST left, right: ARRAY [?] OF LONGREAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGeqASSSLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".>="-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".<="-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGeqAISILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".>="-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".<="-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGeqALSLLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".>="-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".<="-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGeqARSRLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".>="-(CONST left: ARRAY [?] OF REAL; right: REAL): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".<="-(left: REAL; CONST right: ARRAY [?] OF REAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ EGeqAXSXLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".>="-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".<="-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELssASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".<"-(CONST left, right: ARRAY [?] OF SHORTINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELssAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".<"-(CONST left, right: ARRAY [?] OF INTEGER): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELssALALLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".<"-(CONST left, right: ARRAY [?] OF LONGINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELssARARLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".<"-(CONST left, right: ARRAY [?] OF REAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELssAXAXLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".<"-(CONST left, right: ARRAY [?] OF LONGREAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELssASSSLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".<"-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".>"-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELssAISILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".<"-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".>"-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELssALSLLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".<"-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".>"-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELssARSRLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".<"-(CONST left: ARRAY [?] OF REAL; right: REAL): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".>"-(left: REAL; CONST right: ARRAY [?] OF REAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELssAXSXLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".<"-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".>"-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELeqASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".<="-(CONST left, right: ARRAY [?] OF SHORTINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELeqAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".<="-(CONST left, right: ARRAY [?] OF INTEGER): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELeqALALLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".<="-(CONST left, right: ARRAY [?] OF LONGINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELeqARARLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".<="-(CONST left, right: ARRAY [?] OF REAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELeqAXAXLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ ".<="-(CONST left, right: ARRAY [?] OF LONGREAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELeqASSSLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".<="-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".>="-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELeqAISILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".<="-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".>="-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELeqALSLLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".<="-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".>="-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELeqARSRLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".<="-(CONST left: ARRAY [?] OF REAL; right: REAL): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".>="-(left: REAL; CONST right: ARRAY [?] OF REAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ELeqAXSXLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ ".<="-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ ".>="-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ElOrABABLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "OR"-(CONST left, right: ARRAY [?] OF BOOLEAN): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ElAndABABLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "&"-(CONST left, right: ARRAY [?] OF BOOLEAN): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ElOrABSBLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "OR"-(CONST left: ARRAY [?] OF BOOLEAN; right: BOOLEAN): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ "OR"-(left: BOOLEAN; CONST right: ARRAY [?] OF BOOLEAN): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ ElAndABSBLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "&"-(CONST left: ARRAY [?] OF BOOLEAN; right: BOOLEAN): ARRAY [?] OF BOOLEAN; 
	OPERATOR ^ "&"-(left: BOOLEAN; CONST right: ARRAY [?] OF BOOLEAN): ARRAY [?] OF BOOLEAN; 
	PROCEDURE ^ LssASASLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<"-(CONST left, right: ARRAY [?] OF SHORTINT): BOOLEAN; 
	PROCEDURE ^ GeqASASLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">="-(CONST left, right: ARRAY [?] OF SHORTINT): BOOLEAN; 
	PROCEDURE ^ LssAIAILoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<"-(CONST left, right: ARRAY [?] OF INTEGER): BOOLEAN; 
	PROCEDURE ^ GeqAIAILoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">="-(CONST left, right: ARRAY [?] OF INTEGER): BOOLEAN; 
	PROCEDURE ^ LssALALLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<"-(CONST left, right: ARRAY [?] OF LONGINT): BOOLEAN; 
	PROCEDURE ^ GeqALALLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">="-(CONST left, right: ARRAY [?] OF LONGINT): BOOLEAN; 
	PROCEDURE ^ LssARARLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<"-(CONST left, right: ARRAY [?] OF REAL): BOOLEAN; 
	PROCEDURE ^ GeqARARLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">="-(CONST left, right: ARRAY [?] OF REAL): BOOLEAN; 
	PROCEDURE ^ LssAXAXLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<"-(CONST left, right: ARRAY [?] OF LONGREAL): BOOLEAN; 
	PROCEDURE ^ GeqAXAXLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">="-(CONST left, right: ARRAY [?] OF LONGREAL): BOOLEAN; 
	PROCEDURE ^ GtrASASLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">"-(CONST left, right: ARRAY [?] OF SHORTINT): BOOLEAN; 
	PROCEDURE ^ LeqASASLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<="-(CONST left, right: ARRAY [?] OF SHORTINT): BOOLEAN; 
	PROCEDURE ^ GtrAIAILoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">"-(CONST left, right: ARRAY [?] OF INTEGER): BOOLEAN; 
	PROCEDURE ^ LeqAIAILoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<="-(CONST left, right: ARRAY [?] OF INTEGER): BOOLEAN; 
	PROCEDURE ^ GtrALALLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">"-(CONST left, right: ARRAY [?] OF LONGINT): BOOLEAN; 
	PROCEDURE ^ LeqALALLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<="-(CONST left, right: ARRAY [?] OF LONGINT): BOOLEAN; 
	PROCEDURE ^ GtrARARLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">"-(CONST left, right: ARRAY [?] OF REAL): BOOLEAN; 
	PROCEDURE ^ LeqARARLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<="-(CONST left, right: ARRAY [?] OF REAL): BOOLEAN; 
	PROCEDURE ^ GtrAXAXLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">"-(CONST left, right: ARRAY [?] OF LONGREAL): BOOLEAN; 
	PROCEDURE ^ LeqAXAXLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<="-(CONST left, right: ARRAY [?] OF LONGREAL): BOOLEAN; 
	PROCEDURE ^ EqlABABLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "="-(CONST left, right: ARRAY [?] OF BOOLEAN): BOOLEAN; 
	OPERATOR ^ "#"-(CONST left, right: ARRAY [?] OF BOOLEAN): BOOLEAN; 
	PROCEDURE ^ EqlASASLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "="-(CONST left, right: ARRAY [?] OF SHORTINT): BOOLEAN; 
	OPERATOR ^ "#"-(CONST left, right: ARRAY [?] OF SHORTINT): BOOLEAN; 
	PROCEDURE ^ EqlAIAILoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "="-(CONST left, right: ARRAY [?] OF INTEGER): BOOLEAN; 
	OPERATOR ^ "#"-(CONST left, right: ARRAY [?] OF INTEGER): BOOLEAN; 
	PROCEDURE ^ EqlALALLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "="-(CONST left, right: ARRAY [?] OF LONGINT): BOOLEAN; 
	OPERATOR ^ "#"-(CONST left, right: ARRAY [?] OF LONGINT): BOOLEAN; 
	PROCEDURE ^ EqlARARLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "="-(CONST left, right: ARRAY [?] OF REAL): BOOLEAN; 
	OPERATOR ^ "#"-(CONST left, right: ARRAY [?] OF REAL): BOOLEAN; 
	PROCEDURE ^ EqlAXAXLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "="-(CONST left, right: ARRAY [?] OF LONGREAL): BOOLEAN; 
	OPERATOR ^ "#"-(CONST left, right: ARRAY [?] OF LONGREAL): BOOLEAN; 
	PROCEDURE ^ EqlAZAZLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "="-(CONST left, right: ARRAY [?] OF COMPLEX): BOOLEAN; 
	OPERATOR ^ "#"-(CONST left, right: ARRAY [?] OF COMPLEX): BOOLEAN; 
	PROCEDURE ^ EqlALZALZLoop(ladr, radr: ADDRESS; linc, rinc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "="-(CONST left, right: ARRAY [?] OF LONGCOMPLEX): BOOLEAN; 
	OPERATOR ^ "#"-(CONST left, right: ARRAY [?] OF LONGCOMPLEX): BOOLEAN; 
	PROCEDURE ^ EqlABSBLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "="-(CONST left: ARRAY [?] OF BOOLEAN; right: BOOLEAN): BOOLEAN; 
	OPERATOR ^ "="-(left: BOOLEAN; CONST right: ARRAY [?] OF BOOLEAN): BOOLEAN; 
	OPERATOR ^ "#"-(CONST left: ARRAY [?] OF BOOLEAN; right: BOOLEAN): BOOLEAN; 
	OPERATOR ^ "#"-(left: BOOLEAN; CONST right: ARRAY [?] OF BOOLEAN): BOOLEAN; 
	PROCEDURE ^ EqlASSSLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "="-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): BOOLEAN; 
	OPERATOR ^ "="-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): BOOLEAN; 
	OPERATOR ^ "#"-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): BOOLEAN; 
	OPERATOR ^ "#"-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): BOOLEAN; 
	PROCEDURE ^ EqlAISILoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "="-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): BOOLEAN; 
	OPERATOR ^ "="-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): BOOLEAN; 
	OPERATOR ^ "#"-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): BOOLEAN; 
	OPERATOR ^ "#"-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): BOOLEAN; 
	PROCEDURE ^ EqlALSLLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "="-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): BOOLEAN; 
	OPERATOR ^ "="-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): BOOLEAN; 
	OPERATOR ^ "#"-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): BOOLEAN; 
	OPERATOR ^ "#"-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): BOOLEAN; 
	PROCEDURE ^ EqlARSRLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "="-(CONST left: ARRAY [?] OF REAL; right: REAL): BOOLEAN; 
	OPERATOR ^ "="-(left: REAL; CONST right: ARRAY [?] OF REAL): BOOLEAN; 
	OPERATOR ^ "#"-(CONST left: ARRAY [?] OF REAL; right: REAL): BOOLEAN; 
	OPERATOR ^ "#"-(left: REAL; CONST right: ARRAY [?] OF REAL): BOOLEAN; 
	PROCEDURE ^ EqlAXSXLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "="-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): BOOLEAN; 
	OPERATOR ^ "="-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): BOOLEAN; 
	OPERATOR ^ "#"-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): BOOLEAN; 
	OPERATOR ^ "#"-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): BOOLEAN; 
	PROCEDURE ^ GtrASSSLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">"-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): BOOLEAN; 
	OPERATOR ^ "<"-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): BOOLEAN; 
	PROCEDURE ^ GtrAISILoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">"-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): BOOLEAN; 
	OPERATOR ^ "<"-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): BOOLEAN; 
	PROCEDURE ^ GtrALSLLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">"-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): BOOLEAN; 
	OPERATOR ^ "<"-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): BOOLEAN; 
	PROCEDURE ^ GtrARSRLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">"-(CONST left: ARRAY [?] OF REAL; right: REAL): BOOLEAN; 
	OPERATOR ^ "<"-(left: REAL; CONST right: ARRAY [?] OF REAL): BOOLEAN; 
	PROCEDURE ^ GtrAXSXLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">"-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): BOOLEAN; 
	OPERATOR ^ "<"-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): BOOLEAN; 
	PROCEDURE ^ GeqASSSLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">="-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): BOOLEAN; 
	OPERATOR ^ "<="-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): BOOLEAN; 
	PROCEDURE ^ GeqAISILoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">="-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): BOOLEAN; 
	OPERATOR ^ "<="-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): BOOLEAN; 
	PROCEDURE ^ GeqALSLLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">="-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): BOOLEAN; 
	OPERATOR ^ "<="-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): BOOLEAN; 
	PROCEDURE ^ GeqARSRLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">="-(CONST left: ARRAY [?] OF REAL; right: REAL): BOOLEAN; 
	OPERATOR ^ "<="-(left: REAL; CONST right: ARRAY [?] OF REAL): BOOLEAN; 
	PROCEDURE ^ GeqAXSXLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ ">="-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): BOOLEAN; 
	OPERATOR ^ "<="-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): BOOLEAN; 
	PROCEDURE ^ LeqASSSLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<="-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): BOOLEAN; 
	OPERATOR ^ ">="-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): BOOLEAN; 
	PROCEDURE ^ LeqAISILoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<="-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): BOOLEAN; 
	OPERATOR ^ ">="-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): BOOLEAN; 
	PROCEDURE ^ LeqALSLLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<="-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): BOOLEAN; 
	OPERATOR ^ ">="-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): BOOLEAN; 
	PROCEDURE ^ LeqARSRLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<="-(CONST left: ARRAY [?] OF REAL; right: REAL): BOOLEAN; 
	OPERATOR ^ ">="-(left: REAL; CONST right: ARRAY [?] OF REAL): BOOLEAN; 
	PROCEDURE ^ LeqAXSXLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<="-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): BOOLEAN; 
	OPERATOR ^ ">="-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): BOOLEAN; 
	PROCEDURE ^ LssASSSLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<"-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): BOOLEAN; 
	OPERATOR ^ ">"-(left: SHORTINT; CONST right: ARRAY [?] OF SHORTINT): BOOLEAN; 
	PROCEDURE ^ LssAISILoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<"-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): BOOLEAN; 
	OPERATOR ^ ">"-(left: INTEGER; CONST right: ARRAY [?] OF INTEGER): BOOLEAN; 
	PROCEDURE ^ LssALSLLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<"-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): BOOLEAN; 
	OPERATOR ^ ">"-(left: LONGINT; CONST right: ARRAY [?] OF LONGINT): BOOLEAN; 
	PROCEDURE ^ LssARSRLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<"-(CONST left: ARRAY [?] OF REAL; right: REAL): BOOLEAN; 
	OPERATOR ^ ">"-(left: REAL; CONST right: ARRAY [?] OF REAL): BOOLEAN; 
	PROCEDURE ^ LssAXSXLoop(ladr, radr: ADDRESS; linc, len: SIZE): BOOLEAN; 
	OPERATOR ^ "<"-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): BOOLEAN; 
	OPERATOR ^ ">"-(left: LONGREAL; CONST right: ARRAY [?] OF LONGREAL): BOOLEAN; 
	PROCEDURE ^ MaxAXSXLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "MAX"-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ MaxARSRLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "MAX"-(CONST left: ARRAY [?] OF REAL; right: REAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ MaxALSLLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "MAX"-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ MaxAISILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "MAX"-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ MaxASSSLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "MAX"-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ MinAXSXLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "MIN"-(CONST left: ARRAY [?] OF LONGREAL; right: LONGREAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ MinARSRLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "MIN"-(CONST left: ARRAY [?] OF REAL; right: REAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ MinALSLLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "MIN"-(CONST left: ARRAY [?] OF LONGINT; right: LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ MinAISILoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "MIN"-(CONST left: ARRAY [?] OF INTEGER; right: INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ MinASSSLoop(ladr, radr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "MIN"-(CONST left: ARRAY [?] OF SHORTINT; right: SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ MaxAXAXLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "MAX"-(CONST left, right: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ MaxARARLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "MAX"-(CONST left, right: ARRAY [?] OF REAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ MaxALALLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "MAX"-(CONST left, right: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ MaxAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "MAX"-(CONST left, right: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ MaxASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "MAX"-(CONST left, right: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ MinAXAXLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "MIN"-(CONST left, right: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ MinARARLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "MIN"-(CONST left, right: ARRAY [?] OF REAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ MinALALLoop(ladr, radr, dadr: LongintPtr; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "MIN"-(CONST left, right: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ MinAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "MIN"-(CONST left, right: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ MinASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, dinc, len: SIZE); 
	OPERATOR ^ "MIN"-(CONST left, right: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ MinASLoop(ladr, dadr: ADDRESS; linc, len: SIZE); 
	OPERATOR ^ "MIN"-(CONST left: ARRAY [?] OF SHORTINT): SHORTINT; 
	PROCEDURE ^ MinAILoop(ladr, dadr: ADDRESS; linc, len: SIZE); 
	OPERATOR ^ "MIN"-(CONST left: ARRAY [?] OF INTEGER): INTEGER; 
	PROCEDURE ^ MinALLoop(ladr, dadr: ADDRESS; linc, len: SIZE); 
	OPERATOR ^ "MIN"-(CONST left: ARRAY [?] OF LONGINT): LONGINT; 
	PROCEDURE ^ MinARLoop(ladr, dadr: ADDRESS; linc, len: SIZE); 
	OPERATOR ^ "MIN"-(CONST left: ARRAY [?] OF REAL): REAL; 
	PROCEDURE ^ MinAXLoop(ladr, dadr: ADDRESS; linc, len: SIZE); 
	OPERATOR ^ "MIN"-(CONST left: ARRAY [?] OF LONGREAL): LONGREAL; 
	PROCEDURE ^ MaxASLoop(ladr, dadr: ADDRESS; linc, len: SIZE); 
	OPERATOR ^ "MAX"-(CONST left: ARRAY [?] OF SHORTINT): SHORTINT; 
	PROCEDURE ^ MaxAILoop(ladr, dadr: ADDRESS; linc, len: SIZE); 
	OPERATOR ^ "MAX"-(CONST left: ARRAY [?] OF INTEGER): INTEGER; 
	PROCEDURE ^ MaxALLoop(ladr, dadr: ADDRESS; linc, len: SIZE); 
	OPERATOR ^ "MAX"-(CONST left: ARRAY [?] OF LONGINT): LONGINT; 
	PROCEDURE ^ MaxARLoop(ladr, dadr: ADDRESS; linc, len: SIZE); 
	OPERATOR ^ "MAX"-(CONST left: ARRAY [?] OF REAL): REAL; 
	PROCEDURE ^ MaxAXLoop(ladr, dadr: ADDRESS; linc, len: SIZE); 
	OPERATOR ^ "MAX"-(CONST left: ARRAY [?] OF LONGREAL): LONGREAL; 
	OPERATOR ^ "LEN"-(CONST left: ARRAY [?] ): ARRAY [*] OF LONGINT; 
	PROCEDURE ^ SumASLoop(ladr, dadr: ADDRESS; linc, len: SIZE); 
	OPERATOR ^ "SUM"-(CONST left: ARRAY [?] OF SHORTINT): SHORTINT; 
	PROCEDURE ^ SumAILoop(ladr, dadr: ADDRESS; linc, len: SIZE); 
	OPERATOR ^ "SUM"-(CONST left: ARRAY [?] OF INTEGER): INTEGER; 
	PROCEDURE ^ SumALLoop(ladr, dadr: ADDRESS; linc, len: SIZE); 
	OPERATOR ^ "SUM"-(CONST left: ARRAY [?] OF LONGINT): LONGINT; 
	PROCEDURE ^ SumARLoop(ladr, dadr: ADDRESS; linc, len: SIZE); 
	OPERATOR ^ "SUM"-(CONST left: ARRAY [?] OF REAL): REAL; 
	PROCEDURE ^ SumAXLoop(ladr, dadr: ADDRESS; linc, len: SIZE); 
	OPERATOR ^ "SUM"-(CONST left: ARRAY [?] OF LONGREAL): LONGREAL; 
	PROCEDURE ^ SumAZLoop(ladr, dadr: ADDRESS; linc, len: SIZE); 
	OPERATOR ^ "SUM"-(CONST left: ARRAY [?] OF COMPLEX): COMPLEX; 
	PROCEDURE ^ SumALZLoop(ladr, dadr: ADDRESS; linc, len: SIZE); 
	OPERATOR ^ "SUM"-(CONST left: ARRAY [?] OF LONGCOMPLEX): LONGCOMPLEX; 
	PROCEDURE ^ AbsLoopS(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "ABS"-(CONST src: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ AbsLoopI(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "ABS"-(CONST src: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	PROCEDURE ^ AbsLoopL(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "ABS"-(CONST src: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	PROCEDURE ^ AbsLoopR(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "ABS"-(CONST src: ARRAY [?] OF REAL): ARRAY [?] OF REAL; 
	PROCEDURE ^ AbsLoopX(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "ABS"-(CONST src: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ AbsLoopZ(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "ABS"-(CONST src: ARRAY [?] OF COMPLEX): ARRAY [?] OF REAL; 
	PROCEDURE ^ AbsLoopLZ(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
	OPERATOR ^ "ABS"-(CONST src: ARRAY [?] OF LONGCOMPLEX): ARRAY [?] OF LONGREAL; 
	PROCEDURE ^ AssignSBABLoop(ladr, dadr: ADDRESS; dinc, len: SIZE); 
	OPERATOR ^ ":="-(VAR dest: ARRAY [?] OF BOOLEAN; right: BOOLEAN); 
	PROCEDURE ^ AssignSSASLoop(ladr, dadr: ADDRESS; dinc, len: SIZE); 
	OPERATOR ^ ":="-(VAR dest: ARRAY [?] OF SHORTINT; right: SHORTINT); 
	PROCEDURE ^ AssignSIAILoop(ladr, dadr: ADDRESS; dinc, len: SIZE); 
	OPERATOR ^ ":="-(VAR dest: ARRAY [?] OF INTEGER; right: INTEGER); 
	PROCEDURE ^ AssignSLALLoop(ladr, dadr: ADDRESS; dinc, len: SIZE); 
	OPERATOR ^ ":="-(VAR dest: ARRAY [?] OF LONGINT; right: LONGINT); 
	PROCEDURE ^ AssignSRARLoop(ladr, dadr: ADDRESS; dinc, len: SIZE); 
	OPERATOR ^ ":="-(VAR dest: ARRAY [?] OF REAL; right: REAL); 
	PROCEDURE ^ AssignSXAXLoop(ladr, dadr: ADDRESS; dinc, len: SIZE); 
	OPERATOR ^ ":="-(VAR dest: ARRAY [?] OF LONGREAL; right: LONGREAL); 
	PROCEDURE ^ AssignSZAZLoop(ladr, dadr: ADDRESS; dinc, len: SIZE); 
	OPERATOR ^ ":="-(VAR dest: ARRAY [?] OF COMPLEX; right: COMPLEX); 
	PROCEDURE ^ AssignSLZALZLoop(ladr, dadr: ADDRESS; dinc, len: SIZE); 
	OPERATOR ^ ":="-(VAR dest: ARRAY [?] OF LONGCOMPLEX; right: LONGCOMPLEX); 
	PROCEDURE ^ AllocateMatrix(dest: ADDRESS; rows, cols, elementsize: LONGINT): ANY; 
	PROCEDURE ^ AllocateVector(dest: ADDRESS; l0, elementsize: LONGINT): ANY; 
	PROCEDURE ^ ApplyMatMulLoop(dest, left, right: ADDRESS; Size: LONGINT; loop: BinaryAASLoop; fast: FastMatMul); 
	PROCEDURE ^ ApplyMatVecMulLoop(dest, left, right: ADDRESS; Size: LONGINT; loop: BinaryAASLoop; fast: FastMatMul); 
	PROCEDURE ^ ApplyVecMatMulLoop(dest, left, right: ADDRESS; Size: LONGINT; loop: BinaryAASLoop; fast: FastMatMul); 
	PROCEDURE ^ MatMulASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 
	OPERATOR ^ "*"-(CONST left, right: ARRAY [*, *] OF SHORTINT): ARRAY [*, *] OF SHORTINT; 
	OPERATOR ^ "*"-(CONST left: ARRAY [*, *] OF SHORTINT; CONST right: ARRAY [*] OF SHORTINT): ARRAY [*] OF SHORTINT; 
	OPERATOR ^ "*"-(CONST left: ARRAY [*] OF SHORTINT; CONST right: ARRAY [*, *] OF SHORTINT): ARRAY [*] OF SHORTINT; 
	PROCEDURE ^ MatMulAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 
	OPERATOR ^ "*"-(CONST left, right: ARRAY [*, *] OF INTEGER): ARRAY [*, *] OF INTEGER; 
	OPERATOR ^ "*"-(CONST left: ARRAY [*, *] OF INTEGER; CONST right: ARRAY [*] OF INTEGER): ARRAY [*] OF INTEGER; 
	OPERATOR ^ "*"-(CONST left: ARRAY [*] OF INTEGER; CONST right: ARRAY [*, *] OF INTEGER): ARRAY [*] OF INTEGER; 
	PROCEDURE ^ MatMulALALLoop(ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 
	OPERATOR ^ "*"-(CONST left, right: ARRAY [*, *] OF LONGINT): ARRAY [*, *] OF LONGINT; 
	OPERATOR ^ "*"-(CONST left: ARRAY [*, *] OF LONGINT; CONST right: ARRAY [*] OF LONGINT): ARRAY [*] OF LONGINT; 
	OPERATOR ^ "*"-(CONST left: ARRAY [*] OF LONGINT; CONST right: ARRAY [*, *] OF LONGINT): ARRAY [*] OF LONGINT; 
	PROCEDURE ^ MatMulARARLoop(ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 
	OPERATOR ^ "*"-(CONST left, right: ARRAY [*, *] OF REAL): ARRAY [*, *] OF REAL; 
	OPERATOR ^ "*"-(CONST left: ARRAY [*, *] OF REAL; CONST right: ARRAY [*] OF REAL): ARRAY [*] OF REAL; 
	OPERATOR ^ "*"-(CONST left: ARRAY [*] OF REAL; CONST right: ARRAY [*, *] OF REAL): ARRAY [*] OF REAL; 
	PROCEDURE ^ MatMulAXAXLoop(ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 
	OPERATOR ^ "*"-(CONST left, right: ARRAY [*, *] OF LONGREAL): ARRAY [*, *] OF LONGREAL; 
	OPERATOR ^ "*"-(CONST left: ARRAY [*, *] OF LONGREAL; CONST right: ARRAY [*] OF LONGREAL): ARRAY [*] OF LONGREAL; 
	OPERATOR ^ "*"-(CONST left: ARRAY [*] OF LONGREAL; CONST right: ARRAY [*, *] OF LONGREAL): ARRAY [*] OF LONGREAL; 
	PROCEDURE ^ MatMulIncASASLoop(ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 
	OPERATOR ^ "INCMUL"-(CONST left, right: ARRAY [*, *] OF SHORTINT): ARRAY [*, *] OF SHORTINT; 
	OPERATOR ^ "INCMUL"-(CONST left: ARRAY [*, *] OF SHORTINT; CONST right: ARRAY [*] OF SHORTINT): ARRAY [*] OF SHORTINT; 
	OPERATOR ^ "INCMUL"-(CONST left: ARRAY [*] OF SHORTINT; CONST right: ARRAY [*, *] OF SHORTINT): ARRAY [*] OF SHORTINT; 
	OPERATOR ^ "DECMUL"-(CONST left, right: ARRAY [*, *] OF SHORTINT): ARRAY [*, *] OF SHORTINT; 
	OPERATOR ^ "DECMUL"-(CONST left: ARRAY [*, *] OF SHORTINT; CONST right: ARRAY [*] OF SHORTINT): ARRAY [*] OF SHORTINT; 
	OPERATOR ^ "DECMUL"-(CONST left: ARRAY [*] OF SHORTINT; CONST right: ARRAY [*, *] OF SHORTINT): ARRAY [*] OF SHORTINT; 
	PROCEDURE ^ MatMulIncAIAILoop(ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 
	OPERATOR ^ "INCMUL"-(CONST left, right: ARRAY [*, *] OF INTEGER): ARRAY [*, *] OF INTEGER; 
	OPERATOR ^ "INCMUL"-(CONST left: ARRAY [*, *] OF INTEGER; CONST right: ARRAY [*] OF INTEGER): ARRAY [*] OF INTEGER; 
	OPERATOR ^ "INCMUL"-(CONST left: ARRAY [*] OF INTEGER; CONST right: ARRAY [*, *] OF INTEGER): ARRAY [*] OF INTEGER; 
	OPERATOR ^ "DECMUL"-(CONST left, right: ARRAY [*, *] OF INTEGER): ARRAY [*, *] OF INTEGER; 
	OPERATOR ^ "DECMUL"-(CONST left: ARRAY [*, *] OF INTEGER; CONST right: ARRAY [*] OF INTEGER): ARRAY [*] OF INTEGER; 
	OPERATOR ^ "DECMUL"-(CONST left: ARRAY [*] OF INTEGER; CONST right: ARRAY [*, *] OF INTEGER): ARRAY [*] OF INTEGER; 
	PROCEDURE ^ MatMulIncALALLoop(ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 
	OPERATOR ^ "INCMUL"-(CONST left, right: ARRAY [*, *] OF LONGINT): ARRAY [*, *] OF LONGINT; 
	OPERATOR ^ "INCMUL"-(CONST left: ARRAY [*, *] OF LONGINT; CONST right: ARRAY [*] OF LONGINT): ARRAY [*] OF LONGINT; 
	OPERATOR ^ "INCMUL"-(CONST left: ARRAY [*] OF LONGINT; CONST right: ARRAY [*, *] OF LONGINT): ARRAY [*] OF LONGINT; 
	OPERATOR ^ "DECMUL"-(CONST left, right: ARRAY [*, *] OF LONGINT): ARRAY [*, *] OF LONGINT; 
	OPERATOR ^ "DECMUL"-(CONST left: ARRAY [*, *] OF LONGINT; CONST right: ARRAY [*] OF LONGINT): ARRAY [*] OF LONGINT; 
	OPERATOR ^ "DECMUL"-(CONST left: ARRAY [*] OF LONGINT; CONST right: ARRAY [*, *] OF LONGINT): ARRAY [*] OF LONGINT; 
	PROCEDURE ^ MatMulIncARARLoop(ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 
	OPERATOR ^ "INCMUL"-(CONST left, right: ARRAY [*, *] OF REAL): ARRAY [*, *] OF REAL; 
	OPERATOR ^ "INCMUL"-(CONST left: ARRAY [*, *] OF REAL; CONST right: ARRAY [*] OF REAL): ARRAY [*] OF REAL; 
	OPERATOR ^ "INCMUL"-(CONST left: ARRAY [*] OF REAL; CONST right: ARRAY [*, *] OF REAL): ARRAY [*] OF REAL; 
	OPERATOR ^ "DECMUL"-(CONST left, right: ARRAY [*, *] OF REAL): ARRAY [*, *] OF REAL; 
	OPERATOR ^ "DECMUL"-(CONST left: ARRAY [*, *] OF REAL; CONST right: ARRAY [*] OF REAL): ARRAY [*] OF REAL; 
	OPERATOR ^ "DECMUL"-(CONST left: ARRAY [*] OF REAL; CONST right: ARRAY [*, *] OF REAL): ARRAY [*] OF REAL; 
	PROCEDURE ^ MatMulIncAXAXLoop(ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE); 
	OPERATOR ^ "INCMUL"-(CONST left, right: ARRAY [*, *] OF LONGREAL): ARRAY [*, *] OF LONGREAL; 
	OPERATOR ^ "INCMUL"-(CONST left: ARRAY [*, *] OF LONGREAL; CONST right: ARRAY [*] OF LONGREAL): ARRAY [*] OF LONGREAL; 
	OPERATOR ^ "INCMUL"-(CONST left: ARRAY [*] OF LONGREAL; CONST right: ARRAY [*, *] OF LONGREAL): ARRAY [*] OF LONGREAL; 
	OPERATOR ^ "DECMUL"-(CONST left, right: ARRAY [*, *] OF LONGREAL): ARRAY [*, *] OF LONGREAL; 
	OPERATOR ^ "DECMUL"-(CONST left: ARRAY [*, *] OF LONGREAL; CONST right: ARRAY [*] OF LONGREAL): ARRAY [*] OF LONGREAL; 
	OPERATOR ^ "DECMUL"-(CONST left: ARRAY [*] OF LONGREAL; CONST right: ARRAY [*, *] OF LONGREAL): ARRAY [*] OF LONGREAL; 
	OPERATOR ^ "*"-(CONST left, right: ARRAY [*] OF SHORTINT): ARRAY [*] OF SHORTINT; 
	OPERATOR ^ "*"-(CONST left, right: ARRAY [*] OF INTEGER): ARRAY [*] OF INTEGER; 
	OPERATOR ^ "*"-(CONST left, right: ARRAY [*] OF LONGINT): ARRAY [*] OF LONGINT; 
	OPERATOR ^ "*"-(CONST left, right: ARRAY [*] OF REAL): ARRAY [*] OF REAL; 
	OPERATOR ^ "*"-(CONST left, right: ARRAY [*] OF LONGREAL): ARRAY [*] OF LONGREAL; 
	OPERATOR ^ "*"-(CONST left, right: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGREAL; 
	OPERATOR ^ "*"-(CONST left, right: ARRAY [?] OF REAL): ARRAY [?] OF REAL; 
	OPERATOR ^ "*"-(CONST left, right: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	OPERATOR ^ "*"-(CONST left, right: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	OPERATOR ^ "*"-(CONST left, right: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	PROCEDURE ^ Overlap(src1, src2: ADDRESS): BOOLEAN; 
	PROCEDURE ^ AllocateTransposed(VAR dest: ADDRESS; src: ADDRESS; elementsize: SIZE): ANY; 
	PROCEDURE ^ Transpose*(dest, left: ADDRESS; Size: SIZE); 
	OPERATOR ^ "`"-(CONST left: ARRAY [*, *] OF SHORTINT): ARRAY [*, *] OF SHORTINT; 
	OPERATOR ^ "`"-(CONST left: ARRAY [*, *] OF INTEGER): ARRAY [*, *] OF INTEGER; 
	OPERATOR ^ "`"-(CONST left: ARRAY [*, *] OF LONGINT): ARRAY [*, *] OF LONGINT; 
	OPERATOR ^ "`"-(CONST left: ARRAY [*, *] OF REAL): ARRAY [*, *] OF REAL; 
	OPERATOR ^ "`"-(CONST left: ARRAY [*, *] OF LONGREAL): ARRAY [*, *] OF LONGREAL; 
	PROCEDURE ^ CheckTensorGeometry(left, right, dest: ADDRESS; ldim, rdim: LONGINT): BOOLEAN; 
	PROCEDURE ^ DoReshape*(VAR dest: ADDRESS; src: LONGINT; CONST shape: ARRAY [*] OF LONGINT); 
	PROCEDURE ^ AllocateTensorA*(CONST a: ARRAY OF SIZE; elementSize: SIZE; tag: ADDRESS; VAR dest: UnsafeArray); 
	PROCEDURE ^ AllocateArrayA*(CONST a: ARRAY OF SIZE; elementSize: SIZE; tag: ADDRESS; dest: UnsafeArray); 
	PROCEDURE ^ AllocateTensorX*(VAR destA: ARRAY [?] ; CONST a: ARRAY [*] OF LONGINT; Size: SIZE; tag: ADDRESS); 
	PROCEDURE ^ LenA*(VAR dest: ARRAY [*] OF SIZE; src: ADDRESS); 
	PROCEDURE ^ IncrA*(VAR dest: ARRAY [*] OF SIZE; src: ADDRESS); 
	PROCEDURE ^ Len*(src: ADDRESS; d: SIZE): SIZE; 
	PROCEDURE ^ Incr*(src: ADDRESS; d: SIZE): SIZE; 
	PROCEDURE ^ AllocateTensor(VAR dest: ADDRESS; left, right: ADDRESS; Size: SIZE): ANY; 
	PROCEDURE ^ FindPatternTensor(left, right: ADDRESS; VAR rdim, len, linc, ri: SIZE); 
	PROCEDURE ^ ApplyTensorAAAOp(d, l, r: ADDRESS; elementSize: LONGINT; Loop: BinaryASALoop); 
	OPERATOR ^ "**"-(CONST left, right: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
	OPERATOR ^ "**"-(CONST left, right: ARRAY [?] OF INTEGER): ARRAY [?] OF INTEGER; 
	OPERATOR ^ "**"-(CONST left, right: ARRAY [?] OF LONGINT): ARRAY [?] OF LONGINT; 
	OPERATOR ^ "**"-(CONST left, right: ARRAY [?] OF REAL): ARRAY [?] OF REAL; 
	OPERATOR ^ "**"-(CONST left, right: ARRAY [?] OF LONGREAL): ARRAY [?] OF LONGREAL; 
	OPERATOR ^ "**"-(CONST left, right: ARRAY [?] OF COMPLEX): ARRAY [?] OF COMPLEX; 
	OPERATOR ^ "**"-(CONST left, right: ARRAY [?] OF LONGCOMPLEX): ARRAY [?] OF LONGCOMPLEX; 
	PROCEDURE ^ InitOptimization; 
	PROCEDURE ^ CopyDescriptor*(VAR destPtr: ANY; src: LONGINT; prefixIndices, prefixRanges, suffixIndices, suffixRanges: LONGINT); 
	PROCEDURE ^ Reshape*(CONST left: ARRAY [?] ; CONST right: ARRAY [*] OF LONGINT): ARRAY [?] ; 
	PROCEDURE ^ RangeFromInteger*(CONST integer: LONGINT): RANGE; 
	PROCEDURE ^ ExpandDimensions*(CONST sourceArray: ARRAY [?] ; CONST keptDimensions: ARRAY [*] OF BOOLEAN): ARRAY [?] ; 
	OPERATOR ^ "LEN"-(CONST range: RANGE): LONGINT; 
	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF SHORTINT; op: PROCEDURE (x: SHORTINT):SHORTINT): ARRAY [?] OF SHORTINT; 
	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF INTEGER; op: PROCEDURE (x: INTEGER):INTEGER): ARRAY [?] OF INTEGER; 
	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF LONGINT; op: PROCEDURE (x: LONGINT):LONGINT): ARRAY [?] OF LONGINT; 
	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF HUGEINT; op: PROCEDURE (x: HUGEINT):HUGEINT): ARRAY [?] OF HUGEINT; 
	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF REAL; op: PROCEDURE (x: REAL):REAL): ARRAY [?] OF REAL; 
	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF LONGREAL; op: PROCEDURE (x: LONGREAL):LONGREAL): ARRAY [?] OF LONGREAL; 
	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF COMPLEX; op: PROCEDURE (x: COMPLEX):COMPLEX): ARRAY [?] OF COMPLEX; 
	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF LONGCOMPLEX; op: PROCEDURE (x: LONGCOMPLEX):LONGCOMPLEX): ARRAY [?] OF LONGCOMPLEX; 
BEGIN
END FoxArrayBase.