DIRECTORY
CD,
CDInstances,
CDBasics,
CDLayers USING [MakeAbstract, AbstractToPaint],
CDImports,
CDIO,
CDOps,
CDOrient,
CDSymbolicObjects,
CDPrivate,
CDProperties,
CDRects,
Imager,
ImagerPath,
LRUCache,
Rope;

CDSymbolicObjectsImpl: CEDAR MONITOR    
IMPORTS CD, CDInstances, CDBasics, CDLayers, CDIO, CDOps, CDOrient, CDPrivate, CDProperties, CDRects, Imager, ImagerPath, LRUCache, Rope
EXPORTS CDSymbolicObjects
SHARES CDLayers =   
BEGIN

symNameProp: ATOM = $SignalName;
symLayerProp: ATOM = $layerOfPin; 
symOwnerProp: ATOM = $ownerOfPin; 

markObject: CD.Object;
markObjectPath: ImagerPath.Trajectory = CreateMarkObjectPath[];

dummySpecific: REF SymRec = NEW[SymRec];
SymRec: TYPE = RECORD [dummy: INT _ 17];

pinLayer: PUBLIC CD.Layer _ CD.NewLayer[NIL, $pinRepresentation];
segmentLayer: PUBLIC CD.Layer _ CD.NewLayer[NIL, $segmentRepresentation];
markLayer: CD.Layer _ CD.undefLayer;

lruQueue: LRUCache.Handle _ LRUCache.Create[87, CDPrivate.Hash, Equal];

freePin: CD.Object _ NIL; --reduces the allocators work
freeSegment: CD.Object _ NIL; 

GivePin: ENTRY PROC [] RETURNS [ob: CD.Object] = INLINE {
ob _ freePin; freePin _ NIL;
IF ob=NIL THEN 
ob _ NEW[CD.ObjectRep_[class: pinClass, specificRef: dummySpecific, layer: pinLayer]];
};

GiveSegment: ENTRY PROC [] RETURNS [ob: CD.Object] = INLINE {
ob _ freeSegment; freeSegment _ NIL;
IF ob=NIL THEN 
ob _ NEW[CD.ObjectRep_[class: segmentClass, specificRef: dummySpecific, layer: segmentLayer]];
};

Equal: PROC[x, y: REF] RETURNS [BOOL] = {
ob1: CD.Object = NARROW[x];
ob2: CD.Object = NARROW[y];
RETURN [ob1.class=ob2.class AND ob1.size=ob2.size AND ob1.layer=ob2.layer]
};

pinClass: PUBLIC CD.ObjectClass _ CD.RegisterObjectClass[$PinOb0, [
drawMe: DrawPin,
quickDrawMe: DrawPin,
showMeSelected: ShowSelectedSymRL,
internalRead: ReadPin,
internalWrite: WritePinOrSegment,
wireTyped: TRUE,
symbolic: TRUE,
description: "pin",
describeInst: DescribeInstance
]];
segmentClass: PUBLIC CD.ObjectClass _ CD.RegisterObjectClass[$SymbolicSegment, [
drawMe: DrawSegment,
quickDrawMe: DrawSegment,
showMeSelected: ShowSelectedSymRL,
internalRead: ReadSegment,
internalWrite: WritePinOrSegment,
wireTyped: TRUE,
symbolic: TRUE,
description: "segment",
describeInst: DescribeInstance
]];
markClass: PUBLIC CD.ObjectClass _ CD.RegisterObjectClass[$AlignmentMarkOb, [
drawMe: DrawMark,
quickDrawMe: DrawMark,
internalRead: ReadMark,
internalWrite: WriteMark,
symbolic: TRUE,
description: "mark"
]];

CreateMarkObjectPath: PROC [] RETURNS [markObjectPath: ImagerPath.Trajectory] = {
markObjectPath _ ImagerPath.MoveTo[[0, 0]];
markObjectPath _ ImagerPath.LineTo[markObjectPath, [0, 3]];
markObjectPath _ ImagerPath.LineTo[markObjectPath, [1, 2]];
markObjectPath _ ImagerPath.LineTo[markObjectPath, [3, 4]];
markObjectPath _ ImagerPath.LineTo[markObjectPath, [4, 3]];
markObjectPath _ ImagerPath.LineTo[markObjectPath, [2, 1]];
markObjectPath _ ImagerPath.LineTo[markObjectPath, [3, 0]];
markObjectPath _ ImagerPath.LineTo[markObjectPath, [0, 0]];
};

Init: PROC [] = {
CDLayers.MakeAbstract[pinLayer];
CDRects.UseAsCreateRect[pinLayer, RCreatePin, pinClass];
CDLayers.MakeAbstract[segmentLayer];
CDRects.UseAsCreateRect[segmentLayer, RCreateSegment, segmentClass];
markObject _ NEW[CD.ObjectRep _ [
class: markClass,
size: [4, 4],
layer: markLayer,
specificRef: $AlignmentMarkOb
]];
[] _ CDProperties.RegisterProperty[symLayerProp, $layer];
[] _ CDProperties.RegisterProperty[symOwnerProp, $atom];
CDProperties.InstallProcs[prop: symOwnerProp, new: [makeCopy: CDProperties.CopyVal]];
CDProperties.InstallProcs[prop: symLayerProp, new: [makeCopy: CDProperties.CopyVal]];
}; 

CreateMark: PUBLIC PROC [dummySize: CD.Number_0] RETURNS [CD.Object] = {
RETURN [markObject]
};

CreateSegment: PUBLIC PROC [length: CD.Number, dummyWidth: CD.Number_0] RETURNS [ob: CD.Object] = {
used: REF; insert: BOOL; 
ob _ GiveSegment[];
IF dummyWidth<=0 THEN dummyWidth _ 8;
ob.size _ CDBasics.MaxPoint[[dummyWidth, length], [1, 1]];
[insert: insert, used: used] _ LRUCache.Include[lruQueue, ob];
IF ~insert THEN {
freeSegment _ ob;
ob _ NARROW[used];
};
};

RCreateSegment: PROC [size: CD.Position, l: CD.Layer] RETURNS [CD.Object] = {
RETURN [CreateSegment[size.y, size.x]]
};

CreatePin: PUBLIC PROC [size: CD.Position] RETURNS [ob: CD.Object] = {
used: REF; insert: BOOL;
ob _ GivePin[];
ob.size _ CDBasics.MaxPoint[size, [1, 1]];
[insert: insert, used: used] _ LRUCache.Include[lruQueue, ob];
IF ~insert THEN {
freePin _ ob;
ob _ NARROW[used];
};
};

RCreatePin: PROC [size: CD.Position, l: CD.Layer] RETURNS [CD.Object] = {
RETURN [CreatePin[size]]
};

IsSymbolicOb: PUBLIC PROC [ob: CD.Object] RETURNS [BOOL] = {
RETURN [ob.class=markClass OR ob.class=segmentClass OR ob.class=pinClass]
};

IsMark: PUBLIC PROC [ob: CD.Object] RETURNS [BOOL] = {
RETURN [ob.class=markClass]
};

IsSegment: PUBLIC PROC [ob: CD.Object] RETURNS [BOOL] = {
RETURN [ob.class=segmentClass]
};

IsPin: PUBLIC PROC [ob: CD.Object] RETURNS [BOOL] = {
RETURN [ob.class=pinClass]
};

SymbolicKind: PUBLIC PROC [ob: CD.Object] RETURNS [k: CDSymbolicObjects.Kind] = {
SELECT TRUE FROM
ob.class=pinClass => k _ pin;
ob.class=segmentClass => k _ segment;
ob.class=markClass => k _ mark;
ENDCASE => k _ notSymbolic
};


SetOwner: PUBLIC PROC [symInst: CD.Instance, owner: ATOM_NIL] = {
IF IsSymbolicOb[symInst.ob] THEN 
CDProperties.PutInstanceProp[symInst, symOwnerProp, owner]
};

GetOwner: PUBLIC PROC [symInst: CD.Instance] RETURNS [at: ATOM] = {
WITH CDProperties.GetInstanceProp[symInst, symOwnerProp] SELECT FROM
a: ATOM => at _ a
ENDCASE => at _ NIL
};

SetName: PUBLIC PROC [symInst: CD.Instance, name: Rope.ROPE] = {
IF IsSymbolicOb[symInst.ob] THEN 
CDProperties.PutInstanceProp[symInst, symNameProp, name]
};

GetName: PUBLIC PROC [symInst: CD.Instance] RETURNS [r: Rope.ROPE _ NIL] = {
IF IsSymbolicOb[symInst.ob] THEN {
WITH CDProperties.GetInstanceProp[symInst, symNameProp] SELECT FROM
n: Rope.ROPE => r _ n;
rt: REF READONLY TEXT => r _ Rope.FromRefText[rt];
ENDCASE => NULL;
}
};

SetLayer: PUBLIC PROC [symInst: CD.Instance, layer: CD.Layer] = {
IF IsSymbolicOb[symInst.ob] THEN 
CDProperties.PutInstanceProp[symInst, symLayerProp, CDPrivate.layers[layer]]
};

GetLayer: PUBLIC PROC [symInst: CD.Instance] RETURNS [layer: CD.Layer] = {
WITH CDProperties.GetInstanceProp[symInst, symLayerProp] SELECT FROM
lp: CDPrivate.LayerRef => layer _ lp^.number
ENDCASE => layer _ CD.undefLayer
};

DirectionFromOrient: PUBLIC PROC [o: CD.Orientation] RETURNS [dir: CDSymbolicObjects.Direction] = {
SELECT o FROM
CDOrient.original, CDOrient.rotate180X => dir _ west;
CDOrient.rotate90, CDOrient.rotate90X => dir _ south;
CDOrient.rotate180, CDOrient.mirrorX => dir _ east;
CDOrient.rotate270, CDOrient.rotate270X => dir _ north;
ENDCASE => ERROR;
};

OrientFromDirection: PUBLIC PROC [dir: CDSymbolicObjects.Direction] RETURNS [o: CD.Orientation] = {
SELECT dir FROM
west => o _ CDOrient.original;
south => o _ CDOrient.rotate90;
east => o _ CDOrient.rotate180;
north => o _ CDOrient.rotate270;
ENDCASE => ERROR;
};


CreateSymInst: PUBLIC PROC [name: Rope.ROPE, denotes: CD.Rect, dummySize: CD.Number, layer: CD.Layer, owner: ATOM, approachFrom: CDSymbolicObjects.Direction] RETURNS [symInst: CD.Instance] = {
symOb: CD.Object;
orient: CD.Orientation _ OrientFromDirection[approachFrom];
loc: CD.Position;
denotes _ CDBasics.NormalizeRect[denotes];
IF denotes.x1#denotes.x2 AND denotes.y1#denotes.y2 THEN {
loc _ CDBasics.BaseOfRect[denotes];
symOb _ CreatePin[CDOrient.OrientedSize[CDBasics.SizeOfRect[denotes], orient]]; 
}
ELSE IF denotes.x1=denotes.x2 AND denotes.y1=denotes.y2 THEN {
p: CD.Position;
symOb _ CreateMark[dummySize]; 
p _ CDOrient.MapPoint[
pointInCell: [0, 0],
cellSize: symOb.size,
cellInstOrient: orient,
cellInstPos: [0, 0]
];
loc _ [x: denotes.x1-p.x, y: denotes.y1-p.y];
}
ELSE {
l: CD.Number;
IF denotes.x1=denotes.x2 THEN {
l _ denotes.y2-denotes.y1;
IF approachFrom=south OR approachFrom=north THEN {
approachFrom _ west;
orient _ OrientFromDirection[approachFrom];
}
}
ELSE {
l _ denotes.x2-denotes.x1;
IF approachFrom=west OR approachFrom=east THEN {
approachFrom _ south;
orient _ OrientFromDirection[approachFrom];
}
};
symOb _ CreateSegment[length: l, dummyWidth: dummySize]; 
loc _ CDBasics.BaseOfRect[denotes];
SELECT approachFrom FROM
west, south => NULL;
east => loc.x _ loc.x-symOb.size.x; 
north => loc.y _ loc.y-symOb.size.x;
ENDCASE => ERROR;
};
layer _ CDLayers.AbstractToPaint[layer];
symInst _ CDInstances.NewInst[ob: symOb, location: loc, orientation: orient];
IF name#NIL THEN SetName[symInst, name];
IF layer#CD.undefLayer THEN SetLayer[symInst, layer];
IF owner#NIL THEN SetOwner[symInst, owner];
};

Denotes: PUBLIC PROC [symInst: CD.Instance] RETURNS [CD.Rect] = {
itemInCell: CD.Rect; 
SELECT TRUE FROM
symInst.ob.class=pinClass => itemInCell _ [x1: 0, y1: 0, x2: symInst.ob.size.x, y2: symInst.ob.size.y];
symInst.ob.class=segmentClass => itemInCell _ [x1: 0, y1: 0, x2: 0, y2: symInst.ob.size.y];
symInst.ob.class=markClass => itemInCell _ [0, 0, 0, 0];
ENDCASE => ERROR;
RETURN [CDOrient.MapRect[
itemInCell: itemInCell,
cellInstPos: symInst.location,
cellSize: symInst.ob.size, 
cellInstOrient: symInst.orientation
]]
};
EnumerateSymbolicObs: PUBLIC PROC [cellOb: CD.Object_NIL, eachInst: CDSymbolicObjects.InstEnumerator] RETURNS [quit: BOOL_FALSE] = {
cp: CD.CellPtr;
WITH cellOb.specificRef SELECT FROM
c: CD.CellPtr => cp _ c;
ip: CDImports.ImportPtr => { -- HACK? until imports handle symbolic objects more reasonably
IF ip.boundInstance=NIL THEN RETURN [TRUE];
quit _ EnumerateSymbolicObs[ip.boundInstance.ob, eachInst];
RETURN
};
ENDCASE => RETURN [TRUE];
FOR list: CD.InstanceList _ cp.contents, list.rest WHILE (list#NIL AND ~quit) DO
IF IsSymbolicOb[list.first.ob] THEN {
quit _ eachInst[list.first]; -- do NOT catch errors
};
ENDLOOP;
};

FindSymbolicObs: PUBLIC PROC [cellOb: CD.Object_NIL, name: Rope.ROPE] RETURNS [il: CD.InstanceList_NIL] = {
Enumerate: CDSymbolicObjects.InstEnumerator = {
IF Rope.Equal[GetName[inst], name] THEN il _ CONS[inst, il];
};
[] _ EnumerateSymbolicObs[cellOb, Enumerate];
};

WritePinOrSegment: CD.InternalWriteProc -- PROC [me: Object] -- = {
CDIO.WritePos[me.size];
};

WriteMark: CD.InternalWriteProc --PROC [me: Object]-- = {
};

ReadPin: CD.InternalReadProc --PROC [] RETURNS [Object]-- = {
RETURN [CreatePin[CDIO.ReadPos[]]]
};

ReadSegment: CD.InternalReadProc --PROC [] RETURNS [Object]-- = {
p: CD.Position _ CDIO.ReadPos[];
RETURN [CreateSegment[p.y, p.x]]
};

ReadMark: CD.InternalReadProc --PROC [] RETURNS [Object]-- = {
RETURN [markObject]
};

DescribeInstance: PROC[i: CD.Instance] RETURNS [Rope.ROPE] = {
RETURN [Rope.Cat[CDOps.LayerName[GetLayer[i]], " ", i.ob.class.description]];
};

ShowSelectedSymRL: PROC [inst: CD.Instance, pos: CD.Position, orient: CD.Orientation, pr: CD.DrawRef] = {
pr.drawRect[CDOrient.RectAt[pos, inst.ob.size, orient], CD.shadeLayer, pr]
};

DrawPin: PROC [inst: CD.Instance, pos: CD.Position, orient: CD.Orientation,
pr: CD.DrawRef] = {
DrawPinInContext: PROC [context: Imager.Context, ob: CD.Object, layer: CD.Layer] = {
Imager.MaskVector[context, [0, 0], [ob.size.x, ob.size.y]];
Imager.MaskVector[context, [0, ob.size.y], [ob.size.x, 0]];
};
IF pr.symbolics AND (pr.scaleHint*MIN[inst.ob.size.y, inst.ob.size.x]>3 OR pr.scaleHint<=0) THEN {
pr.drawContext[pr, DrawPinInContext, inst.ob, pos, orient, pinLayer];
pr.drawComment[r: CDOrient.RectAt[pos, inst.ob.size, orient], comment: GetName[inst], pr: pr]
};
}; 

DrawSegment: PROC [inst: CD.Instance, pos: CD.Position, orient: CD.Orientation,
pr: CD.DrawRef] = {
DrawSegmentInContext: PROC [context: Imager.Context, ob: CD.Object, layer: CD.Layer] = {
Imager.MaskVector[context, [0, 0], [0, ob.size.y]];
Imager.MaskVector[context, [0, 0], [ob.size.x, ob.size.y/2]];
Imager.MaskVector[context, [0, ob.size.y], [ob.size.x, ob.size.y/2]];
};
IF pr.symbolics AND (pr.scaleHint*inst.ob.size.y>3 OR pr.scaleHint<=0) THEN {
pr.drawContext[pr, DrawSegmentInContext, inst.ob, pos, orient, segmentLayer];
pr.drawComment[r: CDOrient.RectAt[pos, inst.ob.size, orient], comment: GetName[inst], pr: pr]
}
}; 

DrawMark: PROC [inst: CD.Instance, pos: CD.Position, orient: CD.Orientation,
pr: CD.DrawRef] = {
DrawPath: PROC [context: Imager.Context, ob: CD.Object, layer: CD.Layer] = {
Imager.MaskFillTrajectory[context, markObjectPath];
};
IF pr.symbolics AND (pr.scaleHint*inst.ob.size.y>2 OR pr.scaleHint<=0) THEN { 
pr.drawContext[pr, DrawPath, markObject, pos, orient, markLayer]
}
}; 

Init[];
END. 



ŽCDSymbolicObjectsImpl.mesa  (part of ChipNDale)
Copyright c 1984, 1986 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi,  August 8, 1984 12:41:50 pm PDT 
Last Edited by: Christian Jacobi, August 16, 1986 6:32:13 pm PDT
--rects
--lines
--points
--common
--has the right form for CDRects type
--pin
--mark
--segment
-- erroneous parameters..
-- erroneous parameters..


Κ;˜
codeš
œ/™/Kšœ
Οm
œ7™BKš
œ=™=K™@—K˜š
Οk	˜	Kšžœ
˜K˜K˜	Kšœ	žœ!˜/Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ	˜	Kš
œ˜K˜
K˜
K˜Kš
œ˜Kš
œ˜Kš
œ	˜	Kš
œ˜—K˜šΠblœžœ
žœ˜(Kšžœ
žœ~˜ˆ
Kšžœ˜Kšžœ˜—Kš
ž˜K˜Kšœ
žœ˜ Kšœžœ˜"Kšœžœ˜"K˜šœžœ˜Kš
œ?˜?—K˜šœžœ
žœ	˜(Kšœžœžœ	žœ˜(K˜—Kšœ
ž	œ	žœ
žœ˜AKšœž	œ	žœ
žœ˜IKšœžœ	žœ˜$K˜Kš
œG˜GK˜Kšœ	žœ
žœΟc˜7Kšœ
žœ
žœ˜K˜šΟnœžœ
žœžœžœžœ˜9Kšœžœ
˜šžœžœ
žœ
˜Kšœžœ
žœK˜V—K˜—K˜š‘œžœ
žœžœžœžœ˜=Kšœ žœ
˜$šžœžœ
žœ
˜Kšœžœ
žœS˜^—K˜—K˜š
‘œžœžœžœžœ˜)Kšœžœ
žœ˜Kšœžœ
žœ˜Kšžœžœžœ˜JKš
œ˜—K˜šœ
žœ
žœžœ˜CKš
œ˜Kš
œ˜Kš
œ"˜"Kš
œ˜Kš
œ!˜!Kšœžœ
˜Kšœ
žœ
˜Kš
œ˜Kš
œ˜Kš
œ˜—šœžœ
žœžœ(˜PKš
œ˜Kš
œ˜Kš
œ"˜"Kš
œ˜Kš
œ!˜!Kšœžœ
˜Kšœ
žœ
˜Kš
œ˜Kš
œ˜Kš
œ˜—šœžœ
žœžœ(˜MKš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœ
žœ
˜Kš
œ˜Kš
œ˜K˜—š‘œžœžœ,˜QKš
œ+˜+Kš
œ;˜;Kš
œ;˜;Kš
œ;˜;Kš
œ;˜;Kš
œ;˜;Kš
œ;˜;Kš
œ;˜;Kš
œ˜—K˜š‘œžœ˜Kš
œ™Kš
œ ˜ Kš
œ8˜8Kš
œ™Kš
œ$˜$Kš
œD˜DKš
œ™šœ
žœ
žœ˜!Kš
œ˜K˜
Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ™Kš
œ9˜9Kš
œ8˜8Kš
œU˜UKš
œU˜UKš
œ˜—K˜š‘
œžœ
žœ
žœžœžœ˜HJšžœ
˜Kš
œ˜—K˜š‘
œžœ
žœ
žœžœžœžœ˜cKšœžœ
žœ˜Kš
œ˜Kšžœžœ˜%Kš
œ:˜:Kš
œ>˜>šžœ	žœ˜Kš
œ˜Kšœžœ˜K˜—Kš
œ˜K˜—š‘œžœžœžœžœžœ˜MKšžœ ˜&Kšž
œ
˜—K˜š‘	œžœ
žœžœžœžœ˜FKšœžœ
žœ
˜Kš
œ˜Kš
œ*˜*Kš
œ>˜>šžœ	žœ˜Kš
œ
˜
Kšœžœ˜K˜—Kš
œ˜K˜—š‘
œžœžœžœžœžœ˜IK™%Kšžœ˜Kš
œ˜—K˜š‘œžœ
žœžœ	žœžœ˜<Kšžœžœžœ˜IK˜—K˜š‘œžœ
žœžœ	žœžœ˜6Kšžœ˜K˜K˜—š‘	œžœ
žœžœ	žœžœ˜9Kšžœ˜K˜—K˜š‘œžœ
žœžœ	žœžœ˜5Kšžœ˜K˜—K˜š
‘œžœ
žœžœ	žœ ˜Qšžœ
žœ
ž˜Kš
œ˜Kš
œ%˜%Kš
œ˜Kšžœ˜—Kš
œ˜—K˜K˜š
‘œžœžœžœ
žœ˜Ašžœžœ
˜!Kš
œ:˜:—Kšž
œ
˜—K˜š
‘œžœžœžœžœ˜Cšžœ5žœ
ž˜DKšœžœ
˜Kšžœ	ž˜—Kšž
œ
˜—K˜š
‘œžœ
žœžœžœ˜@šžœžœ
˜!Kš
œ8˜8—Kš
œ˜—K˜š‘œžœ
žœžœžœ
žœžœ˜Lšžœžœ˜"šžœ4žœ
ž˜CKšœžœ
˜Kšœžœ
žœ
žœ˜2Kšžœžœ
˜—K˜
—Kš
œ˜—K˜š
‘œžœ
žœžœžœ˜Ašžœžœ
˜!Kš
œL˜L—Kš
œ˜—K˜š‘œžœ
žœžœžœ	žœ˜Jšžœ5žœ
ž˜DKš
œ,˜,Kšžœžœ˜ —Kš
œ˜—K˜š
‘œžœ
žœžœžœ'˜cšžœž˜
Jš
œ5˜5Jš
œ5˜5Jš
œ3˜3Jš
œ7˜7Jšžœžœ
˜—Kš
œ˜—K˜š
‘œžœ
žœ$žœžœ˜cšžœž˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ ˜ Jšžœžœ
˜—Kš
œ˜—K˜K˜š‘
œžœ
žœ
žœžœžœžœžœ-žœžœ˜ΐ
Jšœžœ˜Jšœžœ1˜;Jšœžœ
˜Jš
œ*˜*šžœžœžœ˜9Jš
œ™Kš
œ#˜#Jš
œP˜PJ˜
—šžœ
žœžœžœ˜>Jš
œ™Jš
œ˜Jš
œ˜š
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜J˜—Jš
œ-˜-J˜
—šžœ˜Jš
œ	™	Jšœžœ˜
šžœžœ˜Jš
œ˜šžœžœžœ˜2J™Jš
œ˜Jš
œ+˜+J˜
—Jš
œ
˜
—šžœ˜Jš
œ˜šžœžœžœ˜0J™Jš
œ˜Jš
œ+˜+J˜
—J˜—Jš
œ9˜9Jš
œ#˜#šžœž˜Jšœžœ
˜Jš
œ$˜$Jš
œ$˜$Jšžœžœ
˜—J˜—Kš
œ(˜(Kš
œM˜MKšžœžœ
žœ˜(Kšžœžœžœ˜5Kšžœžœ
žœ˜+Kš
œ˜—K˜š‘œžœ
žœžœžœžœ
˜AKšœžœ˜šžœ
žœ
ž˜Kš
œg˜gKš
œ[˜[Kš
œ8˜8Kšžœžœ
˜—šžœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ#˜#Kš
œ˜—Kš
œ˜—K™š‘œžœ
žœ
žœžœ.žœžœ
žœ˜„
Kšœžœ	˜šžœžœ
ž˜#Kšœžœ˜šœ >˜[Kš
žœžœ
žœ
žœžœ˜+Kš
œ;˜;Kš
ž˜Kš
œ˜—Kšžœžœžœ˜—šžœžœ'žœžœ
žœž˜Pšžœžœ˜%Kšœ ˜3K˜—Kšžœ
˜—Kš
œ˜—K˜š‘œžœ
žœ
žœžœ
žœžœžœžœ˜kšΠbn	œ&˜/Kšžœ!žœžœ˜<Kš
œ˜—Kš
œ-˜-Kš
œ˜—K™K˜š’œžœ œ˜CKšžœ˜Kš
œ˜—K˜šΟb	œžœ œ˜9Kš
œ˜K˜—š’œžœ œ˜=Kšžœžœ˜"Kš
œ˜K˜—š’œžœ œ˜AKšœžœžœ˜ Kšžœ˜ Kš
œ˜K˜—š£œžœ œ˜>Kšžœ
˜Kš
œ˜K˜—š
‘œžœžœžœžœ˜>KšžœG˜MKš
œ˜—K˜š‘œžœžœžœžœžœ
˜iKšœ8žœ˜JKš
œ˜—K˜š
‘œžœžœžœžœ
˜KKšœžœ
˜š‘œžœžœžœ˜TKš
œ;˜;Kš
œ;˜;Kš
œ˜—š
žœžœžœ#žœžœ˜bKš
œE˜EKš
œ]˜]K˜—Kš
œ˜—K˜š
‘œžœžœžœžœ
˜OKšœžœ
˜š‘œžœžœžœ˜XKš
œ3˜3Kš
œ=˜=Kš
œE˜EKš
œ˜—šžœžœ žœžœ˜MKš
œM˜MKš
œ]˜]K˜
—Kš
œ˜—K˜š
’œžœžœžœžœ
˜LKšœžœ
˜š‘œžœžœžœ˜LKš
œ3˜3Kš
œ˜—šžœžœ žœžœ˜NKš
œ@˜@K˜
—Kš
œ˜—K˜Kš
œ˜Kšžœ˜K˜
—…—0άB₯