DIRECTORY
PFS,
FileNames,
RefText,
Rope,
SystemNames;

FileNamesOnPFSImpl: CEDAR MONITOR
IMPORTS PFS, RefText, Rope, SystemNames 
EXPORTS FileNames
= BEGIN

LOR: TYPE = LIST OF ROPE;
LORA: TYPE = LIST OF REF ANY;
ROPE: TYPE = Rope.ROPE;

lastPreSlash1: ROPE м NIL;
lastPostSlash1: ROPE м NIL;
lastPreSlash2: ROPE м NIL;
lastPostSlash2: ROPE м NIL;
lastUserName: ROPE м NIL;
lastHomeDirectory: ROPE м NIL;

FileWithSearchRules: PUBLIC PROC
[root: ROPE, defaultExtension: ROPE,
requireExtension: BOOL м TRUE, requireExact: BOOL м TRUE, searchRules: REF ANY]
RETURNS [fullPath: ROPE м NIL, ambiguous: BOOL м FALSE] = {
fullPathName: BOOL м FALSE;
withExt: ROPE м NIL;
withStarExt: ROPE м NIL;
rules: LORA;
ropeRules: LOR;
list: LORA;
ropeList: LOR;
hasExtension: BOOL м FALSE;
hasVersion: BOOL м FALSE;
doRoot, doWithExt, doWithStarExt: BOOL м FALSE;
defaultExtLen: INT = Rope.Length[defaultExtension];
rootLen: INT м Rope.Length[root м ResolveRelativePath[root]];
Try: PROC [name: ROPE, wDir: ROPE м NIL] RETURNS [found: BOOL] = {
IF NOT Rope.IsEmpty[name] THEN {
fullPathName: PFS.PATH м NIL;
Inner: PROC ~ {
fullPathName м PFS.FileInfo[name: PFS.PathFromRope[name]
! PFS.Error => IF error.group = user THEN CONTINUE].fullFName;
};
IF wDir = NIL THEN Inner[] ELSE PFS.DoInWDir[PFS.PathFromRope[wDir], Inner];
fullPath м PFS.RopeFromPath[fullPathName];
RETURN [fullPathName # NIL];
};
RETURN [FALSE];
};
UniqueMatch: PROC [name: ROPE, wDir: ROPE м NIL] RETURNS [found: BOOL] = {
lst: LOR м NIL;
p: PFS.NameProc = {
continue м lst = NIL;  -- give up after this name if it is the second one
IF lst # NIL THEN ambiguous м TRUE;
lst м CONS[PFS.RopeFromPath[name], lst];
};
IF name.IsEmpty[] THEN {
fullPath м NIL;
RETURN [TRUE];
};
BEGIN
Inner: PROC ~ {
PFS.EnumerateForNames[pattern: PFS.PathFromRope[name], proc: p
! PFS.Error => IF error.group = user THEN CONTINUE];
};
IF wDir = NIL THEN Inner[] ELSE PFS.DoInWDir[PFS.PathFromRope[wDir], Inner];
END;
IF lst = NIL THEN RETURN [FALSE];
IF ambiguous THEN {
fullPath м NIL;
RETURN [TRUE];
};
ambiguous м TRUE;
fullPath м ConvertToSlashFormat[lst.first];
RETURN [TRUE];
};

IF rootLen = 0 THEN RETURN [NIL];
SELECT Rope.Fetch[root, 0] FROM
'/, '[ => fullPathName м TRUE;
ENDCASE;
FOR i: INT DECREASING IN [0..rootLen) DO
SELECT Rope.Fetch[root, i] FROM
'>, '], '/ => EXIT;
'. => {hasExtension м TRUE; EXIT};
'! => hasVersion м TRUE;
ENDCASE;
ENDLOOP;
IF requireExtension AND NOT hasExtension AND hasVersion THEN RETURN [NIL];
IF requireExtension AND hasExtension AND defaultExtLen # 0 THEN
IF Rope.Find[s1: root, s2: defaultExtension, pos1: 0, case: FALSE]
# (Rope.Index[s1: root, s2: "!", pos1: 0, case: TRUE] - defaultExtLen) THEN
RETURN [NIL];
IF NOT hasExtension THEN {
withExt м Rope.Concat[root, defaultExtension];
withStarExt м Rope.Cat[root, "*", defaultExtension];
IF NOT hasVersion THEN {
withExt м Rope.Concat[withExt, "!H"];
withStarExt м Rope.Concat[withStarExt, "!H"];
};
};
doRoot м NOT requireExtension OR hasExtension;
doWithExt м NOT hasExtension;
doWithStarExt м (NOT requireExact) AND (NOT hasExtension);
IF fullPathName
THEN {
IF doRoot AND Try[name: root] THEN RETURN;
IF doWithExt AND Try[name: withExt] THEN RETURN;
IF doWithStarExt AND UniqueMatch[name: withStarExt] THEN RETURN;
}
ELSE {
IF doRoot AND Try[name: root] THEN RETURN;
WITH searchRules SELECT FROM
lra: LORA => rules м lra;
lr: LOR => ropeRules м lr;
ENDCASE;
list м rules;
ropeList м ropeRules;
IF doRoot THEN {
WHILE list # NIL DO
IF Try[name: root, wDir: NARROW[list.first, ROPE]] THEN RETURN;
list м list.rest;
ENDLOOP;
WHILE ropeList # NIL DO
IF Try[name: root, wDir: ropeList.first] THEN RETURN;
ropeList м ropeList.rest;
ENDLOOP;
};
IF doWithExt AND Try[name: withExt] THEN RETURN;
IF doWithExt THEN {
list м rules;
ropeList м ropeRules;
WHILE list # NIL DO
IF Try[name: withExt, wDir: NARROW[list.first, ROPE]] THEN RETURN;
list м list.rest;
ENDLOOP;
WHILE ropeList # NIL DO
IF Try[name: withExt, wDir: ropeList.first] THEN RETURN;
ropeList м ropeList.rest;
ENDLOOP;
};
IF doWithStarExt THEN {
IF UniqueMatch[name: withStarExt] THEN RETURN;
list м rules;
ropeList м ropeRules;
WHILE list # NIL DO
IF UniqueMatch[name: withStarExt, wDir: NARROW[list.first, ROPE]] THEN RETURN;
list м list.rest;
ENDLOOP;
WHILE ropeList # NIL DO
IF UniqueMatch[name: withStarExt, wDir: ropeList.first] THEN RETURN;
ropeList м ropeList.rest;
ENDLOOP;
};
};
};

ParseState: TYPE = {idle, slash, oneDot, twoDots};

CurrentWorkingDirectory: PUBLIC PROC RETURNS [ROPE] = {
RETURN [PFS.RopeFromPath[PFS.GetWDir[]]]
};

ResolveRelativePath: PUBLIC PROC [path: ROPE] RETURNS [ROPE] = {
i: INT м 0;
state: ParseState м slash;
pathLength: INT м Rope.Length[path м ConvertToSlashFormat[path]];
out: REF TEXT м NIL;
char: CHAR;
usedCWD: BOOL м FALSE;
HandleDot: PROC [pos: INT] = {
IF out = NIL THEN out м RefText.New[pathLength];
IF pos - 1 > 0 THEN out м RefText.AppendRope[to: out, from: path, start: 0, len: pos - 1];
IF pos >= pathLength THEN path м NIL ELSE path м path.Substr[pos + 1];
pathLength м path.Length[];  -- recompute pathLength
};
HandleDotDot: PROC [pos: INT] = {
first: BOOL м TRUE;
IF out = NIL THEN out м RefText.New[pathLength];
IF pos - 2 > 0 THEN out м RefText.AppendRope[to: out, from: path, start: 0, len: pos - 2];
IF pos >= pathLength THEN path м NIL ELSE path м path.Substr[pos + 1];
pathLength м path.Length[];  -- recompute pathLength
pos м out.length - 1;  -- index of last character in out
DO
IF pos < 0 THEN {
out.length м 0;
IF usedCWD THEN EXIT;
usedCWD м TRUE;
out м RefText.AppendRope[to: out, from: PFS.RopeFromPath[PFS.GetWDir[]]];
pos м out.length - 1;  -- continue scanning at end of CWD
LOOP;
};
IF out[pos] = '/ AND NOT first THEN {
out.length м pos + 1;
EXIT;
};
pos м pos - 1;
first м FALSE;
ENDLOOP;
};
IF pathLength = 0 THEN RETURN [path];
IF path.Fetch[0] = '~ THEN {
usedCWD м TRUE;
out м RefText.AppendRope[to: RefText.New[pathLength], from: HomeDirectory[]];
out.length м out.length - 1;
state м idle;
pathLength м Rope.Length[path м Rope.Substr[path, 1]];
};

DO
IF i >= pathLength THEN EXIT;
char м path.Fetch[i];
SELECT state FROM
idle => IF char = '/ THEN state м slash;
slash => {
SELECT char FROM
'. => state м oneDot;
'/ => state м slash;
ENDCASE => state м idle;
};
oneDot => {
SELECT char FROM
'. => state м twoDots;
'/ => {
HandleDot[i];
i м 0;
state м slash;
LOOP;
};
ENDCASE => state м idle;
};
twoDots => {
IF char = '/ THEN {
HandleDotDot[i];
i м 0;
state м slash;
LOOP;
}
ELSE state м idle;
};
ENDCASE => ERROR;
i м i + 1;
ENDLOOP;
IF state = oneDot OR state = twoDots
THEN {
IF state = oneDot THEN HandleDot[pathLength]
ELSE HandleDotDot[pathLength];
path м Rope.FromRefText[out];
}
ELSE
IF out # NIL THEN path м Rope.Concat[Rope.FromRefText[out], path];
IF path.IsEmpty[] AND NOT usedCWD THEN path м PFS.RopeFromPath[PFS.GetWDir[]];
RETURN [path];
};

ConvertToSlashFormat: PUBLIC ENTRY PROC [path: ROPE] RETURNS [ROPE] = {
ENABLE UNWIND => NULL;
SELECT TRUE FROM
Rope.Equal[path, lastPreSlash1] => RETURN [lastPostSlash1];
Rope.Equal[path, lastPreSlash2] => RETURN [lastPostSlash2];
ENDCASE => {
ToSlash: Rope.TranslatorType = {
gnu: CHAR м SELECT old FROM
'[, '], '<, '> => '/
ENDCASE => old;
RETURN[gnu];
};
pos: INT м path.Find["]<"];
lastPreSlash1 м lastPreSlash2;
lastPostSlash1 м lastPostSlash2;
lastPreSlash2 м path;
IF pos # -1 THEN path м Rope.Replace[base: path, start: pos, len: 2, with: "/"];
IF Rope.SkipTo[s: path, pos: 0, skip: "[]<>"] # path.Length[] THEN
path м Rope.Translate[base: path, translator: ToSlash];
lastPostSlash2 м path;
RETURN [path];
};
};

HomeDirectory: PUBLIC ENTRY PROC RETURNS [ROPE] = {
ENABLE UNWIND => NULL;
user: ROPE м SystemNames.UserName[]; --UserCredentials.Get[].name;
IF ( NOT Rope.Equal[lastUserName, user] ) THEN {
lastHomeDirectory м SystemNames.SimpleHomeDirectory[];
lastUserName м user;
};
RETURN [lastHomeDirectory];
};

IsADirectory: PUBLIC PROC [path: ROPE] RETURNS [BOOL] = {
length: INT м Rope.Length[path];
IF length # 0 THEN SELECT Rope.Fetch[path, length-1] FROM
'/, '], '> => RETURN [TRUE];
ENDCASE;
RETURN [FALSE];
};

IsAPattern: PUBLIC PROC [path: ROPE] RETURNS [BOOL] = {
RETURN [Rope.SkipTo[path, 0, "*"] # Rope.Length[path]];
};

GetShortName: PUBLIC PROC
[path: ROPE, stripOffVersionNumber: BOOL м TRUE] RETURNS [ROPE] = {
len: INT м Rope.Length[path];
bang: INT м len;
pos: INT м len;
WHILE pos # 0 DO
np: INT м pos - 1;
c: CHAR м Rope.Fetch[path, np];
SELECT c FROM
'! => IF stripOffVersionNumber THEN bang м np;
'>, '], '/ => RETURN [Rope.Substr[path, pos, bang-pos]];
ENDCASE;
pos м np;
ENDLOOP;
RETURN [Rope.Substr[path, 0, bang]];
};

Tail: PUBLIC PROC [s: ROPE, char: CHAR] RETURNS [ROPE] = {
pos: INT м s.Length[];
WHILE pos # 0 DO
IF Rope.Fetch[s, pos-1] = char THEN RETURN [Rope.Substr[s, pos]];
pos м pos - 1;
ENDLOOP;
RETURN [s];
};

StripVersionNumber: PUBLIC PROC [path: ROPE] RETURNS [ROPE] = {
pos: INT м path.Find["!"];
IF pos = -1 THEN RETURN [path];
RETURN [path.Substr[0, pos]];
};
IsRemote: PUBLIC PROC [path: ROPE] RETURNS [BOOL] = {
first, second: CHAR;
IF path.Length[] < 2 THEN RETURN [FALSE];
first м path.Fetch[0];
second м path.Fetch[1];
SELECT first FROM
'/ => RETURN [second # '/];
'[ => RETURN [second # ']];
ENDCASE;
RETURN [FALSE];
};
InASubdirectory: PUBLIC PROC [parent: ROPE, path: ROPE] RETURNS [BOOL] = {
pos: INT;
path м ConvertToSlashFormat[path];
parent м ConvertToSlashFormat[parent];
pos м Rope.Find[s1: path, s2: parent, case: FALSE];
IF pos = -1 THEN RETURN [FALSE];
RETURN [Rope.Find[s1: path, s2: "/", pos1: parent.Length[]] # -1];
};

FirstSubdirectory: PUBLIC PROC [parent: ROPE, path: ROPE] RETURNS [ROPE] = {
pos: INT;
end: INT;
path м ConvertToSlashFormat[path];
parent м ConvertToSlashFormat[parent];
pos м Rope.Find[s1: path, s2: parent, case: FALSE];
IF pos # 0 THEN RETURN [NIL];
pos м parent.Length[];
IF pos = 0 THEN RETURN [NIL];
end м Rope.Find[s1: path, s2: "/", pos1: pos];
IF end = -1 THEN RETURN [NIL];
RETURN [Rope.Substr[base: path, start: 0, len: end + 1]];
};

DirectoryContaining: PUBLIC PROC [path: ROPE, pos: INT] RETURNS [ROPE] = {
WHILE pos > 0 DO
c: CHAR м Rope.Fetch[path, pos м pos - 1];
SELECT c FROM
'>, '], '/ => RETURN [Rope.Substr[path, 0, pos+1]];
ENDCASE;
ENDLOOP;
RETURN [NIL];
};
Directory: PUBLIC PROC [path: ROPE] RETURNS [ROPE] = {
RETURN [DirectoryContaining[path, Rope.Length[path]]];
};

Parent: PUBLIC PROC [path: ROPE] RETURNS [ROPE] = {
len: INT м Rope.Length[path];
pos: INT м len;
first: BOOL м TRUE;
WHILE pos # 0 DO
c: CHAR м Rope.Fetch[path, pos - 1];
SELECT c FROM
'>, '], '/ => IF pos # len THEN RETURN [Rope.Substr[path, 0, pos]];
ENDCASE;
pos м pos - 1;
ENDLOOP;
RETURN [NIL];
};


RelativizePath: PUBLIC PROC [path: ROPE] RETURNS [ROPE] = {
homeDir: ROPE м HomeDirectory[];
homeDirLen: INT м Rope.Length[homeDir];
slashName: ROPE м ConvertToSlashFormat[path];
IF Rope.Run[homeDir, 0, slashName, 0, FALSE] = homeDirLen THEN
path м Rope.Replace[path, 0, homeDirLen, "~/"];
RETURN [path];
};

END.
    
FileNamesOnPFSImpl.mesa
Copyright ╙ 1985, 1987, 1989, 1991 by Xerox Corporation.  All rights reserved.
L. Stewart, January 16, 1984 1:03 pm
Russ Atkinson (RRA) February 16, 1987 7:46:03 pm PST
Doug Wyatt, January 24, 1987 11:50:39 pm PST
JKF December 22, 1988 2:35:42 pm PST
Bill Jackson (bj) October 24, 1988 12:42:06 pm PDT
Carl Hauser, November 30, 1988 10:45:59 am PST
Pier, February 2, 1989 2:20:16 pm PST
Michael Plass, November 29, 1989 1:00:07 pm PST

Clients of this should be converted to use PFS directly.
Willie-s, August 20, 1991 5:46 pm PDT

A few small caches
FileWithSearchRules uses the working directory and the search rules to try to translate the short name of a file into a full path name.  Calls ResolveRelativePath first.  NIL is returned if the file cannot be found.
searchRules should either be a LIST OF REF ANY or a LIST OF Rope.ROPE.
If requireExtension, then if root has an extension, it must be the same as defaultExtension.
FileWithSearchRules adds !H to all pattern matches
IF requireExact = TRUE, then FileWithSearchRules will not try for a unique pattern match, but will only check exact names.
FileWithSearchRules returns NIL and ambiguous = TRUE if it finds more than one matching file.
FileNames returns not-NIL and ambiguous = TRUE if the result was found as a consequence of an exact pattern match.
FileWithSearchRules uses the following rules:
IF root is a full path name
THEN {
tries root
tries Concat[root, defaultExtension]
tries for a unique match for Cat[root, *, defaultExtension]
}
ELSE {
tries root (automatically used $WorkingDirectory)
FOR wdir _ each element of search rules {
tries Concat[wdir, root]
}
tries Concat[root, defaultExtension] (automatically used $WorkingDirectory)
FOR wdir _ each element of search rules {
tries Cat[wdir, root, defaultExtension]
}
IF NOT requireExact THEN FOR wdir _ each element of search rules {
tries for a unique match for Cat[wdir, root, *, defaultExtension]
}
}
Returns NIL if can't find it.
Exactly one match
try the exact matches
try for a unique match
If path starts with or contains ./ or ../, ResolveRelativePath converts it into the equivalent full path name using the $WorkingDirectory property on the process properties list.
If path is exactly . or .., ResolveRelativePath converts it to the current or parent directory.
HandleDot is called with pos pointing to the location of the trailing '/ is the "/./" construct, it works if either the leading or trailing slash aren't there, as in "./xxx" or "xxx/."
After execution of HandleDot, out holds the path tp to and including the leading / while path holds the path after the trailing slash.
If the leading slash doesn't exist, then out will be allocated but empty.
If the trailing slash doesn't exist (or was the last character in path), then path will be empty
out now includes up to and including the leading slash.
path now starts at the character after the trailing slash
HandleDotDot is called with pos pointing to the location of the trailing '/ is the "/../" construct. It worksif either the leading or trailing slash aren't there, as in "../xxx" or "xxx/.."
After execution of HandleDotDot, out holds the path tp to and including the / terminating the parent directory while path holds the path after the trailing slash.
If the leading slash doesn't exist, then out will contain the parent of CWD.
If the trailing slash doesn't exist (or was the last character in path), then path will be empty
pos is the location of the trailing '/
out now contains the path up to and including the leading slash
path now starts at the character after the trailing slash
Now strip back out to the last slash, provided it is not the first character examined
Put in ///Users/name/, then pull back on the trailing /
delete the "./" construct
continue scanning from beginning (since HandleDot has re-written path)
handle the "../" construct
continue scanning from beginning (since HandleDot has re-written path)
The next character we get should be the one after the slash
handle state at end of path
The next lines call HandleDot (or DotDot) with a pointer to the '/ which is off the end of the path.
TYPE = PROC [old: CHAR] RETURNS [CHAR]
Convert to slashes
Tail returns the part of a rope after the last instance of char.


Return the prefix of the part of name before pos which is the name of a directory.

Return the directory part of a name.
If path is a directory, then returns the parent directory.  If path is a file, then returns the current directory.  In either case, this means that Parent returns the directory which contains the current object.
Extras
 Э╩У  Ц(cedarcode) styleХNewlineDelimiter
Щ codeЪЬЩKЪЬ
╧eЬCЩNKЩ$KЪЬ╧kЬЮЩ4KЪЬ)ЮЩ,KЪЮЬЮЩ$KЪЬ/ЮЩ2KЪЬ+ЮЩ.KЪЬ%Щ%KЩ/KЩ KЩ8KЩ%KЩ ЧЪЮ	Ш	KЪЮЬШKЪЬ
Ш
KЪЬШKЪЬШKШЧKШ Ъ╧nЬЮЬЮШ!KЪЮЬЮЬШ(KЪЮЬ
ШKЪЬЮШKШ KЪ
ЮЬЮЬЮЬЮЬЮЬШKЪЮЬЮЬЮЬЮЬЮЬЮЬШKЪЮЬЮЬЮЬШKШ ЧЩKЪЬЮЬЮЬШKЪЬЮЬЮЬШKЪЬЮЬЮЬШKЪЬЮЬЮЬШKЪЬЮЬЮЬШKЪЬЮЬЮЬШKШ ЧЪ ЯЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬШ╤KЪЬлЮЬ)Щ╫KЪЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬЩFKЪЬ\Щ\KЩ2KЪЮЬЮЬdЩzKЪЬЮЬЮЬ)Щ]KЪЬЮЬЮЬDЩrЪЬ-Щ-ЪЮЬЩЪЮЬЩKЪЬ
Щ
KЪЬ$Щ$KЪЬ;Щ;KЩЧЪЮЬЩKЪЬ1Щ1ЪЮЬ&Щ)KЪЬЩKЩЧKЪЬKЩKЪЮЬ&Щ)KЪЬ'Щ'KЩЧЪЮЬЮЬЮЬЮЬ&ЩBKЪЬAЩAKЩЧKЩЧЧKЪЬЮЬЩЧKЪЬЮЬЮЬШKЪЬ	ЮЬЮЬШKЪЬЮЬЮЬШKЪЬЮЬШKЪЬЮЬШKЪЬЮЬШKЪЬ
ЮЬШKЪЬЮЬЮЬШKЪЬЮЬЮЬШKЪЬ"ЮЬЮЬШ/KЪЬЮЬ!Ш3KЪЬ	ЮЬ1Ш=ЪЯЬЮЬЮЬЮЬЮЬЮЬ	ЮЬШBЪЮЬЮЬЮЬШ KЪЬЮЬЮЬЮЬШЪЯЬЮЬШЪЬЮЬЮЬШ8KЪ	ЬЮЬ
ЮЬЮЬЮЬШ>ЧKЪЬШЧKЪЮЬЮЬЮЬ	ЮЬЮЬ
ЮЬШLKЪЬЮЬШ*KЪЮЬЮЬШKШЧKЪЮЬЮЬШKШЧЪЯЬЮЬЮЬЮЬЮЬЮЬ	ЮЬШJKЪЬЮЬЮЬШЪЬЮЬШKЪЬЮЬ╧c2ШIKЪЮЬЮЬЮЬЮЬШ#KЪЬЮЬЮЬШ(KЪЬШЧЪЮЬЮЬШKЪЬЮЬШKЪЮЬЮЬШKШЧЪЮШЪЯЬЮЬШЪЮЬЮЬШ>KЪ	ЬЮЬ
ЮЬЮЬЮЬШ4ЧKЪЬШЧKЪЮЬЮЬЮЬ	ЮЬЮЬ
ЮЬШLKЪЮЬШЧKЪ
ЮЬЮЬЮЬЮЬЮЬШ!ЪЮЬЮЬШKЪЬЮЬШKЪЮЬЮЬШKШЧKЩKЪЬЮЬШKЪЬ+Ш+KЪЮЬЮЬШKШЧKШ KЪЮЬЮЬЮЬЮЬШ!ЪЮЬЮШKЪЬЮЬШKЪЮЬШЧЪ	ЮЬЮЬЮ
ЬЮЬЮШ(ЪЮЬЮШKЪЬЮЬШKЪЬЮЬЮЬШ"KЪЬЮЬШKЪЮЬШЧKЪЮЬШЧKЪЮЬЮЬЮЬЮЬЮЬЮЬЮЬШJЪЮЬЮЬЮЬЮШ?ЪЮЬ:ЮЬ2ЮЬЮШОKЪЮЬЮЬШЧЧЪЮЬЮЬЮЬШKЪЬ.Ш.KЪЬ4Ш4ЪЮЬЮЬЮЬШKЪЬ%Ш%KЪЬ-Ш-KШЧKШЧKЪЬ	ЮЬЮЬШ.KЪЬЮЬШKЪЬЮЬЮЬЮЬШ:ЪЮЬШЪЮЬШKЩKЪЮЬЮЬЮЬЮЬШ*KЪЮЬЮЬЮЬЮЬШ0KЩKЪЮЬЮЬ ЮЬЮЬШ@KШЧЪЮЬШKЪЮЬЮЬЮЬЮЬШ*ЪЮЬЮЬЮШKЪЬЮЬШKЪЬЮЬШKЪЮЬШЧKШKШЪЮЬЮЬШЪЮЬЮЬЮШKЪ
ЮЬЮЬЮЬЮЬЮЬШ?KЪЬШKЪЮЬШЧЪЮЬЮЬЮШKЪЮЬ'ЮЬЮЬШ5KЪЬШKЪЮЬШЧKШЧKЪЮЬЮЬЮЬЮЬШ0ЪЮЬЮЬШKШKШЪЮЬЮЬЮШKЪ
ЮЬЮЬЮЬЮЬЮЬШBKЪЬШKЪЮЬШЧЪЮЬЮЬЮШKЪЮЬ*ЮЬЮЬШ8KЪЬШKЪЮЬШЧKШЧЪЮЬЮЬШKЪЮЬ ЮЬЮЬШ.KШKШЪЮЬЮЬЮШKЪ
ЮЬ&ЮЬЮЬЮЬЮЬШNKЪЬШKЪЮЬШЧЪЮЬЮЬЮШKЪЮЬ6ЮЬЮЬШDKЪЬШKЪЮЬШЧKШЧKШЧЧKЪЬШKШ ЧЪЬЮЬ"Ш2KШ ЧЪ
ЯЬЮЬЮЬЮЬЮЬШ7KЪЮЬЮЬЮЬШ(KЪЬШKШ ЧЪЯЬЮЬЮЬЮЬЮЬЮЬШ@KЪЬ▓Щ▓KЪЬ_Щ_KЪЬЮЬШKШKЪЬЮЬ2ШAKЪЬЮЬЮЬЮЬШKЪЬЮЬШKЪЬ	ЮЬЮЬШKЩ╕KЩЖKЩIKЩ`ЪЯ	ЬЮЬЮЬШKЪЮЬЮЬЮЬШ0KЪЮЬЮЬGШZKЩ7KЪЮЬЮЬЮЬЮЬШFKЩ9KЪЬаШ4KШЧЪЯЬЮЬЮЬШ!KЩ╜KЩвKЪЬHЮЬЩLKЩ`KЪЬЮЬЮЬШKЩ&KЪЮЬЮЬЮЬШ0KЪЮЬЮЬGШZKЩ?KЪЮЬЮЬЮЬЮЬШFKЩ9KЪЬаШ4KЩUKЪЬа!Ш8ЪЮШЪЮЬ	ЮЬШKШKЪЮЬ	ЮЬЮЬШKЪЬ
ЮЬШKЪЬ(ЮЬЮЬШIKЪЬа"Ш9KЪЮЬШKШЧЪЮЬЮЬЮЬЮЬШ%KШKЪЮЬШKШЧKШKЪЬЮЬШKЪЮЬШЧKШЧKЪЮЬЮЬЮЬШ%ЪЮЬЮЬШKЪЬ╧zЬ#Щ7KЪЬ
ЮЬШKЪЬMШMKЪЬШKЪЬШKЪЬ6Ш6KШЧKШ ЪЮШKЪЮЬЮЬЮЬШKЪЬШЪЮЬЮШKЪЬЮЬЮЬШ(Ш
ЪЮЬЮШKШKШKЪЮЬШЧKШЧШЪЮЬЮШKШЪЬШKЪЬЩKШЪЬШKЪЬFЩFЧKШKЪЮЬШKШЧKЪЮЬШЧKШЧШЪЮЬЮЬШKЪЬЩKШЪЬШKЪЬFЩFЧKШKЩ;KЪЮЬШKШЧKЪЮЬШKШЧKЪЮЬЮЬШЧKШ
KЪЮЬШЧKЩЪЮЬЮЬШ$ЪЮЬШKЪЬdЩdKЪЮЬЮЬШ,KЪЮЬШKЪЬШKШЧЪЮШKЪЮЬЮЬЮЬ1ШBЧЧKЪЮЬЮЬЮЬ	ЮЬЮЬЮЬШNKЪЮЬШKШKШ ЧЪЯЬЮЬЮЬЮЬЮЬЮЬЮЬШGKЪЮЬЮЬЮЬШЪЮЬЮЬЮШKЪЬ#ЮЬШ;KЪЬ#ЮЬШ;ЪЮЬШЪЯЬШ KЪ
ЮЬЮЬЮЬЮЬЮЬЩ&ЪЬЮЬЮЬЮШKШKЪЮЬШKЪЮЬШЧKШЧKЩKЪЬЮЬШKЪЬШKЪЬ Ш KЪЬШKЪЮЬ
ЮЬ@ШPЪЮЬ<ЮШBKЪЬ7Ш7ЧKЪЬШKЪЮЬШKШЧЧKШЧKШ ЪЯЬЮЬЮЬЮЬЮЬЮЬШ3KЪЮЬЮЬЮЬШKЪЬЮЬаШBЪЮЬЮЬ"ЮЬШ0KЪЬ6Ш6KЪЬШKШЧKЪЮЬШKШKШ ЧЪЯЬЮЬЮЬЮЬЮЬЮЬШ9KЪЬЮЬШ ЪЮЬЮЬЮЬЮШ9KЪЬЮЬЮЬШKЪЮЬШЧKЪЮЬЮЬШKШKШ ЧЪЯ
ЬЮЬЮЬЮЬЮЬЮЬШ7KЪЮЬ1Ш7KШKШ ЧЪЯЬЮЬЮЬЮЬЮЬЮЬЮЬЮЬШ]KЪЬЮЬШKЪЬЮЬШKЪЬЮЬШЪЮЬ	ЮШKЪЬЮЬШKЪЬЮЬШЪЮЬЮШKЪЬЮЬЮЬШ.KЪЬЮЬ$Ш8KЪЮЬШЧKЪЬ	Ш	KЪЮЬШЧKЪЮЬШ$KШKШ ЧЪЯЬЮЬЮЬЮЬЮЬЮЬЮЬШ:KЩ@KЪЬЮЬШЪЮЬ	ЮШKЪЮЬЮЬЮЬШAKШKЪЮЬШЧKЪЮЬШKШKШ ЧЪЯЬЮЬЮЬЮЬЮЬЮЬШ?KЪЬЮЬШKЪЮЬ
ЮЬЮЬШKЪЮЬШKШKЩ ЧЪЯЬЮЬЮЬЮЬЮЬЮЬШ5KЪЬЮЬШKЪЮЬЮЬЮЬЮЬШ)KШKШЪЮЬЮШKЪЬЮЬШKЪЬЮЬШKЪЮЬШЧKЪЮЬЮЬШKШKЩ ЧЪЯЬЮЬЮЬ
ЮЬЮЬЮЬЮЬШJKЪЬЮЬШ	KЪЬ"Ш"KЪЬ&Ш&KЪЬ,ЮЬШ3KЪЮЬ
ЮЬЮЬЮЬШ KЪЮЬ<ШBKШKШ ЧЪЯЬЮЬЮЬ
ЮЬЮЬЮЬЮЬШLKЪЬЮЬШ	KЪЬЮЬШ	KЪЬ"Ш"KЪЬ&Ш&KЪЬ,ЮЬШ3KЪЮЬ	ЮЬЮЬЮЬШKЪЬШKЪЮЬ	ЮЬЮЬЮЬШKЪЬ.Ш.KЪЮЬ
ЮЬЮЬЮЬШKЪЮЬ3Ш9KШKШ ЧЪЯЬЮЬЮЬЮЬЮЬЮЬЮЬШJKЩRЪЮЬ	ЮШKЪЬЮЬ#Ш*ЪЮЬЮШKЪЬЮЬШ3KЪЮЬШЧKЪЮЬШЧKЪЮЬЮЬШKШKЩ ЧЪЯ	ЬЮЬЮЬЮЬЮЬЮЬШ6KЩ$KЪЮЬ0Ш6KШKШ ЧЪЯЬЮЬЮЬЮЬЮЬЮЬШ3KЩ╙KЪЬЮЬШKЪЬЮЬШKЪЬЮЬЮЬШЪЮЬ	ЮШKЪЬЮЬШ$ЪЮЬЮШKЪЬЮЬЮЬЮЬШCKЪЮЬШЧKШKЪЮЬШЧKЪЮЬЮЬШKШKШ ЧЪ╨blЩKШ ЪЯЬЮЬЮЬЮЬЮЬЮЬШ;KЪЬ	ЮЬШ KЪЬЮЬШ'KЪЬЮЬШ-ЪЮЬ$ЮЬЮШ>KЪЬ/Ш/ЧKЪЮЬШKШKШ ЧЧKЪЮЬШЧ ЕЧ    *─  Q[  