DIRECTORY
Alloc USING [AddNotify, Bounds, DropNotify, Failure, Handle, Notifier, OrderedIndex, Top, Units],
Basics USING [HighHalf, LowHalf],
ConvertUnsafe USING [EqualSubStrings, SubString],
Host: TYPE MachineParms USING [bitsPerLongWord],
LiteralOps USING [],
Literals,
MimZonePort,
MimZones USING [RegisterForReset, permZone, tempUZ],
SymbolOps USING [DecodeCard],
Symbols USING [Type, UNSPEC],
Target: TYPE MachineParms USING [bitsPerByte, bitsPerLongWord];
LiteralOpsImpl: PROGRAM
IMPORTS Alloc, Basics, ConvertUnsafe, MimZonePort, MimZones, SymbolOps
EXPORTS LiteralOps = {
OPEN Literals, Target;

UNSPEC: TYPE = Symbols.UNSPEC;

table: Alloc.Handle м NIL;

ltb: Literals.Base м NIL;	-- literal table base
stb: Literals.Base м NIL;	-- string table base

UpdateBases: Alloc.Notifier = {
ltb м base[ltType];
stb м base[stType];
};

ltbZoneScratch: MimZonePort.Scratch;
ltbZone: UNCOUNTED ZONE м MimZonePort.MakeZone[
alloc: LtbZoneProc, free: NIL, scratch: @ltbZoneScratch];
LtbZoneProc: PROC
[self: UNCOUNTED ZONE, size: CARDINAL] RETURNS [ptr: LONG POINTER] = {
index: Alloc.OrderedIndex = table.Units[ltType, size];
IF index > ltMax THEN ERROR table.Failure[ltType];
ptr м @ltb[index];
};
LTBRelative: PROC [ptr: LONG POINTER TO LTRecord] RETURNS [LTIndex] = INLINE {
RETURN [LOOPHOLE[ptr-LOOPHOLE[ltb, LONG POINTER TO LTRecord]]];
};

stbZoneScratch: MimZonePort.Scratch;
stbZone: UNCOUNTED ZONE м MimZonePort.MakeZone[
alloc: StbZoneProc, free: NIL, scratch: @stbZoneScratch];
StbZoneProc: PROC
[self: UNCOUNTED ZONE, size: CARDINAL] RETURNS [ptr: LONG POINTER] = {
index: Alloc.OrderedIndex = table.Units[stType, size];
IF index > stMax THEN ERROR table.Failure[stType];
stLimit м stLimit + size;
ptr м @stb[index];
};
STBRelative: PROC [ptr: LONG POINTER TO STRecord] RETURNS [STIndex] = INLINE {
RETURN [LOOPHOLE[ptr-LOOPHOLE[stb, LONG POINTER TO STRecord]]];
};

RoundUpBytes: PROC [bytes: CARDINAL] RETURNS [CARDINAL] = INLINE {
bytesPerLongWord: CARDINAL = bitsPerLongWord/bitsPerByte;
mod: CARDINAL = bytes MOD bytesPerLongWord;
IF mod # 0 THEN bytes м bytes + (bytesPerLongWord-mod);
RETURN [bytes];
};

ltMax: Alloc.OrderedIndex = LOOPHOLE[LTLast];
stMax: Alloc.OrderedIndex = LOOPHOLE[STLast];
bitsPerHostUnspec: NAT = BITS[UNSPEC];
checkThisOut: [Host.bitsPerLongWord..Host.bitsPerLongWord] = bitsPerHostUnspec;
bytesPerLongWord: NAT = Target.bitsPerLongWord/Target.bitsPerByte;

initialized: BOOL м FALSE;

Initialize: PUBLIC PROC [ownTable: Alloc.Handle] = { 
IF initialized THEN Finalize[];
table м ownTable;
table.AddNotify[UpdateBases];
[] м ForgetEntries[];
stLimit м localStart м STFirst;
locals м markBit м FALSE;
initialized м TRUE;
};

Finalize: PUBLIC PROC = {
IF table # NIL THEN {table.DropNotify[UpdateBases]; table м NIL};
initialized м FALSE;
};

ClassError: PUBLIC ERROR = CODE;


litHVLength: INTEGER = 53;
LitHVIndex: TYPE = [0..litHVLength);

hashVec: REF ARRAY LitHVIndex OF LTIndex
м MimZones.permZone.NEW[ARRAY LitHVIndex OF LTIndex];

IsShort: PUBLIC PROC [lti: LTIndex] RETURNS [BOOL] = {
WITH entry: ltb[lti] SELECT FROM
short => RETURN [TRUE];
ENDCASE => RETURN [FALSE];
};

Find: PUBLIC PROC [class: LitClass, val: UNSPEC] RETURNS [lti: LTIndex] = {
hvi: LitHVIndex = Basics.LowHalf[SymbolOps.DecodeCard[val]] MOD litHVLength;
FOR lti м hashVec[hvi], ltb[lti].link UNTIL lti = LTNull DO
WITH entry: ltb[lti] SELECT FROM
short => IF entry.value = val AND entry.class = class THEN RETURN [lti];
ENDCASE;
ENDLOOP;
hashVec[hvi] м lti м LTBRelative[ltbZone.NEW[LTRecord.short
м [link: hashVec[hvi], class: class, datum: short[value: val]]]];
};

FindMultiWord: PROC [baseP: Literals.Finger, desc: LitDescriptor] RETURNS [lti: LTIndex] = {
bits: INT = desc.bits;
words: NAT = (bits + bitsPerHostUnspec - 1) / bitsPerHostUnspec;
v: CARD м bits;
hvi: LitHVIndex;
FOR i: CARDINAL IN [0..words) DO
v м v + Basics.HighHalf[v] + i + SymbolOps.DecodeCard[basePн[desc.offset][i]];
ENDLOOP;
hvi м Basics.LowHalf[v] MOD litHVLength;
FOR lti м hashVec[hvi], ltb[lti].link UNTIL lti = LTNull DO
WITH entry: ltb[lti] SELECT FROM
long =>
IF bits = entry.bits THEN
FOR i: CARDINAL IN [0 .. words) DO
IF entry.value[i] # basePн[desc.offset][i] THEN EXIT;
REPEAT
FINISHED => GO TO found;
ENDLOOP;
ENDCASE;
REPEAT
found => NULL;
FINISHED => {
ptr: LONG POINTER TO LTRecord.long м ltbZone.NEW[LTRecord.long[words]];
ptr.link м hashVec[hvi];
ptr.bits м bits;
ptr.class м desc.class;
hashVec[hvi] м lti м LTBRelative[ptr];
FOR i: CARDINAL IN [0 .. words) DO
ptr[i] м basePн[desc.offset][i];
ENDLOOP;
};
ENDLOOP;
RETURN [lti];
};

Value: PUBLIC PROC [lti: LTIndex] RETURNS [class: LitClass, val: UNSPEC] = {
WITH entry: ltb[lti] SELECT FROM
short => RETURN [entry.class, entry.value];
ENDCASE;
ERROR;
};

FindDescriptor: PUBLIC PROC [bits: INT, ptr: WordSequencePtr] RETURNS [LTIndex] = {
desc: LitDescriptor м [bits: bits, class: bits, words: 0, offset: LOOPHOLE[(0).LONG]];
base: Literals.Base м LOOPHOLE[ptr];
RETURN [FindMultiWord[@base, desc]];
};

deltaShort: CARDINAL = LTRecord.short.SIZE - Symbols.UNSPEC.SIZE;
deltaLong: CARDINAL = SIZE[LTRecord.long[0]];

DescriptorValue: PUBLIC PROC [lti: LTIndex] RETURNS [LitDescriptor] = {
WITH entry: ltb[lti] SELECT FROM
short => RETURN [[class: entry.class, offset: LOOPHOLE[lti + deltaShort],
bits: bitsPerHostUnspec, words: 1]];
long => RETURN [[class: entry.class, offset: LOOPHOLE[lti + deltaLong],
bits: entry.bits, words: entry.max]];
ENDCASE => ERROR;
};

CopyLiteral: PUBLIC PROC [literal: LTId] RETURNS [lti: LTIndex] = {
desc: LitDescriptor;
WITH entry: literal.basePн[literal.index] SELECT FROM
short => lti м Find[entry.class, entry.value];
long => {
desc м [class: bits, offset: LOOPHOLE[literal.index + deltaLong],
bits: entry.bits, words: 0];
lti м FindMultiWord[literal.baseP, desc];
};
ENDCASE => ERROR;
};

ForgetEntries: PUBLIC PROC RETURNS [ltBias: CARD, stBias: CARD] = {
hashVecн м ALL[LTNull];
sHashVecн м ALL[MSTNull];
RETURN [table.Bounds[ltType].size, table.Bounds[stType].size];
};


MSTNull: MSTIndex = LOOPHOLE[STNull];
SLitHVLength: INTEGER = 23;
SLitHVIndex: TYPE = [0..SLitHVLength);

sHashVec: REF ARRAY SLitHVIndex OF MSTIndex
м MimZones.permZone.NEW[ARRAY SLitHVIndex OF MSTIndex];

stLimit: STIndex м STNull;
localStart: STIndex м STNull;
locals: BOOL м FALSE;
markBit: BOOL м FALSE;

sizeSTPrefix: NAT = STRecord.master.SIZE - StringBody[0].SIZE;

CopyStringLiteral: PUBLIC PROC [baseP: Literals.Finger, index: Literals.STIndex]
RETURNS [sti: Literals.STIndex м STNull] = {
DO
ptr: LONG POINTER TO Literals.STRecord м @basePн[index];
WITH s: ptrн SELECT FROM
master => {
scratchLen: NAT = 80;
scratch: STRING м [scratchLen];
len: NAT = s.length;
new: LONG STRING м scratch;
IF len > scratchLen THEN new м MimZones.tempUZ.NEW[StringBody[len]];
FOR i: NAT IN [0..len) DO
new[i] м s[i];
ENDLOOP;
new.length м len;
sti м FindString[[new, 0, len]];
IF len > scratchLen THEN MimZones.tempUZ.FREE[@new];
EXIT;
};
copy => index м s.link;
heap => index м s.link;
ENDCASE => EXIT;
ENDLOOP;
};

FindString: PUBLIC PROC [s: ConvertUnsafe.SubString] RETURNS [sti: STIndex] = {
hash: WORD м 0;
hvi: SLitHVIndex;
FOR i: CARDINAL IN [s.offset .. s.offset+s.length) DO
hash м hash + i + LOOPHOLE[s.base[i], CARDINAL];
ENDLOOP;
hvi м hash MOD SLitHVLength;
FOR sti м sHashVec[hvi], stb[sti].link UNTIL sti = MSTNull DO
v: LONG STRING = StringValue[sti];
vs: ConvertUnsafe.SubString м [base: v, offset: 0, length: v.length];
IF s.EqualSubStrings[vs] THEN EXIT;
REPEAT
FINISHED => {
len: CARDINAL = s.length;
max: CARDINAL = RoundUpBytes[len];
ptr: LONG POINTER TO STRecord.master м stbZone.NEW[STRecord.master[max]];
ptr.info м 0;
ptr.codeIndex м 0;
ptr.local м FALSE;
ptr.link м sHashVec[hvi];
ptr.length м len;
FOR i: CARDINAL IN [0 .. len) DO
ptr[i] м s.base[s.offset+i];
ENDLOOP;
FOR i: CARDINAL IN [len .. max) DO
ptr[i] м '\000;
ENDLOOP;
sHashVec[hvi] м LOOPHOLE[sti м STBRelative[ptr]];
};
ENDLOOP;
RETURN [sti];
};

MasterString: PUBLIC PROC [sti: STIndex] RETURNS [MSTIndex] = {
RETURN [WITH s: stb[sti] SELECT FROM
master => LOOPHOLE[sti],
copy => s.link,
heap => s.link,
ENDCASE => MSTNull];
};

StringReference: PUBLIC PROC [sti: STIndex] = {
WITH s: stb[sti] SELECT FROM
master => s.info м s.info + 1;
ENDCASE;
};

StringValue: PUBLIC PROC [sti: STIndex] RETURNS [LONG STRING] = {
ptr: LONG POINTER TO STRecord.master = @stb[MasterString[sti]];
RETURN [LOOPHOLE[ptr + SIZE[STRecord.master[0]] - SIZE[StringBody[0]]]];
};

TextType: PUBLIC PROC [sti: STIndex] RETURNS [Symbols.Type] = {
RETURN [WITH s: stb[sti] SELECT FROM heap => s.type, ENDCASE => ERROR];
};

ResetLocalStrings: PUBLIC PROC RETURNS [key: STIndex] = {
IF ~locals THEN key м STNull ELSE {key м localStart; markBit м ~markBit};
locals м FALSE;
localStart м table.Top[stType];
};

FindHeapString: PUBLIC PROC [key: STIndex, type: Symbols.Type] RETURNS [sti: STIndex] = {
master: MSTIndex = MasterString[key];
FOR sti м localStart, sti UNTIL sti = stLimit DO
WITH s: stb[sti] SELECT FROM
master => sti м sti + STRecord.master[s.maxLength].SIZE;
copy => sti м sti + STRecord.copy.SIZE;
heap => {
IF s.type = type AND s.link = master THEN RETURN;
sti м sti + STRecord.heap.SIZE;
};
ENDCASE;
ENDLOOP;
sti м STBRelative[stbZone.NEW[STRecord.heap
м [link: master, cases: heap[type: type, info: 0]]]];
};

FindLocalString: PUBLIC PROC [key: STIndex] RETURNS [sti: STIndex] = {
master: MSTIndex = MasterString[key];
FOR sti м localStart, sti UNTIL sti = stLimit DO
WITH s: stb[sti] SELECT FROM
master => sti м sti + STRecord.master[s.maxLength].SIZE;
copy => {
IF s.link = master THEN RETURN;
sti м sti + STRecord.copy.SIZE;
};
heap => sti м sti + STRecord.heap.SIZE;
ENDCASE => ERROR;
REPEAT
FINISHED => {
sti м STBRelative[stbZone.NEW[STRecord.copy
м [link: master, cases: copy[mark: markBit]]]];
locals м TRUE;
};
ENDLOOP;
};

MimZones.RegisterForReset[Finalize];
}.

   d  
LiteralOpsImpl.mesa
Copyright ╙ 1985, 1986, 1988, 1991 by Xerox Corporation.  All rights reserved.
Satterthwaite, June 19, 1986 9:45:28 am PDT
Russ Atkinson (RRA) June 21, 1989 11:50:46 am PDT
JKF August 16, 1988 12:44:27 pm PDT
Willie-s, September 24, 1991 1:45 pm PDT

called whenever the main symbol table is repacked
called to set up the compiler's literal table 
literal table management
Don't trust the # of words coming in.
Try to get a good hash value
string literal table management
EnumerateHeapStrings: PUBLIC PROC [proc: PROC [STIndex]] = {
sti: STIndex _ STFirst;
WHILE sti # stLimit DO
WITH s: stb[sti] SELECT FROM
master => sti _ sti + STRecord.master[s.maxLength].SIZE;
copy => sti _ sti + STRecord.copy.SIZE;
heap => {proc[sti]; sti _ sti + STRecord.heap.SIZE};
ENDCASE => ERROR;
ENDLOOP;
};

EnumerateLocalStrings: PUBLIC PROC [key: STIndex, proc: PROC [MSTIndex]] = {
sti: STIndex _ STFirst;
started, mark: BOOL;
IF key = STNull THEN RETURN;
started _ FALSE;
WHILE sti # stLimit DO
WITH s: stb[sti] SELECT FROM
master => sti _ sti + STRecord.master[s.maxLength].SIZE;
copy => {
IF ~started THEN {mark _ s.mark; started _ TRUE};
IF s.mark # mark THEN EXIT;
proc[s.link];
sti _ sti + STRecord.copy.SIZE;
};
heap => sti _ sti + STRecord.heap.SIZE;
ENDCASE => ERROR;
ENDLOOP;
};

EnumerateMasterStrings: PUBLIC PROC [proc: PROC [MSTIndex]] = {
sti: STIndex _ STFirst;
WHILE sti # stLimit DO
WITH s: stb[sti] SELECT FROM
master => {
proc[LOOPHOLE[sti]];
sti _ sti + STRecord.master[s.maxLength].SIZE;
};
copy => sti _ sti + STRecord.copy.SIZE;
heap => sti _ sti + STRecord.heap.SIZE;
ENDCASE => ERROR;
ENDLOOP;
};

Э╩'  Ц(cedarcode) styleХNewlineDelimiter
Щ codeЪЬЩKЪЬ
╧eЬCЩNKЪ╧y+Щ+KЩ1KЩ#KЩ(KЩ Ъ╧k	Ш	KЪЬЯЬVШaKЪЬЯЬШ!KЪЬЯЬШ1KЪЬЯЬЯЬШ0KЪЬЯЬШKЪЬ	Ш	KЪЬШKЪЬ	ЯЬ&Ш4KЪЬ
ЯЬШKЪЬЯЬЯЬШKЪЬЯЬЯЬ Ш?ЧЧheadЪ╧nЬЯШKЪЯЬ?ШFKЪЯЬШKЪЯЬШKШ KЪЯЬЯЬЯЬШKШ KЪЬЯЬШKШ KЪЬЯЬ╧cШ/KЪЬЯЬбШ.KШ ЪаЬШKЪЬ1Щ1KЪЬШKЪЬШKЪЬШKШ ЧKЪЬ$Ш$KЪЬ	Я	ЬЯЬ3ЯЬШiЪаЬЯЬЯ	ЬЯЬЯЬЯЬЯЬЯЬШXKЪЬ6Ш6KЪЯЬЯЬЯЬШ2KЪЬШKШЧЪаЬЯЬЯЬЯЬЯЬЯЬЯЬШNKЪЯЬЯЬЯЬЯЬЯЬЯЬШ?KШKШ ЧKЪЬ$Ш$KЪЬ	Я	ЬЯЬ3ЯЬШiЪаЬЯЬЯ	ЬЯЬЯЬЯЬЯЬЯЬШXKЪЬ6Ш6KЪЯЬЯЬЯЬШ2KЪЬШKЪЬШKШЧЪаЬЯЬЯЬЯЬЯЬЯЬЯЬШNKЪЯЬЯЬЯЬЯЬЯЬЯЬШ?KШKШ ЧЪаЬЯЬ	ЯЬЯЬЯЬЯЬШBKЪЬЯЬШ9KЪЬЯЬ	ЯЬШ+KЪЯЬ	ЯЬ(Ш7KЪЯЬ	ШKШKШ ЧKЪЬЯЬ	Ш-KЪЬЯЬ	Ш-ЪЬЯЬЯЬЯЬШ&KЪЬOШOЧKЪЬЯЬ-ШBKШ KЪЬЯЬЯЬШKШ Ъа
ЬЯЬЯЬШ5KЪЬ.Щ.KЪЯЬЯЬШKШKШKЪЬШKЪЬШKЪЬЯЬШKЪЬЯЬШKЪЬШKШ ЧЪаЬЯЬЯЬШKЪЯЬ	ЯЬЯЬ)ЯЬШAKЪЬЯЬШKЪЬШKШ ЧЪа
ЬЯЬЯЬЯЬШ KШ ЧЧKЪЬЩШ KЪЬЯЬШKЪЬЯЬШ$KШ KЪЬ	ЯЬЯЬЯЬЯЬЯЬЯЬ
Ш^KШ Ъ
аЬЯЬЯЬЯЬЯЬШ6ЪЯЬЯЬЯШ KЪЬ	ЯЬЯЬШKЪЯЬЯЬЯЬШЧKЪЬШKШ ЧЪ
аЬЯЬЯЬЯЬЯЬШKKЪЬ<ЯЬШLЪЯЬ#ЯЬЯШ;ЪЯЬЯЬЯШ KЪ	Ь	ЯЬЯЬЯЬЯЬШHKЪЯЬШЧKЪЯЬШЧKЪЬ)ЯЬQШ}KЪЬШKШ ЧЪаЬЯЬ.ЯЬШ\KЪЬЯЬШЪЬЯЬ6Ш@KЩ%ЧKЪЬЯЬШKШЪЯЬЯЬЯЬЯШ KЩKЪЬNШNKЪЯЬШЧKЪЬЯЬШ(ЪЯЬ#ЯЬЯШ;ЪЯЬЯЬЯШ ШЪЯЬЯШЪЯЬЯЬЯЬЯШ"KЪЯЬ)ЯЬЯЬШ5ЪЯШKЪЯЬЯЬЯЬШЧKЪЯЬШЧЧЧKЪЯЬШЧЪЯШKЪЬ	ЯЬШЪЯЬШKЪ	ЬЯЬЯЬЯЬЯЬШGKЪЬШKЪЬШKШKШ&ЪЯЬЯЬЯЬЯШ"KЪЬ Ш KЪЯЬШЧKШЧЧKЪЯЬШЧKЪЯЬШKЪЬШKШ ЧЪ
аЬЯЬЯЬЯЬЯЬШLЪЯЬЯЬЯШ KЪЬ	ЯЬШ+KЪЯЬШЧKЪЯЬШKЪЬШKШ ЧЪ
аЬЯЬЯЬЯЬЯЬШSKЪЬBЯЬЯЬШVKЪЬЯЬШ$KЪЯЬШ$ЪЬШKШ ЧЧKЪ	ЬЯЬЯЬЯЬЯЬШAKЪЬЯЬЯЬШ-KШ ЪаЬЯЬЯЬЯЬШGЪЯЬЯЬЯШ KЪЬ	ЯЬЯЬ8ШnKЪЬЯЬЯЬ8ШmKЪЯЬЯЬШЧЪЬШKШ ЧЧЪаЬЯЬЯЬЯЬШCKШЪЯЬ&ЯЬЯШ5KШ.Ш	KЪЬЯЬ9Ш^KШ)KШЧKЪЯЬЯЬШЧKЪЬШKШ ЧЪаЬЯЬЯЬЯЬ
ЯЬ
ЯЬШCKЪЬЯЬ	ШKЪЬЯЬ
ШKЪЯЬ8Ш>KЪЬШKШ ЧЧKЪЬЩШ KЪЬЯЬ	Ш%KЪЬЯЬШKЪЬЯЬШ&KШ KЪЬ
ЯЬЯЬЯЬЯЬЯЬЯЬШcKШ KШKШKЪЬЯЬЯЬШKЪЬ	ЯЬЯЬШKШ KЪЬЯЬЯЬЯЬШ>KШ ЪаЬЯЬЯЬ3ЯЬ%Ш}ЪЯШKЪЬЯЬЯЬЯЬ$Ш8ЪЯЬ	ЯЬЯШЪЬШKЪЬЯЬШKЪЬ	ЯЬШKЪЬЯЬШKЪЬЯЬЯЬШKЪЯЬЯЬЯЬШDЪЯЬЯЬЯЬ
ЯШKЪЬШKЪЯЬШЧKШKЪЬ Ш KЪЯЬЯЬЯЬШ4KЪЯЬШKШЧKЪЬШKЪЬШKЪЯЬЯЬШЧKЪЯЬШЧKЪЬШKШ ЧЪа
ЬЯЬЯЬЯЬШOKЪЬЯЬШKШЪЯЬЯЬЯЬ!ЯШ5KЪЬЯЬЯЬШ0KЪЯЬШЧKЪЬЯЬШЪЯЬ$ЯЬЯШ=KЪЬЯЬЯЬШ"KЪЬEШEKЪЯЬЯЬЯЬШ#ЪЯШЪЯЬШKЪЬЯЬШKЪЬЯЬШ"KЪ	ЬЯЬЯЬЯЬЯЬШIKЪЬШKЪЬШKЪЬЯЬШKЪЬШKЪЬШЪЯЬЯЬЯЬЯШ KЪЬШKЪЯЬШЧЪЯЬЯЬЯЬЯШ"KЪЬШKЪЯЬШЧKЪЬЯЬШ1KШЧЧKЪЯЬШЧKЪЯЬШKЪЬШKШ ЧЪаЬЯЬЯЬЯЬШ?ЪЯЬЯЬЯЬЯШ$KЪЬ
ЯЬШKШKШKЪЯЬШЧЪЬШKШ ЧЧЪаЬЯЬЯЬШ/ЪЯЬЯЬЯШKШKЪЯЬШЧЪЬШKШ ЧЧЪаЬЯЬЯЬЯЬЯЬЯЬШAKЪЬЯЬЯЬЯЬ+Ш?KЪЯЬЯЬЯЬЯЬШHKЪЬШKШ ЧЪаЬЯЬЯЬЯЬШ?KЪЯЬЯЬЯЬЯЬЯЬЯЬШGKЪЬШKШ ЧЪаЬЯЬЯЬШ9KЪЯЬ	ЯЬЯЬ(ШIKЪЬ	ЯЬШKЪЬШKЪЬШKШ ЧЪаЬЯЬЯЬ$ЯЬШYKШ%ЪЯЬЯЬЯШ0ЪЯЬЯЬЯШKЪЬ3ЯЬШ8KЪЬ"ЯЬШ'Ш	KЪЯЬЯЬЯЬЯЬШ1KЪЬЯЬШKЪЬШЧKЪЯЬШЧKЪЯЬШЧKЪЬЯЬDШaKЪЬШKШ ЧЪаЬЯЬЯЬЯЬШFKШ%ЪЯЬЯЬЯШ0ЪЯЬЯЬЯШKЪЬ3ЯЬШ8Ш	KЪЯЬЯЬЯЬШKЪЬЯЬШKЪЬШЧKЪЬ"ЯЬШ'KЪЯЬЯЬШЧЪЯШЪЯЬШKЪЬЯЬ>Ш[KЪЬ	ЯЬШKЪЬШЧЧKЪЯЬШЧKЪЬШKШ ЧЪаЬЯЬЯЬЯЬЩ<KЪЬЩЪЯЬЯЩЪЯЬЯЬЯЩKЪЬ3ЯЬЩ8KЪЬ"ЯЬЩ'KЪЬ.ЯЬЩ4KЪЯЬЯЬЩЧKЪЯЬЩЧKЪЬЩKЩ ЧЪаЬЯЬЯЬЯЬЩLKЪЬЩKЪЬЯЬЩKЪЯЬЯЬЯЬЩKЪЬ
ЯЬЩЪЯЬЯЩЪЯЬЯЬЯЩKЪЬ3ЯЬЩ8ЪЬ	Щ	KЪЯЬ
ЯЬЯЬЩ1KЪЯЬЯЬЯЬЩKЩKЪЬЯЬЩKЩЧKЪЬ"ЯЬЩ'KЪЯЬЯЬЩЧKЪЯЬЩЧЪЬЩKЩ ЧЧЪаЬЯЬЯЬЯЬЩ?KЪЬЩЪЯЬЯЩЪЯЬЯЬЯЩЪЬЩKЪЬЯЬЩKЪЬ)ЯЬЩ.KЩЧKЪЬ"ЯЬЩ'KЪЬ"ЯЬЩ'KЪЯЬЯЬЩЧKЪЯЬЩЧЪЬЩKЩ ЧЧЧKЪЬ$Ш$ШKШ ЧЧ ЕЧ    &h  <є  