DIRECTORY AMBridge, AMModel, AMModelBridge, AMTypes, Atom, BackStop, BBUrpEval, Commander, EvalQuote, Interpreter, InterpreterOps, IO, List, Misp, ProcessProps, Rope, RTTypesPrivate, StatementInterpreter, SymTab;

MispCedar: CEDAR PROGRAM
IMPORTS AMBridge, AMModel, AMModelBridge, AMTypes, Atom, BackStop, BBUrpEval, EvalQuote, Interpreter, InterpreterOps, IO, List, Misp, ProcessProps, Rope, StatementInterpreter, SymTab

={

LORA: TYPE = LIST OF REF ANY;
ROPE: TYPE = Rope.ROPE;
TV: TYPE = AMTypes.TV;
ReallyTV: TYPE = REF RTTypesPrivate.TypedVariableRec;
EvalCedarExpr: PROC [args: LORA, environment: Misp.Environment, data: REF ANY _ NIL, stack: Misp.Stack] RETURNS [cooked: REF ANY] --Misp.EvalProc-- = {
cedarExpression: ROPE _ NARROW[args.first];
symTab: SymTab.Ref _ Symtabize[environment];
result: TV;
errorRope: ROPE;
noResult: BOOL;
[result, errorRope, noResult] _ Interpreter.Evaluate[
rope: cedarExpression,
symTab: symTab,
abort: Misp.EnvStop[environment]
];
IF errorRope.Length[] # 0 THEN ERROR Misp.Error[environment, stack, errorRope];
cooked _ IF NOT noResult THEN CedarToMisp[result] ELSE NIL;
};

EvalCedarStmt: PROC [args: LORA, environment: Misp.Environment, data: REF ANY _ NIL, stack: Misp.Stack] RETURNS [cooked: REF ANY] --Misp.EvalProc-- = {
cedarStatement: ROPE _ NARROW[args.first];
symTab: SymTab.Ref _ Symtabize[environment];
errorRope: ROPE;
cooked _ NIL;
errorRope _ StatementInterpreter.InterpretStatement[
blockAsRope: cedarStatement,
symTab: symTab,
abort: Misp.EnvStop[environment]
!Yield => {
cooked _ CedarToMisp[value];
CONTINUE
}
];
IF errorRope.Length[] # 0 THEN ERROR Misp.Error[environment, stack, errorRope];
};

Yield: ERROR [value: TV] = CODE;

EvalYield: PROC [head: InterpreterOps.EvalHead, tree: InterpreterOps.Tree, target: AMTypes.Type _ AMTypes.nullType, data: REF _ NIL] RETURNS [return: TV] --EvalQuote.EvalQuoteProc-- = {
argTree: InterpreterOps.Tree _ InterpreterOps.GetArg[tree, 1];
argTV: TV _ InterpreterOps.Eval[tree: argTree, head: head, target: target];
BackStop.SuspendBackStop[];
ERROR Yield[argTV];
};

Symtabize: PROC [env: Misp.Environment] RETURNS [symTab: SymTab.Ref] = {
size: NAT _ 0;
FOR e: Misp.Environment _ env, e.parent WHILE e # NIL DO
size _ size + e.class.Size[e];
ENDLOOP;
size _ size*2 + 1;
symTab _ SymTab.Create[size];
FOR e: Misp.Environment _ env, e.parent WHILE e # NIL DO
Per: PROC [key: ATOM, binding: REF ANY] = {
name: ROPE _ Atom.GetPName[key];
[] _ symTab.Insert[name, MispToCedar[binding]]; 
};
e.class.Enumerate[e, Per];
ENDLOOP;
};

DefineCedar: PROC [environment: Misp.Environment] = {
environment.Defun[$cedarExpr, EvalCedarExpr];
environment.Defun[$cedarStmt, EvalCedarStmt];
};
EvalMisp: PROC [head: InterpreterOps.EvalHead, tree: InterpreterOps.Tree, target: AMTypes.Type _ AMTypes.nullType, data: REF _ NIL] RETURNS [return: TV] --EvalQuote.EvalQuoteProc-- = {
argTree: InterpreterOps.Tree _ InterpreterOps.GetArg[tree, 1];
argTV: TV _ InterpreterOps.Eval[tree: argTree, head: head];
argRef, raw, cooked: REF ANY;
env: Misp.Environment _ Environmentize[head];
TRUSTED {argRef _ CedarToMisp[argTV]};
WITH argRef SELECT FROM
rope: ROPE => raw _ GetStreamRefAny[IO.RIS[rope]];
text: REF TEXT => raw _ GetStreamRefAny[IO.TIS[text]];
ENDCASE => raw _ argRef;
BackStop.SuspendBackStop[];
cooked _ Misp.Eval[raw: raw, environment: env, stack: NIL !
Misp.Error => {
BackStop.ResumeBackStop[];
BBUrpEval.UrpFatal[head, tree, IO.PutFR["Misp: %g, stack = %g", IO.rope[msg], IO.rope[Misp.PrintValRope[stack]]]];
ERROR;
};
UNWIND => BackStop.ResumeBackStop[]
];
BackStop.ResumeBackStop[];
return _ MispToCedar[cooked];
};

GetStreamRefAny: PROC [s: IO.STREAM] RETURNS [ra: REF ANY] = {
ra _ s.GetRefAny[];
[] _ s.SkipWhitespace[];
IF NOT s.EndOf[] THEN ERROR;
s.Close[];
};

Environmentize: PROC [head: InterpreterOps.EvalHead] RETURNS [env: Misp.Environment] = {
cc: AMModel.Class;
DoRecord: PROC [tv: TV, name: ROPE] =
{IF tv # NIL THEN env _ Misp.NewEnvironment[name: name, parent: env, class: recordClass, initData: tv]};
in, out: IO.STREAM _ NIL;
WITH List.Assoc[$CommanderHandle, ProcessProps.GetPropList[]] SELECT FROM
cmd: Commander.Handle => {in _ cmd.in; out _ cmd.out};
ENDCASE;
env _ Misp.NewEnvironment[name: "Standard Misp stuff for a Cedar evaluation", in: in, out: out, sizeGuess: 200, stop: head.abortClosure];
Misp.DefinePrimitives[env];
TRUSTED {cc _ AMModel.ContextClass[head.context]};
SELECT cc FROM
world => NULL --don't define the Cedar world for Misp ... it can't use it--;
model => ERROR --don't know how to break down a CONFIG--;
statement => ERROR --don't know how to break down a statement--;
interface => TRUSTED {
DoRecord[
AMModelBridge.IRFromContext[head.context],
AMModel.ContextName[head.context]];
};
prog => TRUSTED {
DoRecord[
AMTypes.Globals[AMModelBridge.FrameFromContext[head.context]],
AMModel.ContextName[head.context]];
};
proc => TRUSTED {
context: TV _ AMModelBridge.FrameFromContext[head.context];
Work: UNSAFE PROC [tv: TV] = {
IF tv # NIL THEN {
Work[AMTypes.EnclosingBody[tv]];
DoRecord[
AMTypes.Locals[tv],
AMTypes.TVToName[AMTypes.Procedure[tv]]
];
}
ELSE DoRecord[
AMTypes.Globals[AMTypes.GlobalParent[context]],
AMModel.ContextName[AMModel.ParentContext[context]]
];
};
Work[context];
};
ENDCASE => ERROR;
env _ Misp.NewEnvironment[name: "Cedar specials", parent: env, class: symtabClass, initData: head.specials];
};

recordClass: Misp.EnvironmentClass _ NEW [Misp.EnvironmentClassRep _ [
Init: InitRecord,
GetBinding: GetRecordBinding,
SetBinding: SetRecordBinding,
Enumerate: EnumerateRecord,
Size: RecordSize]];

InitRecord: PROC [env: Misp.Environment, sizeGuess: NAT, initData: REF ANY] = {
env.rep _ initData;
};

GetRecordBinding: PROC [env: Misp.Environment, key: ATOM] RETURNS [found: BOOL, binding: REF ANY] = {
name: ROPE _ Atom.GetPName[key];
record: TV _ NARROW[env.rep];
type: AMTypes.Type _ AMTypes.TVType[record];
index: CARDINAL;
valTV: TV;
found _ TRUE;
index _ AMTypes.NameToIndex[type, name !AMTypes.Error => {IF reason = badName THEN {found _ FALSE; CONTINUE}};];
IF NOT found THEN RETURN;
valTV _ AMTypes.IndexToTV[record, index];
binding _ CedarToMisp[valTV];
};

SetRecordBinding: PROC [env: Misp.Environment, key: ATOM, binding: REF ANY, overwriteOld: BOOL] = {
name: ROPE _ Atom.GetPName[key];
record: TV _ NARROW[env.rep];
type: AMTypes.Type _ AMTypes.TVType[record];
index: CARDINAL;
varTV, valTV: TV;
found: BOOL _ TRUE;
index _ AMTypes.NameToIndex[type, name !AMTypes.Error => {IF reason = badName THEN {found _ FALSE; CONTINUE}};];
IF NOT found THEN ERROR Misp.Error[env, NIL, "Can't add fields to a Cedar frame"];
varTV _ AMTypes.IndexToTV[record, index];
SELECT AMTypes.TVStatus[varTV] FROM
mutable => NULL;
readOnly, const => ERROR Misp.Error[env, NIL, Rope.Cat["Can't update ", name]];
ENDCASE => ERROR;
valTV _ MispToCedar[binding];
AMTypes.Assign[varTV, valTV];
};

EnumerateRecord: PROC [env: Misp.Environment, consume: PROC [key: ATOM, binding: REF ANY]] = {
record: TV _ NARROW[env.rep];
type: AMTypes.Type _ AMTypes.TVType[record];
n: NAT _ AMTypes.NComponents[type];
FOR i: NAT IN [1 .. n] DO
name: ROPE _ AMTypes.IndexToName[type, i];
key: ATOM _ Atom.MakeAtom[name];
valTV: TV _ AMTypes.IndexToTV[record, i];
valRef: REF ANY _ CedarToMisp[valTV];
consume[key, valRef];
ENDLOOP;
n _ n;
};

RecordSize: PROC [env: Misp.Environment] RETURNS [NAT] = {
record: TV _ NARROW[env.rep];
type: AMTypes.Type _ AMTypes.TVType[record];
n: NAT _ AMTypes.NComponents[type];
RETURN [n];
};

symtabClass: Misp.EnvironmentClass _ NEW [Misp.EnvironmentClassRep _ [
Init: InitSymtab,
GetBinding: GetSymtabBinding,
SetBinding: SetSymtabBinding,
Enumerate: EnumerateSymtab,
Size: SymtabSize]];

InitSymtab: PROC [env: Misp.Environment, sizeGuess: NAT, initData: REF ANY] = {
env.rep _ initData;
};

GetSymtabBinding: PROC [env: Misp.Environment, key: ATOM] RETURNS [found: BOOL, binding: REF ANY] = {
name: ROPE _ Atom.GetPName[key];
symtab: SymTab.Ref _ NARROW[env.rep];
tv: TV;
[found, tv] _ symtab.Fetch[name];
IF NOT (found AND ISTYPE[tv, ReallyTV]) THEN RETURN [FALSE, NIL];
binding _ CedarToMisp[tv];
};

SetSymtabBinding: PROC [env: Misp.Environment, key: ATOM, binding: REF ANY, overwriteOld: BOOL] = {
name: ROPE _ Atom.GetPName[key];
symtab: SymTab.Ref _ NARROW[env.rep];
tv: TV;
tv _ MispToCedar[binding];
[] _ (IF overwriteOld THEN SymTab.Store ELSE SymTab.Insert)[symtab, name, tv];
};

EnumerateSymtab: PROC [env: Misp.Environment, consume: PROC [key: ATOM, binding: REF ANY]] = {
symtab: SymTab.Ref _ NARROW[env.rep];
PerPair: PROC [key: ROPE, val: REF ANY] RETURNS [quit: BOOL] --SymTab.EachPairAction-- = {
atom: ATOM _ Atom.MakeAtom[key];
WITH val SELECT FROM
tv: ReallyTV => {
binding: REF ANY _ CedarToMisp[tv];
consume[atom, binding];
};
ENDCASE;
quit _ FALSE;
};
[] _ symtab.Pairs[PerPair];
symtab _ symtab};

SymtabSize: PROC [env: Misp.Environment] RETURNS [NAT] = {
symtab: SymTab.Ref _ NARROW[env.rep];
RETURN [symtab.GetSize[]];
};

ROPEType: AMTypes.Type _ AMTypes.UnderType[CODE[ROPE]];
ATOMType: AMTypes.Type _ AMTypes.UnderType[CODE[ATOM]];

CedarToMisp: PROC [tv: TV] RETURNS [ref: REF ANY] = TRUSTED {
class: AMTypes.Class _ AMTypes.UnderClass[AMTypes.TVType[tv]];
SELECT class FROM
atom, rope, list, ref => ref _ AMBridge.TVToRef[tv];
nil => ref _ NIL;
ENDCASE => ref _ AMBridge.SomeRefFromTV[tv];
};

MispToCedar: PROC [ref: REF ANY] RETURNS [tv: TV] = TRUSTED {
tv _ AMBridge.TVForReferent[NEW [REF ANY _ ref], const];
};

Start: PROC = {
Misp.RegisterPrimitiveDefiner[DefineCedar];
EvalQuote.Register[name: "&yield", proc: EvalYield, symTab: NIL];
EvalQuote.Register[name: "&misp", proc: EvalMisp, symTab: NIL];
};

Start[];

}.
.MispCedar.Mesa
Spreitzer, July 30, 1985 2:05:25 pm PDT
Accessing Cedar from Misp:
Accessing Misp from Cedar:
A different way to Environmentize:
Environmentize: PROC [head: InterpreterOps.EvalHead] RETURNS [env: Misp.Environment] = {
top: Misp.Environment _ Misp.NewEnvironment[name: "Standard Misp stuff for a Cedar evaluation", sizeGuess: 200, stop: head.abortClosure];
fromCedar: Misp.Environment _ Misp.NewEnvironment[name: "stuff from Cedar", parent: top, class: fromCedarClass, initData: head];
Misp.DefinePrimitives[top];
};

fromCedarClass: Misp.EnvironmentClass _ NEW [Misp.EnvironmentClassRep _ [
Init: InitFromCedar,
GetBinding: GetCedarBinding,
SetBinding: SetCedarBinding,
Enumerate: EnumerateCedar,
Size: CedarSize]];

InitFromCedar: PROC [env: Misp.Environment, sizeGuess: NAT, initData: REF ANY] = {
env.rep _ initData;
};

GetCedarBinding: PROC [env: Misp.Environment, key: ATOM] RETURNS [found: BOOL, binding: REF ANY] = {
name: ROPE _ Atom.GetPName[key];
head: InterpreterOps.EvalHead _ NARROW[env.rep];
valTV: TV;
errorRope: ROPE;
noResult: BOOL;
[valTV, errorRope, noResult] _ Interpreter.Evaluate[
rope: name,
context: head.context,
symTab: head.specials,
abort: head.abortClosure];
IF found _ NOT (errorRope.Length[] # 0 OR noResult) THEN binding _ CedarToMisp[valTV];
};

SetCedarBinding: PROC [env: Misp.Environment, key: ATOM, binding: REF ANY, overwriteOld: BOOL] = {
name: ROPE _ Atom.GetPName[key];
head: InterpreterOps.EvalHead _ NARROW[env.rep];
varTV, valTV: TV;
errorRope: ROPE;
noResult: BOOL;
[varTV, errorRope, noResult] _ Interpreter.Evaluate[
rope: name,
context: head.context,
symTab: head.specials,
abort: head.abortClosure];
IF errorRope.Length[] # 0 THEN Misp.Error[env, NIL, errorRope];
IF noResult THEN Misp.Error[env, NIL, name.Cat[" has no value"]];
valTV _ MispToCedar[binding];
AMTypes.Assign[varTV, valTV];
};

EnumerateCedar: PROC [env: Misp.Environment, consume: PROC [key: ATOM, binding: REF ANY]] = {
head: InterpreterOps.EvalHead _ NARROW[env.rep];
cc: AMModel.Class;
FromRecord: PROC [record: TV] = {
type: AMTypes.Type _ AMTypes.TVType[record];
n: NAT _ AMTypes.NComponents[type];
FOR i: NAT IN [1 .. n] DO
name: ROPE _ AMTypes.IndexToName[type, i];
key: ATOM _ Atom.MakeAtom[name];
valTV: TV _ AMTypes.IndexToTV[record, i];
valRef: REF ANY _ CedarToMisp[valTV];
consume[key, valRef];
ENDLOOP;
};
PerSpecial: PROC [name: ROPE, help: ROPE, tv: TV, data: REF] RETURNS [stop: BOOL] = {
WITH tv SELECT FROM
reallyTV: ReallyTV => {
key: ATOM _ Atom.MakeAtom[name];
valRef: REF ANY _ CedarToMisp[tv];
consume[key, valRef];
};
ENDCASE;
stop _ FALSE;
};
TRUSTED {cc _ AMModel.ContextClass[head.context]};
[] _ InterpreterOps.EnumerateSymbols[PerSpecial, NIL, head.specials];
SELECT cc FROM
world => NULL --don't define the Cedar world for Misp ... it can't use it--;
model => ERROR --don't know how to break down a CONFIG--;
statement => ERROR --don't know how to break down a statement--;
interface => FromRecord[AMModelBridge.IRFromContext[head.context]];
prog => FromRecord[AMTypes.Globals[AMModelBridge.FrameFromContext[head.context]]];
proc => {
context: TV _ AMModelBridge.FrameFromContext[head.context];
FOR tv: TV _ context, AMTypes.EnclosingBody[tv] WHILE tv # NIL DO
FromRecord[AMTypes.Locals[tv]];
ENDLOOP;
FromRecord[AMTypes.Globals[AMTypes.GlobalParent[context]]];
};
ENDCASE => ERROR;

};

CedarSize: PROC [env: Environment] RETURNS [NAT] = {
head: InterpreterOps.EvalHead _ NARROW[env.rep];
size: NAT _ 0;
Per: PROC [key: ATOM, binding: REF ANY] = {size _ size + 1};
env.class.Enumerate[env, Per];
RETURN [size];
};
Yet another way to Environmentize:
Environmentize: PROC [head: InterpreterOps.EvalHead] RETURNS [env: Misp.Environment] = {
size: NAT _ head.specials.GetSize[];
cc: AMModel.Class;
context: TV _ NIL;
contextType: AMTypes.Type;
FromRecord: PROC [record: TV] = {
type: AMTypes.Type _ AMTypes.TVType[record];
n: NAT _ AMTypes.NComponents[type];
FOR i: NAT IN [1 .. n] DO
name: ROPE _ AMTypes.IndexToName[type, i];
key: ATOM _ Atom.MakeAtom[name];
valTV: TV _ AMTypes.IndexToTV[record, i];
valRef: REF ANY _ CedarToMisp[valTV];
env.class.SetBinding[env, key, valRef, FALSE];
ENDLOOP;
};
PerSpecial: PROC [name: ROPE, help: ROPE, tv: TV, data: REF] RETURNS [stop: BOOL] = {
key: ATOM _ Atom.MakeAtom[name];
valRef: REF ANY _ CedarToMisp[tv];
env.class.SetBinding[env, key, valRef, FALSE];
stop _ FALSE;
};
TRUSTED {cc _ AMModel.ContextClass[head.context]};
SELECT cc FROM
world => NULL --don't define the Cedar world for Misp ... it can't use it--;
model => ERROR --don't know how to break down a CONFIG--;
statement => ERROR --don't know how to break down a statement--;
interface => TRUSTED {
context _ AMModelBridge.IRFromContext[head.context];
contextType _ AMTypes.TVType[context];
size _ size + AMTypes.NComponents[contextType];
};
prog => TRUSTED {
context _ AMTypes.Globals[ AMModelBridge.FrameFromContext[head.context]];
contextType _ AMTypes.TVType[context];
size _ size + AMTypes.NComponents[contextType];
};
proc => TRUSTED {
context _ AMModelBridge.FrameFromContext[head.context];
contextType _ AMTypes.TVType[context];
FOR tv: TV _ context, AMTypes.EnclosingBody[tv] WHILE tv # NIL DO
size _ size + AMTypes.NComponents[AMTypes.TVType[AMTypes.Locals[tv]]];
ENDLOOP;
size _ size + AMTypes.NComponents[AMTypes.TVType[AMTypes.Globals[context]]];
};
ENDCASE => ERROR;
size _ size*2 + 201;
env _ Misp.NewEnvironment[name: "Cedar values", sizeGuess: size, stop: head.abortClosure];
Misp.DefinePrimitives[env];
[] _ InterpreterOps.EnumerateSymbols[PerSpecial, NIL, head.specials];
SELECT cc FROM
world => NULL --don't define the Cedar world for Misp ... it can't use it--;
model => ERROR --don't know how to break down a CONFIG--;
statement => ERROR --don't know how to break down a statement--;
interface => FromRecord[context];
prog => FromRecord[context];
proc => {
FOR tv: TV _ context, AMTypes.EnclosingBody[tv] WHILE tv # NIL DO
FromRecord[AMTypes.Locals[tv]];
ENDLOOP;
FromRecord[AMTypes.Globals[context]];
};
ENDCASE => ERROR;
};
Utilities:
atom => ref _ AMBridge.TVToATOM[tv];
rope => ref _ AMTypes.TVToName[tv];
list, ref => ref _ AMBridge.SomeRefFromTV[
AMTypes.Referent[tv !
AMTypes.Error => IF reason = typeFault THEN {
SELECT TRUE FROM
SafeStorage.EquivalentTypes[type, ROPEType] => ref _ AMTypes.TVToName[tv];
SafeStorage.EquivalentTypes[type, ATOMType] => ref _ AMBridge.TVToATOM[tv];
ENDCASE => ref _ AMBridge.SomeRefFromTV[tv];
CONTINUE}
]
];
Κ·–

"cedar" style˜
code™K™'—K˜KšΟk	œzœO˜Τ
K˜šΠbx	œœ
˜Kšœoœ>˜Ά
K˜K˜K˜Kšœœœ
œ
œ
œ
˜Kšœœœ
˜Kšœœœ
˜Kšœ
œœ!˜5
head™šΟn
œœœ'œ
œœœ
œ
œΟcœ˜—
Kšœœœ
˜+Kš
œ,˜,Kš
œ˜Kšœœ
˜Kšœ
œ
˜š
œ5˜5Kš
œ˜K˜Kš
œ ˜ Kš
œ˜—Kšœœ
œ+˜OKšœ	œ
œ
œœ
œ
˜;K˜—K˜šŸ
œœœ'œ
œœœ
œ
œ œ˜—
Kšœœœ
˜*Kš
œ,˜,Kšœœ
˜Kšœ	œ
˜
š
œ4˜4Kš
œ˜K˜Kš
œ ˜ š
œ˜K˜Kš
˜K˜
—Kš
œ˜—Kšœœ
œ+˜OK˜—K˜Kšœœ	œœ
˜ K˜šŸ	œœkœœœ
œ œ˜Ή
Kš
œ>˜>KšœœB˜KKš
œ˜Kšœ˜K˜—K˜šŸ	œœœ˜HKšœœ˜šœ%œœ
˜8K˜Kšœ
˜—K˜K˜šœ%œœ
˜8š
Ÿœœœœ
œ˜+Kšœœ˜ Kš
œ0˜0K˜—K˜Kšœ
˜—K˜—K˜šŸœœ$˜5Kš
œ-˜-Kš
œ-˜-K˜——™šŸœœkœœœ
œ œ˜Έ
Kš
œ>˜>Kšœœ2˜;Kšœœ
œ
˜Kš
œ-˜-Kšœ˜&šœœ
˜Kšœœœ
œ˜2Kš	œœ
œœ
œ˜6Kšœ˜—Kš
œ˜šœ6œ˜;˜Kš
œ˜Kšœœœœ"˜rKšœ
˜K˜—Kšœ˜#Kš
œ˜—Kš
œ˜Kš
œ˜K˜—K˜šŸœœœ
œœœ
œ˜>Kš
œ˜K˜Kšœ
œœ
œ
˜K˜
K˜—K˜šŸœœ!œ˜XKš
œ˜šŸœœœœ˜%Kšœ
œœ
œW˜h—Kšœ	œ
œœ
˜šœ:œ
˜IKš
œ6˜6Kšœ
˜—Kš
œ‰
˜‰
Kš
œ˜Kšœ+˜2šœ˜Kšœ	œ
 =œ
˜LKšœ	œ
 )œ
˜9Kšœ
œ
 ,œ
˜@šœ
œ˜š
œ	˜	Kš
œ*˜*Kš
œ#˜#—Kš
œ˜—šœœ˜š
œ	˜	Kš
œ>˜>Kš
œ#˜#—Kš
œ˜—šœœ˜Kšœ	œ0˜;šŸœœ
œœ˜šœœ
œ˜Kš
œ ˜ š
œ	˜	Kš
œ˜K˜'Kš
œ˜—K˜
—šœ
˜Kš
œ/˜/Kš
œ3˜3Kš
œ˜—K˜—K˜Kš
œ˜—Kšœœ
˜—Kš
œl˜lK˜—K˜šœ%œ˜FKš
œ˜Kš
œ˜Kš
œ˜K˜K˜—K˜š
Ÿ
œœ$œœ
œ˜OK˜K˜—K˜šŸœœœœ	œœ
œ˜eKšœœ˜ Kšœœœ
˜K˜,Kšœœ
˜Kšœœ
˜
Kšœœ
˜
Kš	œ:œœ
œœ˜pKšœ
œœ
œ
˜K˜)Kš
œ˜K˜—K˜šŸœœœœ
œœ˜cKšœœ˜ Kšœœœ
˜K˜,Kšœœ
˜Kšœœ
˜Kšœœœ
˜Kš	œ:œœ
œœ˜pKš
œ
œœ
œœ'˜RKš
œ)˜)šœ˜#Kšœœ
˜Kšœœœ#˜OKšœœ
˜—K˜K˜K˜—K˜šŸœœ"œœœ
œ˜^Kšœœœ
˜K˜,Kšœœ˜#šœœ
œ
˜Kšœœ ˜*Kšœœ˜ Kšœœ ˜)Kšœœ
œ˜%Kš
œ˜Kšœ
˜—K˜Kš
œ˜—K˜šŸ
œœœœ˜:Kšœœœ
˜K˜,Kšœœ˜#Kšœ˜Kš
œ˜—K˜šœ%œ˜FKš
œ˜Kš
œ˜Kš
œ˜K˜K˜—K˜š
Ÿ
œœ$œœ
œ˜OK˜K˜—K˜šŸœœœœ	œœ
œ˜eKšœœ˜ Kšœœ
˜%Kšœœ
˜K˜!Kšœ
œœ
œœ
œœœ˜AK˜K˜—K˜šŸœœœœ
œœ˜cKšœœ˜ Kšœœ
˜%Kšœœ
˜K˜Kšœœœœ"˜NK˜—K˜šŸœœ"œœœ
œ˜^Kšœœ
˜%šŸœœœœ
œœœ œ˜ZKšœœ˜ šœœ
˜š
œ˜Kšœ	œ
œ˜#K˜K˜—Kšœ
˜—Kšœœ
˜
Kš
œ˜—Kš
œ˜Kš
œ˜—K˜šŸ
œœœœ˜:Kšœœ
˜%Kšœ˜Kš
œ˜—K˜™"šŸœœ!œ™XKš
œ‰
™‰
Kš
œ€
™€
Kš
œ™K™—K™šœ(œ™IKš
œ™Kš
œ™Kš
œ™K™K™—K™š
Ÿ
œœ$œœ
œ™RK™K™—K™šŸœœœœ	œœ
œ™dKšœœ™ Kšœ œ
™0Kšœœ
™
Kšœœ
™Kšœ
œ
™š
œ4™4K™K™K™K™—Kšœ	œœœ™VK™—K™šŸœœœœ
œœ™bKšœœ™ Kšœ œ
™0Kšœœ
™Kšœœ
™Kšœ
œ
™™4K™K™K™K™—Kšœœœ
™?Kšœ
œœ™AK™K™K™—K™šŸœœ"œœœ
œ™]Kšœ œ
™0Kš
œ™šŸ
œœ
œ™!K™,Kšœœ™#šœœ
œ
™Kšœœ ™*Kšœœ™ Kšœœ ™)Kšœœ
œ™%Kš
œ™Kšœ
™—K™—šŸ
œœœœœœœœ™Ušœœ
™š
œ™Kšœœ™ Kšœœ
œ™"Kš
œ™K™—Kšœ
™—Kšœœ
™
K™—Kšœ+™2Kšœ1œ™Ešœ™Kšœ	œ
 =œ
™LKšœ	œ
 )œ
™9Kšœ
œ
 ,œ
™@Kš
œC™CKš
œR™Rš
œ	™	Kšœ	œ0™;š	œœ&œœ
™AKš
œ™Kšœ
™—Kš
œ;™;Kš
œ™—Kšœœ
™—K™Kš
œ™—K™šŸ	œœœœ™4Kšœ œ
™0Kšœœ™Kš
Ÿœœœœ
œ™<K™Kšœ™Kš
œ™——™"šŸœœ!œ™XKšœœ™$Kš
œ™Kšœ	œœ
™K™šŸ
œœ
œ™!K™,Kšœœ™#šœœ
œ
™Kšœœ ™*Kšœœ™ Kšœœ ™)Kšœœ
œ™%Kšœ'œ™.Kšœ
™—K™—šŸ
œœœœœœœœ™UKšœœ™ Kšœœ
œ™"Kšœ'œ™.Kšœœ
™
K™—Kšœ+™2šœ™Kšœ	œ
 =œ
™LKšœ	œ
 )œ
™9Kšœ
œ
 ,œ
™@šœ
œ™Kš
œ4™4K™&Kš
œ/™/Kš
œ™—šœœ™Kš
œI™IK™&Kš
œ/™/K™—šœœ™Kš
œ7™7K™&š	œœ&œœ
™AKš
œF™FKšœ
™—Kš
œL™LKš
œ™—Kšœœ
™—K™Kš
œZ™ZKš
œ™Kšœ1œ™Ešœ™Kšœ	œ
 =œ
™LKšœ	œ
 )œ
™9Kšœ
œ
 ,œ
™@Kš
œ!™!Kš
œ™š
œ	™	š	œœ&œœ
™AKš
œ™Kšœ
™—Kš
œ%™%Kš
œ™—Kšœœ
™—K™———™
Kšœ+œ
œ˜7Kšœ+œ
œ˜7K˜šŸœœœœœ
œœ˜=Kš
œ>˜>šœ˜Kš
œ$™$Kš
œ#™#š
œ*™*š
œ™šœœœ™-šœ
œ
™Kš
œJ™JKš
œK™KKšœ%™,—Kšœ
™	—Kš
œ
™
—Kš
œ™—Kš
œ4˜4Kšœ
œ
˜Kšœ%˜,—K˜—K˜šŸœœœ
œœœœ˜=Kšœœœ
œ˜8K˜——K˜šŸœœ˜Kš
œ+˜+Kšœ<œ˜AKšœ:œ˜?K˜—K˜K˜K˜K˜——…—%’Q‡