DIRECTORY
Atom,
CD,
CDPrivate,
CDApplications,
CDConvertLayers,
CDDirectory,
CDEvents,
CDBasics,
CDOrient,
Graphics,
Process,
RefTab,
Rope USING [Cat, IsEmpty, ROPE],
SafeStorage,
TerminalIO;

CDImpl: CEDAR MONITOR 
IMPORTS Atom, CD, CDApplications, CDDirectory, CDEvents, CDBasics, CDOrient, Graphics, Process, RefTab, Rope, SafeStorage, TerminalIO 
EXPORTS CD, CDPrivate, CDConvertLayers
SHARES CD, CDPrivate = 
BEGIN

Error: PUBLIC ERROR[ec: CD.ErrorCode _ programmingError, explanation: Rope.ROPE _ NIL] = CODE;
DebugCall: PUBLIC SIGNAL[what: REF] = CODE;
permanent: ZONE = SafeStorage.GetPermanentZone[]; 

layers: PUBLIC REF ARRAY CD.Layer OF CDPrivate.LayerRef = 
permanent.NEW[ARRAY CD.Layer OF CDPrivate.LayerRef]; 

registerTechEvent: CDEvents.EventRegistration = CDEvents.RegisterEventType[$RegisterTechnology];

technologyRegistration: RefTab.Ref = RefTab.Create[]; -- contains technologies

TechnologyPrivate: TYPE = REF TechnologyPrivateRep;
TechnologyPrivateRep: PUBLIC TYPE = RECORD [
objectRegisterTab: RefTab.Ref, -- contains object types
layerKeyTab: RefTab.Ref -- contains Layers
];


nilTechnologyPrivate: TechnologyPrivate = NEW[TechnologyPrivateRep_[
objectRegisterTab: RefTab.Create[], --for technology dependant objects it contains NIL 
layerKeyTab: RefTab.Create[]
]];


RegisterObjectType: PUBLIC PROC [objectType: ATOM, technology: CD.Technology_NIL] 
RETURNS [REF CD.ObjectProcs] = 
BEGIN
done: BOOL;
p: REF CD.ObjectProcs = permanent.NEW[CD.ObjectProcs];
p.technology _ technology;
p.objectType _ objectType;
p.further _ RefTab.Create[];
p.drawMe _ DefaultDrawMe;
p.quickDrawMe _ DefaultQuickDrawMe;
p.showMeSelected _ OutlineObjectProc;
p.hitInside _ DefaultHitInside;
p.interestRect _ DefaultInterestRect;
p.oldInsideRect _ DefaultOldInsideRect;
p.inDirectory _ FALSE;
p.wireTyped _ FALSE;
p.describe _ DefaultDescribe;
p.describeApp _ DefaultDescribeApp;
p.origin _ DefaultOrigin;
IF technology=NIL THEN done _ RefTab.Insert[nilTechnologyPrivate.objectRegisterTab, objectType, p]
ELSE {
techPriv: TechnologyPrivate = technology.technologyPrivate;
objectRegisterTab: RefTab.Ref = techPriv.objectRegisterTab;
globFound: BOOL;
x: REF;
[globFound, x] _ RefTab.Fetch[nilTechnologyPrivate.objectRegisterTab, objectType]; 
IF globFound AND x#NIL THEN done _ FALSE
ELSE { 
[] _ RefTab.Insert[nilTechnologyPrivate.objectRegisterTab, objectType, NIL]; 
done _ RefTab.Insert[objectRegisterTab, objectType, p]; -- technology register
}
};
IF NOT done THEN RETURN [NIL];
RETURN [p]
END;

FetchObjectProcs: PUBLIC PROC [objectType: REF, technology: CD.Technology_NIL] 
RETURNS [REF CD.ObjectProcs] =
BEGIN
x: REF;
p: REF CD.ObjectProcs_NIL;
found: BOOL _ FALSE;
IF technology#NIL THEN { -- search in technology table
techPriv: TechnologyPrivate = technology.technologyPrivate;
[found, x] _ RefTab.Fetch[techPriv.objectRegisterTab, objectType];
};
IF NOT found THEN { -- search in global table
[found, x] _ RefTab.Fetch[nilTechnologyPrivate.objectRegisterTab, objectType];
};
IF found THEN TRUSTED {p _ LOOPHOLE[x]};
RETURN [p]
END; 

DefaultDrawMe: PROC [aptr: CD.ApplicationPtr, pos: CD.DesignPosition, orient: CD.Orientation,
pr: CD.DrawRef] =
BEGIN
IF aptr.ob.p.quickDrawMe#DefaultQuickDrawMe THEN 
aptr.ob.p.quickDrawMe[aptr, pos, orient, pr]
ELSE {
ob1: CD.ObPtr = CDDirectory.ExpandHard[aptr.ob, pr.design, NIL];
IF ob1#NIL THEN {
app: CD.ApplicationPtr = NEW[CD.Application_[ob: ob1, properties: aptr.properties, location: pos, selected: FALSE]];
ob1.p.drawMe[app, pos, orient, pr];
app.ob _ NIL;
app.properties _ NIL;
}
ELSE pr.drawRect[CDOrient.RectAt[pos, aptr.ob.size, orient], CD.highLightShade, pr]
}
END; 

DefaultDrawChild: PROC [aptr: CD.ApplicationPtr, pos: CD.DesignPosition, orient: CD.Orientation,
pr: CD.DrawRef] =
BEGIN
aptr.ob.p.drawMe[aptr, pos, orient, pr]
END; 

DefaultQuickDrawMe: PROC [aptr: CD.ApplicationPtr, pos: CD.DesignPosition, orient: CD.Orientation,
pr: CD.DrawRef] =
BEGIN
IF aptr.ob.p.drawMe#DefaultDrawMe THEN 
aptr.ob.p.drawMe[aptr, pos, orient, pr]
ELSE { 
ob1: CD.ObPtr = CDDirectory.ExpandHard[aptr.ob, pr.design, NIL];
IF ob1#NIL THEN {
app: CD.ApplicationPtr = NEW[CD.Application_[ob: ob1, properties: aptr.properties, location: pos, selected: FALSE]];
ob1.p.quickDrawMe[app, pos, orient, pr];
app.ob _ NIL;
app.properties _ NIL;
}
ELSE pr.drawRect[CDOrient.RectAt[pos, aptr.ob.size, orient], CD.highLightShade, pr]
}
END; 

OutlineObjectProc: PROC [aptr: CD.ApplicationPtr, pos: CD.DesignPosition, orient: CD.Orientation,
pr: CD.DrawRef] =
BEGIN
pr.outLineProc[
CDOrient.MapRect[
itemInCell: CD.InterestRect[aptr.ob],
cellSize: aptr.ob.size,
cellInstOrient: orient,
cellInstPos: pos
],
pr
]
END; 

DefaultHitInside: PROC [aptr: CD.ApplicationPtr, hitRect: CD.DesignRect] RETURNS [BOOL] =
BEGIN
RETURN [
CDBasics.Intersect[hitRect, CDApplications.ARectO[aptr]] AND
CDBasics.Intersect[hitRect,
CDOrient.MapRect[
itemInCell: CD.InterestRect[aptr.ob],
cellSize: aptr.ob.size,
cellInstOrient: aptr.orientation,
cellInstPos: aptr.location
]]
]
END; 

DefaultDefaultsInterestRecProc: PROC [ob: CD.ObPtr] RETURNS [BOOL] = 
BEGIN
RETURN [TRUE]
END;

DefaultInterestRect: PROC [ob: CD.ObPtr] RETURNS [CD.DesignRect] = 
BEGIN
RETURN [CDBasics.RectAt[[0, 0], ob.size]]
END;

DefaultOrigin: PROC [ob: CD.ObPtr] RETURNS [CD.DesignPosition] = 
BEGIN
RETURN [CDBasics.BaseOfRect[ob.p.interestRect[ob]]]
END;

DefaultOldInsideRect: PROC [ob: CD.ObPtr] RETURNS [CD.DesignRect] = 
BEGIN
RETURN [ob.p.interestRect[ob]]
END;

DefaultDescribeApp: PROC [app: CD.ApplicationPtr] RETURNS [Rope.ROPE] =
BEGIN
RETURN [app.ob.p.describe[app.ob]]
END;

DefaultDescribe: PROC [me: CD.ObPtr] RETURNS [Rope.ROPE] =
BEGIN
Desc: PROC [p: REF READONLY CD.ObjectProcs] RETURNS [Rope.ROPE] =
INLINE BEGIN
RETURN [
IF p.description=NIL THEN Atom.GetPName[p.objectType]
ELSE p.description
]
END;
IF me.p.inDirectory THEN {
n: Rope.ROPE = CDDirectory.Name[me];
IF ~Rope.IsEmpty[n] THEN RETURN [Rope.Cat[Desc[me.p], " ", n]] 
};
RETURN [Desc[me.p]]
END;

DefaultDrawComment: PROC [r: CD.DesignRect, comment: Rope.ROPE, pr: CD.DrawRef] =
BEGIN
END;

lastLayer: CD.Layer _ 3;

InitiateLayer: PROC [lev: CD.Layer, technology: CD.Technology_NIL, uniqueKey: ATOM] =
BEGIN
techPriv: TechnologyPrivate;
layers[lev].technology _ technology;
layers[lev].uniqueKey _ uniqueKey;
IF technology=NIL THEN techPriv _ nilTechnologyPrivate
ELSE {
techPriv _ technology.technologyPrivate;
technology.usedLayers _ CONS[lev, technology.usedLayers]
};
[] _ RefTab.Insert[techPriv.layerKeyTab, uniqueKey, layers[lev]];
END;

ConvertLayer: PUBLIC ENTRY PROC [technology: CD.Technology, uniqueKey: ATOM, into: CD.Layer] =
BEGIN
ENABLE UNWIND => NULL;
techPriv: TechnologyPrivate;
IF uniqueKey=NIL OR uniqueKey=$NIL THEN 
RETURN WITH ERROR Error[callingError, "bad uniqueKey"]; -- avoid problems with NIL as ATOM; any IO routine might use $NIL instead
IF technology=NIL THEN techPriv _ nilTechnologyPrivate
ELSE techPriv _ technology.technologyPrivate;
[] _ RefTab.Insert[techPriv.layerKeyTab, uniqueKey, layers[into]];
END;

NewLayer: PUBLIC ENTRY PROC [technology: CD.Technology_NIL, uniqueKey: ATOM] RETURNS [CD.Layer] =
BEGIN
ENABLE UNWIND => NULL;
IF uniqueKey=NIL OR uniqueKey=$NIL THEN 
RETURN WITH ERROR Error[callingError, "bad uniqueKey"]; -- avoid problems with NIL as ATOM; any IO routine might use $NIL instead
IF lastLayer>=CD.layerNum-1 THEN 
RETURN WITH ERROR Error[noResource, "too many layers have been requested; (probaly too many different technologies are used)"];
lastLayer _ lastLayer+1;
InitiateLayer[lastLayer, technology, uniqueKey];
RETURN [lastLayer]
END;

DefaultDrawContext: PROC [pr: CD.DrawRef, proc: CD.DrawContextLayerProc, ob: CD.ObPtr, pos: CD.DesignPosition, orient: CD.Orientation, layer: CD.Layer] =
BEGIN
IF pr.deviceContext#NIL AND pr.contextFilter#NIL AND pr.contextFilter[layer].doit THEN { 
mark: Graphics.Mark = pr.deviceContext.Save[];
[] _ pr.deviceContext.SetPaintMode[pr.contextFilter[layer].paintMode];
pr.deviceContext.SetColor[pr.contextFilter[layer].color];
IF ob#NIL THEN {
pr.deviceContext.Translate[pos.x, pos.y];
CDOrient.OrientateContext[pr.deviceContext, ob.size, orient];
};
proc[pr.deviceContext, ob, layer ! 
UNWIND => {
pr.deviceContext.Restore[mark]; 
GOTO return
}
];
pr.deviceContext.Restore[mark]
}
EXITS
return => NULL;
END;

FetchLayer: PUBLIC PROC [t: CD.Technology, uniqueKey: ATOM] RETURNS [CD.Layer] =
BEGIN
found: BOOL_FALSE;
l: CD.Layer _ CD.highLightError;
x: REF;
IF t#NIL THEN {
techPriv: TechnologyPrivate = t.technologyPrivate;
[found: found, val: x] _ RefTab.Fetch[techPriv.layerKeyTab, uniqueKey];
};
IF ~found THEN {
[found: found, val: x] _ RefTab.Fetch[nilTechnologyPrivate.layerKeyTab, uniqueKey];
};
IF found THEN l _ NARROW[x, CDPrivate.LayerRef].number;
RETURN [l]
END;

LayerTechnology: PUBLIC PROC [l: CD.Layer] RETURNS [CD.Technology] =
BEGIN
RETURN [layers[l].technology];
END;

LayerKey: PUBLIC PROC [l: CD.Layer] RETURNS [ATOM] =
BEGIN
RETURN [layers[l].uniqueKey];
END;

nestingDepht: CARDINAL _ 400;

CreateDrawRef: PUBLIC PROC [design: CD.Design, deviceContext: Graphics.Context] RETURNS [CD.DrawRef] =
BEGIN
p: CD.DrawRef ~ NEW[CD.DrawInformation];
p.interestClip _ CDBasics.universe;
p.minimalSize _ 0;
p.scaleHint _ 0.0;
p.drawRect _ DrawRectWithGraphics;
p.drawComment _ DefaultDrawComment;
p.drawChild _ DefaultDrawChild;
p.outLineProc _ EmptyOutLineProc;
p.saveRect _ SaveByDraw;
p.stopFlag _ NEW[BOOL _ FALSE]; 
p.drawContext _ DefaultDrawContext;
p.deviceContext _ deviceContext;
p.devicePrivate _ NIL; 
p.setGround _ DefaultSetGround;
p.design _ design;
p.nesting _ NEW[CD.Nesting[nestingDepht]];
p.nestDepth _ 0;
RETURN [p]
END;

EmptyOutLineProc: PROC[r: CD.Rect, pr: CD.DrawRef] = {};
SaveByDraw: PROC [r: CD.Rect, l: CD.Layer, pr: CD.DrawRef] = {pr.drawRect[r, l, pr]};
DefaultSetGround: PROC [pr: CD.DrawRef, pushedOut: BOOL] = {};

DrawRectWithGraphics: PROC [r: CD.Rect, l: CD.Layer, pr: CD.DrawRef] = 
BEGIN
DrawRectInContext: PROC [context: Graphics.Context, ob: CD.ObPtr, layer: CD.Layer] = {
context.DrawBox[Graphics.Box[xmin: r.x1, xmax: r.x2, ymin: r.y1, ymax: r.y2]];
};
pr.drawContext[pr, DrawRectInContext, NIL, [0, 0], 0, l]
END;

RegisterTechnology: PUBLIC PROC [key: ATOM, name: Rope.ROPE] RETURNS [CD.Technology] =
BEGIN
t: CD.Technology = permanent.NEW[CD.TechnologyRec];
IF ~RefTab.Insert[technologyRegistration, key, t] THEN RETURN[NIL];
t.key _ key;
t.name _ name;
t.usedLayers _ NIL;
t.technologyPrivate _ permanent.NEW[TechnologyPrivateRep _
[RefTab.Create[], RefTab.Create[]]];
[] _ CDEvents.ProcessEvent[ev: registerTechEvent, design: NIL, x: t];
RETURN[t]
END;

FetchTechnology: PUBLIC PROC [key: ATOM] RETURNS [CD.Technology] =
BEGIN
x: REF;
found: BOOL;
tech: CD.Technology _ NIL;
[found: found, val: x] _ RefTab.Fetch[technologyRegistration, key];
IF found THEN tech _ NARROW[x];  
RETURN[tech]
END;

BreakProc: PROC [msg: Rope.ROPE, what: REF] = {SIGNAL DebugCall[what]};

Debug: PUBLIC PROC [msg: Rope.ROPE_NIL, what: REF_NIL, mayProceed: BOOL_TRUE] = 
BEGIN 
n: INT_0;
IF msg=NIL THEN msg _ "Unknown error";
IF mayProceed THEN {
DO
TerminalIO.WriteRope[msg];
TerminalIO.WriteRope["\nif you don't know what to do,\n"]; 
TerminalIO.WriteRope["   then mouse-click on proceed,\n"];
TerminalIO.WriteRope["   save your design onto a new file,\n"];
TerminalIO.WriteRope["   and restart chipndale\n"];
n _ TerminalIO.RequestSelection[
label: "Debug options",
choice: LIST["proceed", "signal and proceed", "signal in main process"]];
SELECT n FROM
1 => {TerminalIO.WriteRope["proceed\n"]; EXIT};
2 => {TRUSTED {Process.Detach[FORK BreakProc[msg, what]]}; EXIT};
3 => {BreakProc[msg, what]; EXIT};
ENDCASE => TerminalIO.WriteRope["skipped\n"];
ENDLOOP;
}
ELSE {
TerminalIO.WriteRope[msg];
ERROR DebugCall[what]
}; 
END;
IF registerTechEvent=NIL THEN ERROR;  
FOR l: CD.Layer IN CD.Layer DO
layers[l] _ permanent.NEW[CDPrivate.LayerRec];
layers[l].number _ l;
layers[l].globalUniqueKey _ layers[l];
ENDLOOP;
InitiateLayer[CD.combined, NIL, $combined];
InitiateLayer[CD.highLightShade, NIL, $highLightShade];
InitiateLayer[CD.highLightError, NIL, $highLightError];
InitiateLayer[CD.backGround, NIL, $backGround];
END. 


2CDImpl.mesa   (part of ChipNDale)
Copyright c 1983, 1985 by Xerox Corporation.  All rights reserved.
Christian Jacobi, June 24, 1983 5:07 pm 
last edited Christian Jacobi, May 7, 1985 12:45:59 pm PDT
--assume everithing gets correct even if all references are lost, 
--don't care about memory area, hint only
--also initializes procedures with default values 
--still check if it might be global
--global register it used per technology
--may find it but have NIL value: then is technologydependant
--sorry XXXX IF found THEN p _ NARROW[x];
--pr.drawRect[CDOrient.RectAt[pos, aptr.ob.size, orient], CD.highLightShade, pr]
--Helps conversion when layers are renamed
--calls proc which may use context; mode and color are set to layer's need
--call is suppressed if layer does not need drawing; this is default.
--on recursive calls, the context may or may not include previous transformations
--pr.deviceContext.ClipBox[[xmin: pr.interestClip.x1, ymin: pr.interestClip.y1, xmax: pr.interestClip.x2, ymax: pr.interestClip.y2]];
--Returns NIL if key is already in use
--This must be the only way to create data of type TechnologyRec
--not ENTRY since RefTab.Insert does necessary monitoring and CDEvents.ProcessEvent
--is dangerous
--Returns NIL if key is not registered
-- -- -- -- -- -- -- -- --

-- -- -- -- -- -- -- -- --
�Ê5˜š
œ!™!Jšœ
Ïm
œ7™BJš
œ(™(Jš
œ9™9—J˜š
Ïk	˜	Jš
œ˜Jšžœ
˜Jš
œ
˜
J˜Jš
œ˜Jš
œ˜J˜	J˜	Jš
œ	˜	J˜	J˜J˜Jšœžœžœ˜ J˜J˜—J˜šÏbœžœ
žœ
˜Jšžœ˜†
Jšžœ
žœ˜&Jšžœ
žœ˜—Jš
ž˜J˜Jš
œžœ
žœžœ1žœžœžœ
˜^Jš	œžœ
žœžœžœ
˜+šœžœ#˜2Jš
œB™BJš
œ)™)—J˜šœžœ
žœ
žœ
žœžœ˜:Jš	œ
žœ
žœ
žœžœ˜5—J˜J˜`J˜Jšœ6Ïc˜NJ˜Jšœžœžœ˜3šœžœ
žœžœ˜,Jšœ ˜7Jšœ ˜*J˜J˜J˜—šœ*žœ˜DJšœ$ 3˜WJš
œ˜Jš
œ˜—J˜J˜šÏnœžœ
žœžœžœžœ˜RJšžœžœ˜Jš
œ2™2Jš
ž˜Jšœžœ
˜Jšœžœžœ
žœ˜6J˜J˜Jš
œ˜J˜J˜#J˜%J˜J˜%Jš
œ'˜'Jšœžœ
˜Jšœžœ
˜Jš
œ˜Jš
œ#˜#Jšžœ˜Jšžœžœ
žœL˜bš
ž˜J˜;J˜;Jšœžœ
˜Jšœžœ
˜š
œS˜SJš
œ#™#—Jš	žœžœžœ
žœž˜(šžœ
˜šœGžœ˜MJš
œ(™(—Jšœ8 ˜NJš
ž
˜
—Jšž
œ
˜—Jš
žœ
žœžœ
žœžœ˜Jšžœ˜
Jšžœ
˜J˜—š¡œžœ
žœžœžœžœ˜OJšžœžœ˜Jš
ž˜Jšœžœ
˜Jšœžœ
žœ
˜Jšœžœ
žœ
˜šžœžœ
žœ
 ˜6J˜;J˜BJš
œ˜—šžœ
žœžœ
 ˜-Jš
œN˜NJš
œ=™=Jš
œ˜—Jš
œ)™)Jšžœžœ
žœžœ˜(Jšžœ˜
Jšžœ˜J˜—š
¡
œžœžœžœžœ
˜]Jšœžœ˜Jš
ž˜šžœ*žœ
˜1Jš
œ,˜,—šžœ˜Jšœžœ4žœ˜@šžœžœ
žœ˜Jš	œžœžœ
žœMžœ˜tJš
œ#˜#Jšœ	žœ
˜
Jšœžœ
˜J˜
—Jšžœ9žœ˜SJ˜
—Jšžœ˜J˜—š
¡œžœžœžœžœ
˜`Jšœžœ˜Jš
ž˜Jš
œ'˜'Jšžœ˜J˜—š
¡œžœžœžœžœ
˜bJšœžœ˜Jš
ž˜šžœ žœ
˜'Jš
œ'˜'—šžœ
˜Jšœ:žœ™PJšœžœ4žœ˜@šžœžœ
žœ˜Jš	œžœžœ
žœMžœ˜tJš
œ(˜(Jšœ	žœ
˜
Jšœžœ
˜J˜
—Jšžœ9žœ˜SJ˜
—Jšžœ˜J˜—š¡œžœ žœžœ
˜aJšœžœ˜Jš
ž˜š
œ˜š
œ˜Jš
œ%˜%Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œ˜Jš
œ
˜
—Jšžœ˜J˜—š¡œžœžœžœ
žœžœ˜YJš
ž˜šžœ˜Jšœ9ž˜<š
œ˜š
œ˜Jšœžœ˜%Jš
œ˜Jš
œ!˜!Jš
œ˜Jš
œ˜——J˜
—Jšžœ˜J˜—š
¡œžœžœžœžœ˜EJš
ž˜Jšžœžœ
˜
Jšžœ
˜J˜—š
¡œžœžœžœžœ˜CJš
ž˜Jšžœ#˜)Jšžœ
˜J˜—š
¡
œžœžœžœžœ˜AJš
ž˜Jšžœ-˜3Jšžœ
˜J˜—š
¡œžœžœžœžœ˜DJš
ž˜Jšžœ˜Jšžœ
˜J˜—š
¡œžœžœžœžœ˜GJš
ž˜Jšžœ˜"Jšžœ
˜—J˜š
¡œžœžœžœžœ˜:Jš
ž˜š¡œžœžœ
žœžœžœ˜AJš
ž˜šžœ˜Jšžœžœ
žœ˜5Jšžœ˜J˜
—Jšžœ
˜—šžœžœ˜Jšœžœ˜$Jšžœžœ
žœ ˜?Jš
œ˜—Jšžœ
˜Jšžœ
˜—J˜š
¡œžœžœžœžœ˜QJš
ž˜Jšžœ
˜—J˜Jšœžœ˜J˜š¡
œžœžœžœžœ
žœ˜UJš
ž˜Jš
œ˜Jš
œ$˜$Jš
œ"˜"Jšžœžœ
žœ ˜6šžœ˜J˜(Jšœžœ˜8J˜—Jš
œA˜AJšžœ
˜—J˜š¡œžœ
žœ
žœžœžœžœ	˜^Jš
œ*™*Jš
ž˜Jšžœ
žœžœ
˜Jš
œ˜šžœžœ
žœžœ
˜(Jšžœ
žœ
žœ' I˜�
—Jšžœžœ
žœ ˜6Jšžœ)˜-Jš
œB˜BJšžœ
˜—J˜š¡œžœ
žœ
žœžœžœ
žœžœžœ	˜aJš
ž˜Jšžœ
žœžœ
˜šžœžœ
žœžœ
˜(Jšžœ
žœ
žœ' I˜�
—šžœžœžœ
˜!Jšžœ
žœ
žœn˜—J˜Jš
œ0˜0Jšžœ˜Jšžœ
˜J˜—š¡œžœžœžœžœ
žœžœžœ	˜™
Jš
œJ™JJš
œE™EJš
œQ™QJš
ž˜šžœžœ
žœžœ
žœžœ˜YJš
œ.˜.Jš
œF˜FJš
œ9˜9Jš
œ…
™…
šžœžœ
žœ˜Jš
œ)˜)Jš
œ=˜=J˜—š
œ#˜#šžœ˜Jš
œ ˜ Jšžœ˜Jš
œ
˜
—Jš
œ˜—Jš
œ˜J˜
—š
ž˜Jšœ
žœ
˜—Jšžœ
˜—J˜š¡
œžœ
žœžœžœžœžœ	˜PJš
ž˜Jšœž
œ
˜Jšœžœ	žœ˜ Jšœžœ
˜šžœžœ
žœ˜J˜2Jš
œG˜GJš
œ˜—šžœžœ˜Jš
œS˜SJ˜—Jšžœžœžœ˜7Jšžœ˜
Jšžœ
˜J˜—š¡œžœ
žœžœ˜DJš
ž˜Jšžœ˜Jšžœ
˜—J˜š¡œžœ
žœžœžœžœ˜4Jš
ž˜Jšžœ˜Jšžœ
˜—J˜Jšœžœ˜J˜š¡
œžœ
žœ
žœ*žœžœ˜fJš
ž˜Jšœžœžœ
žœ˜(Jš
œ#˜#J˜Jš
œ˜Jš
œ"˜"Jš
œ#˜#Jš
œ˜J˜!J˜Jšœ
žœ
žœžœ˜ Jš
œ#˜#Jš
œ ˜ Jšœžœ˜Jš
œ˜J˜Jšœžœ
žœ˜*Jš
œ˜Jšžœ˜
šžœ
˜J˜——Jš¡œžœžœžœ˜8Jš
¡
œžœžœ
žœžœ$˜UJš¡œžœžœžœ˜>J˜š
¡œžœžœ
žœžœ˜GJš
ž˜š¡œžœ!žœžœ˜VJš
œN˜NJš
œ˜—Jš
œ8˜8Jšžœ
˜—J˜š¡œžœ
žœžœ
žœžœžœ˜VJš
œ&™&š
œ@™@Jš
œS™SJš
œ™—Jš
ž˜Jšœžœžœ
žœ˜3Jšžœ0žœ
žœ
žœ˜CJ˜J˜Jšœžœ
˜šœ žœ˜:Jš
œ$˜$—Jšœ:žœ˜EJšžœ˜	Jšžœ
˜J˜—š¡œžœ
žœžœžœžœ˜BJš
œ&™&Jš
ž˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
žœ
˜J˜CJšžœžœžœ˜!Jšžœ˜Jšžœ
˜—J˜Jš
œ™Jš
¡	œžœžœžœžœ˜GJ˜š¡œžœ
žœžœ
žœžœ
žœžœ
žœ˜PJšžœ
˜Jšœžœ˜	Jšžœžœ
žœ˜&šžœžœ˜š
ž˜Jš
œ˜Jš
œ;˜;Jš
œ:˜:Jš
œ?˜?Jš
œ3˜3š
œ ˜ J˜Jšœžœ=˜I—šžœž˜
Jšœ)žœ˜/Jšœžœžœžœ˜AJšœžœ˜"Jšžœ&˜-—Jšžœ
˜—J˜
—šžœ˜Jš
œ˜Jšžœ˜Jš
œ˜—Jšžœ
˜—J™Jš
œ™Jšžœžœ
žœ
žœ˜&š	žœžœžœ
žœž˜Jšœžœ˜.Jš
œ˜Jš
œ&˜&Jšžœ
˜—Jšœžœžœ
˜+Jšœžœžœ˜7Jšœžœžœ˜7Jšœžœ
žœ˜/Jšžœ˜J˜J˜—…—/zEá