DIRECTORY
Convert USING [CardFromRope, IntFromRope],
FS USING [StreamOpen],
HashTable USING [Create, EachPairAction, Fetch, HashRope, Insert, Pairs, RopeEqual, Table, Value],
IO USING [card, int, rope, BreakProc, CharClass, Close, CR, GetTokenRope, PutF, PutFR, STREAM],
ParserPrivateDef USING [MkCType, SendError],
Rope USING [ROPE, Cat, Concat, Equal, Length, Substr],
RopeList USING [Cons, Map],
SiroccoPrivate USING [AquireState, CComponent, CComponentBody, CType, CTypeBody, DirectoryEntry, FunctionList, Handle, TABLES, TablesBody, Variable],
WartDef USING [Generic, identifierNode, numberDNode, numberHNode, numberONode, RopeNode];

ParserPrivate1Impl: CEDAR PROGRAM
IMPORTS ParserPrivateDef, Convert, FS, HashTable, IO, Rope, RopeList, SiroccoPrivate
EXPORTS ParserPrivateDef, SiroccoPrivate ~ {
OPEN SiroccoPrivate, ParserPrivateDef;

EachPairAction: TYPE ~ HashTable.EachPairAction;
numberHNode: TYPE ~ WartDef.numberHNode;
numberDNode: TYPE ~ WartDef.numberDNode;
numberONode: TYPE ~ WartDef.numberONode;
Generic: TYPE ~ WartDef.Generic;
identifierNode: TYPE ~ WartDef.identifierNode;
ROPE: TYPE ~ Rope.ROPE;
RopeNode: TYPE ~ WartDef.RopeNode;
Value: TYPE ~ HashTable.Value;

AddOne: PUBLIC PROC [in: INT] RETURNS [out: INT] ~ {
out _ in+1;
};

card: PUBLIC PROC [in: INT] RETURNS [out: CARD] ~ {
out _ CARD[in];
};

int: PUBLIC PROC [in: CARD] RETURNS [out: INT] ~ {
out _ INT[in];
}; 

nat: PUBLIC PROC [in: INT] RETURNS [out: NAT] ~ {
out _ NAT[in];
}; 

CheckResultsForSourceAndSink: PUBLIC PROC [list: CComponent] RETURNS [final: INT] ~  {
WHILE (list # NIL) DO
IF (Rope.Equal[list.type, "SOURCE"])
OR Rope.Equal[list.type, "SINK"]
THEN [] _ SendError["Result Has Source or Sink"];
list _ list.sibling
ENDLOOP;
final _ -1;
};

CheckCanonicalType: PUBLIC PROC [r1, r2: ROPE, t: TABLES] RETURNS [checked: TABLES] ~ { 
IF NOT (Rope.Equal[r1, r2])
THEN [] _ SendError[Rope.Cat["Type Mismatch Expected ", r2, " found ", r1]];
checked _ t;
};

ClassToRope: PROC [class: Generic] RETURNS [rope: ROPE] ~ {
SELECT class FROM
array => rope _ "ARRAY";
procedure => rope _ "PROCEDURE";
sequence => rope _ "SEQUENCE";
boolean => rope _ "BOOLEAN";
cardinal => rope _ "CARDINAL";
longCardinal => rope _ "LONGCARDINAL";
integer => rope _ "INTEGER";
longInteger => rope _ "LONGINTEGER";
string => rope _ "STRING";
unspecified => rope _ "UNSPECIFIED";
error => rope _ "ERROR";
enumeration => rope _ "ENUMERATION";
record => rope _ "RECORD";
choice => rope _ "CHOICE";
bulkDataSource => rope _ "SOURCE";
bulkDataSink => rope _ "SINK";
ENDCASE => ERROR;
};

Collapse: PUBLIC PROC ~ {
failure: BOOLEAN;
outStream: IO.STREAM;
tables: TABLES;
h: SiroccoPrivate.Handle;
AddUsedTypes: EachPairAction ~ {
success: BOOLEAN;
type: Value;
ctype: CType;
entry: REF DirectoryEntry;
TraverseCtype: PUBLIC PROC [type: CType] ~ {
list: CComponent _ type.children;
success: BOOLEAN;
value: Value;
ctype: CType;

WHILE (list # NIL) DO
IF NOT (Rope.Equal["", list.type] OR (list.type = NIL))
THEN {
[success, value] _ HashTable.Fetch[tables.typeTable, list.type];
IF HashTable.Insert[tables.condensedTypeTable, list.type, value]
THEN {
ctype _ NARROW[value];
TraverseCtype[ctype];
};
};
list _ list.sibling;
ENDLOOP;
};
entry _ NARROW[value];
[success, type] _ HashTable.Fetch[tables.typeTable, entry.type];

IF HashTable.Insert[tables.condensedTypeTable, entry.type, type]
THEN {
ctype _ NARROW[type];
TraverseCtype[ctype];
}
ELSE RETURN[FALSE];
};
ConstantOrVariable: EachPairAction ~ {
type: CType _ NARROW[value];
list: CComponent _ type.children;
success: BOOLEAN;
unresolved: BOOLEAN _ TRUE;
siblingValue: Value;
siblingType: CType;

SELECT type.class FROM
sequence,
string => {
type.variable _ variable;
};

integer,
longInteger,
cardinal,
longCardinal,
boolean,
procedure,
error,
unspecified,
enumeration => {
type.variable _ constant;
};

ENDCASE => { 
IF (type.variable = unvisited) THEN
WHILE unresolved DO
IF (list = NIL)
THEN {
type.variable _ constant;
unresolved _ FALSE;
}
ELSE {
[success, siblingValue] _ HashTable.Fetch[tables.condensedTypeTable, list.type]; 
siblingType _ NARROW[siblingValue];
IF siblingType.variable = unvisited
THEN success _ ConstantOrVariable[list.type, siblingValue];

IF siblingType.variable = variable
THEN {
type.variable _ variable;
unresolved _ FALSE;
}
ELSE list _ list.sibling;
};
ENDLOOP;
};
};
WriteOutLocalTableEntry: EachPairAction ~ {
keyRope: ROPE _ NARROW[key];
entry: REF DirectoryEntry _ NARROW[value];
FuctionsToDisk: PROC[name: ROPE] ~ {
IO.PutF[outStream, "%g|",
IO.rope[name]
];
};
IO.PutF[outStream, "|%g|%g|%g |\nFunctions|",
IO.rope[keyRope],
IO.rope[entry.type],
IO.rope[entry.constant]
];
RopeList.Map[entry.functions, FuctionsToDisk];
IO.PutF[outStream, "~~~~~\n"]
};

WriteOutTypeTableEntry: EachPairAction ~ {
type: CType _ NARROW[value];
keyRope: ROPE _ NARROW[key];
list: CComponent _ type.children;

IO.PutF[outStream, "TYPE|%g|%g|%g|%g|\n",
IO.rope[keyRope],
IO.rope[ClassToRope[type.class]],
IO.rope[VarToRope[type.variable]],
IO.card[type.bound]
];

WHILE (list # NIL) DO
IO.PutF[outStream, "%g |%g |%g |\n",
IO.rope[list.name],
IO.int[list.val],
IO.rope[list.type]
];

list _ list.sibling;
ENDLOOP;

};
WriteOutFunctionTableEntry: EachPairAction ~ {
IO.PutF[outStream, "%g|%g\n", 
IO.rope[NARROW[key]],
IO.rope[NARROW[value]]
]
};
h _ SIGNAL SiroccoPrivate.AquireState;
tables _ h.allTheTables;
failure _ HashTable.Pairs[tables.localTable, AddUsedTypes];
failure _ HashTable.Pairs[tables.condensedTypeTable, ConstantOrVariable];
outStream _ FS.StreamOpen[Rope.Concat[h.programKey,"Tables"], $create];
IO.PutF[outStream, "LocalTables\n"];
failure _ HashTable.Pairs[tables.localTable, WriteOutLocalTableEntry];
IO.PutF[outStream, "\nTypeTables\n"];
failure _ HashTable.Pairs[tables.condensedTypeTable, WriteOutTypeTableEntry];
IO.PutF[outStream, "\nTYPE|.\n"];
IO.PutF[outStream, "\nFunctions\n"];
failure _ HashTable.Pairs[tables.functionTable, WriteOutFunctionTableEntry];
IO.PutF[outStream, "\n.\n"];

IO.Close[outStream];
};



CompareTypes: PUBLIC PROC [first: CType,  second: CType, tables: TABLES] RETURNS [INT _ 1] ~ {
CompareCComponents: PROC [first: CComponent, second: CComponent] ~ {
firstCtype:  CType;
secondCtype: CType;
successful: BOOLEAN;
value: Value;

IF (first = NIL OR second = NIL) 
AND NOT (first = NIL AND  second = NIL)
THEN ERROR 
ELSE
IF first = NIL THEN RETURN;

IF NOT Rope.Equal[first.name, second.name]
OR first.val # second.val
THEN
[] _ SendError["Type Mismatch"];

IF NOT Rope.Equal[first.type, second.type] THEN {
[successful, value] _ HashTable.Fetch[tables.typeTable, first.type];
firstCtype _ NARROW[value];
[successful, value] _ HashTable.Fetch[tables.typeTable, second.type];
secondCtype _ NARROW[value];
[] _ CompareTypes[firstCtype, secondCtype, tables];
};

 CompareCComponents[first.sibling, second.sibling];
};
SELECT first.class FROM
boolean,
cardinal,
longCardinal,
integer,
longInteger,
string,
unspecified => {
IF (first.class = second.class)
THEN RETURN[1--Just to return an INT--]
ELSE [] _ SendError["Type Mismatch"];
};

enumeration,
record,
choice => {
RETURN[1--Just to return an INT--]; -- Comparison of names already done
};

array,
sequence => {
IF (first.class = second.class)
AND (first.bound = second.bound)
THEN {
CompareCComponents[first.children, second.children];
IF (GetLengthOfCComponentList[first.children, first.bound] # 0)
THEN ERROR;
}
ELSE {
RETURN[1--Just to return an INT--]; 
};
};

procedure,
error => {
IF (second.class = cardinal)
THEN RETURN[1--Just to return an INT--]
ELSE {
IF (first.class = second.class)
AND (first.bound = second.bound)
THEN {
CompareCComponents[first.children, second.children];
RETURN[1--Just to return an INT--];
}
ELSE
[] _ SendError["Type Mismatch"];
};
};

ENDCASE => {
[] _ SendError["Type Mismatch"];
};

RETURN[1--Just to return an INT--]; 
};

CopyRope: PUBLIC PROC [in:ROPE] RETURNS [out: ROPE] ~ {
out _ in;
};

CopyTables: PUBLIC PROC [t1: TABLES] RETURNS [t2: TABLES] ~ {
t2 _ t1;
};

CopyFunctionList: PUBLIC PROC [in: FunctionList] RETURNS [out: FunctionList] ~ {
out _ in;
};

CopyAll: PUBLIC PROC [in1: ROPE, in2: FunctionList, in3: TABLES] RETURNS [out1: ROPE, out2: FunctionList, out3: TABLES] ~ {
out1 _ in1;
out2 _ in2;
out3 _ in3;
}; 

CreateCanonicalKey: PUBLIC PROC [id: identifierNode, progno: numberDNode, verno: numberDNode] RETURNS [key: ROPE] ~ {
h: SiroccoPrivate.Handle;
h _ SIGNAL SiroccoPrivate.AquireState;

h.versionNo _ Convert.IntFromRope[verno.text];
h.programNo _ Convert.IntFromRope[progno.text];
h.programName _ id.text;

key _ h.programKey _ IO.PutFR["%gP%gV%g.",
IO.rope[id.text],
IO.int[Convert.IntFromRope[progno.text]], -- to canonicalize it
IO.int[Convert.IntFromRope[verno.text]] -- ditto
];
};

CreateKey: PUBLIC PROC [id: identifierNode] RETURNS [key: ROPE] ~ {
key _ id.text;
};

CreateTables: PUBLIC PROC RETURNS [t: TABLES] ~ {
h: SiroccoPrivate.Handle;
NewTable: PROC RETURNS [new: HashTable.Table] ~ {
new _ HashTable.Create[equal~HashTable.RopeEqual, hash~HashTable.HashRope];
};

InsertValue: PROC [key: ROPE, type: Generic] RETURNS [ok: BOOLEAN] ~ {
ok _ HashTable.Insert[h.allTheTables.typeTable, key, MkCType[type, 0, NIL]]
};
h _ SIGNAL SiroccoPrivate.AquireState;
h.allTheTables _ NEW[TablesBody];
h.allTheTables.globalTable _ NewTable[];
h.allTheTables.typeTable _ NewTable[];
h.allTheTables.localTable _ NewTable[];
h.allTheTables.unresolvedTypeTable _ NewTable[];
h.allTheTables.unresolvedConstantTable _ NewTable[];
h.allTheTables.workTable _ NewTable[];
h.allTheTables.directory _ NewTable[];
h.allTheTables.errors _ NewTable[];
h.allTheTables.procedures _ NewTable[];
h.allTheTables.condensedTypeTable _ NewTable[];
h.allTheTables.functionTable _ NewTable[];
h.allTheTables.condensedFunctionTable _ NewTable[];
h.allTheTables.madeUpNameTable _ NewTable[];


IF NOT (InsertValue["BOOLEAN", boolean]) THEN ERROR;
IF NOT (InsertValue["CARDINAL", cardinal]) THEN ERROR;
IF NOT (InsertValue["LONGCARDINAL", longCardinal]) THEN ERROR;
IF NOT (InsertValue["INTEGER", integer]) THEN ERROR;
IF NOT (InsertValue["LONGINTEGER", longInteger]) THEN ERROR;
IF NOT (InsertValue["STRING", string]) THEN ERROR;
IF NOT (InsertValue["UNSPECIFIED", unspecified]) THEN ERROR;
IF NOT (InsertValue["SOURCE", bulkDataSource]) THEN ERROR;
IF NOT (InsertValue["SINK", bulkDataSink]) THEN ERROR;
RETURN[h.allTheTables] ;
};

DiskToTable:  PUBLIC PROC [t1: TABLES, id: identifierNode, progno: numberDNode, verno: numberDNode] RETURNS [new: TABLES] ~  {
info: REF DirectoryEntry;
keyRope: ROPE;
sibling: CComponent;
sourceStream: IO.STREAM _ FS.StreamOpen[Rope.Concat[ProgramFile[], ".Tables"]];
successful: BOOLEAN;
table: HashTable.Table _ HashTable.Create[equal~HashTable.RopeEqual, hash~HashTable.HashRope];
token: ROPE;
type: CType;

ProgramFile: PROC RETURNS [name: ROPE] ~ {
name _ IO.PutFR["%gP%gV%g",
IO.rope[id.text],
IO.int[Convert.IntFromRope[progno.text]],
IO.int[Convert.IntFromRope[verno.text]]
];
};
NextToken: PROC RETURNS [text: ROPE] ~ {
charsSkipped: INT;
[text, charsSkipped] _ IO.GetTokenRope[sourceStream, Control]; 
};

Control: IO.BreakProc ~ {
SELECT char FROM
IO.CR, '| => RETURN[sepr];
ENDCASE => RETURN[other];
};

Normalize: PROC [arg: ROPE] RETURNS [res: ROPE] ~ {
length: INT _ Rope.Length[arg];
res _ IF (length = 1)
THEN ""
ELSE Rope.Substr[arg, 0, length-1];
};

 TokenToInt: PROC [arg: ROPE] RETURNS [res: INT] ~ {
length: INT _ Rope.Length[arg];
res _ IF (length = 1)
THEN 0
ELSE Convert.IntFromRope[Rope.Substr[arg, 0, length-1]];
};

[] _ HashTable.Insert[t1.directory, id.text, ProgramFile[]];
token _ NextToken[]; -- Skip Heading
keyRope _ token _ NextToken[]; -- Get First Key

WHILE (NOT Rope.Equal[keyRope, "TypeTables"]) DO -- While Local Table is not exhausted
info _ NEW[DirectoryEntry];
info.type _ token _ NextToken[];
info.constant _ Normalize[token _ NextToken[]];
token _ NextToken[];  -- Throw away Function Header
token _ NextToken[];
WHILE NOT Rope.Equal[token,  "~~~~~"] DO
info.functions _ RopeList.Cons[info.functions, token];
token _ NextToken[];
ENDLOOP;
info.value _ NIL;
successful _ HashTable.Insert[table, keyRope, info];
keyRope _ token _ NextToken[];
ENDLOOP;
[] _ HashTable.Insert[t1.globalTable, id.text, table]; -- Local Tables over
token _ NextToken[];  -- Skip Type Heading
keyRope _ token _ NextToken[]; -- Get First Type Name
WHILE (NOT Rope.Equal[keyRope, "."]) DO -- Process Type Table
type _ NEW[CTypeBody]; -- Allocate CType
type.class _ RopeToClass[token _ NextToken[]]; -- Get Class
type.variable _ RopeToVar[token _ NextToken[]]; -- Get variable status
type.bound _ Convert.CardFromRope[token _ NextToken[]]; -- Get bound
token _ NextToken[];
IF NOT Rope.Equal[token, "TYPE"]  THEN { -- Are there any children
sibling _ NEW[CComponentBody];
type.children _ sibling --First Child
};
WHILE (NOT Rope.Equal[token, "TYPE"]) DO
sibling.name _ Normalize[token];
sibling.val _ TokenToInt[token _ NextToken[]];
sibling.type _ Normalize[token _ NextToken[]];
token _ NextToken[];
IF (NOT Rope.Equal[token, "TYPE"]) THEN {
sibling.sibling _ NEW[CComponentBody]; --Rest Of the Children
sibling _ sibling.sibling;
}
ENDLOOP;
[] _ HashTable.Insert[t1.typeTable, keyRope, type]; -- Enter Type
keyRope _ token _ NextToken[]; -- Get Next Type Name
ENDLOOP;
token _ NextToken[]; --Skip Header
keyRope _ token _ NextToken[];
WHILE (NOT Rope.Equal[keyRope, "."]) DO
token _ NextToken[];
[] _ HashTable.Insert[t1.functionTable, keyRope, token];
keyRope _ token _ NextToken[];
ENDLOOP;
new _ t1;
};

FetchFromGlobalTable: PUBLIC PROC [t1: TABLES, key: ROPE] RETURNS [value: HashTable.Table] ~ { 
successful: BOOLEAN;
temp: Value;
[successful, temp] _ HashTable.Fetch[t1.globalTable, key];
IF (NOT successful) THEN ERROR;
value _ NARROW[temp];
};

GetCardFromDecimal: PUBLIC PROC [decimal: numberDNode] RETURNS [card: CARD] ~ {
card _ Convert.CardFromRope[decimal.text]; 
};

GetCardFromHex: PUBLIC PROC [hex: numberHNode] RETURNS [card: CARD] ~ {
card _ Convert.CardFromRope[hex.text, 16];  
};

GetCardFromOctal: PUBLIC PROC [octal: numberONode] RETURNS [card: CARD] ~ {
card _ Convert.CardFromRope[octal.text, 8]; 
};

GetCType: PUBLIC PROC [ id: identifierNode, list: CComponent,  tables: TABLES] RETURNS [type: CType _ NIL, name: ROPE _ ""] ~ {
successful: BOOLEAN;
temp: Value;
templist: CComponent;
templist _ list; 

WHILE (templist # NIL)
AND (NOT Rope.Equal[id.text, templist.name]) DO
templist _ templist.sibling;
ENDLOOP;

IF (templist = NIL)
THEN [] _ SendError["Type Mismatch"]
ELSE {
name _ templist.type;
[successful, temp] _ HashTable.Fetch[tables.typeTable,  name];
IF NOT successful
THEN ERROR -- COMILER ERROR
ELSE type _ NARROW[temp];
};
};

GetLengthOfCComponentList: PUBLIC PROC [list: CComponent, initial: INT] RETURNS [final: INT] ~ {
WHILE (list # NIL) DO
initial _ initial - 1;
list _ list.sibling
ENDLOOP;
final _ 0 - initial;
IF (final >= 0)
THEN {
final _ 0 - initial;
RETURN;
}
ELSE [] _ SendError["Type Mismatch"]; -- LIST OF INCORRECT LENGTH
final _ -1;
};

RopeToClass: PROC [rope: ROPE] RETURNS [class: Generic] ~ {
SELECT TRUE FROM
Rope.Equal[rope, "ARRAY"] => class _ array;
Rope.Equal[rope, "PROCEDURE"] => class _ procedure;
Rope.Equal[rope, "SEQUENCE"] => class _ sequence;
Rope.Equal[rope, "BOOLEAN"] => class _ boolean;
Rope.Equal[rope, "CARDINAL"] => class _ cardinal;
Rope.Equal[rope, "LONGCARDINAL"] => class _ longCardinal;
Rope.Equal[rope, "INTEGER"] => class _ integer;
Rope.Equal[rope, "LONGINTEGER"] => class _ longInteger;
Rope.Equal[rope, "STRING"] => class _ string;
Rope.Equal[rope, "UNSPECIFIED"] => class _ unspecified;
Rope.Equal[rope, "ERROR"] => class _ error;
Rope.Equal[rope, "ENUMERATION"] => class _ enumeration;
Rope.Equal[rope, "RECORD"]=> class _ record;
Rope.Equal[rope, "CHOICE"] => class _ choice;
Rope.Equal[rope, "SOURCE"] => class _ bulkDataSource;
Rope.Equal[rope, "SINK"] => class _ bulkDataSink;
ENDCASE => ERROR;
};

RopeTokenToROPE: PUBLIC PROC [r: RopeNode] RETURNS [rope: ROPE] ~ {
quote: ROPE ~ """";
rope _ Rope.Cat[quote, r.text, quote];
};

RopeToVar: PROC [rope: ROPE] RETURNS [var: Variable] ~ {
SELECT TRUE FROM
Rope.Equal[rope, "VARIABLE"] => var _ variable;
Rope.Equal[rope, "CONSTANT"] => var _ constant;
ENDCASE => ERROR;
};

SeeIfArrOrSeq: PUBLIC PROC [first: CType, size: CARD, tables: TABLES] RETURNS [type: CType _ NIL, name: ROPE _ ""] ~ {
successful: BOOLEAN;
value: Value;
IF (first.class # array)
AND (first.class # sequence)
THEN [] _ SendError["Type Mismatch"] 
ELSE {
[successful, value] _ HashTable.Fetch[tables.typeTable, first.children.type];
IF (NOT successful) THEN ERROR;
type _ NARROW[value]; 
IF (first.class = array)
AND (first.bound # size)
THEN [] _ SendError["Wrong No. Of Array Elements in Constant"];
IF (first.class = sequence)
AND (first.bound < size)
THEN [] _ SendError["No. Of Sequence Elements exceeds declared bound in Constant"];
name _ first.children.type;
}
};

VarToRope: PROC [variable: Variable] RETURNS [rope: ROPE] ~ {
SELECT variable FROM
variable => rope _ "VARIABLE";
constant => rope _ "CONSTANT";
ENDCASE => ERROR;
};

}...


*ParserPrivate1Impl.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Bhargava, August 9, 1986 2:56:46 pm PDT
Bill Jackson (bj) September 25, 1986 3:43:40 am PDT
Copied Types

Procs

Check on status of unspecified
Put Predefined Values: integer, boolean, etc. into the table

Κl˜
codeš
œ™Kšœ
Οm
œ1™<K™'K™3—K˜š
Οk	˜	Kšœžœ˜*Kšžœ
žœ˜Kšœ
žœS˜bKšžœ
žœ0žœžœ˜_Kšœžœ˜,Kšœžœžœ&˜6Kšœ	žœ
˜Kšœžœcžœ˜•
KšœžœL˜Y—K˜šΟnœžœ
ž˜!Kšžœžœ
žœ ˜TKšžœ%˜,Kšžœ"˜&—K˜™K™Kšœžœ˜0Kšœ
žœ˜(Kšœ
žœ˜(Kšœ
žœ˜(Kšœ	žœ˜ Kšœžœ˜.Kšžœžœžœ
˜Kšœ
žœ˜"Kšœžœ˜K˜—™K™šŸœžœ
žœžœžœžœ˜4Kš
œ˜K˜K˜—šΟbœžœ
žœžœžœžœ˜3Kšœžœ˜K˜K˜—š œžœ
žœžœžœžœ˜2Kšœžœ˜Kš
œ˜K˜—š œžœ
žœžœžœžœ˜1Kšœžœ˜Kš
œ˜—K˜š
Ÿœžœ
žœžœ	žœ˜Všžœ	žœž˜šžœ"˜$Kšžœ˜ Kšžœ-˜1—Kš
œ˜Kšžœ
˜—Kš
œ˜K˜K˜—šΠbnœžœ
žœ
žœžœžœžœ˜Xšžœ
žœ˜KšžœH˜L—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š
œ˜šŸœ˜ Kšœ	žœ
˜K˜K˜
Kšœžœ˜šŸ
œžœ
žœ˜,K˜!Kšœ	žœ
˜K˜
K˜
K˜šžœ	žœž˜šžœ
žœžœžœ˜7šžœ˜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˜K˜—Kš
œ˜Kš
œ˜Kš
œ	˜	Kš
œ
˜
Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜š
œ˜Kš
œ˜K˜K˜—šžœ˜
šžœž˜#šžœž˜šžœ	žœ
˜šžœ˜Kš
œ˜Kšœ
žœ
˜Kš
œ
˜
—šžœ˜Kš
œQ˜QKšœžœ˜#šžœ!˜#Kšžœ7˜;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˜šžœ'˜)Kšžœ˜Kšžœ˜!Kšžœ ˜"Kšžœ˜Kš
œ˜K˜—šžœ	žœž˜šžœ"˜$Kšžœ˜Kšžœ˜Kšžœ˜Kš
œ˜K˜—Kš
œ˜Kšžœ
˜K˜—K˜—šŸœ˜.šžœ˜Kšžœžœ˜Kšžœžœ˜Kš
œ
˜
—K˜—Kšœžœ˜&Kš
œ˜Kš
œ;˜;Kš
œI˜IKšœžœ9˜GKšžœ"˜$Kš
œF˜FKšžœ#˜%Kš
œM˜MKšžœ˜!Kšžœ"˜$Kš
œL˜LKšžœ˜K˜Kšžœ˜K˜K˜—˜K˜—šŸœžœ
žœ(žœžœžœ	˜^šŸœžœ,˜DKš
œ˜Kš
œ˜Kšœžœ
˜K˜
K˜šžœ
žœ
žœ
žœ˜!Kš
žœ
žœ
žœ
žœžœ
˜'Kšžœ
žœ
˜š
ž˜Kšžœ	žœ
žœ
žœ
˜K˜——šžœ
žœ$˜*Kšžœ˜š
ž˜Kš
œ ˜ ——K˜šžœ
žœ%žœ˜1Kš
œD˜DKšœ
žœ˜Kš
œE˜EKšœžœ˜Kš
œ3˜3K˜K˜—Kš
œ3˜3Kš
œ˜—Kš
œ™šžœ
ž˜Kš
œ˜Kš
œ	˜	Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜š
œ˜šžœ˜Kšžœ
žœΟcœ
˜'Kšžœ!˜%—K˜K˜—Kš
œ˜Kš
œ˜š
œ˜Kšžœ’œ’#˜GK˜K˜—Kš
œ˜š
œ
˜
šžœ˜Kšžœ˜ šžœ˜Kš
œ4˜4šžœ=˜?Kšžœ
žœ
˜—Kš
œ
˜
—šžœ˜Kšžœ’œ˜$K˜—K˜K˜——Kš
œ
˜
š
œ
˜
šžœ˜Kšžœ
žœ’œ
˜'šžœ˜šžœ˜Kšžœ˜ šžœ˜Kš
œ4˜4Kšžœ’œ˜#K˜
—š
ž˜Kš
œ ˜ ——Kš
œ˜—K˜K˜——šžœ˜Kš
œ ˜ K˜K˜——Kšžœ’œ˜$K˜K˜—šŸœžœ
žœžœžœžœ˜7Kš
œ	˜	K˜K˜—šŸ
œžœ
žœžœžœžœ˜=Kš
œ˜K˜K˜—šŸœžœ
žœžœ˜PK˜	K˜K˜—šŸœžœ
žœžœžœžœžœžœ˜{K˜K˜K˜Kš
œ˜K˜—š
Ÿœžœ
žœ?žœžœ˜uKš
œ˜Kšœžœ˜&K˜Kš
œ.˜.Kš
œ/˜/Kš
œ˜K˜šœžœ˜*Kšžœ˜Kšžœ(’˜?Kšžœ&’˜0K˜—K˜K˜—š
Ÿ	œžœ
žœžœžœ˜CKš
œ˜K˜K˜—š
Ÿœžœ
žœ
žœžœ˜1Kš
œ˜šŸœžœ
žœ˜1Kš
œK˜KK˜K˜—š
Ÿœžœžœžœžœ˜FKšœFžœ˜KK˜—Kšœžœ˜&Kšœžœ
˜!Kš
œ(˜(Kš
œ&˜&Kš
œ'˜'Kš
œ0˜0Kš
œ4˜4Kš
œ&˜&Kš
œ&˜&Kš
œ#˜#Kš
œ'˜'Kš
œ/˜/Kš
œ*˜*Kš
œ3˜3Kš
œ,˜,K˜K˜K™<K™Kšžœ
žœ#žœ
žœ
˜4Kšžœ
žœ%žœ
žœ
˜6Kšžœ
žœ-žœ
žœ
˜>Kšžœ
žœ#žœ
žœ
˜4Kšžœ
žœ+žœ
žœ
˜<Kšžœ
žœ!žœ
žœ
˜2Kšžœ
žœ+žœ
žœ
˜<Kšžœ
žœ)žœ
žœ
˜:Kšžœ
žœ%žœ
žœ
˜6Kšžœ˜Kš
œ˜K˜—šŸœžœ
žœžœ?žœžœ˜~Kšœžœ˜Kšœ	žœ
˜K˜Kšœžœ
žœžœ3˜OKšœžœ
˜Kš
œ^˜^Kšœžœ
˜K˜K˜šŸœžœ
žœžœ˜*šœžœ˜Kšžœ˜Kšžœ'˜)Kšžœ%˜'K˜—K˜—šŸ	œžœ
žœžœ˜(Kšœžœ
˜Kšœžœ&˜?K˜K˜—šŸœžœ˜šžœž˜Kšžœ
žœžœ˜Kšžœžœ˜—Kš
œ˜K˜—š
Ÿ	œžœžœžœžœ˜3Kšœžœ˜šœžœ
˜Kšžœ˜Kšžœ˜#—K˜K˜—šœ
Ÿ
œžœžœžœžœ˜4Kšœžœ˜šœžœ
˜Kšžœ˜Kšžœ4˜8—K˜K˜—Kš
œ<˜<Kšœ’˜$Kšœ’˜/K˜šžœžœ$žœ
’%˜VKšœžœ˜Kš
œ ˜ Kš
œ/˜/Kšœ’˜3Kš
œ˜šžœ
žœž˜(Kš
œ6˜6Kš
œ˜Kšžœ
˜—Kšœ
žœ
˜Kš
œ4˜4Kš
œ˜Kšžœ
˜—Kšœ7’˜KKšœ’˜*Kšœ’˜5šžœžœžœ
’˜=Kšœžœ
’˜(Kšœ/’˜;Kšœ0’˜FKšœ8’˜DKš
œ˜šžœ
žœžœ’˜BKšœ
žœ˜Kšœ’
˜%Kš
œ˜—šžœžœž˜(Kš
œ ˜ Kš
œ.˜.Kš
œ.˜.Kš
œ˜šžœžœžœ˜)Kšœžœ’˜=Kš
œ˜Kš
œ
˜
—Kšžœ
˜—Kšœ4’
˜AKšœ’˜4Kšžœ
˜—Kšœ’
˜"Kš
œ˜šžœžœž˜'Kš
œ˜Kš
œ8˜8Kš
œ˜Kšžœ
˜—Kš
œ	˜	K˜K˜—šŸœžœ
žœžœžœžœ˜_Kšœžœ
˜K˜Kš
œ:˜:Kšžœžœ
žœ
žœ
˜Kšœžœ˜K˜K˜—š
Ÿœžœ
žœžœžœ˜OKš
œ+˜+K˜K˜—š
Ÿœžœ
žœžœžœ˜GKš
œ,˜,K˜K˜—š
Ÿœžœ
žœžœžœ˜KKš
œ,˜,K˜K˜—šŸœžœ
žœ2žœžœžœžœ
˜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šžœ"’˜A—Kš
œ˜K˜K˜—šŸœžœžœžœ˜;šžœ
žœ
ž˜Kš
œ+˜+Kš
œ3˜3Kš
œ1˜1Kš
œ/˜/Kš
œ1˜1Kš
œ9˜9Kš
œ/˜/Kš
œ7˜7Kš
œ-˜-Kš
œ7˜7Kš
œ+˜+Kš
œ7˜7Kš
œ,˜,Kš
œ-˜-Kš
œ5˜5Kš
œ1˜1Kšžœžœ
˜—K˜K˜—š
Ÿœžœ
žœžœžœ˜CKš œžœ˜Kšœ œ
 œ˜&K˜K˜—šŸ	œžœžœžœ˜8šžœ
žœ
ž˜Kš
œ/˜/Kš
œ/˜/Kšžœžœ
˜—K˜K˜—šŸ
œžœ
žœžœ
žœžœžœžœ
˜vKšœžœ
˜Kš
œ
˜
šžœ˜Kšžœ˜Kšžœ!˜%šžœ˜Kš
œM˜MKšžœžœ
žœ
žœ
˜Kšœžœ	˜šžœ˜Kšžœ˜Kšžœ;˜?—šžœ˜Kšžœ˜KšžœO˜S—Kš
œ˜K˜
——K˜K˜—šŸ	œžœžœžœ˜=šžœ
ž˜Kš
œ˜Kš
œ˜Kšžœžœ
˜—K˜——K˜Kš
œ˜K˜—…—BxZ