DIRECTORY BasicTime, CD, CDBasics, CDInstances, CDLayers, CDOps, CDRects, CDSequencer, CDValue, IO, PopUpSelection, Rope, TerminalIO; CDBasicCommands: CEDAR PROGRAM IMPORTS BasicTime, CDInstances, CDLayers, CDOps, CDSequencer, CDValue, PopUpSelection, TerminalIO, CDRects, CDBasics = BEGIN DescribeInst: PROC [inst: CD.Instance, design: CD.Design_NIL] RETURNS [r: Rope.ROPE] = { r _ CDOps.InstRope[inst, design]; }; MatchLayer: PROC [template, found: CD.Layer] RETURNS [BOOL] = INLINE { IF template#CD.undefLayer THEN IF CDLayers.AbstractToPaint[template]#CDLayers.AbstractToPaint[found] THEN RETURN [FALSE]; RETURN [TRUE] }; RectDist: PROC [pos: CD.Position, r: CD.Rect] RETURNS [CD.Number] = { RETURN [MAX[ (IF pos.xr.x2 THEN (pos.x-r.x2) ELSE 0), (IF pos.yr.y2 THEN (pos.y-r.y2) ELSE 0) ]] }; ComputeBB: PROC [list: CD.InstanceList, selectedOnly: BOOL_FALSE] RETURNS [bound: CD.Rect_CDBasics.empty, cnt: INT_0] = { FOR l: LIST OF CD.Instance _ list, l.rest WHILE l#NIL DO IF selectedOnly AND NOT l.first.selected THEN LOOP; cnt _ cnt+1; bound _ CDBasics.Surround[bound, CDInstances.InstRectO[l.first]] ENDLOOP; }; lastPos: CD.Position; lastKey: REF _ NIL; lastTime: BasicTime.GMT _ BasicTime.earliestGMT; ReUseSameSelection: PROC [comm: CDSequencer.Command] RETURNS [yes: BOOL] = { lambda: CD.Number = comm.design.technology.lambda; ReallyClose: PROC [p1, p2: CD.Position] RETURNS [BOOL] = INLINE { RETURN [ABS[p1.x-p2.x]<=lambda AND ABS[p1.y-p2.y]<=lambda] }; now: BasicTime.GMT _ BasicTime.Now[]; yes _ ReallyClose[lastPos, comm.pos] AND lastKey=comm.key AND BasicTime.Period[lastTime, now]<=2; lastPos _ comm.pos; lastKey _ comm.key; lastTime _ now; }; Select: PROC [design: CD.Design, pos: CD.Position] = { sel: CD.Instance _ NIL; FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO IF ~w.first.selected THEN { IF CDInstances.PointToI[pos, w.first] THEN {sel _ w.first; EXIT} }; ENDLOOP; IF sel#NIL THEN { sel.selected _ TRUE; CDOps.ReOrderInstance[design, sel]; CDOps.RedrawInstance[design, sel]; TerminalIO.PutRope[DescribeInst[sel, design]]; } ELSE { FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO IF w.first.selected THEN { IF CDInstances.PointToI[pos, w.first] THEN { TerminalIO.PutRopes[DescribeInst[w.first, design], " again"]; RETURN } }; ENDLOOP; TerminalIO.PutRope[" no pointed object"]; } }; DeSelect: PROC [design: CD.Design, pos: CD.Position] = { inst: CD.Instance _ CDInstances.InstanceAt[CDOps.InstList[design], pos, TRUE]; IF inst#NIL THEN { inst.selected _ FALSE; CDOps.RedrawInstance[design, inst]; CDOps.ReOrderInstance[design, inst]; }; TerminalIO.PutRope[DescribeInst[inst, design]]; }; AreaSelect: PROC [design: CD.Design, area: CD.Rect, includePartial: BOOL_FALSE] = { FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO IF ~w.first.selected THEN { IF CDBasics.Intersect[area, CDInstances.InstRectI[w.first]] THEN IF includePartial OR CDBasics.Inside[CDInstances.InstRectI[w.first], area] THEN { w.first.selected _ TRUE; CDOps.RedrawInstance[design, w.first, FALSE]; }; }; ENDLOOP; }; AreaDeSelect: PROC [design: CD.Design, area: CD.Rect, includePartial: BOOL_FALSE] = { FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO IF w.first.selected THEN { IF CDBasics.Intersect[area, CDInstances.InstRectI[w.first]] THEN IF includePartial OR CDBasics.Inside[CDInstances.InstRectI[w.first], area] THEN { w.first.selected _ FALSE; CDOps.RedrawInstance[design, w.first]; }; }; ENDLOOP; }; SelectExclusiveComm: PROC [comm: CDSequencer.Command] = { TerminalIO.PutRope["select pointed "]; CDOps.DeselectAll[comm.design, FALSE]; Select[comm.design, comm.pos]; TerminalIO.PutRope["\n"]; }; ReSelectExclusive: PROC [design: CD.Design, pos: CD.Position, verbose: BOOL_TRUE, layer: CD.Layer_CD.undefLayer] RETURNS [done: BOOL_TRUE] = { Deselect: PROC [i: CD.Instance] = INLINE { IF i.selected THEN { i.selected _ FALSE; CDOps.RedrawInstance[design, i] } }; DeselectList: PROC [list: CD.InstanceList] = { FOR w: CD.InstanceList _ list, w.rest WHILE w#NIL DO Deselect[w.first] ENDLOOP }; ValidForSelection: PROC [inst: CD.Instance] RETURNS [BOOL] = INLINE { RETURN [ CDInstances.PointToI[pos, inst] AND MatchLayer[layer, inst.ob.layer] ]; }; inst: CD.Instance _ NIL; --any instance where pos points to FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO IF ValidForSelection[w.first] THEN { IF w.first.selected THEN { DeselectList[w.rest]; CDOps.ReOrderInstance[design, w.first]; IF verbose THEN TerminalIO.PutRope[DescribeInst[w.first, design]]; RETURN } ELSE IF inst=NIL THEN inst _ w.first } ELSE Deselect[w.first] ENDLOOP; IF inst#NIL THEN { inst.selected _ TRUE; CDOps.ReOrderInstance[design, inst]; CDOps.RedrawInstance[design, inst, FALSE]; IF verbose THEN TerminalIO.PutRope[DescribeInst[inst, design]] } ELSE { done _ FALSE; IF verbose THEN TerminalIO.PutRope[" (no object)"]; } }; CloseReSelectExclusive: PROC [design: CD.Design, pos: CD.Position, verbose: BOOL_TRUE, dist: CD.Number_100, layer: CD.Layer_CD.undefLayer] = { IF ~ReSelectExclusive[design, pos, verbose, layer] THEN { inst: CD.Instance _ NIL; FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO d: CD.Number = RectDist[pos, CDInstances.InstRectI[w.first]]; IF d=start.x-wireWidth AND (stop.ystart.y+wireWidth) THEN { --crazy vertical wire IF ABS[start.y-stop.y]=start.y AND stop.y<=start.y+wireWidth THEN { --horizontal wire stop.y _ start.y+wireWidth; AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l] } ELSE { --L shaped (firsthorizontal) IF start.x<=stop.x THEN {stop.x _ stop.x+wireWidth} ELSE {t: CD.Number=stop.x; stop.x _ start.x; start.x _ t}; stop.y _ start.y+wireWidth; AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l]; IF firstOnly THEN RETURN; start.x _ comm.pos.x; stop.y _ comm.pos.y; stop.x _ start.x+wireWidth; AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l]; } } ELSE { -- NOT firstHorizontalVC -- IF stop.y<=start.y AND stop.y>=start.y-wireWidth AND (stop.xstart.x+wireWidth) THEN { --crazy horizontal wire IF ABS[stop.x-start.x]=start.x AND stop.x<=start.x+wireWidth THEN { --vertical wire stop.x _ start.x+wireWidth; AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l] } ELSE { --L shaped (firstVertical) IF start.y<=stop.y THEN {stop.y _ stop.y+wireWidth} ELSE {t: CD.Number = stop.y; stop.y _ start.y; start.y _ t}; stop.x _ start.x+wireWidth; AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l]; IF firstOnly THEN RETURN; start.y _ comm.pos.y; stop.y _ start.y+wireWidth; stop.x _ comm.pos.x; AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l]; } } }; AddRectComm: PROC [comm: CDSequencer.Command] = { TerminalIO.PutRope["draw rect\n"]; AddARect[comm.design, CDBasics.ToRect[comm.sPos, comm.pos], comm.l]; }; AddWireComm: PROC [comm: CDSequencer.Command] = { InternalAddWire[comm: comm, firstOnly: FALSE] }; ContinueWireComm: PROC [comm: CDSequencer.Command] = { InternalAddWire[comm: comm, firstOnly: TRUE] }; RedrawMoved: PROC [design: CD.Design, r: CD.Rect, offset: CD.Position] = { moved: CD.Rect _ CDBasics.MoveRect[r, offset]; IF CDBasics.Intersect[r, moved] THEN CDOps.Redraw[design, CDBasics.Surround[r, moved], TRUE] ELSE { CDOps.Redraw[design, r]; CDOps.Redraw[design, moved]; -- use eraseFirst because also used by copy } }; OrientSelected: PROC [design: CD.Design, transform: CD.Orientation, base: CD.Rect_[0,0,-1,-1]] = { ib, is, orientOff: CD.Position; r, oldbb: CD.Rect; oldPseudoCellT, newPseudoCellT: CD.Transformation; sel: CD.InstanceList = CDInstances.OnlySelected[CDOps.InstList[design]]; IF sel=NIL THEN RETURN; oldbb _ CDInstances.BoundingRectO[sel]; IF ~CDBasics.NonEmpty[base] THEN base _ CDInstances.BoundingRectI[sel]; ib _ CDBasics.BaseOfRect[base]; is _ CDBasics.SizeOfRect[base]; oldPseudoCellT _ [ib, original]; r _ CDBasics.MapRect[CDBasics.RectAt[[0,0], is], [[0,0], transform]]; orientOff _ CDBasics.BaseOfRect[r]; newPseudoCellT _ [CDBasics.SubPoints[ib, orientOff], transform]; FOR w: CD.InstanceList _ sel, w.rest WHILE w#NIL DO pseudoCellRel: CD.Transformation _ CDBasics.DecomposeTransform[w.first.trans, oldPseudoCellT]; w.first.trans _ CDBasics.ComposeTransform[pseudoCellRel, newPseudoCellT] ENDLOOP; CDOps.Redraw[design, oldbb]; CDOps.Redraw[design, CDBasics.MapRect[CDBasics.DeMapRect[oldbb, oldPseudoCellT], newPseudoCellT]] }; MoveSelected: PROC [design: CD.Design, offset: CD.Position] = { sel: CD.InstanceList = CDInstances.OnlySelected[CDOps.InstList[design]]; bounding: CD.Rect _ CDBasics.empty; FOR w: CD.InstanceList _ sel, w.rest WHILE w#NIL DO inst: CD.Instance _ w.first; bounding _ CDBasics.Surround[bounding, CDInstances.InstRectO[inst]]; inst.trans.off _ CDBasics.AddPoints[inst.trans.off, offset]; ENDLOOP; RedrawMoved[design, bounding, offset] }; CopySelected: PUBLIC PROC [design: CD.Design, offset: CD.Position] = { new: CD.InstanceList_NIL; sel: CD.InstanceList = CDInstances.OnlySelected[CDOps.InstList[design]]; bounding: CD.Rect _ CDInstances.BoundingRectO[sel]; FOR w: CD.InstanceList _ sel, w.rest WHILE w#NIL DO inst: CD.Instance _ CDInstances.Copy[w.first]; inst.trans.off _ CDBasics.AddPoints[inst.trans.off, offset]; inst.selected _ TRUE; new _ CONS[inst, new]; w.first.selected _ FALSE; ENDLOOP; CDOps.IncludeInstanceList[design, new, FALSE]; RedrawMoved[design, bounding, offset]; }; TransformS: PROC [comm: CDSequencer.Command] = { n: CARDINAL; TerminalIO.PutRope["transform: "]; n _ PopUpSelection.Request[ header: "transform", choice: LIST["mirror x", "mirror y", "rot 90", "rot 180", "rot 270"]]; SELECT n FROM 1 => {TerminalIO.PutRope["mirror x\n"]; OrientSelected[comm.design, mirrorX]}; 2 => {TerminalIO.PutRope["mirror y\n"]; OrientSelected[comm.design, rotate180]; OrientSelected[comm.design, mirrorX]}; 3 => {TerminalIO.PutRope["rot 90\n"]; OrientSelected[comm.design, rotate90]}; 4 => {TerminalIO.PutRope["rot 180\n"]; OrientSelected[comm.design, rotate180]}; 5 => {TerminalIO.PutRope["rot 270\n"]; OrientSelected[comm.design, rotate270]}; ENDCASE => TerminalIO.PutRope["Skipped\n"]; }; RotS: PROC [comm: CDSequencer.Command] = { TerminalIO.PutRope["rotate counterclockwise\n"]; OrientSelected[comm.design, rotate90] }; MirrorS: PROC [comm: CDSequencer.Command] = { TerminalIO.PutRope["mirror on x axis\n"]; OrientSelected[comm.design, mirrorX] }; MirrorYS: PROC [comm: CDSequencer.Command] = { TerminalIO.PutRope["mirror on y axis\n"]; OrientSelected[comm.design, CD.mirrorY]; }; SimpleMoveSCommand: PROC [comm: CDSequencer.Command] = { TerminalIO.PutRope["move (no stretch)\n"]; MoveSelected[design: comm.design, offset: CD.Position[comm.pos.x-comm.sPos.x, comm.pos.y-comm.sPos.y]] }; CopySCommand: PROC [comm: CDSequencer.Command] = { IF comm.pos.x#comm.sPos.x OR comm.pos.y#comm.sPos.y THEN { IF comm.data#NIL AND comm.data#comm.design AND ISTYPE[comm.data, CD.Design] THEN { p: CDSequencer.CommandProc _ CDSequencer.FetchCommand[$UnqueuedCopyInterDesign].proc; IF p=NIL THEN TerminalIO.PutRope["failed, command issued in other design\n"] ELSE CDSequencer.ExecuteProc[p, comm.design, dontQueue, comm]; RETURN }; TerminalIO.PutRope["copy\n"]; CopySelected[comm.design, CD.Position[comm.pos.x-comm.sPos.x, comm.pos.y-comm.sPos.y]] } ELSE TerminalIO.PutRope["no copy in place\n"]; }; StepSize: PROC [comm: CDSequencer.Command] RETURNS [n: CD.Number] = { design: CD.Design _ comm.design; n _ CDValue.FetchInt[boundTo: design, key: $CDxStepValue, propagation: design]; IF n<=0 THEN { n _ CDOps.GetGrid[design, comm]; IF n<=0 THEN n _ design.technology.lambda } }; LambdaUpS: PROC [comm: CDSequencer.Command] = { MoveSelected[comm.design, [0, StepSize[comm]]] }; LambdaDownS: PROC [comm: CDSequencer.Command] = { MoveSelected[comm.design, [0, -StepSize[comm]]] }; LambdaLeftS: PROC [comm: CDSequencer.Command] = { MoveSelected[comm.design, [-StepSize[comm], 0]] }; LambdaRightS: PROC [comm: CDSequencer.Command] = { MoveSelected[comm.design, [StepSize[comm], 0]] }; RenameDesign: PROC [comm: CDSequencer.Command] = { name: Rope.ROPE; done: BOOL; TerminalIO.PutRopes["rename design ", comm.design.name, "\n"]; name _ TerminalIO.RequestRope["enter name: "]; done _ CDOps.RenameDesign[comm.design, name]; IF done THEN TerminalIO.PutRope["done\n"] ELSE TerminalIO.PutRope["not done\n"]; }; CDValue.StoreInt[boundTo: NIL, key: $CDxStepValue, value: 0]; CDSequencer.ImplementCommand[$DrawRect, AddRectComm]; CDSequencer.ImplementCommand[$DrawWire, AddWireComm]; CDSequencer.ImplementCommand[$ContinueWire, ContinueWireComm]; CDSequencer.ImplementCommand[$DeleteS, DeleteSelectedComm]; CDSequencer.ImplementCommand[$Undel, UndeleteComm]; CDSequencer.ImplementCommand[$AbortCommand, AbortComm,, dontQueue]; CDSequencer.ImplementCommand[$OnlySelectP, SelectExclusiveComm,, doQueue]; CDSequencer.ImplementCommand[$ReSelectOnlyP, ReSelectExclusiveComm,, doQueue]; CDSequencer.ImplementCommand[$ReSelectOnlyWithLayerP, ReSelectExclusiveWithLayerComm,, doQueue]; CDSequencer.ImplementCommand[$CloseReSelectOnlyP, CloseReSelectComm,, doQueue]; CDSequencer.ImplementCommand[$AddSelectP, AddSelectionComm,, doQueue]; CDSequencer.ImplementCommand[$DeSelectLP, DeselectLastSelectedComm,, doQueue]; CDSequencer.ImplementCommand[$DeSelectFP, DeselectPointedComm,, doQueue]; CDSequencer.ImplementCommand[$DeSelectS, DeselectAllComm,, doQueue]; CDSequencer.ImplementCommand[$SelectAll, SelectAllComm,, doQueue]; CDSequencer.ImplementCommand[$AreaOnlySelect, AreaOnlySelectComm,, doQueue]; CDSequencer.ImplementCommand[$MultiOnlySelect, MultiOnlySelectComm,, doQueue]; CDSequencer.ImplementCommand[$AreaAddSelect, AreaAddSelectComm,, doQueue]; CDSequencer.ImplementCommand[$AreaAddSelectTouching, AreaAddSelectTouchingComm,, doQueue]; CDSequencer.ImplementCommand[$MultiAddSelect, MultiAddSelectComm,, doQueue]; CDSequencer.ImplementCommand[$DoubleAddSelect, DoubleAddSelectComm,, doQueue]; CDSequencer.ImplementCommand[$AreaDeSelect, AreaDeSelectComm,, doQueue]; CDSequencer.ImplementCommand[$AreaDeSelectTouching, AreaDeSelectTouchingComm,, doQueue]; CDSequencer.ImplementCommand[$ADeSelect, ADeSelectComm,, doQueue]; CDSequencer.ImplementCommand[$MoveS, SimpleMoveSCommand]; CDSequencer.ImplementCommand[$CopyS, CopySCommand]; CDSequencer.ImplementCommand[$LambdaUpS, LambdaUpS]; CDSequencer.ImplementCommand[$LambdaDownS, LambdaDownS]; CDSequencer.ImplementCommand[$LambdaLeftS, LambdaLeftS]; CDSequencer.ImplementCommand[$LambdaRightS, LambdaRightS]; CDSequencer.ImplementCommand[$RotS, RotS]; CDSequencer.ImplementCommand[$MirrorYS, MirrorYS]; CDSequencer.ImplementCommand[$MirrorS, MirrorS]; CDSequencer.ImplementCommand[$TransformS, TransformS]; CDSequencer.ImplementCommand[$RenameDesign, RenameDesign]; END. HCDBasicCommands.mesa (part of ChipNDale) Copyright c 1983, 1986, 1987 by Xerox Corporation. All rights reserved. Created by Christian Jacobi, June 29, 1983 4:44 pm Last edited by: Christian Jacobi, April 2, 1987 3:27:41 pm PST -- common xxxxxxxxxxxxxxxxxxxxxx IF inst#NIL AND inst.ob.class.composed THEN { r _ IO.PutFR["%g [%g]", [rope[r]], [cardinal[LOOPHOLE[inst.ob]]]]; }; -- selections xxxxxxxxxxxxxxxxxxxxxx --Distance between a point and a rectangle --Crazy heuristics to determine which kind of selection is wanted --these variables are used by PROC ReUseSameSelection only --Select an instance at position pos --check whether a different instances should be selected --a new instance will be selected --reorder list, future selection will selects next lower instance --no new instance found; can we select an already selected one? --Deselect an instance at position pos --reorder list, future selection will find next instance --hit --if a selected inst is pointed we already did return --select pointed instance exclusive; --(but dont select an other instance if the pointed one is already the right one) --select pointed instance of right layer exclusive --select pointed instance exclusive; --(but dont select an other instance if the pointed one is already the right one) --if there is none, select closest --cycle through if exactly sme position --Auto select area or pointed or changed --Auto deselect area or pointed -- xx delete, abort xxxxxxxxxxxxxxxxxxxxxx -- xx wires xxxxxxxxxxxxxxxxxxxxxx --this procedure knows EXACTLY the algorithm used for drawing --temporary wires in the rubber banding part --not only crazy vertical -- not only crazy horizontal --uses pos, sPos, n (for width), b (for firstHorizontal), l (for layer) -- moves and copies xxxxxxxxxxxxxxxxxxxxxx --Orientates the selection such that: --takes the base rectangle, transforms orientation and translates the transformed rectangle --to fit its lower left point [after transformation] to be at the same point as the lower left --point of the base rectangle before the transformation. --If base is empty, use bbox of selection. --we dont want to import fancy imports; copy is logically deeper in hierachy --TerminalIO.PutRope["step move up\n"]; --TerminalIO.PutRope["step move down\n"]; --TerminalIO.PutRope["step move left\n"]; --TerminalIO.PutRope["step move right\n"]; Κ-˜codešœ*™*Kšœ Οmœ=™HKšœ3™3K™>—K˜šΟk ˜ Kšœ ˜ Kšžœ˜K˜ Kšœ ˜ Kšœ ˜ K˜K˜K˜ K˜K˜K˜Kšœ˜Kšœ ˜ K˜—šΟnœžœž˜Kšžœp˜w—Kšž˜K˜Kšœ ™ K™šŸ œžœžœžœžœžœ žœ˜XKšœ!˜!šžœžœžœžœ™-Kšœžœ'žœ ™BK™—Kšœ˜—K™Kšœ$™$K˜K˜š Ÿ œžœžœžœžœžœ˜Fšžœ žœ ž˜KšžœDž œžœ˜Z—Kšžœžœ˜ Kšœ˜—K˜š Ÿœžœžœžœžœžœ ˜EK™*šžœžœ˜ Kš œžœ žœžœžœ žœžœ˜NKš œžœ žœžœžœ žœžœ˜MK˜—Kšœ˜—K˜šŸ œžœžœžœžœžœ žœžœ˜yš žœžœžœžœžœžœž˜8Kš žœžœžœžœžœ˜3K˜ Kšœ@˜@Kšžœ˜—Kšœ˜—K˜šœB™BKšœ:™:K˜Kšœ žœ ˜Kšœ žœžœ˜Kšœžœ˜0—K˜šŸœžœžœžœ˜LKšœžœ(˜2š Ÿ œžœ žœ žœžœžœ˜AKšžœžœžœžœ˜:Kšœ˜—Kšœžœ˜%Kšœ%žœžœ$˜aKšœ˜Kšœ˜Kšœ˜Kšœ˜—K˜šŸœžœ žœžœ˜6Kšœ$™$Kšœžœ žœ˜K™8š žœžœ/žœžœž˜Fšžœžœ˜Kšžœ$žœžœ˜@K˜—Kšžœ˜—šžœžœžœ˜K™!Kšœžœ˜KšœA™AKšœ#˜#Kšœ"˜"Kšœ.˜.Kšœ˜—šžœ˜K™?š žœžœ/žœžœž˜Fšžœžœ˜šžœ$žœ˜,Kšœ=˜=Kšž˜Kšœ˜—K˜—Kšžœ˜—Kšœ)˜)K˜—Kšœ˜K˜—šŸœžœ žœžœ˜8Kšœ&™&Kšœžœ@žœ˜Nšžœžœžœ˜Kšœžœ˜Kšœ#˜#Kšœ8™8Kšœ$˜$Kšœ˜—Kšœ/˜/Kšœ˜K˜—š Ÿ œžœ žœžœžœžœ˜Sš žœžœ/žœžœž˜Fšžœžœ˜šžœ:žœ˜Ašžœžœ7žœ˜QKšœžœ˜Kšœ&žœ˜-K˜——K˜—Kšžœ˜—Kšœ˜K˜—š Ÿ œžœ žœžœžœžœ˜Uš žœžœ/žœžœž˜Fšžœžœ˜šžœ:žœ˜Ašžœžœ7žœ˜QKšœžœ˜Kšœ&˜&K˜——K˜—Kšžœ˜—Kšœ˜—K˜šŸœžœ ˜9Kšœ&˜&Kšœžœ˜&Kšœ˜Kšœ˜Kšœ˜K˜—šŸœžœ žœžœžœžœ žœžœ žœžœžœ˜ŽšŸœžœžœ žœ˜*šžœ žœ˜Kšœ žœ˜Kšœ˜K˜—Kšœ˜—šŸ œžœžœ˜.š žœžœžœžœž˜4Kšœ˜Kšž˜—Kšœ˜—š Ÿœžœžœ žœžœžœ˜EKšœžœ#žœ$˜QK˜—Kšœžœ žœΟc"˜;š žœžœ/žœžœž˜Fšžœžœ˜$Kš ™šžœžœ˜Kšœ˜Kšœ'˜'Kšžœ žœ3˜BKšž˜Kšœ˜—Kšžœžœžœžœ˜$Kšœ˜—Kšžœ˜Kšžœ˜—Kš 5™5šžœžœžœ˜Kšœžœ˜Kšœ$˜$Kšœ#žœ˜*Kšžœ žœ/˜>K˜—šžœ˜Kšœžœ˜ Kšžœ žœ$˜3K˜—Kšœ˜K˜—šŸœžœ žœžœžœžœžœžœžœ˜Žšžœ1žœ˜9Kšœžœ žœ˜š žœžœ/žœžœž˜FKšœžœ8˜=Kšžœžœ%žœ˜QKšžœ˜—šžœžœžœ˜Kšœžœ˜Kšœ#žœ˜*Kšžœ žœI˜XK˜—K˜—Kšœ˜K˜—šŸœžœ ˜;Kšœ$™$KšœQ™QKšœ˜Kšœ.˜.Kšœ˜Kšœ˜K˜—šŸœžœ ˜DKš 2™2Kšœžœs˜|KšœI˜IKšœ.žœ ˜;Kšœ˜Kšœ˜K˜—šŸœžœ ˜7Kšœ$™$KšœQ™QK™"K™'Kšœ˜Kšžœžœ žœ˜HKšœ3žœ˜=Kšœ˜Kšœ˜—K˜šΠbnœžœ ˜9š Ÿ œžœ žœ žœžœžœ˜AKšžœžœžœžœ˜9Kšœ˜—Kšœžœ(˜2šžœ"˜$Kšžœ˜Kšžœ˜—Kšœ˜K˜—š‘œžœ ˜9šžœžœ˜"Kšœ*˜*Kšœ)žœ˜/K˜—Kšžœ'˜+Kšœ˜Kšœ˜Kšœ˜K˜—šŸœžœ ˜9Kšœ)˜)Kšœ ˜ Kšœ˜Kšœ˜K˜—šŸ œžœ žœžœžœžœžœžœžœ˜jKšœžœ žœ˜š žœžœ/žœžœž˜Fšžœžœ˜Kšžœ žœ$žœ˜DK˜—Kšžœ˜—šžœžœžœ˜Kšœžœ˜Kšœžœ˜ Kšœ!˜!K˜—Kšœ˜—K˜šŸœžœ ˜>Kšœ)˜)Kšœ)žœ˜/Kšœ˜Kšœ˜K˜—šŸœžœ!˜7Kšœ'˜'Kšœ˜Kšœ˜Kšœ˜K˜—šŸœžœ ˜5Kšœ'˜'Kšœžœ˜%Kšœ˜K˜—šŸ œžœ ˜3Kšœžœ˜ Kšœ$˜$Kšœžœ˜%š žœžœ4žœžœž˜KKšœ ˜ Kšžœ˜—Kšœ;˜;Kšœ˜—K˜šŸœžœ ˜7Kšœ/˜/Kšœ=˜=Kšœ˜—K˜šŸœžœ ˜8Kšœ(™(š Ÿœžœ žœ žœžœžœ˜=Kšžœžœžœžœ˜9Kšœ˜—Kšœžœ(˜2Kšžœžœ˜>šžœ˜Kšœ/˜/Kšœ=˜=K˜—Kšœ˜—K˜šŸœžœ ˜?Kšœ3˜3Kšœ>žœ˜CKšœ˜—K˜šŸœžœ ˜8Kšœ%˜%Kšœžœ˜&Kšœ=˜=Kšœ˜—K˜šŸ œžœ ˜3Kšœ™Kšœ"˜"Kšžœžœ ˜:KšžœA˜EKšœ˜Kšœ˜—K˜šŸœžœ ˜6Kšœ(˜(Kšœ?˜?Kšœ˜—K˜šŸœžœ ˜>Kšœ,˜,Kšœ@žœ˜EKšœ˜—K˜K˜Kšœ*™*K™šŸœžœ žœ ˜,Kšœžœžœ˜7Kšœ^˜^Kšœ'˜'K˜!š žœžœ!žœžœž˜8Kšœ˜Kšœ&žœ˜,Kšžœ˜—Kšžœ žœ1˜@Kšžœ9˜=Kšœ˜K˜—šŸœžœ ˜8Kšœ(˜(Kšœ˜Kšœ˜Kšœ˜K˜—šŸ œžœ ˜2Kšœžœ1˜7Kšœ#˜#Kšœ+˜+Kšœ˜K˜—šŸ œžœ ˜/Kšœ6˜6Kšœ,˜,Kšœ˜—K˜Kšœ"™"K˜š Ÿœžœ žœ žœ žœ ˜@Kšžœžœ0˜Mšžœ˜Kšœžœ˜"Kšœžœ#˜)šžœ žœ˜Kšœžœ'˜,Kšœ˜Kšœ˜—Kšœ˜K˜—Kšœ˜K˜—šŸœžœ(žœžœ˜LKšœ=™=Kšœ,™,Kšœžœ˜ Kšœžœ˜Kšœ žœ˜Kšžœ žœžœ˜0Kšœ#˜#šžœ œžœ˜$šžœžœ˜0Kšžœžœžœ ˜Mšžœžœ/žœ˜—Kšž˜K˜—Kšœ˜Kšœžœ:˜VK˜—Kšžœ*˜.Kšœ˜K˜—šŸœžœžœžœ ˜EKšœžœ˜ KšœO˜Ošžœžœ˜Kšœ ˜ Kšžœžœ˜)Kšœ˜—Kšœ˜—K˜šŸ œžœ ˜/Kšœ'™'Kšœ.˜.Kšœ˜K˜—šŸ œžœ ˜1Kšœ)™)Kšœ/˜/Kšœ˜K˜—šŸ œžœ ˜1Kšœ)™)Kšœ/˜/Kšœ˜K˜—šŸ œžœ ˜2Kšœ*™*Kšœ.˜.Kšœ˜—K˜šŸ œžœ ˜2Kšœ žœžœ˜Kšœ?˜?K˜.Kšœ-˜-Kšžœžœžœ"˜PKšœ˜K˜—K˜Kšœžœ ˜=K˜K˜5Kšœ5˜5K˜>K˜;K˜3KšœC˜CK˜KšœJ˜JKšœN˜NKšœ`˜`KšœO˜OKšœF˜FK˜KšœN˜NKšœI˜IKšœD˜DKšœB˜BKšœL˜LKšœN˜NK˜KšœJ˜JKšœZ˜ZKšœL˜LKšœN˜NK˜KšœH˜HKšœX˜XKšœB˜BK˜Kšœ9˜9K˜3Kšœ4˜4Kšœ8˜8Kšœ8˜8Kšœ:˜:K˜*K˜2K˜0K˜6Kšœ:˜:Kšžœ˜—…—T’w