DIRECTORY
Ascii USING [Lower],
Basics USING [MoveWords],
BTree USING [Compare, CompareEntries, DeleteKey, Entry, EntryFromRecord, EntrySize, EnumerateEntries, GetState, Key, New, NewPathStk, NewRecordFromEntry, Open, PageNumber, PagePtr, PageSize, PageStorage, PathStk, ReadEntry, ReferencePage, Relation, ReleasePage, SalvageEntries, SetState, SetUpdateInProgress, State, Tree, UpdateEntry, UpdateType, Validate],
BTreeSimple,
BTreeVM,
IO USING [STREAM],
Rope USING [Flatten, NewText];


BTreeSimpleImpl: CEDAR PROGRAM
IMPORTS Ascii, Basics, BTree, BTreeVM,  Rope
EXPORTS BTreeSimple
SHARES Rope
= { OPEN BTreeSimple;

KeyFromEntry: PUBLIC UNSAFE PROC [entryKey: EntryKey] 
RETURNS [key: InternalKey м NIL] = UNCHECKED {
IF entryKey # NIL THEN {
key м Rope.NewText[entryKey.length]; -- on Michael Plass's recommendation
key.length м entryKey.length;  
Basics.MoveWords[dst: LOOPHOLE[key, POINTER]+SIZE[TEXT[0]], 
src:  LOOPHOLE[entryKey+SIZE[EntryKeyObject[0]]], 
count: WORDS[EntryKeyObject[entryKey.length]] - WORDS[EntryKeyObject[0]] ];
RETURN[key];
};
};

ValueFromEntry: PUBLIC UNSAFE PROC [entryValue: EntryValue]
 RETURNS [value: Value м NIL] = UNCHECKED {
IF entryValue # NIL THEN {
value м NEW[ValueObject[entryValue.length]];
Basics.MoveWords[dst: LOOPHOLE[value, POINTER]+SIZE[ValueObject[0]],
src: LOOPHOLE[entryValue, POINTER]+SIZE[ValueObject[0]],
count: entryValue.length];	-- entryValue.length is in words
RETURN[value];
};
};

DefaultCompare: Compare --[key: InternalKey, entryKey: EntryKey] RETURNS [Comparison]-- = UNCHECKED {

FOR i: CARDINAL IN [0 .. MIN[key.length, entryKey.length]) DO
kc: CHAR м Ascii.Lower[key[i]];
ec: CHAR м Ascii.Lower[entryKey[i]];
IF kc # ec THEN {
IF kc < ec THEN RETURN[less] ELSE RETURN[greater]
};
ENDLOOP;
IF key.length = entryKey.length THEN RETURN[equal]
ELSE {IF key.length < entryKey.length 
 THEN RETURN[less]
 ELSE  RETURN[greater];
 };
};

DefaultCompareEntries: CompareEntries --[entryKey1, entryKey2: EntryKey] RETURNS [Comparison]-- = UNCHECKED {
FOR i: CARDINAL IN [0 .. MIN[entryKey1.length, entryKey2.length]) DO
c1: CHAR м Ascii.Lower[entryKey1[i]];
c2: CHAR м Ascii.Lower[entryKey2[i]];
IF c1 # c2 THEN {
IF c1<c2 THEN RETURN[less] ELSE RETURN[greater];
}
ENDLOOP;
IF entryKey1.length = entryKey2.length THEN RETURN[equal]
ELSE  {IF entryKey1.length < entryKey2.length
THEN RETURN[less] 
ELSE RETURN[greater]
};
};

defaultCompareProcs: PUBLIC CompareProcs м 
[compare: DefaultCompare, compareEntries: DefaultCompareEntries];
New: PUBLIC PROC [compareProcs: CompareProcs м defaultCompareProcs, initialState: State[closed..suspended] м closed] RETURNS [tree: Tree] = {
RETURN[BTree.New[repPrim: [compare: LOOPHOLE[compareProcs.compare], 
compareEntries: LOOPHOLE[compareProcs.compareEntries], 
entrySize: EntrySize, 
entryFromRecord: EntryFromRecord, 
newRecordFromEntry: NewRecordFromEntry], 
storPrim: [referencePage: BTreeVM.ReferencePage, releasePage: BTreeVM.ReleasePage], 
minEntrySize: SIZE[EntryKeyObject[1]] + SIZE[ValueObject[0]], 
initialState: initialState]];
};

Open: PUBLIC PROC [tree: Tree, readFile, writeFile: IO.STREAM, pageSize: BTreeSimple.PageSize, cacheSize: CacheSize м 40, offset: CARD м 0, initialize: BOOLEAN м FALSE, maintainRecomputableState: BOOLEAN м TRUE] = {
storage: BTreeVM.Ref;
storage м BTreeVM.Open[readBacking: readFile, writeBacking: writeFile, pageSize: pageSize, cacheSize: cacheSize, offset: offset];

tree.Open[storage: storage, pageSize: pageSize, 
initialize: initialize, maintainRecomputableState: maintainRecomputableState];
};

SetState: PUBLIC PROC [tree: Tree, state: State[closed..suspended]] = {
tree.SetState[state];
};

GetState: PUBLIC PROC [tree: Tree] RETURNS [state: State, entryCount: CARD, greatestPage: BTree.PageNumber, depth: CARD] = {
storage: BTree.PageStorage;
[state: state, entryCount: entryCount, greatestPage: greatestPage, depth: depth, storage: storage] м tree.GetState[];
};

GetStatistics: PUBLIC PROC [tree: Tree] RETURNS [hits, misses, reads, writes, cumChainLength, cumReadWriteTime: CARD] = {
stats: BTreeVM.Stats;
h: BTreeVM.Ref;
h м NARROW[BTree.GetState[tree].storage];
stats м BTreeVM.GetStats[h];
RETURN [stats.hits, stats.misses, stats.reads, stats.writes, stats.cumChainLength, stats.cumReadWriteTime];
};

Validate: PUBLIC PROC [tree: Tree] = {
tree.Validate[];
};

SetUpdateInProgress: PUBLIC PROC [tree: Tree, updateInProgress: BOOLEAN] = {
tree.SetUpdateInProgress[updateInProgress];
};
ReadRecord: PUBLIC PROC [tree: Tree, key: Key, relation: Relation м equal, pathStk: PathStk м NIL, useExistingPath: BOOLEAN м FALSE] RETURNS [actualKey: InternalKey, value: Value] = TRUSTED {
EntryProc: UNSAFE PROC [key: EntryKey, value: EntryValue] = UNCHECKED {
IF key=NIL THEN {actualKey м NIL; returnValue м NIL}
ELSE {actualKey м KeyFromEntry[key]; returnValue м ValueFromEntry[value]};
};
returnValue: Value;
ReadEntry[tree: tree, key: key, relation: relation, pathStk: pathStk, useExistingPath: useExistingPath, Proc: EntryProc];
RETURN [actualKey, returnValue];
};

ReadValue: PUBLIC PROC [tree: Tree, key: Key, relation: Relation м equal, pathStk: PathStk м NIL, useExistingPath: BOOLEAN м FALSE] RETURNS [value: Value] = TRUSTED {
EntryProc: UNSAFE PROC [key: EntryKey, value: EntryValue] = UNCHECKED {
returnValue м (IF value=NIL THEN NIL ELSE ValueFromEntry[value]);
};
returnValue: Value;
ReadEntry[tree: tree, key: key, relation: relation, pathStk: pathStk, useExistingPath: useExistingPath, Proc: EntryProc];
RETURN [returnValue];
};

EnumerateRecords: PUBLIC PROC [tree: Tree, key: Key, relation: Relation м equal, pathStk: PathStk м NIL, useExistingPath: BOOLEAN м FALSE, Proc: PROC [key: InternalKey, value: Value] RETURNS [continue: BOOLEAN]] RETURNS [exhausted: BOOLEAN] = TRUSTED {
EntryProc: UNSAFE PROC [key: EntryKey, value: EntryValue] RETURNS [continue: BOOLEAN] = UNCHECKED {
RETURN [Proc[key: KeyFromEntry[key], value: ValueFromEntry[value]]] };
exhausted м EnumerateEntries[tree: tree, key: key, pathStk: pathStk, useExistingPath: useExistingPath, Proc: EntryProc];
};

UpdateRecord: PUBLIC PROC [tree: Tree, key: Key, value: Value, pathStk: PathStk м NIL, useExistingPath: BOOLEAN м FALSE, updateType: UpdateType м insertOrReplace] = TRUSTED {
ProduceEntry: UNSAFE PROC [value: EntryValue] = UNCHECKED  {
Basics.MoveWords[dst: LOOPHOLE[value],
 src: LOOPHOLE[suppliedValue],
 count: WORDS[ValueObject[suppliedValue.length]]];
}; 
 
suppliedValue: POINTER TO ValueObject = LOOPHOLE[value];
UpdateEntry[tree: tree, key: key, pathStk: pathStk, useExistingPath: useExistingPath, valueLength:  suppliedValue.length, Proc: ProduceEntry, updateType: updateType];
};

DeleteKey: PUBLIC PROC [tree: Tree, key: Key, pathStk: PathStk м NIL, useExistingPath: BOOLEAN м FALSE] RETURNS [found: BOOLEAN] = {
found м tree.DeleteKey[key: key.Flatten[], pathStk: pathStk, useExistingPath: useExistingPath];
RETURN[found];
};
ReadEntry: PUBLIC UNSAFE PROC [tree: Tree, key: Key, relation: Relation м equal, pathStk: PathStk м NIL, useExistingPath: BOOLEAN м FALSE, Proc: UNSAFE PROC [key: EntryKey, value: EntryValue]] = UNCHECKED {
EntryProc: UNSAFE PROC [entry: BTree.Entry] = UNCHECKED {
IF entry=NIL THEN Proc[NIL, NIL]
ELSE  {
entryKey: EntryKey = LOOPHOLE[entry, EntryKey];
entryKeySize: CARD м SIZE[EntryKeyObject[entryKey.length]];
Proc[entry, entry + entryKeySize];
};
};
tree.ReadEntry[key: key.Flatten[], relation: relation, pathStk: pathStk, useExistingPath: useExistingPath, Proc: EntryProc];
};

EnumerateEntries: PUBLIC UNSAFE PROC [tree: Tree, key: Key, relation: Relation м equal, pathStk: PathStk м NIL, useExistingPath: BOOLEAN м FALSE, Proc: UNSAFE PROC [key: EntryKey, value: EntryValue] RETURNS [continue: BOOLEAN]] RETURNS [exhausted: BOOLEAN] = UNCHECKED {
EntryProc: UNSAFE PROC [entry: BTree.Entry] RETURNS [continue: BOOLEAN] = UNCHECKED {
entryKey: EntryKey = LOOPHOLE[entry, EntryKey];
entryKeySize: CARD м SIZE[EntryKeyObject[entryKey.length]];
RETURN[Proc[entry, entry + entryKeySize]];
};
exhausted м tree.EnumerateEntries[key: key.Flatten[], relation: relation, pathStk: pathStk, useExistingPath: useExistingPath, Proc: EntryProc];
};

UpdateEntry: PUBLIC UNSAFE PROC [tree: Tree, key: Key, pathStk: PathStk м NIL, useExistingPath: BOOLEAN м FALSE, valueLength: CARD, Proc: UNSAFE PROC [value: EntryValue], updateType: UpdateType м insertOrReplace] = UNCHECKED {
EntryProc: UNSAFE PROC [entry: BTree.Entry] = UNCHECKED {
entryKey: EntryKey;
entryValue: EntryValue;
entryKey м LOOPHOLE[entry];
entryValue м LOOPHOLE[entry+entryKeySize];

LOOPHOLE[entryKey, POINTER TO CARD]н м internalKey.length;
Basics.MoveWords[dst: LOOPHOLE[entryKey+SIZE[EntryKeyObject[0]]], 
src: LOOPHOLE[internalKey, POINTER]+SIZE[TEXT[0]], 
count: WORDS[TEXT[internalKey.length]] - WORDS[TEXT[0]]];
Proc[entryValue];
LOOPHOLE[entryValue, POINTER TO CARD]н м valueLength; 
-- entryValue.length м valueLength
};

internalKey: InternalKey = key.Flatten[];
entryKeySize: CARD = SIZE[EntryKeyObject[internalKey.length]];
valueLengthSize: CARD = SIZE[ValueObject[valueLength]];
totalNumberOfBytes: CARD = entryKeySize + valueLengthSize;

tree.UpdateEntry[key: internalKey, pathStk: pathStk, useExistingPath: useExistingPath, bytes: totalNumberOfBytes, Proc: EntryProc, updateType: updateType];
};

SalvageEntries: PUBLIC UNSAFE PROC [tree: Tree, Proc: UNSAFE PROC [key: EntryKey, value: EntryValue] RETURNS [continue: BOOLEAN]] RETURNS [exhausted: BOOLEAN] = UNCHECKED {
EntryProc: UNSAFE PROC [entry: BTree.Entry] RETURNS [continue: BOOLEAN] = UNCHECKED {
RETURN[Proc[entry, entry+EntryKeyObject[LOOPHOLE[entry, EntryKey].length].SIZE]]};
exhausted м tree.SalvageEntries[Proc: EntryProc];
};
NewPathStk: PUBLIC PROC RETURNS [pathStk: PathStk] = {
RETURN[BTree.NewPathStk[]];
};
EntrySize: BTree.EntrySize --[entry: BTree.Entry] RETURNS [bytes: BTree.EntSize]-- = UNCHECKED {
lengthOfEntryKey: CARD;
lengthOfValueObject: CARD;
entryKeySize: CARD;
valueObjectSize: CARD;

lengthOfEntryKey м LOOPHOLE[entry, EntryKey].length;
entryKeySize м SIZE[EntryKeyObject[lengthOfEntryKey]];
lengthOfValueObject м LOOPHOLE[entry+entryKeySize, EntryValue].length;
valueObjectSize м SIZE[ValueObject[lengthOfValueObject]];
bytes м entryKeySize + valueObjectSize;
};

EntryFromRecord: BTree.EntryFromRecord --[record: BTree.Record] RETURNS [entry: BTree.Entry]-- = UNCHECKED {
ERROR Bug[cantGetHere]; -- we never call the BTree procedures that traffic in Records
};

NewRecordFromEntry: BTree.NewRecordFromEntry --[entry: BTree.Entry] RETURNS [record: BTree.Record]-- = UNCHECKED {
ERROR Bug[cantGetHere]; -- we never call the BTree procedures that traffic in Records
};

Bug: ERROR [type: BugType] = CODE;
BugType: TYPE = {cantGetHere};

}.
    
BTreeSimpleImpl.mesa
Copyright ╙ 1985, 1986, 1987, 1988, 1992 by Xerox Corporation.  All rights reserved.
Taft, January 21, 1984 5:00:25 pm PST
Russ Atkinson (RRA) March 11, 1985 9:48:59 pm PST
Tim Diebert: May 18, 1988 4:55:30 pm PDT
Doug Wyatt, June 3, 1987 11:13:55 am PDT
Brian Oki,  August 17, 1990 4:12 pm PDT
Willie-s, April 23, 1992 11:34 am PDT


BTree representation
key _ NEW[Rope.TextRep[entryKey.length]];
nWords is really the number of bytes to move from src to dst.  We first compute of words given the entryKey.length: adding 3 and doing integer division  by 4 does the trick.  E.g., if the length is 6, then (6+3)/4 = 2 words.  Then multiply by SIZE[BYTE], which is 4 for a sun 4.  Note that although SIZE[BYTE] = 4 here, it's wrong to multiply through and cancel out the other 4.  old comment, left for historical documentation
BTree global operations
The following should not be here because it violates abstraction.
WITH storage SELECT FROM
handle: BTreeVM.Handle => file _ handle.backing;
ENDCASE => file _ NIL;
Higher-level BTree access
Lower-level BTree access
entryKey.length м internalKey.length
         
--Body of UpdateEntry Procedure
PathStk hints
Private
The following are the procedures passed to the BTree package as the RepresentationPrimitives (in addition to the client's Compare and CompareEntries procedures).

MoveOverlapped:  PUBLIC  UNSAFE PROC [dst: POINTER, src: POINTER, nWords: CARD] =  UNCHECKED
BEGIN
WordPtr: TYPE = POINTER TO WORD;
Test to see if blocks overlap--does destination overlap with source in the direction of increasing addresses? Note that this is an unsafe operation.
IF LOOPHOLE[dst, CARD] > LOOPHOLE[src, CARD]
AND LOOPHOLE[dst, CARD] - LOOPHOLE[src, CARD] < nWords THEN {
WHILE nWords > 0 DO
nWords м nWords - 1 * SIZE[BYTE];
LOOPHOLE[dst+nWords, WordPtr]н м LOOPHOLE[src+nWords, WordPtr]н;
ENDLOOP;
RETURN
};

Destination either overlaps with source in the reverse direction, or overlaps not at all. 
We use Basics.
Basics.MoveWords[dst: dst, src: src, count: nWords/SIZE[BYTE]];
END;

Errors
 Э╩e  ХNewlineDelimiter
Ц(cedarcode) styleЩ headЩIcodeЪЬ
╧eЬIЩTLЩ%LЩ1LЩ(LЩ(LЩ'LЩ%LЩ Ъ╧k	Ш	LЪЬЮЬ	ШLЪЬЮЬШLЪЬЮЬ┌ШхLШLШLЪЮЬЮЬЮЬШLЪЬЮЬШLШ LШ ЧЧЪ╨bnЬЮЬЮШLЪЮЬ%Ш,LЪЮЬШLЪЮЬШLЪЬЮЬШLШ LЩ ЧЪЬЩЪ╧nЬЮЬЮЬЮЬШ6LЪЮЬЮЬЮ	ЬШ.ЪЮЬЮЬЮЬШLЪЬЮЬ Щ)LЪЬ%╧c$ШILШLЩкЪ	ЬЮЬЮЬЮЬЮЬШ<LЪЬЮЬ
ЮЬШ2LЪЬЮЬ$ЮЬШKЧLЪЮЬШLШЧIcode2ШLШ ЧЪаЬЮЬЮЬЮЬШ;LЪЬЮЬЮЬЮ	ЬШ+ЪЮЬЮЬЮЬШLЪЬЮЬ!Ш,ЪЬЮЬЮЬЮЬШDLЪЬЮЬЮЬЮЬШ8LЪЬб Ш;ЧLЪЮЬШLШЧLЪЬШLШ ЧЪаЬ
б?ЬЮ	ЬШeLШ Ъ	ЮЬЮЬЮЬЮЬЮШ=LЪЬЮЬШLЪЬЮЬШ$ЪЮЬ	ЮЬШLЪ
ЮЬ	ЮЬЮЬЮЬЮЬ	Ш1LЪЬШЧLЪЮЬШЧLЪЮЬЮЬЮЬШ2ЪЮЬЮЬШ&LЪЬЮЬЮЬШLЪЬЮЬЮЬ
ШLШЧLЪЬШLШ ЧЪаЬб9ЬЮ	ЬШmЪ	ЮЬЮЬЮЬЮЬ&ЮШDLЪЬЮЬШ%LЪЬЮЬШ%ЪЮЬ	ЮЬШLЪ
ЮЬЮЬЮЬЮЬЮЬ
Ш0LШЧLЪЮЬШЧLЪЮЬ%ЮЬЮЬШ9ЪЮЬЮЬ$Ш-LЪЮЬЮЬШLЪЮЬЮЬ	ШLШЧLЪЬШLШ ЧЪЬЮЬШ+LЪЬAШAЧЧЪЬЩЪаЬЮЬeЮЬШНLЪ
ЮЬЮЬ)ЮЬчЮЬЮЬ0ШТLЪЬШLШ ЧЪаЬЮЬЮЬ#Ю	ЬEЮЬЮЬЮЬЮЬЮЬШ╫LШLШБLШ ЪЬ0Ш0LЪЬNШNЧLЪЬШLШ ЧЪаЬЮЬ2ШGLШLЪЬШLШ ЧЪаЬЮЬЮЬЮЬЮЬ)ЮЬШ|LШLШuLЩAЪЮЬ	ЮЬЮЩLЩ0LЪЮЬЮЬЩЧLЪЬШLШ ЧЪ
аЬЮЬЮЬЮЬAЮЬШyLЪЬШLЪЬШLЪЬЮЬШ)LШLЪЮЬeШkLЪЬШLШ ЧЪаЬЮЬШ&LШLЪЬШLШ ЧЪаЬЮЬ ЮЬШLLЪЬ+Ш+LЪЬШЧЧЪЬЩЪа
ЬЮЬЮЬGЮЬЮЬЮЬЮЬ*ЮЬШ┐Ъа	ЬЮЬЮЬ&Ю	ЬШGLЪ
ЮЬЮЬЮЬЮЬЮЬШ4LЪЮЬFШJLЪЬШЧLШLЪЬyШyLЪЮЬШ LЪЬШLШ ЧЪа	ЬЮЬGЮЬЮЬЮЬЮЬЮЬШжЪа	ЬЮЬЮЬ&Ю	ЬШGLЪЬЮЬЮЬЮЬЮЬЮЬШALЪЬШЧLШLЪЬyШyLЪЮЬШLЪЬШLШ ЧЪаЬЮЬGЮЬЮЬЮЬЮЬ"ЮЬЮЬЮЬЮЬЮЬШ№Ъа	ЬЮЬЮЬ$ЮЬЮЬЮ	ЬШcLЪЮЬ@ШFЧLШxLЪЬШLШ ЧЪаЬЮЬ9ЮЬЮЬЮЬ.ЮЬШоЪаЬЮЬЮЬЮ	ЬШ<ЪЬЮЬШ&LЪЬЮЬШLЪЬЮЬ%Ш2LЪЬШЧLЪЬШЧLЪЬЮЬЮЬЮЬШ8LЪЬжШжLЪЬШLШ ЧЪа	ЬЮЬ+ЮЬЮЬЮЬЮЬ	ЮЬШДLШ_LЪЮЬШLЪЬШЧЧЪЬЩЪа	ЬЮЬЮЬЮЬGЮЬЮЬЮЬЮЬЮЬ'Ю	ЬШ╬Ъа	ЬЮЬЮЬЮ	ЬШ9LЪ
ЮЬЮЬЮЬЮЬЮЬШ ЪЮЬШLЪЬЮЬШ/LЪЬЮЬЮЬ"Ш;LЪЬ"Ш"LШЧLЪЬШЧLЪЬ|Ш|LЪЬШLШ ЧЪаЬЮЬЮЬGЮЬЮЬЮЬЮЬЮЬ$ЮЬЮЬЮЬЮЬЮ	ЬШОЪа	ЬЮЬЮЬЮЬЮЬЮ	ЬШULЪЬЮЬШ/LЪЬЮЬЮЬ"Ш;LЪЮЬ$Ш*LЪЬШЧLШПLЪЬШLШ ЧЪаЬЮЬЮЬ+ЮЬЮЬЮЬЮЬЮЬЮЬBЮ	ЬШтЪа	ЬЮЬЮЬЮ	ЬШ9LЪЬШLЪЬШLЪЬЮЬШLЪЬЮЬШ*LШ ЪЮЬЮЬЮЬЮЬШ:LЩ$ЧLЪЬЮЬ
ЮЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬШ░LЪЬ	Щ	LШЪЮЬЮЬЮЬЮЬШ6LЪбЬбШ"ЧLЪЬШЧLШ LЩLШ)LЪЬЮЬЮЬ%Ш>LЪЬЮЬЮЬШ7LЪЬЮЬ"Ш:LШ LЪЬЫШЫLЪЬШLШ ЧЪаЬЮЬЮЬЮЬЮЬ$ЮЬЮЬЮЬЮЬЮ	ЬШмЪа	ЬЮЬЮЬЮЬЮЬЮ	ЬШULЪЮЬ"ЮЬЮЬШRЧLШ1LЪЬШЧЧЪЬЩЪа
ЬЮЬЮЬШ6LЪЮЬШLЪЬШЧЧЩLЩбLЩ Ъа	Ьб7ЬЮ	ЬШ`LЪЬЮЬШLЪЬЮЬШLЪЬЮЬШLЪЬЮЬШLШ LЪЬЮЬШ4LЪЬЮЬ#Ш6LЪЬЮЬ(ШFLЪЬЮЬ#Ш9LШ'LЪЬШLШ ЧЪаЬб╨ckбЬЮ	ЬШlLЪЮЬб=ШULЪЬШLШ ЧЪаЬбвбЬЮ	ЬШrLЪЮЬб=ШULЪЬШLШ ЧЪаЬЮЬЮЬЮЬЮЬЮЬ
ЮЬЮ	Щ\ЪЮЩLЪ	Ь	ЮЬЮЬЮЬЮЬЩ LЪ╨ci╧i8г=ЩФЪЮЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬЩjЪЮЬЮЩMЪЬЮЬЮЬЩ!MЪЮЬЮЬЩ@MЪЮЬЩЧMЪЮЩMЪЬЩMЩ ЧMЪгZЩZMЪЬЩMЪЬ3ЮЬЮЬЩ?MЪЮЬЩMЩ ЧЧЧЩLЪЬЮЬЮЬШ"LЪЬ	ЮЬШLШ LЪЬШЧЧ ЕЧ    )║  >1  