DIRECTORY
Atom, Customize, CustomizeExtras, <<PFS,>> IO, PreDebug, Rope, SymTab;

CustomizeImpl: CEDAR MONITOR 
IMPORTS Atom, <<PFS,>> IO, PreDebug, Rope, SymTab 
EXPORTS Customize, CustomizeExtras = 
BEGIN OPEN Customize;

ROPE: TYPE = Rope.ROPE;
STREAM: TYPE = IO.STREAM;
error: ERROR = CODE;
Error: PROC [] = {ERROR error};

DB: TYPE = REF DBRec;
DBreadonly: TYPE = REF READONLY DBRec;
DBRec: PUBLIC TYPE = RECORD [
value: REF м NIL, 
identifier: SymTab.Ref м NIL, -- contains following identifiers
wildN: DB м NIL, 
wild1: DB м NIL 
];

CopyDB: PUBLIC PROC [source: DBreadonly] RETURNS [copy: DB] = {
copy м CreateDB[];
MergeDB[copy, source, FALSE];
RETURN;
};

MergeDB: PUBLIC PROC [into: DB, from: DBreadonly, overwrite: BOOL] = {
IF from.value#NIL THEN {
IF overwrite OR into.value=NIL THEN into.value м from.value;
};
IF from.wildN#NIL THEN {
IF into.wildN=NIL THEN into.wildN м CreateDB[];
MergeDB[into.wildN, from.wildN, overwrite];
};
IF from.wild1#NIL THEN {
IF into.wild1=NIL THEN into.wild1 м CreateDB[];
MergeDB[into.wild1, from.wild1, overwrite];
};
IF from.identifier#NIL THEN {
MergeOneEntry: SymTab.EachPairAction = {
WITH val SELECT FROM
fromChild: DB => {
Update: SymTab.UpdateAction = {
IF found
THEN {
WITH val SELECT FROM
intoChild: DB => {
MergeDB[intoChild, fromChild, overwrite];
op м none;
};
ENDCASE => {}
}
ELSE {
newChild: DB м CreateDB[];
MergeDB[newChild, fromChild, overwrite];
op м store; new м newChild;
};
};
SymTab.Update[into.identifier, key, Update]
}
ENDCASE => {};
};
IF into.identifier=NIL THEN 
into.identifier м SymTab.Create[SymTab.GetSize[from.identifier]+1];
[] м SymTab.Pairs[from.identifier, MergeOneEntry];
};
};

freeQuery: Query м NIL;
FreeQuery: PUBLIC PROC [query: Query] = {
old: Query м freeQuery;
IF old=NIL OR old.count<query.count THEN freeQuery м query;
};

INewQuery: ENTRY PROC [reserve: NAT] RETURNS [Query] = {
query: Query м freeQuery; 
IF query#NIL AND query.count>reserve THEN {freeQuery м NIL; RETURN [query]};
query м NEW[QueryRec[reserve+1]];
RETURN [query];
};

Token: TYPE = RECORD [
type: {name, dot, wildN, wild1, colon, bang, error, eof, leftParen, rightParen, verticalbar},
data: Rope.ROPE м NIL --scanned name 
];

Break: IO.BreakProc = {
RETURN[SELECT char FROM
IN ['A..'Z], IN ['a..'z], IN ['0..'9], '-, '_ => other
ENDCASE => sepr]
};

GetToken: PROC [stream: STREAM, buffer: REF TEXT м NIL] RETURNS [t: Token] = {
c: CHAR;
IF IO.EndOf[stream] THEN {t.type м eof; RETURN};
[] м IO.SkipWhitespace[stream];
IF IO.EndOf[stream] THEN {t.type м eof; RETURN};
SELECT c м IO.GetChar[stream] FROM
IN ['A..'Z], IN ['a..'z], IN ['0..'9], '-, '_ => { 
rt: REF TEXT;
IO.Backup[stream, c];
rt м IO.GetToken[stream, Break, buffer].token;
t.type м name;
t.data м Rope.FromRefText[rt];
};
'.  => t.type м dot;
'* => t.type м wildN;
':  => t.type м colon;
'!  => t.type м bang;
'(  => t.type м leftParen;
')  => t.type м rightParen;
'|  => t.type м verticalbar;
'?  => t.type м wild1;
ENDCASE => {t.type м error; t.data м NIL};
};

emptyRope: ROPE м "";
ScanValue: PROC [stream: STREAM] RETURNS [val: ROPE м emptyRope] = {
IF IO.EndOf[stream] THEN RETURN;
[] м IO.SkipWhitespace[stream];
IF ~IO.EndOf[stream] THEN {
value: ROPE м IO.GetLineRope[stream];
IF value=NIL THEN value м emptyRope;
RETURN [value];
};
};

SkipLine: PROC [stream: STREAM] = {
c: CHAR;
WHILE ~IO.EndOf[stream] DO
SELECT c м IO.GetChar[stream] FROM
IO.CR, IO.LF => RETURN[];
ENDCASE => NULL;
ENDLOOP;
};


Parse: PROC [db: DB, stream: IO.STREAM, expliciteValue: REF м NIL] RETURNS [errors: ROPE м NIL] = {
newEntry: BOOL м TRUE;
token: Token;
buffer: REF TEXT м NEW[TEXT[64]];
currentRDB: DB м NIL;

AddId: PROC [id: Rope.ROPE] = {
action: SymTab.UpdateAction = {
WITH val SELECT FROM
db: DB => currentRDB м db;
ENDCASE => {
currentRDB м CreateDB[];
RETURN [store, currentRDB];
};
};
IF currentRDB.identifier=NIL THEN currentRDB.identifier м SymTab.Create[3];
SymTab.Update[currentRDB.identifier, id, action];
};

FinishEntry: PROC [ignore: BOOL м FALSE] = {
val: REF м ScanValue[stream];
IF expliciteValue#NIL THEN val м expliciteValue;
currentRDB.value м val; 
};

ParseError: PROC [message: ROPE] = {
pos: INT м IO.GetIndex[stream];
errors м IO.PutFR["%g %g at pos %g\n", IO.rope[errors], IO.rope[message], IO.int[pos]];
SkipLine[stream];
newEntry м TRUE;
};

wasWildN: BOOL; --hack to optimize adjacent wildcards
WHILE TRUE DO
IF newEntry THEN {
currentRDB м db; 
newEntry м FALSE;
wasWildN м FALSE;
};
token м GetToken[stream, buffer];
SELECT token.type FROM
name => {AddId[token.data]; wasWildN м FALSE};
dot => {--ignore dots; they are separators...--}; 
colon => {FinishEntry[]; newEntry м TRUE}; 
wildN => {
IF wasWildN THEN LOOP;
wasWildN м TRUE;
IF currentRDB.wildN=NIL THEN currentRDB.wildN м CreateDB[];
currentRDB м currentRDB.wildN;
}; 
wild1 => {
IF currentRDB.wild1=NIL THEN currentRDB.wild1 м CreateDB[];
currentRDB м currentRDB.wild1;
wasWildN м FALSE;
}; 
bang => {SkipLine[stream]; newEntry м TRUE}; 
eof => {
IF expliciteValue#NIL THEN currentRDB.value м expliciteValue; 
RETURN []
}; 
ENDCASE => ParseError["Syntax error"];
ENDLOOP;
};


QueryRep: PUBLIC TYPE = QueryRec; 
QueryRec: TYPE = RECORD [
lastDef: NAT м 1, 
atoms: SEQUENCE count: NAT OF Rope.ROPE
]; 

separator: Rope.ROPE = NIL;

QueryState: PUBLIC PROC [query: REF QueryRec] RETURNS [NAT] = {
RETURN [query.lastDef]
};

NewQuery: PUBLIC PROC [reserve: NAT м 6, useMemory: REF QueryRep м NIL] RETURNS [q: REF QueryRep] = {
SELECT TRUE FROM
useMemory#NIL AND useMemory.count>reserve =>  q м useMemory;
freeQuery#NIL => q м INewQuery[reserve];
ENDCASE => q м NEW[QueryRec[reserve+1]];
q.lastDef м 1;
q[0] м q[1] м separator;
};

ResetQuery: PUBLIC PROC [query: REF QueryRep, state: NAT м 0] = {
IF query=NIL THEN {IF state>1 THEN Error[] ELSE RETURN};
state м MAX[state, 1];
IF query.lastDef<state THEN Error[];
query[state] м separator;
query.lastDef м state;
};

CopyQuery: PUBLIC PROC [query: REF QueryRep, reserve: NAT м 0] RETURNS [q: REF QueryRep] = {
IF query=NIL THEN RETURN [NewQuery[reserve]];
q м NewQuery[reserve+query.lastDef];
q.lastDef м query.lastDef;
FOR i: NAT IN [0..q.lastDef] DO
q[i] м query[i];
ENDLOOP;
};

AppendStepOnly: PUBLIC PROC [query: REF QueryRep] RETURNS [REF QueryRep] = {
IF query=NIL THEN query м NewQuery[6];
BEGIN 
next: NAT м query.lastDef+1;
IF query[next-2]=separator THEN RETURN [query]; --no empty steps
IF next>=query.count THEN query м CopyQuery[query, next/2+4];
query[next] м separator;
query.lastDef м next;
END;
RETURN [query];
};

AppendOptionOnly: PUBLIC PROC [query: REF QueryRep, option: AnyString] RETURNS [REF QueryRep] = {
IF query=NIL THEN Error[];
IF option=NIL THEN RETURN [query];
BEGIN
next: NAT м query.lastDef+1;
IF next>=query.count THEN query м CopyQuery[query, next/2+4];
query[next] м separator;
query[next-1] м ToRope[option];
query.lastDef м next;
END;
RETURN [query];
};
ToRope: PROC [x: REF] RETURNS [Rope.ROPE] = INLINE {
RETURN [WITH x SELECT FROM
r: ROPE => r,
a: ATOM => Atom.GetPName[a],
r: REF TEXT => Rope.FromRefText[r],
ENDCASE => ERROR error
];
};

AppendStep: PUBLIC PROC [query: REF QueryRep, val1, val2: AnyString м NIL] RETURNS [REF QueryRep] = {
query м AppendStepOnly[query];
IF val1#NIL THEN query м AppendOptionOnly[query, val1];
IF val2#NIL THEN query м AppendOptionOnly[query, val2];
RETURN [query];
};

ParseQuery: PUBLIC PROC [string: AnyString] RETURNS [query: Query м NIL] = {
buffer: REF TEXT м NEW[TEXT[64]];
query м StreamParseQuery[ToStream[string], buffer];
};

StreamParseQuery: PROC [stream: STREAM, buffer: REF TEXT] RETURNS [q: Query м NewQuery[]] = {
state: {expectStep, expectOption} м expectStep;
token: Token;
WHILE TRUE DO
token м GetToken[stream, buffer];
SELECT state FROM
expectStep => {
SELECT token.type FROM
leftParen => {
q м AppendStepOnly[q];
state м expectOption;
};
name => {
q м AppendStepOnly[q];
q м AppendOptionOnly[q, token.data];
state м expectStep;
};
eof => RETURN; 
ENDCASE => QueryError["( expected"];
};
expectOption => {
SELECT token.type FROM
name => {
q м AppendOptionOnly[q, token.data];
state м expectOption;
};
rightParen => state м expectStep;
verticalbar => state м expectOption;
ENDCASE => QueryError["| or ) or ident expected"];
};
ENDCASE => Error[]; -- can't happen
ENDLOOP;
};


QueryError: PUBLIC ERROR [what: Rope.ROPE м NIL] = CODE;

DoQueryString: PUBLIC PROC [db: DBreadonly, string: AnyString] RETURNS [x: REF] = {
q: Query м ParseQuery[string];
x м DoQuery[db, q];
FreeQuery[q];
};

DoQuery: PUBLIC PROC [db: DBreadonly, query: Query] RETURNS [REF м NIL] = {
xdb: DB;
TRUSTED {xdb м LOOPHOLE[db]};
RETURN [ Follow[xdb, query, 0] ];
};

Follow: PROC [db: DB, query: REF QueryRep, sepIdx: NAT] RETURNS [REF] = {
value: REF; 
this: NAT м sepIdx + 1; --index of first option
next: NAT м 0; --index of separator after last option
FindNextSeparator: PROC [] = INLINE {
FOR next м this + 1, next + 1 WHILE query[next]#separator DO ENDLOOP;
};
IF sepIdx>=query.lastDef THEN RETURN [db.value];
IF query[sepIdx]#separator THEN Error[];
FindNextSeparator[];
IF db.identifier#NIL THEN {
FOR i: NAT IN [this..next) DO
follow: REF ~ SymTab.Fetch[db.identifier, query[i]].val;
IF follow#NIL THEN {
WITH follow SELECT FROM
db2: DB => {
value м Follow[db2, query, next];
IF value # NIL THEN RETURN [value];
};
ENDCASE => {}
};
ENDLOOP;
};
IF db.wild1#NIL THEN {
value м Follow[db.wild1, query, next];
IF value # NIL THEN RETURN [value];
};
IF db.wildN#NIL THEN {
DO
value м Follow[db.wildN, query, next];
IF value # NIL THEN RETURN [value];
this м next+1;
IF this>=query.lastDef THEN RETURN [NIL];
FindNextSeparator[];
ENDLOOP;
};
RETURN [NIL];
};

CreateDB: PUBLIC PROC [] RETURNS [x: DB] = {
x м NEW[DBRec];
};

UpdateDB: PUBLIC PROC [db: DB, stream: STREAM] RETURNS [errors: ROPE м NIL] = {
errors м Parse[db, stream, NIL];
};

ToStream: PROC [x: AnyString] RETURNS [stream: IO.STREAM] = {
WITH x SELECT FROM
r: ROPE => stream м IO.RIS[r];
rt: REF TEXT => stream м IO.TIS[rt];
s: STREAM => stream м s;
ENDCASE => Error[];
};

UpdateDBString: PUBLIC PROC [db: DB, string: AnyString] RETURNS [errors: ROPE м NIL] = {
stream: STREAM м ToStream[string];
errors м Parse[db, stream, NIL];
};

UpdateDBExplicite: PUBLIC PROC [db: DB, key: AnyString, value: REF] RETURNS [errors: ROPE м NIL] = {
stream: STREAM  м ToStream[key];
SELECT TRUE FROM
value=NIL => value м emptyRope;
ISTYPE[value, DB] => Error[]; --this type has internal functions
ENDCASE => {};
errors м Parse[db, stream, value];
};

UpdateDBFromFile: PUBLIC PROC [file: REF, inputDb: DB м NIL] RETURNS [db: DB, errors: ROPE м NIL] = {
IF inputDb=NIL THEN db м CreateDB[] ELSE db м inputDb;
WITH file SELECT FROM
stream: STREAM => errors м UpdateDB[db, stream];
ENDCASE => Error[];
};

ExplainQueryError: PreDebug.Explainer = {
msg м "Customize.QueryError";
IF args=NIL THEN RETURN;
PreDebug.Raise[signalOrError, args ! QueryError => {
IF ~Rope.IsEmpty[what] THEN msg м Rope.Cat[msg, " """, what, """"];
CONTINUE
}];
};

PreDebug.RegisterErrorExplainer[QueryError, ExplainQueryError];
PreDebug.RegisterErrorExplainer[error, NIL, "Customize.error"];
END.


  T  
CustomizeImpl.mesa
Copyright ╙ 1989, 1991 by Xerox Corporation.  All rights reserved.
Goran Rydqvist and Christian Jacobi, July 24, 1989 9:20:43 pm PDT
Simplified algorithm Christian Jacobi, November 22, 1991 3:20 pm PST
Christian Jacobi, April 30, 1992 10:23 am PDT

Small Point:
Should xsoft take advantage of Xl and shed away from PFS; the use of PFS is not critical and could be commented out

--
copy.value м source.value;
IF source.wildN#NIL THEN copy.wildN м CopyDB[source.wildN];
IF source.wild1#NIL THEN copy.wild1 м CopyDB[source.wild1];
IF source.identifier#NIL THEN {
<<copy.identifier м COPY[source.identifier]>>
EachEntry: SymTab.EachPairAction = {
x: REF м val;
WITH val SELECT FROM
db: DB => x м CopyDB[db];
ENDCASE => {};
[] м SymTab.Insert[copy.identifier, key, x];
};
copy.identifier м SymTab.Create[SymTab.GetSize[source.identifier]+1];
[] м SymTab.Pairs[source.identifier, EachEntry];
};
Merges the entries of "from" into "into" 
In case of conflict, the "from" value will overwrite the "into" value
Memory allocations hacks

Returns query for re-use.  Caller asserts that he won't modify query anymore.
It is ok to not worry but leave query's to the garbage collector.

Database Scanner
--wild1 is represented as a question mark
--wildN is represented as a asterix

Database Parser

This builds a data structure specially tailored to efficiently answering a query.  For each step in the tree representing the database, a node is generated.  A lookup table is created in each node to facilitate finding the next possible steps.

Query Types
--lastIdx: number of entries or index of last step 
--I know: atoms[0]=separator all the time; but it is queried
--atoms[lastIdx+1]=separator
Returns <state> of query in construction.  Meaning of numerical value is private.  
Creates new empty query.  Query does not yet have any steps or options.
<reserve>: allocates enough memory for about <reserve> steps or options.
Resets state of query to <state>. <state>=0 means reset to empty.
Creates new copy which does not share memory with query. 
<reserve> is a guess: allocates enough memory to append about <reserve> more steps or options.
Appends step to <query>; The new step has no options yet.
Returns <query> or new query if new memory allocation needed.
Append query option to the current step of <query>. 
<query> must not be empty.
Returns <query> or new query if new memory allocation needed.

Parses <string> into a query. 
May raise error QueryError. 
Query Resolver
Conveniance procedure.
Query the database <db> strings.
Query the database <db> with <query>. 

Database creation

Creates new, empty DB.
Parse <stream> and merge database entries into <db>.  If a specification is identical to one that already exists, the later one takes precedence. 
Parse <string> and and merge database entries into <db>.  
Parse <key> and add <value> as database entry into <db>.  
Database values may be overwriten, but, they can't be removed.  
Conveniance procedure: <inputDb> is updated and returned again.  <file> a STREAM or a string (string is interpreted as a file name).  Not found files are reported like syntax errors in the data base.
name: ROPE => {
BEGIN
ENABLE PFS.Error => {
errors _ IO.PutFR["file not opened: %g", IO.rope[error.explanation]]; 
GOTO failed;
};
stream: STREAM _ PFS.StreamOpen[PFS.PathFromRope[name]];
errors _ UpdateDB[db, stream];
EXITS failed => {};
END;
};
Э╩ї  ХNewlineDelimiter
Ц(cedarcode) styleЩ codeЪЬЩKЪЬ
╧eЬ7ЩBKЪЬ>╧kЩAKЪЬDЩDKЩ-KЩ ЩKЩsЧKЩ ЧЪЮ	Ш	KЪЬ$ЮЬЮЬШFKШ ЧЪ╨lnЬЮЬЮЬШKЪЮЬЮЬЮЬШ2KЪЮЬШ%ЧЪЮЬЮЬШKШ KЪЮЬЮЬЮЬШKЪЮЬЮЬЮЬЮЬШKЪЬЮЬЮЬШKЪ╧nЬЮЬЮЬШKШ KЪЮЬЮЬЮЬШKЪЬЮЬЮЬЮЬШ&ЪЬЮЬЮЬЮЬШKЪЬЮЬЮЬШKЪЬЮЬ╧c!Ш?KЪЬЮЬЮЬШKЪЬЮЬЮЬШKШЧKШ Ъ
аЬЮЬЮЬЮЬЮЬШ?KШKЪЬЮЬШKЪЮЬШKЩKЩKЪЮЬЮЬЮЬ#Щ;KЪЮЬЮЬЮЬ#Щ;ЪЮЬЮЬЮЬЩKЩ-Ъа	ЬЩ$KЪЬЮЬЩЪЮЬЮЬЮЩKЪЬЮЬЩKЪЮЬЩЧKЩ,KЩЧKЩEKЩ0KЩЧKШKШ ЧЪ
аЬЮЬЮЬЮЬЮЬШFKЩ)KЩEЪЮЬЮЬЮЬШKЪЮЬЮЬЮЬЮЬШ<KШЧЪЮЬЮЬЮЬШKЪЮЬЮЬЮЬШ/KШ+KШЧЪЮЬЮЬЮЬШKЪЮЬЮЬЮЬШ/KШ+KШЧЪЮЬЮЬЮЬШЪаЬШ(ЪЮЬЮЬЮШЪЬЮЬШЪаЬШЪЮЬШЪЮЬШЪЮЬЮЬЮШЪЬЮЬЬШKШ)KШ
KШЧKЪЮЬШЧKШЧЪЮЬШKЪЬ
ЮЬШKШ(KШKШЧЧKШЧKШ+KШЧKЪЮЬШЧKШЧЪЮЬЮЬЮЬШKШCЧKШ2KШЧKШЧKШ ЧЪ╤aelЩKЩ KЪЬЮЬШЪа	ЬЮЬЮЬШ)KЪЬMЩMKЪЬAЩAKЪЬШKЪЮЬЮЬЮЬЮЬШ;KШЧKШ Ъ
а	ЬЮЬЮЬЮЬЮЬШ8KЪЬШKЪЮЬЮЬЮЬЮЬЮЬЮЬ
ШLKЪЬЮЬШ!KЪЮЬ	ШKЪЬШЧKЩ ЧЪвЩKШ ЪЬЮЬЮЬШKЪЬ]Ш]KЪЬЮЬЮЬбШ%ШKЩ)KЩ#ЧЧKШ ЪаЬЮЬШЪЮЬЮЬЮШKЪЮЬЮЬЮЬШ6KЪЮЬ	ШЧKЪЬШЧKШ ЪаЬЮЬ
ЮЬ
ЮЬЮЬЮЬЮЬШNKЪЬЮЬШKЪЮЬЮЬЮЬЮЬШ0KЪЬЮЬШKЪЮЬЮЬЮЬЮЬШ0ЪЮЬЮЬЮШ"ЪЮЬЮЬЮЬШ3KЪЬЮЬЮЬШKЪЮЬШKЪЬЮЬ'Ш.KШKЪЬШKЪЬШЧKЪЬШKЪЬШKЪЬШKЪЬШKЪЬШKЪЬШKЪЬШKЪЬШKЪЮЬЮЬШ*ЧKШKШ ЧKЪЬЮЬШЪ
а	ЬЮЬ
ЮЬЮЬЮЬШDKЪЮЬЮЬЮЬЮЬШ KЪЬЮЬШЪЮЬЮЬЮЬШKЪЬЮЬЮЬШ%KЪЮЬЮЬЮЬШ$KЪЮЬ	ШKШЧKШЧKШ ЪаЬЮЬ
ЮЬШ#KЪЬЮЬШЪЮЬЮЬЮШЪЮЬЮЬЮШ"KЪ
ЮЬЮЬЮЬЮЬЮЬШKЪЮЬЮЬШЧKЪЮЬШЧKШKШ ЧKЩ ЧЪвЩKЩ KЩєKШ ЪаЬЮЬЮЬ
ЮЬЮЬЮЬЮЬЮЬ
ЮЬЮЬШcKЪЬ
ЮЬЮЬШKЪЬШKЪ	ЬЮЬЮЬЮЬЮЬШ!KЪЬЮЬЮЬШKШ ЪаЬЮЬЮЬШЪ╧bЬШЪЮЬЮЬЮШKЪЬЮЬШЪЮЬШKЪЬШKЪЮЬШKШЧЧKШЧKЪЮЬЮЬЮЬ*ШKKЪЬ1Ш1KЪЬШЧKШ ЪаЬЮЬ
ЮЬЮЬШ,KЪЬЮЬШKЪЮЬЮЬЮЬШ0KЪЬШKЪЬШЧKШ Ъа
ЬЮЬЮЬШ$KЪЬЮЬЮЬШKЪ	Ь	ЮЬЮЬЮЬЮЬШWKЪЬШKЪЬЮЬШKЪЬШЧKШ KЪЬ
ЮЬб%Ш5ЪЮЬЮЬЮШЪЮЬ
ЮЬШKЪЬШKЪЬЮЬШKЪЬЮЬШKШЧKЪЬ!Ш!ЪЮЬЮШKЪЬ'ЮЬШ.KЪЬб'ЬШ2KЪЬ$ЮЬШ+Ш
KЪЮЬ
ЮЬЮЬШKЪЬЮЬШKЪЮЬЮЬЮЬШ;KЪЬШKЪЬШЧШ
KЪЮЬЮЬЮЬШ;KЪЬШKЪЬЮЬШKШЧKЪЬ&ЮЬШ-ЪЬШKЪЮЬЮЬЮЬ$Ш>KЪЮЬШ	KЪЬШЧKЪЮЬШ&ЧKЪЮЬШЧKШЧKШ KЩ ЧЪвЩKШ KЪЬ
ЮЬЮЬШ"ЪЬ
ЮЬЮЬШKЪЬ	ЮЬШKЪЬЮЬЮЬЮЬЮШ'KЪЬШKЪЬ3Щ3KЪЬ<Щ<KЪЬЩЧKШ KЪЬЮЬЮЬШKШ Ъа
ЬЮЬЮЬ	ЮЬЮЬЮЬШ?KЪЬSЩSKЪЮЬШKШKШ ЧЪаЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬШeKЪЬGЩGKЪЬHЩHЪЮЬЮЬЮШKЪЬ
ЮЬЮЬ+Ш<KЪЬ
ЮЬШ(KЪЮЬЮЬШ(ЧKЪЬШKЪЬШKШKШ ЧЪ
а
ЬЮЬЮЬ	ЮЬЮЬ	ШAKЪЬAЩAKЪЮЬЮЬЮЬЮЬ	ЮЬ	ЮЬЮЬШ8KЪЬЮЬШKЪЮЬЮЬ	Ш$KЪЬШKЪЬШKШЧKШ Ъа	ЬЮЬЮЬ	ЮЬЮЬЮЬЮЬШ\KЪЬ9Щ9KЪЬ^Щ^KЪЮЬЮЬЮЬЮЬШ-KЪЬ$Ш$KЪЬШЪЮЬЮЬЮЬЮШKЪЬШKЪЮЬШЧKЪЬШKШ ЧЪаЬЮЬЮЬ	ЮЬЮЬЮЬШLKЪЬ9Щ9KЪЬ=Щ=KЪЮЬЮЬЮЬШ&ЪЮЬШKЪЬЮЬШKЪЮЬЮЬЮЬ
бШ@KЪЮЬЮЬ$Ш=KЪЬШKЪЬШKЪЮЬШЧKЪЮЬ	ШKШЧKШ Ъ
аЬЮЬ	ЮЬЮЬЮЬШaKЪЬ4Щ4KЪЬЩKЪЬ=Щ=KЪЮЬЮЬЮЬ	ШKЪЮЬЮЬЮЬЮЬ	Ш"ЪЮШKЪЬЮЬШKЪЮЬЮЬ$Ш=KЪЬШKЪЬШKЪЬШKЪЮЬШЧKЪЮЬ	ШKШKЩ ЧЪаЬЮЬЮЬЮЬЮЬЮЬШ4ЪЮЬЮЬЮЬЮШKЪЬЮЬШKЪЬЮЬШKЪЬЮЬЮЬШ#KЪЮЬЮЬШKШЧKШЧKШ Ъа
ЬЮЬЮЬ	ЮЬ#ЮЬЮЬЮЬШeKЪЬШKЪЮЬЮЬЮЬ'Ш7KЪЮЬЮЬЮЬ'Ш7KЪЮЬ	ШKШKШ ЧЪ
а
ЬЮЬЮЬЮЬЮЬШLKЪЬЩKЪЬЩKЪ	ЬЮЬЮЬЮЬЮЬШ!KЪЬ3Ш3KШKШ ЧЪаЬЮЬ
ЮЬ
ЮЬЮЬЮЬШ]KЪЬ/Ш/KЪЬШЪЮЬЮЬЮШKЪЬ!Ш!ЪЮЬЮШЪЬШЪЮЬЮШЪЬШKЪЬШKЪЬШKЪЬШЧЪЬ	Ш	KЪЬШKЪЬ$Ш$KЪЬШKЪЬШЧKЪЬЮЬШKЪЮЬШ$ЧKШЧЪЬШЪЮЬЮШЪЬ	Ш	KЪЬ$Ш$KЪЬШKЪЬШЧKЪЬ!Ш!KЪЬ$Ш$KЪЮЬ+Ш2ЧKШЧKЪЮЬбШ#ЧKЪЮЬШЧKШЧKШ KШ ЧЪвЩKШ KЪа
ЬЮЬЮЬЮЬЮЬЮЬШ8KШ Ъ
аЬЮЬЮЬ%ЮЬЮЬШSKЪЬЩKЪЬ Щ KЪЬШKЪЬШKЪЬШKЪЬШЧKШ ЪаЬЮЬЮЬ ЮЬЮЬЮЬШKKЪЬ&Щ&KЪЬЮЬШKЪЮЬЮЬШKЪЮЬШ!KШЧKШ ЪаЬЮЬЮЬ	ЮЬЮЬЮЬЮЬШIKЪЬЮЬШKЪЬЮЬбШ/KЪЬЮЬб&Ш5ЪаЬЮЬЮЬШ%KЪЮЬЮЬЮЬЮЬШEKШЧKЪЮЬЮЬЮЬШ0KЪЮЬЮЬ	Ш(KЪЬШЪЮЬЮЬЮЬШЪЮЬЮЬЮЬЮШKЪЬЮЬ-Ш8ЪЮЬЮЬЮЬШЪЮЬЮЬЮШЪЬЮЬШKЪЬ!Ш!KЪЮЬ	ЮЬЮЬЮЬ	Ш#KШЧKЪЮЬШЧKШЧKЪЮЬШЧKШЧЪЮЬ
ЮЬЮЬШKЪЬ&Ш&KЪЮЬ	ЮЬЮЬЮЬ	Ш#KШЧЪЮЬ
ЮЬЮЬШЪЮШKЪЬ&Ш&KЪЮЬ	ЮЬЮЬЮЬ	Ш#KЪЬШKЪЮЬЮЬЮЬЮЬШ)KЪЬШKЪЮЬШЧKЪЬШЧKЪЮЬЮЬШKЪЬШЧKШ ЧKЩ KЪвЩЩ Ъ
аЬЮЬЮЬЮЬЮЬШ,KЩKЪЬЮЬШKШKШ ЧЪаЬЮЬЮЬЮЬ
ЮЬЮЬ
ЮЬЮЬШOKЪЬТЩТKЪЬЮЬШ KШKШ ЧЪ
аЬЮЬЮЬ
ЮЬЮЬШ=ЪЮЬЮЬЮШKЪЬЮЬЮЬЮЬШKЪ	ЬЮЬЮЬЮЬЮЬШ$KЪЬЮЬШKЪЮЬШЧKШЧKШ ЪаЬЮЬЮЬЮЬЮЬ
ЮЬЮЬШXKЪЬ:Щ:KЪЬЮЬШ"KЪЬЮЬШ KШЧKШ ЪаЬЮЬЮЬЮЬЮЬЮЬ
ЮЬЮЬШdKЪЬ:Щ:KЪЬ@Щ@KЪЬЮЬШ ЪЮЬЮЬЮШKЪЬЮЬШKЪЮЬЮЬб"Ш@KЪЮЬШЧKЪЬ"Ш"KШKШ ЧЪаЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬ
ЮЬЮЬШeKЪЬJЮЬwЩ╟KЪЮЬ	ЮЬЮЬЮЬШ6ЪЮЬЮЬЮШKЪЬЮЬ"Ш0ЪЬЮЬЩЪЮЩЪЮЬЮЬЩKЪЬ	ЮЬЮЬЩFKЪЮЬЩJЩЧJЪЬЮЬЮЬЮЬЩ8JЪЬЩKЪЮЬЩJЪЮЬЩЧJЩЧKЪЮЬШЧKШKШ ЧЧЪаЬШ)KЪЬШKЪЮЬЮЬЮЬЮЬШЪЬ4Ш4KЪЮЬЮЬ(ШCKЪЮШKШЧKШKШ ЧKЪЬ?Ш?KЪЬ'ЮЬШ?ЪЮЬШKШ ЧKШ Ч ЕЧ    +<  MЕ  