DIRECTORY
D2Basic USING [Number, Rect, Vector],
D2Orient USING [Orientation, Transformation],
Imager USING [Color, Context],
Properties USING [PropList],
RefTab USING [Ref],
Rope USING [ROPE],
SymTab USING [Ref],
TokenIO USING [Handle];

CD: CEDAR DEFINITIONS =
BEGIN


Number: TYPE = D2Basic.Number;
Position: TYPE = D2Basic.Vector;
Rect: TYPE = D2Basic.Rect;

Orientation: TYPE = D2Orient.Orientation;

mirrorY: Orientation = rotate180X;

Transformation: TYPE = D2Orient.Transformation;

Error: ERROR [ec: ErrorCode _ programming, explanation: Rope.ROPE _ NIL];
ErrorCode: TYPE = {programming, calling, noResource, doubleRegistration, missingRegistration, directoryInvariant, objectMutability, designMutability, classBehaviour, other};


PropList: TYPE = Properties.PropList;   
PropRef: TYPE = REF PropList _ ; --ABSOLUTELY NEVER NIL

InitPropRef: PROC [] RETURNS [PropRef] = INLINE {
RETURN [NEW[PropList_NIL]]
};

layerNum: NAT = 256;
Layer: TYPE = [0..layerNum);
undefLayer: Layer = 0;	-- Used for object containing different or unknown Layers
shadeLayer: Layer = 1;	-- Visualization; not for generating masks
errorLayer: Layer = 2;	-- Real layer reserved for error messages; rarely for generating masks
backgroundLayer: Layer = 3; -- Special pushed-in backGround; not for generating masks
outlineLayer: Layer = 4;	-- Special color for outline; not for generating masks
selectionLayer: Layer = 5;-- Special color for selection; not for generating masks
commentLayer: Layer = 6;-- Real layer; may or may not be used by technologies


NewLayer: PROC [technology: Technology, uniqueKey: ATOM] RETURNS [Layer];

FetchLayer: PROC [t: Technology, uniqueKey: ATOM] RETURNS [Layer];

LayerTechnology: PROC [l: Layer] RETURNS [Technology];

LayerKey: PROC [l: Layer] RETURNS [ATOM];



Object: TYPE = REF ObjectRep;
ObjectRep: TYPE = RECORD [--read-only except for class implementor  
class: ObjectClass,	
bbox: Rect _ [0, 0, 2, 2],	
layer: Layer _ undefLayer,
immutable: BOOL _ FALSE,
showErrors: BOOL _ FALSE,
reservedO: BOOL _ FALSE,	
specific: REF ANY _ NIL,  
properties: PropList _ NIL 
];

InstanceSequence: TYPE = REF InstanceSequenceRep;
InstanceSequenceRep: TYPE = RECORD [length: NAT_0, elts: SEQUENCE size: NAT OF CD.Instance];

CellSpecific: TYPE = REF CellRep;
CellRep: TYPE = RECORD [
contents: InstanceList _ NIL,	
sequence: InstanceSequence _ NIL,	
ir: Rect _ [0, 0, -1, -1],	
simplifyOn: REAL _ LAST[NAT],	
drawBorder: BOOL _ FALSE,	
changed: BOOL _ FALSE,		
specifiedIr: BOOL _ FALSE,	
dummyCell: --READONLY-- BOOL _ FALSE, 
reserved1: BOOL _ FALSE, 	-- for experiments 
reserved2: BOOL _ FALSE 	-- for experiments 
];

RectSpecific: TYPE = REF RectRep;
RectRep: TYPE = RECORD [filler: PRIVATE REF];

InstanceList: TYPE = LIST OF Instance _ NIL;
Instance: TYPE = REF InstanceRep;
InstanceRep: TYPE = RECORD [
ob: Object,
trans: Transformation _ [],
selected: BOOL _ FALSE,		
reservedI: BOOL _ FALSE,	-- for experiments
properties: PropList _ NIL 
];

ObjectClass: TYPE = REF ObjectClassRec;
ObjectClassRec: TYPE = RECORD [  -- generic class procedures for an object
quickDrawMe: DrawProc _ NIL, 	
drawMe: DrawProc _ NIL, 	
showMeSelected: DrawProc _ NIL,	
hitInside: HitInsideProc _ NIL,  	
interestRect: RectProc _ NIL,	
technology: Technology _ NIL,	
objectType: ATOM _ NIL,		
composed: BOOL _ FALSE, 		
directoryProcs: REF _ NIL,
wireTyped: BOOL _ FALSE, 	
atomicOb: BOOL _ FALSE,	
symbolic: BOOL _ FALSE,  	
xDesign: BOOL _ FALSE,  	
supressTruth: BOOL _ FALSE,	
showsErrors: BOOL _ FALSE,	
reservedC: BOOL _ FALSE,	
describesSignal: BOOL _ FALSE,	
description: Rope.ROPE _ NIL,	
describe: DescribeProc _ NIL,
newLayer: ChangeLayerProc _ NIL,	
internalWrite: InternalWriteProc _ NIL,
internalRead: InternalReadProc _ NIL,
parent: ObjectClass _ NIL,	
properties: PropRef _ NIL 	
];

DrawProc: TYPE = PROC [pr: CD.DrawRef, ob: CD.Object, trans: CD.Transformation_[], readOnlyInstProps: CD.PropList_NIL];
HitInsideProc: TYPE = PROC [ob: CD.Object, hitRect: CD.Rect] RETURNS [BOOL];   
RectProc: TYPE = PROC [ob: CD.Object] RETURNS [CD.Rect];
InternalWriteProc: TYPE = PROC [h: TokenIO.Handle, ob: CD.Object];
InternalReadProc: TYPE = PROC [h: TokenIO.Handle, key: ATOM] RETURNS [CD.Object];
DescribeProc: TYPE = PROC [ob: CD.Object, readOnlyInstProps: CD.PropList_NIL, verbosity: NAT_0] RETURNS [Rope.ROPE];
ChangeLayerProc: TYPE = PROC [inst: CD.Instance, layer: CD.Layer] RETURNS [BOOL_TRUE];
DrawContextProc: TYPE = PROC [pr: CD.DrawRef, proc: CD.DrawContextLayerProc, ob: CD.Object, trans: CD.Transformation, layer: CD.Layer];
DrawContextLayerProc: TYPE = PROC [context: Imager.Context, ob: CD.Object, layer: CD.Layer];

RegisterObjectClass: PROC [objectType: ATOM, class: ObjectClassRec, inherit: REF_NIL] RETURNS [ObjectClass]; 

FetchObjectClass: PROC [objectType: REF, technology: Technology_NIL] RETURNS [--readonly-- ObjectClass]; 



PushRec: TYPE = RECORD [
dummyCell: Instance,  
mightReplace: Instance _ NIL,
desc: Rope.ROPE, 
specific: CellSpecific 
];

Design: TYPE = REF DesignRec;
DesignRec: TYPE = RECORD [ 
actual: LIST OF PushRec, 
name: Rope.ROPE _ NIL,		
technology: Technology _ NIL,	
properties: PropRef _ ,		
edited: BOOL _ FALSE,		
mutability: Mutability _ findOut,	
changedSinceSaving: BOOL _ FALSE,	
cdDirectory1: PRIVATE SymTab.Ref_NIL,
cdDirectory2: PRIVATE RefTab.Ref_NIL,    	
cdDirectoryPriv2: PRIVATE REF,    	
cdValuePriv: PRIVATE PrivateValueDRef _ NIL,	
cdSequencerPriv: PRIVATE PrivateSequencerDRef,	
cdDrawQueuePriv: PRIVATE REF _ NIL,	
delayedRedrawsPriv: PRIVATE REF _ NIL,	
unDoBuffers: PropRef _,		
reservedD: PRIVATE REF _ NIL
];

PrivateSequencerDRef: TYPE = REF PrivateSequencerDRep;
PrivateSequencerDRep: TYPE;  
PrivateValueDRef: TYPE = REF PrivateValueDRep; 
PrivateValueDRep: TYPE; 

Mutability: TYPE = {findOut, editable, inaccessible, readonly} _ findOut;

Technology: TYPE = REF TechnologyRep;
TechnologyRep: TYPE = RECORD [ 
key: ATOM _ NIL,
name: Rope.ROPE _ NIL,
lambda: CD.Number _ ,
usedLayers: LIST OF Layer, 
properties: PropRef _ ,
cdPriv: PRIVATE PrivateTRef,
cdValuePriv: PRIVATE PrivateValueTRef, 	
cdSequencerPriv: PRIVATE PrivateSequencerTRef,
reservedCDSimpleRules: PRIVATE REF _ NIL, 
reservedT: PRIVATE REF _ NIL 
];

PrivateSequencerTRef: TYPE = REF PrivateSequencerTRep; 
PrivateSequencerTRep: TYPE; 
PrivateValueTRef: TYPE = REF PrivateValueTRep; 
PrivateValueTRep: TYPE; 
PrivateTRef: TYPE = PRIVATE REF PrivateTRep; 
PrivateTRep: TYPE;

RegisterTechnology: PROC [key: ATOM, name: Rope.ROPE _ NIL, lambda: CD.Number _ 2] RETURNS [Technology];

FetchTechnology: PROC [key: ATOM] RETURNS [Technology];

EnumerateTechnologies: PROC [proc: TechnologyEnumerator] RETURNS [quit: BOOL];
TechnologyEnumerator: TYPE = PROC [tech: CD.Technology] RETURNS [quit: BOOL_FALSE];


DrawRef: TYPE = REF DrawInformation; 	--this describes an abstract device to draw objects into
DrawInformation: TYPE = RECORD [
interestClip: Rect _ [Number.FIRST/2, Number.FIRST/2, Number.LAST/2, Number.LAST/2], 
drawChild: DrawProc _ NIL, 	-- drawing and recursing
drawRect: DrawRectProc _ NIL,	-- coordinates in cd numbers
stopFlag: REF BOOL _ NIL,	-- setting stopFlag^ to true stops drawing
drawOutLine: DrawRectProc _ NIL,	-- visualization only; not for generating masks
drawContext: DrawContextProc _ NIL,	-- drawing into an imager context
drawComment: DrawCommentProc _ NIL, -- visualization only; not for generating masks
drawChildSel: DrawProc _ NIL, 	-- drawing of selection of child
setGround: SetGroundProc _ NIL,
priorityChecker: CheckPriorityProc _ NIL, --usually no-op
scaleHint: REAL _ 0,		-- to monitor simplifications; 0 means no simplifications
environment: BOOL _ TRUE,	-- draw the outside of pushed in cells
symbolics: BOOL _ TRUE,		-- draw symbolic objects
selections: BOOL _ TRUE,		-- draw selections
showErrors: BOOL _ TRUE,	-- draw error messages
fontSubstitution: BOOL _ FALSE, 	-- usually FALSE; device may replace fonts
checkPriority: BOOL _ FALSE, 	-- usually FALSE; priority of running process
borders: BOOL _ FALSE,		-- visualization only; not for generating masks
b4: BOOL _ TRUE,		-- reserved for experiments 
b5: BOOL _ TRUE,		-- reserved for experiments
devicePrivate: REF _ NIL, -- differentiate among multiple (viewers) with same drawProc's
viewerPrivate: ViewerPrivate _ NIL,	-- speed up for viewers devicePrivate
deviceContext: Imager.Context _ NIL,	-- may or may not be used
contextFilter: REF ContextFilter _ NIL, -- (default uses filter only if deviceContext=NIL)
contextColors: REF ContextColors _ NIL,-- (default uses colors only if deviceContext#NIL)
design: Design _ NIL,		
properties: PropRef _ NIL
];
ViewerPrivate: TYPE = REF ViewerPrivateRep;
ViewerPrivateRep: TYPE;

DrawRectProc: TYPE = PROC [pr: CD.DrawRef, r: CD.Rect, l: CD.Layer];
DrawCommentProc: TYPE = PROC [pr: CD.DrawRef, r: CD.Rect, comment: Rope.ROPE];
SetGroundProc: TYPE = PROC [pr: CD.DrawRef, pushedOut: BOOL];
CheckPriorityProc: TYPE = PROC [pr: CD.DrawRef];

ContextFilter: TYPE = PACKED ARRAY Layer OF BOOL _ ALL[TRUE];
ContextColors: TYPE = ARRAY Layer OF Imager.Color _ ALL[NIL];

CreateDrawRef: PROC [inf: DrawInformation] RETURNS [DrawRef];



Describe: PROC [ob: Object, readOnlyInstProps: PropList_NIL, design: CD.Design_NIL, verbosity: NAT_1] RETURNS [Rope.ROPE];

DrawOb: PROC [pr: DrawRef, ob: CD.Object, trans: Transformation_[], readOnlyInstProps: PropList_NIL] = INLINE {
ob.class.drawMe[pr, ob, trans, readOnlyInstProps]
};

InterestRect: PROC [ob: Object] RETURNS [r: Rect] = INLINE {
RETURN [ob.class.interestRect[ob]]
};

InterestBase: PROC [ob: Object] RETURNS [sz: Position] = INLINE {
r: Rect = ob.class.interestRect[ob];
RETURN [[r.x1, r.y1]];
};

InterestSize: PROC [ob: Object] RETURNS [sz: Position] = INLINE {
r: Rect = ob.class.interestRect[ob];
RETURN [[r.x2-r.x1, r.y2-r.y1]];
};

DesignName: PROC [design: Design_NIL] RETURNS [Rope.ROPE];

END.

'ξCD.mesa   
Copyright c 1983, 1984, 1985, 1986, 1987 by Xerox Corporation.  All rights reserved.
Created by: Christian Jacobi, June 24, 1983 3:54 pm 
Last edited by: Christian Jacobi, April 10, 1987 5:57:11 pm PDT

Main definitions for ChipNDale, a VLSI design editor and database.
-- Measuring
-- RECORD [x, y: Number];
-- RECORD [x1, y1, x2, y2: Number];
-- A Rect is called normalized if (x1>x2) OR (y1>y2) means that the Rect is empty.
-- Rects are normalized, except if an explicite comment denies. 
-- Rect's are closed: they include all the endpoints; as you expect, points have 
-- size 0.
-- MACHINE DEPENDENT {original(0), mirrorX(1), rotate90(2), rotate90X(3), 
--	rotate180(4), rotate180X(5), rotate270(6), rotate270X(7)};
-- An orientation represents an anticlockwise rotation maybe followed by a reflection in x. 
-- [Reflection in x means: modify x coordinates, leave y coordinates]
-- RECORD [off: D2Basic.Vector _ [0, 0], orient: Orientation _ original];
-- A transformation represents an orientation followed by a translation. 


-- Errors

-- Properties
-- Friendly use expected: don't assign properties without first registering their names   
-- with CDProperties.
-- Use only CDProperties to modify ChipNDale PropList; never Properties directly
-- to avoid problems with unmonitored concurrency. 
-- Initialization for variables of type PropRef


-- Layers
-- Creates a new layer for technology
-- May raise Error[noResource]
-- The technolgy implementation must guarantee for uniqueness of uniqueKey's
-- (unique only inside the technology)
-- Returns a layer given a technology and an unique layer key
-- May also return technology independent layers
-- Returns the technology of the layer, or, NIL if layer is technology independent
-- Returns the technology specific unique key of the layer
--Object, cells, instances
-- Objects are the main things in ChipNDale
-- Objects must draw the same way independant of their environment
-- Several different instances may use the same object! 

-- Clients: never modify class nor class^
-- Be aware: Asynchrounous redrawing may be in progress
-- Maximal area drawn in DrawProcs, not electrical influence.
-- Used for all graphical pruning purposes.
-- Readonly, even to object class!
-- immutable being false does not mean the object can be changed: an object can be  
--    changed only if it is mutable, and, it is accessed in a way which allows changes.
-- An immutable object must not have any mutable children.
-- Once immutable, an object can not be made mutable again; but if read from a file,
-- the new copy probably will be mutable.
-- Owned by the error displaying module, not the class!
-- Owned by ChipNDale's implementation [experimental]
-- Owned by object class
-- Usage of properties of immutable Objects is restricted to object class implentors or
-- users which provide unique property keys. 
-- Used for extras/large/pushed-in cells
-- Reduces memory access compared to list
-- Interest rect
-- A treshold for simplification on quickdraw
-- Border should be drawn 
-- Cell changed since push [not IO]
-- Interest rect is explicitelly specified [not defaulted]
-- Used in push stack of a design
-- If set, inhibits use of sequence, assures mutable
-- Meaningfull for instances of pushed in cells only
-- An optimized draw procedure for viewers.
-- Drawing the object into an abstract device.
-- Children objects returned by drawMe must never be muted unless mutability 
-- is guaranteed using other means [immuable bit is NOT sufficient].  
-- The draw procs defines the truth.  
-- Showing the selection [for top level only].
-- For fine grain selection.
-- The boundary the designer likes to think about. 
-- The objects bounding box includes the interestRect. 
-- Or NIL for technology independent classes
-- registration key
   -- Objects which have children must be composed !
   -- Only composed classes can have mutable objects; if class is not composed 
   --    objects are supposed immutable. 
   -- Composed classes have more invariants and class procedures in CDDirectory. 
-- More class procedures for composed classes
-- Field reserved for CDDirectory
-- Allows ChipNDale to stretch object in a certain way
-- If wireTyped then [interestRect] y corresponds to the length
-- Creation using CDAtomicObjects class.
-- A particular subset of non composed classes.
-- Object used for interface specification; no mask
-- Class allows children of composed classes across designs
-- Dont write objects of this class to permanent files in truth mode [expand object]
-- Tells whether drawMe's deal with error messages.
-- Set by class, read by error message handling package.
-- For experiments of ChipNDale itself
-- Hint that describe tells already about the SignalName 
-- Shortcut for NIL describe procs
-- Describes object, but description does not need to include name	
-- Used by some simple non-composed classes only
-- For subclassing purposes
-- Used by ChipNDale, class, and clients
-- Object classes which uses DrawContextProc must guarantee 
--      ob#NIL 
--      ob.bbox fits in [-NAT.LAST/2, -NAT.LAST/2, NAT.LAST/2, NAT.LAST/2]  
-- Registers an object class; initializes procedures with default values.
-- May raise Error[doubleRegistration] and others
-- An object type may be used either in arbitrary technology or technology-independent.
-- This should be the only way to create data of type ObjectProcsRec
-- inherit: objectType ATOM or class; overwrites class.parent
--
-- Think twice before implementing object classes outside the ChipNDale implementation.
-- In general this is not a good idea and will introduce long living data and maintenance
-- problems.
-- Returns registration of object class; NIL if not found
-- Consider ObjectClass as readonly if you are not the implementor of the object class. 
-- Design
-- An instance of a cell describing the current state of the pushed in cell. 
-- Originally a copy of mightReplace; dummyCell.ob is not included in the directory. 
-- Sub instances of cell are mapped to design coordinates. 
-- bbox of cell object may be wrong. 
-- The original instance into which the design is pushed in. 
-- mightReplace is in the coordinate system of the next outer dummyCell. 
-- and is removed from [the next outer dummyCell's] instance list. 
-- Sub instances of mightReplace.ob are in cd coordinate system of the object 
-- May be NIL for top level
-- Description of object pushed in
-- Cache of dummyCell.ob.specific
-- Use only CDOps.CreateDesign to create DesignRec records
-- Use CDValue or CDProperties for more fields 
-- Use CDSequencer to synchronize multi treaded access to designs
-- Stack of pushed in cells 
-- actual.first describes most deeply pushed in object 
-- Treat readonly ! [internal invariants]
-- treat readonly 
-- Use CDProperties
-- Treat readonly ! [internal invariants]
-- Treat readonly ! Write only by CDSequencer
-- Treat readonly ! [internal invariants]
-- Used by CDDirectory for directory
-- Used by CDDirectory for directory
-- Used by CDDirectory for ownership keys
-- Reserved for CDValue
-- Reserved for CDSequencer
-- Reserved for CDDrawQueue
-- Reserved for single module
-- It is ok to use InitPropRef to disable undos
-- Reserved for ChipNDale experiments
--Mutability, defined to be useful for designs.
--   findOut: mutability not yet defined.
--   editable: design or its objects can be edited, but only if the designs lock is hold.
--   inaccessible: this path inhibits any edits on the design, but does not guarantee
--        that there is no other way some other process performs edits. 
--   readonly:  No changes in design are made. 
--If a design is not editable this does not mean complete immutability:
--   Top level instances may be made for visualization.
--   Objects may but do not need to have the immutable flag.
--   Objects accessed accross design boundaries may change.
-- Technology

-- use RegisterTechnology to create TechnologyRep record
-- all fields except properties read only
-- use CDValue or CDProperties for more fields 
-- List of technology dependent Layers
-- Reserved for CDImpl
-- Reserved for CDValue
-- Reserved for CDSequencer
-- Reserved for CDSimpleRules
-- Reserved for experiments
-- This must be the only way to create data of type TechnologyRep
-- May raise Error[doubleRegistration] and others
-- NIL if not found

-- Drawing
-- The drawing process involves three actors:
--     The object class provides drawing object specific features.
--     The abstract device provides rendering procedures. 
--     ChipNDale itself provides some default procedures and the ground rules 
--         how the device and the object class must communicate. 
-- The drawing defines the truth of ChipNDale objects. 
-- interest area; not device area!  
--     might be slightly larger than device area, such that 
--          every feature visible in device area can be gotten with pruning to interest area,
--     small enough, such that 
--          conversion from cd numbers to device numbers does not cause arithmetic overflow 
-- Optional in general, but might be required by some devices.
-- Object classes must not assume that drawn objects are included in this design.
-- Class: Need not be maintained by drawing over design boundaries.
-- use CreateDrawRef for creation of DrawInformation record, unless all fields are set.

-- A TRUE entry means the layer is visible
-- A NIL color entry means the layer is invisible
-- Creates an abstract device and assigns usefull default procedures and values.
-- Vanilla procedures
-- Returns description of an object
-- design: Its ok to ommit design for this procedure, but then name can't be included
-- readOnlyInstProps: some object classes need to access instance properties for good description
-- verbosity: degree of detail requested; 0 very short; 1 typical interaction >1 particular interest
-- Calls the draw procedure; This defines the truth about objects!
-- Drawn sub objects may be not accessible without having immuable flag set.
-- Returns the interest rect of the object.
-- Returns the base of the interest rect. 
-- Returns the size of the interest rect. 
-- Returns a name for a design [never returns a NIL ROPE]. 
Κe˜
codešΟkœ™
Kšœ
Οm
œI™TKš
œ4™4Kš
œ?™?—K™Kšœ"œ™BK˜š
	˜	Kšœœ˜%Kšœ	œ˜-Kšœœ˜Kšœœ˜Kšœœ˜Kšœœœ˜Kšœœ˜Kšœœ
˜—K˜Kšœœ
œ˜Kš
˜K˜Kš
Οc™K˜Kšœœ˜šœ
œ˜ Kš
Ÿ™—šœœ˜Kš
Ÿ#™#Kš
ŸR™RKš
Ÿ@™@Kš
ŸQ™QKš
Ÿ
™
—K˜šœ
œ˜)Kš
ŸJ™JKš
Ÿ=™=Kš
Ÿ\™\Kš
ŸE™E—˜Kš
œ"˜"—K˜šœœ˜/Kš
ŸI™IKš
ŸI™I—K™K™Kš
Ÿ	™	K˜KšΟnœœ1œœ˜IKšœœž
˜­
K˜K™Kš
Ÿ
™
K˜šœ
œ˜(Kš
ŸZ™ZKš
Ÿ™Kš
ŸP™PKš
Ÿ3™3—šœ	œœŸ˜7K˜—š œœœ
œ˜1Kš
Ÿ/™/Kšœœ
œ˜K˜—K™K™Kš
Ÿ	™	K˜Kšœ
œ˜šœœ˜KšœŸ9˜PKšœŸ*˜AKšœŸF˜]KšœŸ9˜UKšœŸ6˜OKšœŸ8˜RKšœŸ5˜MK˜K˜—š œœ%œœ	˜IKš
Ÿ%™%Kš
Ÿ™Kš
ŸL™LKš
Ÿ&™&K˜—š 
œœœœ	˜BKš
Ÿ=™=Kš
Ÿ0™0K˜—š œœœ˜6Kš
ŸR™R—K˜š œœœœ˜)Kš
Ÿ:™:K˜—K˜Kš
Ÿ™K˜šœœœ˜Kš
Ÿ+™+Kš
ŸB™BKš
Ÿ8™8K™—šœœœŸ*˜Dš
œ˜Kš
Ÿ)™)Kš
Ÿ7™7—š
œ˜Kš
Ÿ=™=Kš
Ÿ+™+—Kš
œ˜šœœœ
˜Kš
Ÿ"™"Kš
ŸT™TKš
ŸW™WKš
Ÿ:™:Kš
ŸT™TKš
Ÿ)™)—šœœœ
˜Kš
Ÿ7™7—šœœœ˜Kš
Ÿ5™5—šœ
œ
œœ˜Kš
Ÿ™—šœœ
˜Kš
ŸW™WKš
Ÿ-™-—K˜K˜—Kšœœœ˜1Kšœœœ
œ
œœ
œ
œ˜\K˜Kšœœœ	˜!šœ	œœ˜šœœ˜Kš
Ÿ(™(—šœœ˜"Kš
Ÿ)™)—š
œ˜Kš
Ÿ™—šœœœ
œ˜Kš
Ÿ-™-—šœœœ˜Kš
Ÿ™—šœ	œœ˜Kš
Ÿ#™#—šœ
œœ˜Kš
Ÿ:™:—šœŸœ
œœ˜&Kš
Ÿ!™!Kš
Ÿ4™4—KšœœœŸ˜-KšœœœŸ˜,K˜K˜—Kšœœœ	˜!Kš	œ	œœ
œ
œ˜-K˜Kš	œœœ
œœ
˜,Kšœ
œœ
˜!šœ
œœ˜K˜Kš
œ˜šœ
œœ˜Kš
œ4™4—KšœœœŸ˜+Kšœœ
˜K˜K˜—Kšœ
œœ˜'šœœœŸ)˜Jšœœ˜Kš
Ÿ+™+—šœœ˜Kš
Ÿ.™.Kš
ŸM™MKš
ŸF™FKš
Ÿ&™&—šœœ˜ Kš
Ÿ.™.—šœœ˜"Kš
Ÿ™—šœœ˜Kš
Ÿ3™3Kš
Ÿ7™7—šœœ˜Kš
Ÿ,™,—šœœœ˜Kš
Ÿ™—Kšœ
œœ˜KšœŸ1™4KšœŸL™OKšœŸ&™)KšœŸN™Qšœœœ
˜Kš
Ÿ-™-Kš
Ÿ!™!—šœœœ˜Kš
Ÿ6™6Kš
Ÿ?™?—šœ
œœ˜Kš
Ÿ(™(Kš
Ÿ/™/—šœ
œœ˜Kš
Ÿ3™3—šœ	œœ˜Kš
Ÿ;™;—šœœœ˜Kš
ŸT™T—šœ
œœ˜Kš
Ÿ3™3Kš
Ÿ8™8—šœœœ˜Kš
Ÿ&™&—šœœœ˜Kš
Ÿ9™9—šœœœ˜Kš
Ÿ"™"—šœœ
˜Kš
ŸC™C—šœœ˜!Kš
Ÿ0™0—Kšœ#œ
˜'Kšœ!œ
˜%šœœ˜Kš
Ÿ™—šœœ˜Kš
Ÿ(™(—K˜K˜—Kšœ
œœœœœ'œ
œ˜wKš
œœœœœœœ˜OKšœ
œœœ	œœ˜8Kšœœœœ	˜BKšœœœœœœ	˜QKšœœœœœ
œ
œœœ˜tKšœœœœœœœ
œ˜Všœœœœœœœœ˜‡
Kš
Ÿ<™<Kš
Ÿ™Kš
ŸL™L—Kš	œœœœœ˜\K˜š œœœ"œ
œœ˜mKš
ŸI™IKš
Ÿ1™1Kš
ŸW™WKš
ŸD™DKš
Ÿ=™=Kš
Ÿ™Kš
ŸW™WKš
ŸY™YKš
Ÿ™K˜—š œœœœœŸœ˜iKš
Ÿ9™9Kš
ŸX™XK˜—K˜Kš
œ	™	K˜šœ	œœ˜š
œ˜Kš
ŸM™MKš
ŸU™UKš
Ÿ;™;Kš
Ÿ%™%—šœœ
˜Kš
Ÿ=™=Kš
ŸI™IKš
ŸC™CKš
ŸN™NKš
Ÿ™—šœœ˜Kš
Ÿ"™"—š
œ˜KšŸœ™!—K˜K˜—Kšœœœ˜šœœœ˜Kš
Ÿ:™:Kš
Ÿ/™/Kš
ŸA™Ašœœ
œ
˜Kš
Ÿ™Kš
Ÿ7™7—šœœœ˜KšŸœ&™)—šœœ˜KšŸœ™—š
œ˜KšŸœ™—šœœœ˜KšŸœ&™)—š
œ"˜"KšŸœ*™-—šœœœ˜"KšŸœ&™)—šœœœ
˜%Kš
Ÿ$™$—šœœœ˜*Kš
Ÿ$™$—šœœ
œ˜#KšŸœ&™)—šœ
œœ˜-KšŸœ™—šœœ˜/KšŸœ™—šœœ
œœ˜$KšŸœ™—šœœ
œœ˜'KšŸœ™—š
œ˜Kš
Ÿ/™/—šœœ
œ˜Kš
Ÿ%™%—K˜K˜Kšœœœ˜6Kšœœ˜Kšœœœ˜/Kšœœ˜K˜—šœœ9˜IKš
Ÿ/™/Kš
Ÿ)™)Kš
ŸY™YKš
ŸU™UKš
ŸH™HKš
Ÿ/™/Kš
ŸG™GKš
Ÿ7™7Kš
Ÿ<™<Kš
œ;™;—K˜Kš
Ÿ
™
K™Kšœœœ˜%šœœœ˜Kš
Ÿ8™8Kš
Ÿ)™)Kš
Ÿ/™/Kšœœœ
˜Kšœœœ
˜Kšœœ˜šœœ
œ˜KšŸœ#™&—Kš
œ˜šœœ
˜KšŸœ™—šœ
œ˜(KšŸœ™—šœœ˜.Kš
œ™—šœœ
œœ˜*KšŸœ™—šœœ
œœ
˜KšŸœ™—K˜K˜Kšœœœ˜7Kšœœ˜Kšœœœ˜/Kšœœ˜Kšœ
œœ
œ˜-Kšœ
œ
˜K˜—š œœœ
œœ
œ
œ˜hKš
ŸA™AKš
Ÿ1™1K˜—š œœœœ˜7Kš
Ÿ™—K˜š œœœœ˜NKš
œœœœ
œœ
œ˜SK˜—K™š
Ÿ
™
Kš
Ÿ-™-Kš
ŸB™BKš
Ÿ:™:Kš
ŸN™NKš
ŸA™AK™7—K˜Kšœ	œœŸ8˜^šœœœ˜ š	œœœœœ˜UKš
Ÿ$™$Kš
Ÿ<™<Kš
Ÿ]™]Kš
Ÿ™Kš
Ÿ\™\—KšœœŸ˜4KšœœŸ˜:Kšœ
œ
œœŸ*˜DKšœœŸ/˜PKšœœŸ!˜EKšœœŸ/˜SKšœœŸ ˜?Kšœœ
˜Kšœ%œŸ˜9KšœœŸ9˜OKšœ
œœŸ&˜@KšœœœŸ˜1KšœœœŸ˜,KšœœœŸ˜/KšœœœŸ*˜KKšœœœŸ-˜KKšœ	œœŸ/˜GKšœœœŸ˜.KšœœœŸ˜-KšœœœŸ>˜XKšœœŸ%˜IKšœ œŸ˜>KšœœœŸ2˜ZKšœœœ
Ÿ2˜Yšœœ˜Kš
œ>™>Kš
œQ™QKš
œC™C—Kšœ˜K˜KšŸWœ
™XKšœœœ˜+Kšœœ
˜K˜—Kšœœœœ
œ
œ˜DKšœœœœ
œœ˜NKš	œœœœœ˜=šœœœœ
˜0K˜—šœœœ
œœ
œœ
œ˜=Kš
Ÿ*™*—šœœœœœ
œ˜=Kš
Ÿ1™1K˜—š 
œœœ˜=Kš
ŸP™PK˜—K˜K™K˜š œœ*œ
œœ
œœœ˜zKš
Ÿ#™#Kš
ŸU™UKš
Ÿa™aKš
Ÿd™d—K˜š
 œœœ?œœ˜oKš
ŸB™BKš
ŸL™LKš
œ1˜1K˜K˜—š œœœ
œ˜<Kš
Ÿ+™+Kšœ˜"K˜K˜—š œœœœ˜AKš
Ÿ*™*Kš
œ$˜$Kšœ˜K˜K˜—š œœœœ˜AKš
Ÿ*™*Kš
œ$˜$Kšœ˜ K˜K˜—š
 
œœœœœ˜:Kš
Ÿ;™;K˜—Kšœ
˜K˜—…—&~aΡ