DIRECTORY
IO USING [atom, PutFR1],
RefID USING [Release, Reseal, Seal, Unseal],
SymTab USING [Create, EachPairAction, Fetch, Insert, Pairs, Ref],
LoganBerry,
LoganBerryClass;

LoganBerryClassImpl: CEDAR MONITOR -- for Write proc registration stuff
IMPORTS IO, RefID, SymTab
EXPORTS LoganBerry, LoganBerryClass
~ BEGIN

OPEN LoganBerry, LoganBerryClass;


registeredClasses: LIST OF Class м NIL;	-- list of registered classes

openDBTable: SymTab.Ref м NIL;			-- table of open database handles

GenericOpenDBInfo: TYPE = REF GenericOpenDBRecord;
GenericOpenDBRecord: TYPE = RECORD [
class: Class м NIL,  		-- class associated with generic db handle
db: OpenDB,				-- class-specific db handle
registeredWriteProcs: LIST OF WriteProcRegistration
];

GenericCursorInfo: TYPE = REF GenericCursorRecord;
GenericCursorRecord: TYPE = RECORD[
class: Class,  			-- class associated with generic cursor
cursor: Cursor	 		-- class-specific cursor handle
];

WriteProcRegistration: TYPE = REF WriteProcRegistrationBody;
WriteProcRegistrationBody: TYPE = RECORD[
proc: LoganBerry.WriteProc,
ident: ATOM,
clientData: REF
];

Error: PUBLIC ERROR [ec: ErrorCode, explanation: ROPE м NIL] = CODE;

Open: PUBLIC PROC [conv: Conv м NIL, dbName: ROPE] RETURNS [db: OpenDB] ~ {
dbinfo: GenericOpenDBInfo;
IF openDBTable = NIL THEN
openDBTable м SymTab.Create[mod: 2039, case: FALSE];
dbinfo м NARROW[SymTab.Fetch[openDBTable, dbName].val];
IF dbinfo = NIL 
THEN {  -- database not previously opened (under this name)
dbinfo м NEW[GenericOpenDBRecord];
dbinfo.registeredWriteProcs м NIL;
FOR c: LIST OF Class м registeredClasses, c.rest WHILE c#NIL DO
IF c.first.open # NIL THEN
dbinfo.db м c.first.open[conv, dbName];
IF dbinfo.db # LoganBerry.nullDB THEN {
dbinfo.class м c.first;
EXIT;
};
ENDLOOP;
IF dbinfo.class = NIL THEN
ERROR Error[$CantOpenSchema, "No registered class manages the named database."];
dbinfo м CheckAndSaveOpenDB[dbName, dbinfo];
db м RefID.Seal[dbinfo];
}
ELSE {  -- reopen database
IF dbinfo.class.open # NIL THEN 
dbinfo.db м dbinfo.class.open[conv, dbName]; 
db м RefID.Reseal[dbinfo];
};
};

CheckAndSaveOpenDB: ENTRY PROC [dbName: ROPE, dbinfo: GenericOpenDBInfo] RETURNS [GenericOpenDBInfo] ~ {
CheckDB: SymTab.EachPairAction = {
prevdbinfo: GenericOpenDBInfo м NARROW[val];
IF prevdbinfo.class = dbinfo.class AND prevdbinfo.db = dbinfo.db THEN {
dbinfo м prevdbinfo;
quit м TRUE;
};
};
[] м SymTab.Pairs[x: openDBTable, action: CheckDB];
[] м SymTab.Insert[x: openDBTable, key: dbName, val: dbinfo];
RETURN[dbinfo];
};

ReadEntry: PUBLIC PROC [conv: Conv м NIL, db: OpenDB, key: AttributeType, value: AttributeValue] RETURNS [entry: Entry, others: BOOLEAN] ~ {
dbinfo: GenericOpenDBInfo м GetInfo[db];
IF dbinfo.class.readEntry = NIL THEN ERROR Error[$NotImplemented, IO.PutFR1["procedure not available for class %g.", IO.atom[dbinfo.class.name]]]; 
[entry, others] м dbinfo.class.readEntry[conv, dbinfo.db, key, value];
};

EnumerateEntries: PUBLIC PROC [db: OpenDB, key: AttributeType, start: AttributeValue м NIL, end: AttributeValue м NIL, proc: EntryProc] RETURNS [] ~ {
dbinfo: GenericOpenDBInfo м GetInfo[db];
IF dbinfo.class.enumerateEntries = NIL THEN ERROR Error[$NotImplemented, IO.PutFR1["procedure not available for class %g.", IO.atom[dbinfo.class.name]]]; 
dbinfo.class.enumerateEntries[dbinfo.db, key, start, end, proc];
};

GenerateEntries: PUBLIC PROC [conv: Conv м NIL, db: OpenDB, key: AttributeType, start: AttributeValue м NIL, end: AttributeValue м NIL] RETURNS [cursor: Cursor] ~ {
cinfo: GenericCursorInfo м NEW[GenericCursorRecord];
dbinfo: GenericOpenDBInfo м GetInfo[db];
IF dbinfo.class.generateEntries = NIL THEN ERROR Error[$NotImplemented, IO.PutFR1["procedure not available for class %g.", IO.atom[dbinfo.class.name]]]; 
cinfo.class м dbinfo.class;
cinfo.cursor м dbinfo.class.generateEntries[conv, dbinfo.db, key, start, end];
cursor м RefID.Seal[cinfo];
};

NextEntry: PUBLIC PROC [conv: Conv м NIL, cursor: Cursor, dir: CursorDirection м increasing] RETURNS [entry: Entry] ~ {
cinfo: GenericCursorInfo м GetCursorInfo[cursor];
IF cinfo.class.nextEntry = NIL THEN ERROR Error[$NotImplemented, IO.PutFR1["procedure not available for class %g.", IO.atom[cinfo.class.name]]]; 
entry м cinfo.class.nextEntry[conv, cinfo.cursor, dir];
};

EndGenerate: PUBLIC PROC [conv: Conv м NIL, cursor: Cursor] RETURNS [] ~ {
cinfo: GenericCursorInfo м GetCursorInfo[cursor];
IF cinfo.class.endGenerate = NIL THEN ERROR Error[$NotImplemented, IO.PutFR1["procedure not available for class %g.", IO.atom[cinfo.class.name]]]; 
cinfo.class.endGenerate[conv, cinfo.cursor];
[] м RefID.Release[cursor];
};

WriteEntry: PUBLIC PROC [conv: Conv м NIL, db: OpenDB, entry: Entry, log: LogID м activityLog, replace: BOOLEAN м FALSE] RETURNS [] ~ {
dbinfo: GenericOpenDBInfo м GetInfo[db];
IF dbinfo.class.writeEntry = NIL THEN ERROR Error[$NotImplemented, IO.PutFR1["procedure not available for class %g.", IO.atom[dbinfo.class.name]]]; 
dbinfo.class.writeEntry[conv, dbinfo.db, entry, log, replace];
ReportWrites[dbinfo, entry]; -- to registered procedures.
};

DeleteEntry: PUBLIC PROC [conv: Conv м NIL, db: OpenDB, key: AttributeType, value: AttributeValue] RETURNS [] ~ {
entry: Entry;
dbinfo: GenericOpenDBInfo м GetInfo[db];
IF dbinfo.class.deleteEntry = NIL THEN ERROR Error[$NotImplemented, IO.PutFR1["procedure not available for class %g.", IO.atom[dbinfo.class.name]]]; 
entry м dbinfo.class.deleteEntry[conv, dbinfo.db, key, value];
IF entry#NIL THEN ReportWrites[dbinfo, entry]; -- to registered procedures.
};

Close: PUBLIC PROC [conv: Conv м NIL, db: OpenDB] RETURNS [] ~ {
dbinfo: GenericOpenDBInfo м GetInfo[db];
IF dbinfo.class.close = NIL THEN ERROR Error[$NotImplemented, IO.PutFR1["procedure not available for class %g.", IO.atom[dbinfo.class.name]]]; 
dbinfo.class.close[conv, dbinfo.db];
};

BuildIndices: PUBLIC PROC [conv: Conv м NIL, db: OpenDB] RETURNS [] ~ {
dbinfo: GenericOpenDBInfo м GetInfo[db];
IF dbinfo.class.buildIndices = NIL THEN ERROR Error[$NotImplemented, IO.PutFR1["procedure not available for class %g.", IO.atom[dbinfo.class.name]]]; 
dbinfo.class.buildIndices[conv, dbinfo.db];
};

CompactLogs: PUBLIC PROC [conv: Conv м NIL, db: OpenDB] RETURNS [] ~ {
dbinfo: GenericOpenDBInfo м GetInfo[db];
IF dbinfo.class.compactLogs = NIL THEN ERROR Error[$NotImplemented, IO.PutFR1["procedure not available for class %g.", IO.atom[dbinfo.class.name]]]; 
dbinfo.class.compactLogs[conv, dbinfo.db];
};

Describe: PUBLIC PROC [conv: Conv м NIL, db: OpenDB] RETURNS [info: SchemaInfo] ~ {
dbinfo: GenericOpenDBInfo м GetInfo[db];
IF dbinfo.class.describe = NIL THEN ERROR Error[$NotImplemented, IO.PutFR1["procedure not available for class %g.", IO.atom[dbinfo.class.name]]]; 
info м dbinfo.class.describe[conv, dbinfo.db];
};

IsLocal: PUBLIC PROC [db: LoganBerry.OpenDB] RETURNS[local: BOOL м TRUE] = {
dbinfo: GenericOpenDBInfo м GetInfo[db];
IF dbinfo.class.isLocal = NIL THEN ERROR Error[$NotImplemented, IO.PutFR1["procedure not available for class %g.", IO.atom[dbinfo.class.name]]]; 
local м dbinfo.class.isLocal[dbinfo.db];
};

StartTransaction: PUBLIC PROC [db: LoganBerry.OpenDB, wantAtomic: BOOLEAN м FALSE] = {
dbinfo: GenericOpenDBInfo м GetInfo[db];
IF dbinfo.class.startTransaction = NIL THEN ERROR Error[$NotImplemented, IO.PutFR1["procedure not available for class %g.", IO.atom[dbinfo.class.name]]]; 
dbinfo.class.startTransaction[dbinfo.db, wantAtomic];
};

EndTransaction: PUBLIC PROC [db: LoganBerry.OpenDB, commit: BOOLEAN м TRUE] RETURNS [committed: BOOLEAN] = {
dbinfo: GenericOpenDBInfo м GetInfo[db];
IF dbinfo.class.endTransaction = NIL THEN ERROR Error[$NotImplemented, IO.PutFR1["procedure not available for class %g.", IO.atom[dbinfo.class.name]]]; 
committed м dbinfo.class.endTransaction[dbinfo.db, commit];
};

FlushDBCache: PUBLIC PROC [db: LoganBerry.OpenDB м LoganBerry.nullDB] = {
IF db # LoganBerry.nullDB 
THEN {  -- flush specific database
dbinfo: GenericOpenDBInfo м GetInfo[db];
IF dbinfo.class.flushDBCache # NIL THEN 
dbinfo.class.flushDBCache[dbinfo.db];
}
ELSE { -- flush all databases in all classes
FOR c: LIST OF Class м registeredClasses, c.rest WHILE c # NIL DO
IF c.first.flushDBCache # NIL THEN 
c.first.flushDBCache[LoganBerry.nullDB];
ENDLOOP;
};
};

GetDBSpecifics: PUBLIC PROC [db: LoganBerry.OpenDB] RETURNS [class: ATOM, dbhandle: LoganBerry.OpenDB] = {
dbinfo: GenericOpenDBInfo м GetInfo[db];
class м dbinfo.class.name;
dbhandle м dbinfo.db;
};

GetInfo: PROC [db: OpenDB] RETURNS [GenericOpenDBInfo] ~ INLINE {
ref: REF = RefID.Unseal[db];
IF ref = NIL THEN
ERROR Error[$BadDBHandle, "NIL OpenDB handle."];
WITH ref SELECT FROM
dbinfo: GenericOpenDBInfo => {
RETURN[dbinfo];
};
ENDCASE => ERROR Error[$BadDBHandle, "Invalid OpenDB handle."];
};

GetCursorInfo: PROC [cursor: Cursor] RETURNS [GenericCursorInfo] ~ INLINE {
ref: REF = RefID.Unseal[cursor];
IF ref = NIL THEN
ERROR Error[$BadCursor, "NIL cursor."];
WITH ref SELECT FROM
cinfo: GenericCursorInfo => {
RETURN[cinfo];
};
ENDCASE => ERROR Error[$BadCursor, "Invalid cursor."];
};
RegisterWriteProc: PUBLIC ENTRY PROC [proc: LoganBerry.WriteProc, db: LoganBerry.OpenDB, ident: ATOM, clientData: REF] = {
ENABLE UNWIND => NULL;
dbinfo: GenericOpenDBInfo м GetInfo[db];
reg: WriteProcRegistration м NEW[ WriteProcRegistrationBody м [proc: proc, ident: ident, clientData: clientData]];
FOR r: LIST OF WriteProcRegistration м dbinfo.registeredWriteProcs, r.rest WHILE r#NIL DO
IF r.first.ident=ident THEN { r.first м reg; RETURN; };
ENDLOOP;
dbinfo.registeredWriteProcs м CONS[reg, dbinfo.registeredWriteProcs];
};

UnregisterWriteProc: PUBLIC ENTRY PROC [db: LoganBerry.OpenDB, ident: ATOM] = {
ENABLE UNWIND => NULL;
dbinfo: GenericOpenDBInfo м GetInfo[db];
regs: LIST OF WriteProcRegistration м dbinfo.registeredWriteProcs;
IF regs=NIL THEN RETURN;
IF ident=regs.first.ident THEN { dbinfo.registeredWriteProcs м regs.rest; RETURN; };
FOR r: LIST OF WriteProcRegistrationмregs, r.rest WHILE r.rest#NIL DO
IF r.rest.first.ident=ident THEN { r.rest м r.rest.rest; RETURN; };
ENDLOOP;
};

ReportWrites: --ENTRY-- PROC [dbinfo: GenericOpenDBInfo, entry: Entry] = {
FOR r: LIST OF WriteProcRegistration м dbinfo.registeredWriteProcs, r.rest WHILE r#NIL DO
r.first.proc[RefID.Reseal[dbinfo], entry, r.first.ident, r.first.clientData];
ENDLOOP;
};

Register: PUBLIC PROC [name: ATOM, class: Class, tryLast: BOOLEAN м FALSE] RETURNS [] ~ {
found: BOOLEAN м FALSE;
prev: LIST OF Class м NIL;
FOR c: LIST OF Class м registeredClasses, c.rest WHILE c # NIL DO
IF c.first.name = name THEN {  -- found named class
found м TRUE;
EXIT;
};
prev м c; 
ENDLOOP;
SELECT TRUE FROM
NOT found AND class # NIL => 	-- add named class
IF tryLast AND registeredClasses # NIL 
THEN prev.rest м LIST[class] 
ELSE registeredClasses м CONS[class, registeredClasses];
found AND class # NIL => 	-- replace named class
IF prev = NIL 
THEN registeredClasses.first м class 
ELSE prev.rest.first м class;  
found AND class = NIL => 	-- remove named class
IF prev = NIL 
THEN registeredClasses м registeredClasses.rest 
ELSE prev.rest м prev.rest.rest;  
ENDCASE;
};

Lookup: PUBLIC PROC [name: ATOM] RETURNS [class: Class] ~ {
class м NIL;
FOR c: LIST OF Class м registeredClasses, c.rest WHILE c # NIL DO
IF c.first.name = name THEN {  -- found named class
class м c.first;
EXIT;
};
ENDLOOP;
};
List: PUBLIC PROC [] RETURNS [classes: LIST OF Class] ~ {
classes м registeredClasses;
};
END.
   ╢  
LoganBerryClassImpl.mesa
Copyright ╙ 1989, 1992 by Xerox Corporation.  All rights reserved.
Doug Terry, October 24, 1990 5:43 pm PDT
Christian Jacobi, April 23, 1992 10:44 am PDT

Mechanisms for registering new LoganBerry classes.  A LoganBerry class is a collection of routines that implement the LoganBerry interface.  In addition to the standard LoganBerry implementation, examples of LoganBerry classes include stubs for performing RPC calls to remote LoganBerry servers and "veneers" that enable other databases, such as Cypress, to be accessed as LoganBerry databases.

This module maps calls on the generic LoganBerry interface into calls on a specific LoganBerry class.  A specific class is bound to a database handle during the Open call.  On Open, each registered LoganBerry class is given the opportunity to Open the named database.  The first class that returns a non-null open database handle is used for subsequent calls on that handle.  Thus, the Open routine for each class should first check that the named database is one that is managed by the particular class.

On Open, an effort is made to return the same handle for the same database since write procs are associated with a given database handle.  Unfortunately, only the class-specific Open routine can determine that two names, such as "SampleLB.df" and "/Strowger//Temp/SampleLB.df", refer to the same database.  The algorithm for Open is as follows:
1. Lookup the presented name in the openDBTable; if found then return the associated generic OpenDB handle.  This is simply an optimization to avoid calling the class-specific Open routines.
2. Call each class-specific Open routine until one returns a non-null class-specific OpenDB handle.
3. Look in the openDBTable to see if any generic OpenDB handles are associated with the class-specific OpenDB handle returned in step 2.  If so, then return the previously returned generic OpenDB handle.  In this case, although the presented name differs from the name of any database that has been previously opened, we conclude that the database is really the same.
4. Add an entry to the openDBTable associating the presented database name with the returned generic OpenDB handle.  Note that several entries in the openDBTable may have different names but the same generic OpenDB handle.
Thus, if a LoganBerry class is careful to always return the same handle for the same database (regardless of what name gets passed to it), then the generic level preserves this property.
Willie-s, April 23, 1992 5:13 pm PDT

Opening databases
Try registered Open procedures until one returns a non-null handle.
Add entry to openDBTable table, first making sure that the database name is not an alias for a database previously opened.
This routine is monitored since two or more clients may be trying to open the same database at the same time.  A check is made to see if an entry already in the openDBTable refers to the same class-specific OpenDB handle.  If so, then the existing dbinfo record is returned.  In either case, an new entry is added to the openDBTable.
[key: ROPE, val: SymTab.Val] RETURNS [quit: BOOL _ FALSE]
Methods
Unseals the database handle and ensures that it's valid.
Unseals the cursor and ensures that it's valid.
Write procedure registration
Code written by Dan Swinehart.  

Note: for remote databases this doesn't provide the same guarantees as for local database.  That is, the registered procedures only see updates that are invoked at the same site on the same database handle.  Updates to the database performed by other clients at other sites are not observed.

Warning:  This routine is unmonitored so the list of registered procs may be changing as it is being traversed.  This should be okay.
Registration
Registers the given LoganBerry class with the given name.  Any class already registered with the name is replaced.  class=NIL unregisters the named class.  If tryLast=TRUE then this class is given the last opportunity to open a named database (this is intended for use by the main LoganBerry implementation); otherwise, newly registered classes are placed at the front of the line.
Returns the named class or NIL if a class is not registered under the given name.

Returns a list of all currently registered classes.


Э╩▒  ХNewlineDelimiter
Ц(cedarcode) styleЩ codeЪЬЩKЪЬ
╧eЬ7ЩBKЪЬ(Щ(KЩ-KЩ KЩЛKЩ∙KЪЬ╪Щ╪KЪЬ╛Щ╛KЪЬcЩcKЪЬяЩяKЪЬ▐Щ▐KЪЬ║Щ║KЩ$KЩ ЧЪ╧k	Ш	KЪЮЬЮЬШKЪЬЮЬ!Ш,KЪЬЮЬ5ШAKЪЬШKЪЬШЧKШ KЪ╤blnЬЮЬЮЬ╧c$ШGKЪЮЬШKЪЮЬШ#ЪЬЮШKШ KЪЮЬШ!KШ KШ Icode0ЪЬЮЬЮЬ	ЮЬаШELШ LЪЬЮЬа!ШBLШ LЪЬЮЬЮЬШ2ЪЬЮЬЮЬШ$LЪЬЮЬа*ШALЪЬаШ*LЪЬЮЬЮЬШ3LШЧLШ LЪЬЮЬЮЬШ2ЪЬЮЬЮЬШ#LЪЬа'Ш9LЪЬаЬаШ1LШLШ ЧKЪЬЮЬЮЬШ<ЪЬЮЬЮЬШ)KШKЪЬЮЬШKЪЬЮШKЪЬШKШ ЧЪЬЮЬЮЬЮЬЮЬЮЬШDLШ ЧЧheadЩЪ╧nЬЮЬЮЬЮЬ
ЮЬЮЬШKKЪЬШЪЮЬЮЬЮШKЪЬ-ЮЬШ4ЧKЪЬ	ЮЬ(Ш7ЪЮЬ
ЮЬШЪЮЬа3Ш;KЪЬ	ЮЬШ"KЪЬЮЬШ"KЩCЪЮЬЮЬЮЬ#ЮЬЮЬЮШ?ЪЮЬЮЬЮШKШ'ЧЪЮЬЮЬШ'KШKЪЮЬШKШЧKЪЮЬШЧЪЮЬЮЬЮШKЪЮЬKШPЧKЪЬzЩzKШ,KШKШЧЪЮЬаШЪЮЬЮЬЮШ KШ-ЧKШKШЧЧKЪЬШЧKШ Ъ
бЬЮЬЮЬ
ЮЬЮЬШhKЪЬ═Щ═ХStartOfExpansion= -- [key: ROPE, val: SymTab.Val] RETURNS [quit: BOOL _ FALSE]ЪбЬШ"KЪ╨ck9Щ9KЪЬ ЮЬШ,ЪЮЬ!ЮЬЮЬШGKШKЪЬЮЬШKШЧKШЧKШ3KШ=KЪЮЬ	ШKШЧKШ ЧЩЪб	ЬЮЬЮЬЮЬ9ЮЬЮЬШМKШ(KЪ
ЮЬЮЬЮ
ЬЮЬ1ЮЬШУKШFKШЧKШ Ъ
бЬЮЬ:ЮЬЮЬЮЬШЦKШ(KЪ
ЮЬ!ЮЬЮ
ЬЮЬ1ЮЬШЪKЪЬ@Ш@KШЧKШ ЪбЬЮЬЮЬЮЬ:ЮЬЮЬЮЬШдKЪЬЮЬШ4KШ(KЪ
ЮЬ ЮЬЮ
ЬЮЬ1ЮЬШЩKШKШNKШKЪЬШЧKШ Ъ
б	ЬЮЬЮЬЮЬ5ЮЬШwKШ1KЪ
ЮЬЮЬЮ
ЬЮЬ1ЮЬШСKШ7KШЧKШ Ъ
бЬЮЬЮЬЮЬЮЬШJKШ1KЪ
ЮЬЮЬЮ
ЬЮЬ1ЮЬШУKЪЬ,Ш,KШKШЧKШ Ъб
ЬЮЬЮЬЮЬ?ЮЬЮЬЮЬШЗKШ(KЪ
ЮЬЮЬЮ
ЬЮЬ1ЮЬШФKЪЬ>Ш>KЪЬаШ9KШЧKШ Ъ
бЬЮЬЮЬЮЬ9ЮЬШqKЪЬШKШ(KЪ
ЮЬЮЬЮ
ЬЮЬ1ЮЬШХKШ>KЪЮЬЮЬЮЬаШKKШЧKШ Ъ
бЬЮЬЮЬЮЬЮЬШ@KШ(KЪ
ЮЬЮЬЮ
ЬЮЬ1ЮЬШПKЪЬ$Ш$KШЧKШ Ъ
бЬЮЬЮЬЮЬЮЬШGKШ(KЪ
ЮЬЮЬЮ
ЬЮЬ1ЮЬШЦKЪЬ+Ш+KЪЬШЧKШ Ъ
бЬЮЬЮЬЮЬЮЬШFKШ(KЪ
ЮЬЮЬЮ
ЬЮЬ1ЮЬШХKЪЬ*Ш*KШЧKШ Ъ
бЬЮЬЮЬЮЬЮЬШSKШ(KЪ
ЮЬЮЬЮ
ЬЮЬ1ЮЬШТKЪЬЮЬЮЬ'Ш.KШЧKШ ЪбЬЮЬЮЬЮЬЮЬЮЬШLKШ(KЪ
ЮЬЮЬЮ
ЬЮЬ1ЮЬШСKЪЬЮЬЮЬ Ш(KШKШ ЧЪ
бЬЮЬЮЬ$ЮЬЮЬШVKШ(KЪ
ЮЬ!ЮЬЮ
ЬЮЬ1ЮЬШЪKЪЬ5Ш5KШKШ ЧЪбЬЮЬЮЬ ЮЬЮЬЮЬЮЬШlKШ(KЪ
ЮЬЮЬЮ
ЬЮЬ1ЮЬШШKЪЬ	ЮЬЮЬ/Ш;KШKШ ЧЪбЬЮЬЮЬ/ШIЪЮЬШЪЮЬаШ"KШ(ЪЮЬЮЬЮЬШ(KЪЬ%Ш%ЧKШЧЪЮЬа%Ш,ЪЮЬЮЬЮЬ#ЮЬЮЬЮШAЪЮЬЮЬЮЬШ#KЪЬ(Ш(ЧKЪЮЬШЧKШЧЧKШKШ ЧЪ
бЬЮЬЮЬЮЬ	ЮЬ"ШjKШ(KШKЪЬЮЬЮЬ
ШKШKШ ЧЪбЬЮЬЮЬЮЬШAKЩ8KЪЬЮЬШЪЮЬЮЬЮШKЪЮЬ+Ш0ЧЪЮЬЮЬЮШЪЬЮШKЪЮЬ	ШKШЧKЪЮЬЮЬ/Ш?ЧKШKШ ЧЪбЬЮЬЮЬЮЬШKKЪЬ/Щ/KЪЬЮЬШ ЪЮЬЮЬЮШKЪЮЬ"Ш'ЧЪЮЬЮЬЮШЪЬЮШKЪЮЬШKШЧKЪЮЬЮЬ&Ш6ЧKШЧЧЩKЪа Щ KЩ KЪагЩгKЩ ЪбЬЮЬЮЬЮЬ<ЮЬЮЬШzKЪЮЬЮЬЮЬШKШ(KЪЬЮЬRШrЪЮЬЮЬЮЬ=ЮЬЮЬЮШYKЪЮЬЮЬЮЬШ7KЪЮЬШЧKЪЬЮЬ#ШEKШKШ ЧЪ
бЬЮЬЮЬЮЬ ЮЬШOKЪЮЬЮЬЮЬШKШ(KЪЬЮЬЮЬ5ШBKЪЮЬЮЬЮЬЮЬШKЪЮЬЮЬ,ЮЬШTЪЮЬЮЬЮЬ$ЮЬЮЬЮШEKЪЮЬЮЬЮЬШCKЪЮЬШЧKШKШ ЧЪбЬЮ	ЬЮЬ-ШJKЩЕЪЮЬЮЬЮЬ=ЮЬЮЬЮШYKЪЬMШMKЪЮЬШЧKШKШ ЧЧЩЪбЬЮЬЮЬЮЬЮЬЮЬШYKЪЬ¤Щ¤KЪЬЮЬЮЬШKЪЬЮЬЮЬ	ЮЬШЪЮЬЮЬЮЬ#ЮЬЮЬЮШAЪЮЬЮЬаШ3KЪЬЮЬШKЪЮЬШKШЧKШ
KЪЮЬШЧЪЮЬЮЬЮШЪЮЬЮЬ	ЮЬаШ0ЪЮЬ	ЮЬЮЬШ'KЪЮЬЮЬШKЪЮЬЮЬШ8ЧЧЪЬЮЬ	ЮЬаШ0ЪЮЬЮЬШKЪЮЬ!Ш%KЪЮЬШЧЧЪЬЮЬ	ЮЬаШ/ЪЮЬЮЬШKЪЮЬ,Ш0KЪЮЬШ"ЧЧKЪЮЬШЧШKШ ЧЧЪбЬЮЬЮЬЮЬШ;KЪЬQЩQKЪЬЮЬШЪЮЬЮЬЮЬ#ЮЬЮЬЮШAЪЮЬЮЬаШ3KШKЪЮЬШKШЧKЪЮЬШЧKШKЩ ЧЪ
бЬЮЬЮЬЮЬЮЬШ9KЪЬ3Щ3KШKШKЩ KЩ ЧЧKЪЮЬШKЩ Ч ЕЧ    ,а  K  