DIRECTORY
BasicTime USING [],
FS USING [StreamOpen],
HashTable USING [EachPairAction, Erase, Fetch, Pairs, Value],
IO USING [STREAM, int, rope, Close, PutF, PutFR],
Rope USING [ROPE, Cat, Equal],
SiroccoPrivate USING [AquireState, CComponent, CType, DirectoryEntry, FileHeader, Handle, MakeUpName, Nest, Sort, TABLES, UnDo, UnDoable];

GenerateInterface: CEDAR PROGRAM
IMPORTS FS, HashTable, IO, Rope, SiroccoPrivate
EXPORTS SiroccoPrivate ~ {
OPEN SiroccoPrivate;

ROPE: TYPE ~ Rope.ROPE;
Value: TYPE ~ HashTable.Value;


GenDefs: PUBLIC PROC ~ {
allTheTables: TABLES;
defStream: IO.STREAM;
failure: BOOLEAN;
h: Handle;
initStream: IO.STREAM;
programKey: ROPE;
programKeyWD: ROPE;
GenerateCondensedFcn: HashTable.EachPairAction ~ {
fcn: ROPE ~ NARROW[value];
IO.PutF[initStream, Nest["%g", 1], IO.rope[fcn]];
};

GenerateType: PROC [type: CType, name: ROPE] ~ {
SELECT type.class FROM
array =>  {
IO.PutF[defStream, "TYPE ~ ARRAY [0..%g) OF %g;",
IO.int[type.bound],
IO.rope[UnDo[type.children.type, programKeyWD]]
];
};
boolean => {
IO.PutF[defStream, "TYPE ~ BOOLEAN;"]
};
cardinal => {
IO.PutF[defStream, "TYPE ~ CARDINAL;"]
};
choice => {
list: CComponent _ type.children;
IO.PutF[defStream, Nest["TYPE ~ RECORD [", 2]];
IO.PutF[defStream, Nest["SELECT type: %g FROM", 3],
IO.rope[UnDo[list.type, programKeyWD]]
];

list _ list.sibling;
WHILE (list.sibling # NIL) DO
IO.PutF[defStream, Nest["%g => [%g: %g],", 3],
IO.rope[list.name],
IO.rope[list.name],
IO.rope[UnDo[list.type, programKeyWD]]
];
list _ list.sibling;
ENDLOOP;

IO.PutF[defStream, Nest["%g => [%g: %g]", 3],
IO.rope[list.name],
IO.rope[list.name],
IO.rope[UnDo[list.type, programKeyWD]]
];

IO.PutF[defStream, Nest["ENDCASE", 2]];  
IO.PutF[defStream, "];"];
};
enumeration =>  {
list: CComponent _ Sort[type.children];
type.children _ list;

IO.PutF[defStream, Nest["TYPE ~ MACHINE DEPENDENT {", 2]];

WHILE (list.sibling # NIL) DO
IO.PutF[defStream, Nest["%g(%g),", 2],
IO.rope[list.name],
IO.int[list.val]
];
list _ list.sibling;  
ENDLOOP;

IO.PutF[defStream, Nest["%g(%g)", 2],
IO.rope[list.name],
IO.int[list.val]
];

IO.PutF[defStream, "};"];
};
error => { NULL }; -- always a constant!
integer => {
IO.PutF[defStream, "TYPE ~ INTEGER;"]
};
longCardinal => {
IO.PutF[defStream, "TYPE ~ CARD;"]
};
longInteger => {
IO.PutF[defStream, "TYPE ~ INT;"]
};
procedure => { NULL }; -- always a constant!
record => {
list: CComponent _ type.children;
IO.PutF[defStream, "TYPE ~ RECORD"];
IF (list = NIL)
THEN {
IO.PutF[defStream, " [];"];
}
ELSE {
IO.PutF[defStream, Nest[" [", 2]];

WHILE (list.sibling # NIL) DO
IO.PutF[defStream, Nest["%g: %g, ", 2],
IO.rope[list.name],
IO.rope[UnDo[list.type, programKeyWD]]
];
list _ list.sibling;
ENDLOOP;

IO.PutF[defStream, Nest["%g: %g", 2],
IO.rope[list.name],
IO.rope[UnDo[list.type, programKeyWD]]
];

IO.PutF[defStream, "];"];
}
};
sequence => {
obj: ROPE _ MakeUpName[name, "Object", allTheTables];

IO.PutF[defStream, Nest["TYPE ~ REF %g;", 1], IO.rope[obj]];
IO.PutF[defStream, Nest["%g: TYPE ~ MACHINE DEPENDENT RECORD [", 2], IO.rope[obj]];
IO.PutF[defStream, Nest["body: PACKED SEQUENCE length: CARDINAL OF %g", 2],
IO.rope[UnDo[type.children.type, programKeyWD]]
];
IO.PutF[defStream, "];"];
};
string => {
IO.PutF[defStream, "TYPE ~ ROPE;"]
};
unspecified => {
IO.PutF[defStream, "TYPE ~ CARDINAL;"]
};
ENDCASE => {
IO.PutF[defStream, "TYPE ~ UNKNOWN;"];
ERROR;
};
};

GenerateInterfaceConstant: PROC [type: CType, name: ROPE, entry: REF DirectoryEntry] ~ {
SELECT type.class FROM
array =>  {
IF (type.variable # constant) THEN {
IO.PutF[defStream, "READONLY %g;", IO.rope[UnDo[entry.type, programKeyWD]]];
RETURN;
};

IO.PutF[defStream, "%g ~ %g;",
IO.rope[UnDo[entry.type, programKeyWD]],
IO.rope[entry.constant]
];
};
boolean => {
IO.PutF[defStream, "BOOLEAN ~ %g;", IO.rope[entry.constant]];
};
bulkDataSink => {
IO.PutF[defStream, "READONLY CrRPC.BulkDataSink;"];
};
bulkDataSource => {
IO.PutF[defStream, "READONLY CrRPC.BulkDataSource;"];
};
cardinal => {
IO.PutF[defStream, "CARDINAL ~ %g;", IO.rope[entry.constant]];
};
choice => {
list: CComponent _ type.children;

IF (type.variable # constant) THEN {
IO.PutF[defStream, "READONLY %g;", IO.rope[UnDo[entry.type, programKeyWD]]];
RETURN;
};

IO.PutF[defStream, "%g ~ %g;",
IO.rope[UnDo[entry.type, programKeyWD]],
IO.rope[entry.constant]
];
};
enumeration =>  {
IO.PutF[defStream, "%g ~ %g;",
IO.rope[UnDo[entry.type, programKeyWD]],
IO.rope[entry.constant]
];
};
error => {
list: CComponent _ type.children;

IF (list = NIL) THEN {
IO.PutF[defStream, "ERROR;"];
RETURN;
};

IO.PutF[defStream, "ERROR ["];

WHILE (list.sibling # NIL) DO
IO.PutF[defStream, "%g: %g, ",
IO.rope[list.name],
IO.rope[UnDo[list.type, programKeyWD]]
];
list _ list.sibling;
ENDLOOP;

IO.PutF[defStream, "%g: %g",
IO.rope[list.name],
IO.rope[UnDo[list.type, programKeyWD]]
];

IO.PutF[defStream, "];"];
};
integer => {
IO.PutF[defStream, "INTEGER ~ %g;", IO.rope[entry.constant]];
};
longCardinal => {
IO.PutF[defStream, "CARD ~ %g;", IO.rope[entry.constant]];
};
longInteger => {
IO.PutF[defStream, "INT ~ %g;", IO.rope[entry.constant]];
};
procedure => {
list: CComponent _ type.children;
IF (list = NIL)
THEN {
IO.PutF[defStream, "PROC [h: CrRPC.Handle];"];
}
ELSE {
IO.PutF[defStream, "PROC [h: CrRPC.Handle"];

FOR loopindex: CARD IN [0..type.bound) DO
IO.PutF[defStream, ", %g: %g",
IO.rope[list.name],
IO.rope[UnDo[list.type, programKeyWD]]
];
list _ list.sibling;
ENDLOOP;

IO.PutF[defStream, "]"];

IF (list = NIL)
THEN {
IO.PutF[defStream, ";"];
}
ELSE {
IO.PutF[defStream, " RETURNS ["];
WHILE (list.sibling # NIL) DO
IO.PutF[defStream,"%g: %g, ",
IO.rope[list.name],
IO.rope[UnDo[list.type, programKeyWD]]
];
list _ list.sibling;
ENDLOOP;

IO.PutF[defStream, "%g: %g",
IO.rope[list.name],
IO.rope[UnDo[list.type, programKeyWD]]
];

IO.PutF[defStream, "];"];
};
};
};
record => {
list: CComponent _ type.children;

IF (type.variable # constant) THEN {
IO.PutF[defStream, "READONLY %g;", IO.rope[UnDo[entry.type, programKeyWD]]];
RETURN;
};

IO.PutF[defStream, "%g ~ %g;",
IO.rope[UnDo[entry.type, programKeyWD]],
IO.rope[entry.constant]
];
};
sequence => {
IO.PutF[defStream, "READONLY %g;", IO.rope[UnDo[entry.type, programKeyWD]]];
};
string => {
IO.PutF[defStream, "READONLY ROPE;"];
};
unspecified => {
IO.PutF[defStream, "CARDINAL ~ %g;", IO.rope[entry.constant]];
};
ENDCASE => {
IO.PutF[defStream, "TYPE; -- UNKNOWN"];
ERROR;
};
};

GenerateInitializedConstant: PROC [type: CType, name: ROPE, entry: REF DirectoryEntry] RETURNS [wroteItem: BOOL _ FALSE] ~ {
SELECT type.class FROM
array =>  {
wroteItem _ TRUE;
IF (type.variable # constant)
THEN {
IO.PutF[initStream, " %g: PUBLIC ARRAY [0..%g) OF %g _ %g;", 
IO.rope[name],
IO.int[type.bound],
IO.rope[UnDo[type.children.type, programKeyWD]],
IO.rope[entry.constant]
];
};
};
boolean => { NULL }; -- Interface item
bulkDataSink => { NULL }; -- Interface item
bulkDataSource => { NULL }; -- Interface item
cardinal => { NULL }; -- Interface item
choice => {
list: CComponent _ type.children;
wroteItem _ TRUE;
IF (type.variable # constant)
THEN {
IO.PutF[initStream, " %g: PUBLIC RECORD [",
IO.rope[name]
];
list _ type.children;
IO.PutF[initStream, "SELECT type: %g FROM",
IO.rope[UnDo[list.type, programKeyWD]]
];

list _ list.sibling;
IO.PutF[initStream,"%g => [%g: %g]",
IO.rope[list.name],
IO.rope[list.name],
IO.rope[UnDo[list.type, programKeyWD]]
];

list _ list.sibling;
WHILE (list # NIL) DO
IO.PutF[initStream,",%g => [%g: %g]",
IO.rope[list.name],
IO.rope[list.name],
IO.rope[UnDo[list.type, programKeyWD]]
];
list _ list.sibling;
ENDLOOP;

IO.PutF[initStream, "ENDCASE"];  
IO.PutF[initStream, "] _ %g;",
IO.rope[entry.constant]
];
};
};
enumeration => { NULL }; -- Interface item
error => { NULL }; -- Interface item
integer => { NULL }; -- Interface item
longCardinal => { NULL }; -- Interface item
longInteger => { NULL }; -- Interface item
procedure => { NULL }; -- Interface item
record => {
list: CComponent _ type.children;
wroteItem _ TRUE;
IF (type.variable # constant)
THEN {
IO.PutF[initStream, " %g RECORD [",
IO.rope[name]
];

list _ type.children;
IF (list = NIL)
THEN {
IO.PutF[initStream, "] ~ %g ;",
IO.rope[entry.constant]
];
}
ELSE {
IO.PutF[initStream," %g: %g",
IO.rope[list.name],
IO.rope[UnDo[list.type, programKeyWD]]
];

list _ list.sibling;
WHILE (list # NIL) DO
IO.PutF[initStream,",%g: %g",
IO.rope[list.name],
IO.rope[UnDo[list.type, programKeyWD]]
];
list _ list.sibling;
ENDLOOP;

IO.PutF[initStream, "] ~ %g;",
IO.rope[entry.constant]
];
};
};
};
sequence => {
obj: ROPE _ MakeUpName[name, "Object", allTheTables];
wroteItem _ TRUE;
IO.PutF[initStream, "%g: PUBLIC REF %g _ %g;",
IO.rope[name],
IO.rope[obj],
IO.rope[entry.constant]
];
};
string => {
wroteItem _ TRUE;
IO.PutF[initStream, "%g: PUBLIC ROPE _ %g;",
IO.rope[name],
IO.rope[entry.constant]
];
};
unspecified => { NULL }; -- Interface item
ENDCASE => {
IO.PutF[initStream, "--UNKNOWN--"];
ERROR;
};
};

GenerateInterfaceItem: HashTable.EachPairAction ~ {
name: ROPE _ NARROW [key];
entry: REF DirectoryEntry _ NARROW [value];

successful: BOOLEAN;
tempRope: ROPE;
type: CType;
undid: BOOLEAN;
value1: Value;

IO.PutF[defStream, "%g: ", IO.rope[name]];

[tempRope, undid] _ UnDoable[entry.type, programKeyWD];
IF (undid AND (NOT Rope.Equal[name, tempRope]))
THEN {
IF (Rope.Equal[entry.constant, ""])
THEN {
IO.PutF[defStream, "TYPE ~ %g;", IO.rope[tempRope]];
}
ELSE {
[successful, value1] _ HashTable.Fetch[allTheTables.condensedTypeTable, entry.type];

type _ NARROW[value1];
IF (type.variable = variable)
THEN { 
IO.PutF[defStream, "READONLY %g;",
IO.rope[tempRope]
];
}
ELSE {
IO.PutF[defStream, "%g ~ %g;",
IO.rope[tempRope],
IO.rope[entry.constant]
];
};
};
}
ELSE {
[successful, value1] _ HashTable.Fetch[allTheTables.condensedTypeTable, entry.type];
type _ NARROW[value1];
SELECT TRUE FROM
(type.class = bulkDataSink) => { GenerateInterfaceConstant[type, name, entry]; };
(type.class = bulkDataSource) => { GenerateInterfaceConstant[type, name, entry]; };
Rope.Equal[entry.constant, ""] => { GenerateType[type, name]; };
ENDCASE => { GenerateInterfaceConstant[type, name, entry]; };
};

IO.PutF[defStream, Nest["", 1]];
IO.PutF[defStream, Nest["", 1]];
};

GenerateInitializedItem: HashTable.EachPairAction ~ {
name: ROPE _ NARROW [key];
entry: REF DirectoryEntry _ NARROW [value];

successful: BOOLEAN;
tempRope: ROPE;
type: CType;
undid: BOOLEAN;
value1: Value;

[tempRope, undid] _ UnDoable[entry.type, programKeyWD];
IF (undid AND (NOT Rope.Equal[name, tempRope]))
THEN {
IF ~ (Rope.Equal[entry.constant, ""])
THEN {
[successful, value1] _ HashTable.Fetch[allTheTables.condensedTypeTable, entry.type];

type _ NARROW[value1];
IF (type.variable = variable)
THEN { 
IO.PutF[initStream, "%g: PUBLIC %g _ %g;",
IO.rope[name],
IO.rope[tempRope],
IO.rope[entry.constant]
];
};
};
}
ELSE {
[successful, value1] _ HashTable.Fetch[allTheTables.condensedTypeTable, entry.type];
type _ NARROW[value1];
SELECT TRUE FROM
Rope.Equal[entry.constant, ""] => { NULL; };
ENDCASE => {
IF (GenerateInitializedConstant[type, name, entry].wroteItem = TRUE)
THEN {
IO.PutF[initStream, Nest["", 1]];
IO.PutF[initStream, Nest["", 1]];
};
};
};
};

Heading: PROC [out: IO.STREAM] ~ {
PutDirectory: HashTable.EachPairAction ~ {
interface: ROPE ~ NARROW [value];
IO.PutF[out, Nest["%g,", 1],
IO.rope[interface]
];
};

SiroccoPrivate.FileHeader[out, Rope.Cat[programKeyWD, ".Mesa"]];

IO.PutF[out, Nest["DIRECTORY", 1]];
IO.PutF[out, Nest["CrRPC,", 1]];
failure _ HashTable.Pairs[allTheTables.directory, PutDirectory];
IO.PutF[out, Nest["Rope;", 0]];
IO.PutF[out, Nest["", 0]];

IO.PutF[out, Nest["%g: CEDAR DEFINITIONS ~ {", 1], IO.rope[programKeyWD]];
};

InitHeading: PROC [out: IO.STREAM] ~ {
PutDirectory: HashTable.EachPairAction ~ {
interface: ROPE ~ NARROW [value];
IO.PutF[out, Nest["%g,", 1],
IO.rope[interface]
];
};
SiroccoPrivate.FileHeader[out, Rope.Cat[programKeyWD, "Init.Mesa"]];

IO.PutF[out, Nest["DIRECTORY", 1]];
IO.PutF[out, Nest["CrRPC,", 1]];
IO.PutF[out, Nest["Rope,", 1]];
failure _ HashTable.Pairs[allTheTables.directory, PutDirectory];
IO.PutF[out, Nest["%g;", 0], IO.rope[programKeyWD]]; 
IO.PutF[out, Nest["", 0]];

IO.PutF[out, Nest["%gInit: CEDAR PROGRAM", 1], IO.rope[programKeyWD]];
IO.PutF[out, Nest["EXPORTS %g ~ {", 1], IO.rope[programKeyWD]];
IO.PutF[out, Nest["OPEN %g;", 0], IO.rope[programKeyWD]];
};
h _ SIGNAL AquireState[];
allTheTables _ h.allTheTables;
programKey _ h.programKey;

programKeyWD _ IO.PutFR["%gP%gV%g",
IO.rope[h.programName],
IO.int[h.programNo],
IO.int[h.versionNo]
];

HashTable.Erase[allTheTables.workTable];


defStream _ FS.StreamOpen[Rope.Cat[programKeyWD, ".Mesa"], $create];

Heading[defStream];

IO.PutF[defStream, Nest["", 1]];
IO.PutF[defStream, Nest["ROPE: TYPE ~ Rope.ROPE;", 1]];

IO.PutF[defStream, Nest["", 1]];
failure _ HashTable.Pairs[allTheTables.localTable, GenerateInterfaceItem];

IO.PutF[defStream, Nest["", 0]];
IO.PutF[defStream, Nest["}...", 0]];
IO.Close[defStream];


initStream _ FS.StreamOpen[Rope.Cat[programKeyWD, "Init.Mesa"],  $create];

InitHeading[initStream];

IO.PutF[initStream, Nest["", 1]];
IO.PutF[initStream, Nest["ROPE: TYPE ~ Rope.ROPE;", 1]];

IO.PutF[initStream, Nest["", 1]];
failure _ HashTable.Pairs[allTheTables.localTable, GenerateInitializedItem];

IO.PutF[initStream, Nest["", 1]];
failure _ HashTable.Pairs[allTheTables.condensedFunctionTable, GenerateCondensedFcn];

IO.PutF[initStream, Nest["", 0]];
IO.PutF[initStream, Nest["}...", 0]];
IO.Close[initStream];
};

}.



DGenerateInterface.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Bhargava, August 9, 1986 3:07:06 pm PDT
Bill Jackson (bj) September 25, 1986 3:13:54 am PDT

Copied Types

Procs

this name was already made up! -- (bj)
FIX ME
GenDefs MAIN 
Generate Interface
Generated Constant Initialization Module
ΚΕ˜š
œ™Icodešœ
Οm
œ1™<K™'K™3—K™š
Οk	˜	Jšœ
žœ˜Jšžœ
žœ˜Jšœ
žœ.˜=Jšžœ
žœžœ!˜1Jšœžœžœ˜Jšœžœ^žœ˜Š
—J˜šΟnœžœ
ž˜ Jšžœ
žœ
žœ˜/Jšžœ˜Jšžœ˜—J˜™J™Jšžœžœžœ
˜Jšœžœ˜K˜—™K˜šŸœžœ
žœ˜Kšœžœ
˜Kšœžœ
žœ
˜Kšœ	žœ
˜Kš
œ
˜
Kšœžœ
žœ
˜Kšœžœ
˜Kšœžœ
˜K™šŸœ˜2Kšœžœžœ˜Kšžœ!žœ˜1K˜K˜—šŸœžœžœ˜0šžœž˜š
œ˜šžœ/˜1Kšžœ˜Kšžœ-˜/Kš
œ˜—K˜—š
œ˜Kšžœ#˜%K˜—š
œ
˜
Kšžœ$˜&K˜—š
œ˜Kš
œ!˜!Kšžœ-˜/šžœ1˜3Kšžœ$˜&Kš
œ˜K˜—Kš
œ˜šžœžœž˜šžœ,˜.Kšžœ˜Kšžœ˜Kšžœ$˜&Kš
œ˜—Kš
œ˜Kšžœ
˜K˜—šžœ+˜-Kšžœ˜Kšžœ˜Kšžœ$˜&Kš
œ˜K˜—Kšžœ'˜)Kšžœ˜K˜—š
œ˜Kš
œ'˜'Kš
œ˜K˜Kšžœ8˜:K˜šžœžœž˜šžœ$˜&Kšžœ˜Kšžœ˜Kš
œ˜—Kš
œ˜Kšžœ
˜K˜—šžœ#˜%Kšžœ˜Kšžœ˜Kš
œ˜K˜—Kšžœ˜K˜—KšœžœΟc˜(š
œ˜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šœžœ,˜5K˜Kšžœ,žœ˜<KšžœCžœ˜SšžœI˜KKšžœ-˜/Kš
œ˜—Kšžœ˜K˜—š
œ˜Kšžœ ˜"K˜—š
œ˜Kšžœ$˜&K˜—šžœ˜Kšžœ$˜&Kšžœ
˜K˜——Kš
œ˜K˜—šŸœžœžœ	žœ˜Xšžœž˜š
œ˜šžœžœ˜$Kšžœ!žœ'˜LKšžœ
˜Kš
œ˜K˜—šžœ˜Kšžœ&˜(Kšžœ˜Kš
œ˜—K˜—š
œ˜Kšžœ"žœ˜=K˜—š
œ˜Kšžœ1˜3K˜—š
œ˜Kšžœ3˜5K˜—š
œ
˜
Kšžœ#žœ˜>K˜—š
œ˜Kš
œ!˜!K˜šžœžœ˜$Kšžœ!žœ'˜LKšžœ
˜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šžœžœ˜9K˜—š
œ˜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šžœ!žœ'˜LKšžœ
˜Kš
œ˜K˜—šžœ˜Kšžœ&˜(Kšžœ˜Kš
œ˜—Kš
œ˜—˜
Kšžœ!žœ'˜LK˜—š
œ˜Kšžœ#˜%K˜—š
œ˜Kšžœ#žœ˜>K˜—šžœ˜Kšžœ%˜'Kšžœ
˜K˜——Kš
œ˜K˜—šŸœžœžœ	žœžœ
žœžœ˜|šžœž˜š
œ˜Kšœžœ
˜šžœ˜šžœ˜šžœ;˜=Kšžœ˜Kšžœ˜Kšžœ.˜0Kšžœ˜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š
œ˜—K˜
—šžœ˜šžœ˜Kšžœ˜Kšžœ$˜&Kš
œ˜K˜—Kš
œ˜šžœ	žœž˜šžœ˜Kšžœ˜Kšžœ$˜&Kš
œ˜—Kš
œ˜Kšžœ
˜K˜—šžœ˜Kšžœ˜Kš
œ˜—K˜——Kš
œ˜——Kš
œ˜—˜
Kšœžœ,˜5Kš
œ&™&KšΠbkΟb
‘™Kšœžœ
˜šžœ,˜.Kšžœ˜Kšžœ˜
Kšžœ˜Kš
œ˜—Kš
œ˜—š
œ˜Kšœžœ
˜šžœ*˜,Kšžœ˜Kšžœ˜Kš
œ˜—Kš
œ˜—Kšœžœ ˜*šžœ˜Kšžœ!˜#Kšžœ
˜K˜——Kš
œ˜K˜—šŸœ˜3Kšœžœžœ˜Kšœžœžœ	˜+K˜Kšœžœ
˜Kšœ
žœ
˜K˜Kšœžœ
˜K˜K˜šžœžœ
˜*K˜—Kš
œ7˜7šžœžœžœ˜/šžœ˜šžœ!˜#šžœ˜Kšžœžœ˜4K˜
—šžœ˜Kš
œT˜TK˜Kšœžœ	˜šžœ˜šžœ˜Kšžœ ˜"Kšžœ˜Kš
œ˜K˜
—šžœ˜šžœ˜Kšžœ˜Kšžœ˜Kš
œ˜—K˜——K˜——Kš
œ
˜
—šžœ˜Kš
œT˜TKšœžœ	˜šžœ
žœ
ž˜Kš
œQ˜QKš
œS˜SKš
œ@˜@Kšžœ6˜=—K˜K˜——Kšžœ˜ Kšžœ˜ K˜K˜—šŸœ˜5Kšœžœžœ˜Kšœžœžœ	˜+K˜Kšœžœ
˜Kšœ
žœ
˜K˜Kšœžœ
˜K˜K˜Kš
œ7˜7šžœžœžœ˜/šžœ˜šžœ#˜%šžœ˜Kš
œT˜TK˜Kšœžœ	˜šžœ˜šžœ˜šžœ(˜*Kšžœ˜Kšžœ˜Kšžœ˜Kš
œ˜—K˜——K˜——Kš
œ
˜
—šžœ˜Kš
œT˜TKšœžœ	˜šžœ
žœ
ž˜Kšœ$žœ˜,šžœ˜šžœ=žœ
˜Dšžœ˜Kšžœ˜!Kšžœ˜!K˜——Kš
œ˜——K˜——K˜—K˜šŸœžœžœ
žœ˜"šŸœ˜*Kšœžœžœ	˜!šžœ˜Kšžœ˜Kš
œ˜—K˜—K˜Kš
œ@˜@K˜Kšžœ!˜#Kšžœ˜ Kš
œ@˜@Kšžœ˜Kšžœ˜K˜Kšžœ1žœ˜JKš
œ˜K˜—šŸœžœžœ
žœ˜&šŸœ˜*Kšœžœžœ	˜!šžœ˜Kšžœ˜Kš
œ˜—K˜—Kš
œD˜DK˜Kšžœ!˜#Kšžœ˜ Kšžœ˜Kš
œ@˜@Kšžœžœ˜5Kšžœ˜K˜Kšžœ-žœ˜FKšžœ&žœ˜?Kšžœ žœ˜9Kš
œ˜—Iheadšœžœ
™
Kšœžœ˜Kš
œ˜Kš
œ˜K˜šœžœ˜#Kšžœ˜Kšžœ˜Kšžœ˜Kš
œ˜—K˜Kš
œ(˜(K˜š
œ™K˜Kšœžœ6˜DK˜Kš
œ˜K˜Kšžœ˜ Kšžœ5˜7K˜Kšžœ˜ Kš
œJ˜JK˜Kšžœ˜ Kšžœ"˜$Kšžœ˜K˜—š
œ(™(K˜Kšœ
žœ;˜JK˜Kš
œ˜K˜Kšžœ˜!Kšžœ6˜8K˜Kšžœ˜!Kš
œL˜LK˜Kšžœ˜!Kš
œU˜UK˜Kšžœ˜!Kšžœ#˜%Kšžœ˜—K˜——K˜Jš
œ˜J˜J˜—…—4ΒIΛ