
Basics: CEDAR DEFINITIONS ~ BEGIN 
bitsPerByte: NAT ~ BITS[BYTE];
bitsPerWord: NAT ~ BITS[WORD];
bitsPerLongWord: NAT ~ BITS[CARD]; -- = bitsPerWord!
bitsPerDWord: NAT ~ BITS[DWORD]; -- = 2*bitsPerLongWord
bytesPerWord: NAT ~ BYTES[WORD];
bytesPerDWord: NAT ~ BYTES[DWORD];

logBitsPerByte: NAT ~ BITS[[0..bitsPerByte)]; -- LogBase2[bitsPerByte] (= 3)
logBitsPerWord: NAT ~ BITS[[0..bitsPerWord)];
logBitsPerDWord: NAT ~ BITS[[0..bitsPerDWord)];
logBytesPerWord: NAT ~ BITS[[0..bytesPerWord)];
logBytesPerDWord: NAT ~ BITS[[0..bytesPerDWord)];

bitsPerChar: NAT ~ bitsPerByte;
logBitsPerChar: NAT ~ logBitsPerByte;
charsPerWord: NAT ~ bytesPerWord;
logCharsPerWord: NAT ~ logBytesPerWord;
Word: TYPE ~ MACHINE DEPENDENT RECORD [ -- bitsPerWord bits
SELECT OVERLAID * FROM
card => [card: CARD], -- assert BITS[CARD] = BITS[CARDINAL]
int => [int: INT], -- assert BITS[INT] = BITS[INTEGER]
real => [real: REAL], -- assert BITS[REAL] = BITS[WORD]
bytes => [bytes: PACKED ARRAY [0..bytesPerWord) OF BYTE],
bits => [bits: PACKED ARRAY [0..bitsPerWord) OF BOOL],
ENDCASE
];

DWord: TYPE ~ MACHINE DEPENDENT RECORD [ -- bitsPerDWord bits
SELECT OVERLAID * FROM
card => [card: DCARD],
int => [int: DINT],
real => [real: DREAL],
bytes => [bytes: PACKED ARRAY [0..bytesPerDWord) OF BYTE],
bits => [bits: PACKED ARRAY [0..bitsPerDWord) OF BOOL],
ENDCASE
];

PartialComparison: TYPE ~ {less, equal, greater, incomparable};
Comparison: TYPE ~ PartialComparison [less..greater];
RawWords: TYPE ~ RECORD [SEQUENCE COMPUTED CARD OF WORD];
RawCards: TYPE ~ RECORD [SEQUENCE COMPUTED CARD OF CARD];
RawBytes: TYPE ~ RECORD [PACKED SEQUENCE COMPUTED CARD OF BYTE];
RawChars: TYPE ~ RECORD [PACKED SEQUENCE COMPUTED CARD OF CHAR];
RawBits: TYPE ~ RECORD [PACKED SEQUENCE COMPUTED CARD OF CARDINAL[0..1]];
UnsafeBlock: TYPE ~ RECORD [
base: POINTER TO RawBytes м NIL,
startIndex: INT м 0,
count: INT м 0
];
CompareCard: PROC [a, b: CARD] RETURNS [Comparison]
~ INLINE { RETURN[IF a=b THEN equal ELSE IF a>b THEN greater ELSE less] };

CompareInt: PROC [a, b: INT] RETURNS [Comparison]
~ INLINE { RETURN[IF a=b THEN equal ELSE IF a>b THEN greater ELSE less] };
CompareBits: UNSAFE PROC [
aBase: POINTER TO RawBits, aStart: CARD, 
bBase: POINTER TO RawBits, bStart: CARD, 
count: CARDINAL] RETURNS [Comparison]
~ UNCHECKED MACHINE CODE {"Basics_CompareBits"};

OddCard: PROC [n: CARD] RETURNS [BOOL]
~ INLINE { RETURN [VAL[n MOD 2]] };
OddInt: PROC [n: INT] RETURNS [BOOL]
~ INLINE { RETURN [OddCard[LOOPHOLE[n]]] };
NonNegative: PROC [value: INT] RETURNS [[0..INT.LAST]]
~ INLINE { RETURN[value] };

BoundsCheck: PROC [arg, limit: WORD] RETURNS [WORD]
~ INLINE { IF arg >= limit THEN RaiseBoundsFault[]; RETURN [arg] };

BoundsCheckInt: PROC [arg: INT, limit: [0..INT.LAST]] RETURNS [[0..INT.LAST)]
~ INLINE {
IF LOOPHOLE[arg, CARD] >= limit THEN RaiseBoundsFault[];
RETURN [LOOPHOLE[arg]];
};

RaiseBoundsFault: PROC
~ TRUSTED MACHINE CODE { 
"XR_RaiseBoundsFault"
};

NilCheck: PROC [ptr: POINTER] RETURNS [POINTER] 
~ TRUSTED MACHINE CODE { 
"XR_NilCheck"
};
IsBound: PROC [proc: PROC ANY RETURNS ANY] RETURNS [BOOL] 
~ TRUSTED MACHINE CODE {
"XR_IsBound"
};
BITAND: PROC [WORD, WORD] RETURNS [WORD]
~ TRUSTED MACHINE CODE { 
"*#define XRM_BITAND(x, y) (((word)(x)) & ((word)(y))).XRM_BITAND"
};

BITOR: PROC [WORD, WORD] RETURNS [WORD]
~ TRUSTED MACHINE CODE { 
"*#define XRM_BITOR(x, y) (((word)(x)) | ((word)(y))).XRM_BITOR"
};

BITXOR: PROC [WORD, WORD] RETURNS [WORD]
~ TRUSTED MACHINE CODE { 
"*#define XRM_BITXOR(x, y) (((word)(x)) ^ ((word)(y))).XRM_BITXOR"
};

BITNOT: PROC [WORD] RETURNS [WORD]
~ TRUSTED MACHINE CODE { 
"*#define XRM_BITNOT(x) (~((word)(x))).XRM_BITNOT" 
}; 

BITLSHIFT: PROC [value: WORD, count: [0..bitsPerWord)] RETURNS [WORD]
~ TRUSTED MACHINE CODE {
"*#define XRM_BITLSHIFT(x, y) ((word)(x) << (word)(y)).XRM_BITLSHIFT"
};

BITRSHIFT: PROC [value: WORD, count: [0..bitsPerWord)] RETURNS [WORD]
~ TRUSTED MACHINE CODE {
"*#define XRM_BITRSHIFT(x, y) ((word)(x) >> (word)(y)).XRM_BITRSHIFT"
};
BITSHIFT: PROC [value: WORD, count: INTEGER] RETURNS [WORD]
~ TRUSTED MACHINE CODE {
"Basics_BITSHIFT"
};
CopyWords: UNSAFE PROC [
dst: POINTER TO RawWords, 
src: POINTER TO RawWords, 
count: CARDINAL]
~ UNCHECKED MACHINE CODE { 
"Basics_CopyWords"
};

MoveWords: UNSAFE PROC [
dst: POINTER TO RawWords, 
src: POINTER TO RawWords, 
count: CARDINAL]
~ UNCHECKED MACHINE CODE { 
"Basics_MoveWords"
};

FillWords: UNSAFE PROC [
dst: POINTER TO RawWords, 
count: CARDINAL, value: WORD]
~ UNCHECKED MACHINE CODE { 
"Basics_FillWords"
};
CopyBytes: UNSAFE PROC [
dstBase: POINTER TO RawBytes, dstStart: CARD, 
srcBase: POINTER TO RawBytes, srcStart: CARD, 
count: CARDINAL]
~ UNCHECKED MACHINE CODE { 
"Basics_CopyBytes"
};

MoveBytes: UNSAFE PROC [
dstBase: POINTER TO RawBytes, dstStart: CARD, 
srcBase: POINTER TO RawBytes, srcStart: CARD, 
count: CARDINAL]
~ UNCHECKED MACHINE CODE { 
"Basics_MoveBytes"
};

FillBytes: UNSAFE PROC [
dstBase: POINTER TO RawBytes, dstStart: CARD, 
count: CARDINAL, value: BYTE]
~ UNCHECKED MACHINE CODE { 
"Basics_FillBytes"
};
CopyBits: UNSAFE PROC [
dstBase: POINTER TO RawBits, dstStart: CARD, 
srcBase: POINTER TO RawBits, srcStart: CARD, 
count: CARDINAL]
~ UNCHECKED MACHINE CODE {"Basics_CopyBits"};

MoveBits: UNSAFE PROC [
dstBase: POINTER TO RawBits, dstStart: CARD, 
srcBase: POINTER TO RawBits, srcStart: CARD, 
count: CARDINAL]
~ UNCHECKED MACHINE CODE {"Basics_MoveBits"};

FillBits: UNSAFE PROC [
dstBase: POINTER TO RawBits, dstStart: CARD, 
count: CARDINAL, value: WORD]
~ UNCHECKED MACHINE CODE {"Basics_FillBits"};

ByteBltBlock: TYPE ~ RECORD [blockPointer: POINTER, startIndex, stopIndexPlusOne: CARDINAL];

ByteBlt: UNSAFE PROC [to, from: ByteBltBlock] RETURNS [nBytes: CARDINAL]
~ TRUSTED MACHINE CODE { 
"Basics_ByteBlt"
};

LongNumber: TYPE ~ Word32; -- for backward compatibility
Word32: TYPE ~ MACHINE DEPENDENT RECORD [ -- 32 bits
SELECT OVERLAID * FROM
card => [card: CARD32],
int => [int: INT32],
real => [real: REAL32],
pair => [hi, lo: CARD16],
bytes => [hh, hl, lh, ll: BYTE],
bits => [bits: PACKED ARRAY [0..32) OF BOOL],
lc => [lc: CARD], li => [li: INT], -- for backward compatibility; assert BITS[CARD]=32
ENDCASE
];
Word16: TYPE ~ MACHINE DEPENDENT RECORD [ -- 16 bits
SELECT OVERLAID * FROM
card => [card: CARD16],
int => [int: INT16],
pair => [hi, lo: BYTE],
bits => [bits: PACKED ARRAY [0..16) OF BOOL],
ENDCASE
];

LowHalf: PROC [n: CARD32] RETURNS [CARD16]
~ INLINE { RETURN[n MOD 2**16] };

HighHalf: PROC [n: CARD32] RETURNS [CARD16]
~ INLINE { RETURN[n / 2**16] };

LowByte: PROC [n: CARD16] RETURNS [BYTE]
~ INLINE { RETURN[n MOD 2**8] };

HighByte: PROC [n: CARD16] RETURNS [BYTE]
~ INLINE { RETURN[n / 2**8] };

HWORD: TYPE ~ MACHINE DEPENDENT RECORD [hi, lo: BYTE];
FWORD: TYPE ~ MACHINE DEPENDENT RECORD [hi, lo: HWORD];
FFromCard32: PROC [n: CARD32] RETURNS [FWORD]
~ INLINE { RETURN[LOOPHOLE[n]] };

FFromInt32: PROC [n: INT32] RETURNS [FWORD]
~ INLINE { RETURN[LOOPHOLE[n]] };

Card32FromF: PROC [f: FWORD] RETURNS [CARD32]
~ INLINE { RETURN[LOOPHOLE[f]] };

Int32FromF: PROC [f: FWORD] RETURNS [INT32]
~ INLINE { RETURN[LOOPHOLE[f]] };

HFromCard16: PROC [n: CARD16] RETURNS [HWORD]
~ INLINE { RETURN[LOOPHOLE[n]] };

HFromInt16: PROC [n: INT16] RETURNS [HWORD]
~ INLINE { RETURN[LOOPHOLE[n]] };

Card16FromH: PROC [h: HWORD] RETURNS [CARD16]
~ INLINE { RETURN[LOOPHOLE[h]] };

Int16FromH: PROC [h: HWORD] RETURNS [INT16]
~ INLINE { 
temp: PACKED RECORD[h0, h1: INT16] ~ [0, LOOPHOLE[h]];
RETURN[temp.h1] 
};


END.
   ф  
Basics.mesa
For Sun-3, Sun-4, and other big-endian, 32-bit processors
Copyright ╙ 1985, 1988, 1989, 1991 by Xerox Corporation.  All rights reserved.
Russ Atkinson (RRA) February 27, 1985 8:10:50 pm PST
Carl Hauser, July 11, 1988 3:12:38 pm PDT
JKF August 26, 1988 12:50:28 pm PDT
Willie-s, July 25, 1991 2:56 pm PDT
Michael Plass, September 27, 1991 9:29 am PDT
Doug Wyatt, August 27, 1991 4:38 pm PDT
Commonly-used types and values

Caution: bytes and bits not necessarily in significance order!
Caution: bytes and bits not necessarily in significance order!


... describes the byte sequence base[startIndex..startIndex+count).

Arithmetic utilities

... cheaply tests whether n is odd; equivalent to (but faster than) (n MOD 2)#0.

Bounds checking
Effect is ... ERROR RuntimeError.BoundsFault;
Effect is ... { IF ptr=NIL THEN ERROR RuntimeError.NilFault; RETURN[ptr] };
Control links
Logic utilities
... left-shifts the value by the count.  
... right-shifts the value by the count. 

... shifts the value by the count.  If count is positive, the shift is to the left.  If count is negative, the shift is to the right.
Block copying utilities
Copies a block of words: for all i in [0..count), dst[i] м src[i].
The order of transfer is unspecified; destination and source should be disjoint.
Moves a block of words: ripples in proper order if destination and source overlap.
Fills a block of words with a constant: for all i in [0..count), dst[i] м value.

Copies a block of bytes: for all i in [0..count), dstBase[dstStart+i] м srcBase[srcStart+i].
The order of transfer is unspecified; destination and source should be disjoint.
Moves a block of bytes: ripples in proper order if destination and source overlap.
Fills a block of bytes with a constant: for all i in [0..count), dstBase[dstStart+i] м value.

Retained for compatibility.  The effect is ...
nBytes м MIN[
MAX[to.startIndex, to.stopIndexPlusOne] - to.startIndex,
MAX[from.startIndex, from.stopIndexPlusOne] - from.startIndex
];
MoveBytes[to.blockPointer, to.startIndex, from.blockPointer, from.startIndex, nBytes];
32 and 16 bit types and operations
Caution: bits not necessarily in significance order!

Caution: bits not necessarily in significance order!
Endian types and operations
These definitions are for things that "go on the wire"; well, mostly communication, but arguably anything that has an external representation that passes between machines, e.g. tape drives and floppy disks.
Some machines are big endian, some are little endian... Dorados, DLions, IBM 360s, Motorola 68000s, and SPARCs are big endian; PDP-11s, VAXes and Intel are little endian.
PrincOps LONGs are word swapped from a clean big endian viewpoint.  Beware: Many Cedar programs, in particular RPC, send raw PrincOps (word swapped) LONGs on the wire.
Don't use CARD, CARDINAL, INT, INTEGER, WORD, or subranges bigger than a BYTE in the definition of any record going to or coming from the wire.  Enumerated types bigger than a BYTE (ErrorCodes, for example) won't work either.


Carl Hauser, October 13, 1986 11:23:32 am PDT
Working on conversion for Dragon .
changes to: 
LongNumber reordered contained words, bytes and bits; renamed the tags and subfields 
ShortNumber retyped the subfields; renamed the tags and subfields 
UnsafeBlock retyped the base field.
Carl Hauser, June 11, 1987 4:10:57 pm PDT
added the Endian types and operations.
Carl Hauser, March 24, 1988 11:07:21 am PST
Removed VM parameters. Get them from the VM interface.
Jim Foote, August 26, 1988 10:50:59 am PDT
Added FillBytes, changed Fill to FillWords, added IsBound.
Michael Plass, August 2, 1991 11:54:50 am PDT
Moved the (unimplemented) arithmetic section to the (new) BasicArithmetic interface.
Removed the ERROR declarations; they were unused and redundant with RuntimeError.

 Э╩К  Ц(cedarcode) styleХNewlineDelimiter
Щ codeЪЬЩKЪ╧b9Щ9KЪЬ
╧eЬCЩNJЩ4KЩ)KЩ#KЩ#KЩ-KЩ'ЧKШ KЪ╧nЬ╧kЬаЬаЬШ"headЩKЪЬаЬаЬаЬШKЪЬаЬаЬаЬШKЪЬаЬаЬаЬ╧cШ4KЪЬаЬаЬаЬбШ7KЪЬаЬаЬаЬШ ЪЬаЬаЬаЬШ"KШ ЧKЪЬаЬаЬбШLKЪЬаЬаЬШ-KЪЬаЬаЬШ/KЪЬаЬаЬШ/ЪЬаЬаЬШ1KШ ЧKЪЬаЬШKЪЬаЬШ%KЪЬаЬШ!ЪЬаЬШ'KЩ ЧЪ
ЬаЬаЬа	ЬаЬбШ;ЪаЬаЬаШKЪЬаЬб
╨ckбвбвбвбШ;KЪЬаЬб
вбвбвбвбШ6KЪЬаЬб
вбвбвбвбШ7KЪ	ЬаЬаЬаЬаЬШ9Ъ	ЬаЬаЬаЬаЬШ6KЩ>ЧKЪаШЧKЪЬШKШ ЧЪ
ЬаЬаЬа	ЬаЬбШ=ЪаЬаЬаШKЪЬаЬШKЪЬаЬШKЪЬаЬШKЪ	ЬаЬаЬаЬаЬШ:Ъ	ЬаЬаЬаЬаЬШ7KЩ>ЧKЪаШЧKЪЬШKШ ЧKЪЬаЬ(Ш?ЪЬаЬ%Ш5KЩ ЧKЪЬ
аЬаЬаЬаЬаЬаЬаЬШ9KЪЬ
аЬаЬаЬаЬаЬаЬаЬШ9KЪЬ
аЬаЬаЬаЬаЬаЬаЬШ@KЪЬ
аЬаЬаЬаЬаЬаЬаЬШ@ЪЬ	аЬаЬаЬаЬаЬаЬаЬШIKЩ ЧЪЬаЬаЬШKЪЬаЬаЬаЬШ KЪЬаЬШKЪЬаЬШKЪЬШKЪЬCЩCKЩ ЧЧЪЬЩЪЯЬаЬаЬаЬШ3KЪЬаЬаЬаЬаЬаЬаЬаЬ	аЬ	ШJKШ ЧЪЯ
ЬаЬаЬаЬШ1ЪЬаЬаЬаЬаЬаЬаЬаЬ	аЬ	ШJKЩ ЧЧЪЯЬаЬаЬ
аЬаЬаЬ
аЬаЬаЬ
аЬаЬШФKЪЬа	ЬаЬаЬШ0KШ ЧЪ
ЯЬаЬаЬаЬаЬШ&KЪ	ЬаЬаЬаЬаЬШ#KЪЬGаЬЩPKЩ ЧЪ
ЯЬаЬаЬаЬаЬШ$KЪЬаЬаЬ
аЬШ+ЧЧЩЪЯЬаЬ	аЬаЬаЬаЬШ6KЪЬаЬаЬ
ШKШ ЧЪ
ЯЬаЬаЬаЬаЬШ3KЪ	ЬаЬаЬаЬаЬ	ШCKШ ЧЪЯЬаЬаЬаЬаЬаЬаЬаЬШMЪЬаЬШ
KЪаЬаЬаЬаЬШ8KЪаЬаЬШKЪЬШЧKШ ЧЪЯЬаШKЪЬаЬаЬШIasciiЪЬШKЪЬШKЪЬаЬЩ-KШ ЧЪ
ЯЬаЬаЬаЬаЬШ0KЪЬаЬаЬШMЪЬШKЪЬШKЪЬаЬаЬаЬаЬбЬаЬЩKЧЧЪЬЩЪЯЬаЬаЬаЬаЬаЬаЬаЬШ:KЪЬаЬаЬаЬШMЪЬШKЪЬШЧЧЪЬЩЪ╨bkЬаЬаЬаЬаЬаЬШ(KЪЬаЬаЬаЬШMЪЬBШBKЪЬШKШ ЧЪгЬаЬаЬаЬаЬаЬШ'KЪЬаЬаЬаЬШMЪЬ@Ш@KЪЬШKШ ЧЪгЬаЬаЬаЬаЬаЬШ(KЪЬаЬаЬаЬШMЪЬBШBKЪЬШKШ ЧЪ
гЬаЬаЬаЬаЬШ"KЪЬаЬаЬаЬШMЪЬ╧fЬШ3KЪЬШKШ ЧЪ
╨kn	ЬаЬ	аЬаЬаЬШEKЪЬ)Щ)KЪЬаЬаЬаЬШMЪЬдЬдЬШEKШKШ ЧЪ
е	ЬаЬ	аЬаЬаЬШEKЪЬ)Щ)KЪЬаЬаЬаЬШMЪЬдЬдЬШEKШKЩ ЧЪеЬаЬ	аЬ	аЬаЬаЬШ;KЪЬЕЩЕKЪЬаЬаЬаЬШMЪЬШKШЧЧЪЬЩЪЯ	ЬаЬаЬаЬаЬаЬаЬаЬШ_KЪЬа	ЬаЬШMЪЬШKЪЬШKЪЬBЩBKЩPKШ ЧЪЯ	ЬаЬаЬаЬаЬаЬаЬаЬШ_KЪЬа	ЬаЬШMЪЬШKЪЬШKЪЬRЩRKШ ЧЪЯ	ЬаЬаЬаЬаЬаЬ	аЬШQKЪЬа	ЬаЬШMЪЬШKЪЬШKЪЬPЩPKЩ ЧЪЯ	ЬаЬаЬаЬаЬаЬаЬаЬаЬ
аЬШЗKЪЬа	ЬаЬШMЪЬШKЪЬШKЪЬ\Щ\KЩPKШ ЧЪЯ	ЬаЬаЬаЬаЬаЬаЬаЬаЬ
аЬШЗKЪЬа	ЬаЬШMЪЬШKЪЬШKЪЬRЩRKШ ЧЪЯ	ЬаЬаЬаЬаЬаЬ
аЬ	аЬШeKЪЬа	ЬаЬШMЪЬШKЪЬШKЪЬ]Щ]KЩ ЧЪЯЬаЬаЬаЬаЬаЬаЬаЬаЬ
аЬШДKЪЬа	ЬаЬаЬШ-KШ ЧЪЯЬаЬаЬаЬаЬаЬаЬаЬаЬ
аЬШДKЪЬа	ЬаЬаЬШ-KШ ЧЪЯЬаЬаЬаЬаЬаЬ
аЬ	аЬШcKЪЬа	ЬаЬаЬШ-KШ ЧЪ	ЬаЬаЬаЬ аЬШ\KШ ЧЪ
ЯЬаЬаЬаЬ
аЬШHKЪЬаЬаЬШMЪЬШKЪЬШЩ.ЪЬ	аЬЩKЪаЬ5Щ8KЪаЬ:Щ=KЪЬЩЧKЪЬVЩVЧKШ ЧЧЪЬ"Щ"KЪЬаЬбШ8Ъ
ЬаЬаЬа	ЬаЬб
Ш4ЪаЬаЬаШKЪЬаЬШKЪЬаЬШKЪЬаЬШKЪЬаЬШKЪЬаЬШ Ъ	ЬаЬаЬ	аЬаЬШ-KЩ4ЧKЪ
ЬаЬаЬб&вбвбШVKЪаШЧKЪЬШKЩ ЧЪ
ЬаЬаЬа	ЬаЬб
Ш4ЪаЬаЬаШKЪЬаЬШKЪЬаЬШKЪЬаЬШЪ	ЬаЬаЬ	аЬаЬШ-KЩ4ЧKЪаШЧKЪЬШKШ ЧЪ
ЯЬаЬаЬаЬаЬШ*KЪЬаЬаЬаЬ
Ш!KШ ЧЪ
ЯЬаЬаЬаЬаЬШ+KЪЬаЬаЬШKШ ЧЪ
ЯЬаЬаЬаЬаЬШ(KЪЬаЬаЬаЬ	Ш KШ ЧЪ
ЯЬаЬаЬаЬаЬШ)KЪЬаЬаЬШKШ ЧЧЩKЪаЬаЬаЬа	ЬаЬ
аЬШ6ЪаЬаЬаЬа	ЬаЬ
аЬШ7KЩ╬KЪЬкЩкKЪЬ	╧sЬbаЬ#жЬЩзKЪЬ
аЬаЬаЬаЬаЬcаЬ-ЩсKЩ ЧЪ
ЯЬаЬаЬаЬаЬШ-KЪЬаЬаЬаЬШ!KШ ЧЪ
Я
ЬаЬаЬаЬаЬШ+KЪЬаЬаЬаЬШ!KШ ЧЪ
ЯЬаЬаЬаЬаЬШ-KЪЬаЬаЬаЬШ!KШ ЧЪ
Я
ЬаЬаЬаЬаЬШ+KЪЬаЬаЬаЬШ!KШ ЧЪ
ЯЬаЬаЬаЬаЬШ-KЪЬаЬаЬаЬШ!KШ ЧЪ
Я
ЬаЬаЬаЬаЬШ+KЪЬаЬаЬаЬШ!KШ ЧЪ
ЯЬаЬаЬаЬаЬШ-KЪЬаЬаЬаЬШ!KШ ЧЪ
Я
ЬаЬаЬаЬаЬШ+KЪЬаЬШKЪ	ЬаЬаЬ	аЬаЬШ6KЪаЬ
ШKЪЬШKШ ЧЧKШ ЪаЬШKЩ Щ-KЩ"ЪЬЩKЪ╧r
Ь*зЬзЩUKЪзЬзЬзЩBKЪзЬЩ#ЧЧЩ)KЪз&Щ&ЧЩ+KЪЬ5зЩ6ЧЩ*KЪЬ9зЩ:ЧЩ-KЩTKЩQЧKЩ ЧЧ ЕЧ    T  <┬  