DIRECTORY
AMBridge,
AMTypes,
Atom, 
CD,
CDColors, 
CDColorsExtras, 
CDDrawQueue,
CDProperties,
CDViewerBackdoor,
CDVPrivate,
CDVScale,
Imager, 
ImagerColor, 
ImagerDitherContext,
RefTab,
Rope,
RuntimeError,
ViewerClasses;

CDViewerBackdoorImpl: CEDAR MONITOR
IMPORTS AMBridge, AMTypes, Atom, CD, CDProperties, CDVPrivate, CDVScale, Imager, ImagerColor, ImagerDitherContext, RefTab, Rope, RuntimeError
EXPORTS CDViewerBackdoor, CDVScale, CDColors, CDColorsExtras =
BEGIN

MakeScale: PUBLIC PROC [off: CD.Position_[0, 0], nscale: CDVScale.ScaleRange_4, grid: INTEGER_-1] RETURNS [s: CDVScale.ScaleRec] = {
sE: INTEGER;
noDivisionScale: CDVScale.ScaleRange = 8;
scaleE: ARRAY CDVScale.ScaleRange OF INTEGER = --scale for factors
[24, 16, 12, 8, 6, 4, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
scaleF: ARRAY CDVScale.ScaleRange OF INTEGER = --scale for divisors
[1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192]; 
scaleS: ARRAY CDVScale.ScaleRange OF NAT = --scale for shifts
[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];
s.nscale _ nscale; --MIN[MAX[nscale, 0], CDVScale.scaleNum-1];
s.grid _ MAX[1, grid];
sE _ scaleE[s.nscale];
s.sA _ scaleF[s.nscale];
s.sB _ (s.grid/2)*sE+sE/2;
s.sC _ sE*s.grid;
s.sD _ s.grid;
s.sS _ scaleS[s.nscale];
s.off.x _ off.x/s.grid*s.grid;
s.off.y _ off.y/s.grid*s.grid;
IF s.useMultiply _ s.nscale<noDivisionScale THEN {
s.xx _ sE;
s.designToViewerFactor _ sE;
}
ELSE {
s.xx _ s.sA;
s.designToViewerFactor _ 1.0/s.sA;
};
};
GetClipRecord: PUBLIC PROC[scale: CDVScale.ScaleRec, highX, highY: CARDINAL] RETURNS [CD.Rect] = {

UnGridedScaleViewerToDesignUp: PROC [scale: CDVScale.ScaleRec, v: LONG CARDINAL] RETURNS [CD.Number] = INLINE {
sE: INTEGER = IF scale.useMultiply THEN scale.xx ELSE 1;
RETURN [LOOPHOLE[(v*scale.sA+sE+sE)/sE, CD.Number]]
};

RETURN [CD.Rect[
x1: CDVScale.ViewerToDesignScalar[scale, 0]+scale.off.x,
y1: CDVScale.ViewerToDesignScalar[scale, 0]+scale.off.y,
x2: UnGridedScaleViewerToDesignUp[scale, highX+1]+scale.off.x,
y2: UnGridedScaleViewerToDesignUp[scale, highY+1]+scale.off.y]
]
};

getList: CDProperties.PropRef _ CDProperties.InitPropRef[];
setList: CDProperties.PropRef _ CDProperties.InitPropRef[];

InstallGetProc: PUBLIC PROC [op: ATOM, proc: ViewerClasses.GetProc] = {
ENABLE UNWIND => NULL;
val: REF = IF proc=NIL THEN NIL ELSE NEW[ViewerClasses.GetProc_proc];
IF proc=CallGetProc THEN ERROR; --don't do that, it causes infinite recursion
CDProperties.PutProp[getList, op, val]
}; 

InstallSetProc: PUBLIC PROC [op: ATOM, proc: ViewerClasses.SetProc] = {
ENABLE UNWIND => NULL;
val: REF = IF proc=NIL THEN NIL ELSE NEW[ViewerClasses.SetProc_proc];
IF proc=CallSetProc THEN ERROR; --don't do that, it causes infinite recursion
CDProperties.PutProp[setList, op, val]
}; 

CallGetProc: PUBLIC ViewerClasses.GetProc = {
WITH CDProperties.GetListProp[getList^, op] SELECT FROM
gp: REF ViewerClasses.GetProc => RETURN [gp[self, op]];
ENDCASE => RETURN [NIL];
};

CallSetProc: PUBLIC ViewerClasses.SetProc = {
WITH CDProperties.GetListProp[setList^, op] SELECT FROM
sp: REF ViewerClasses.SetProc => sp[self, data, finalise, op];
ENDCASE => NULL;
};



PaintRegRec: TYPE = RECORD [type: AMTypes.Type, proc: CDViewerBackdoor.FurtherPaintProc];
paintList: LIST OF REF PaintRegRec _ NIL;
paintKeyTable: RefTab.Ref _ RefTab.Create[]; 

InstallFurtherPaint: PUBLIC PROC[keyReferentType: AMTypes.Type_AMTypes.nullType, keyValue: REF_NIL, proc: CDViewerBackdoor.FurtherPaintProc] = {
IF proc=NIL THEN ERROR;
IF keyValue#NIL THEN 
[] _ RefTab.Store[paintKeyTable, keyValue, NEW[CDViewerBackdoor.FurtherPaintProc_proc]]
ELSE IF keyReferentType=CODE[CDDrawQueue.Request] OR keyReferentType=AMTypes.nullType THEN ERROR
ELSE 
paintList _ CONS[NEW[PaintRegRec_[type: keyReferentType, proc: proc]], paintList]
};

CallFurtherPaint: PUBLIC PROC[me: CDVPrivate.VRef, key: REF] = {
ENABLE RuntimeError.UNCAUGHT => 
IF CDVPrivate.ShallContinue[me, TRUE, "CDVDraw.back"] THEN GOTO oops;
transmitt: REF _ key;
WITH key SELECT FROM
req: REF CDDrawQueue.Request => key _ req.key
ENDCASE => NULL;
WITH RefTab.Fetch[paintKeyTable, key].val SELECT FROM
p: REF CDViewerBackdoor.FurtherPaintProc => p^[me, transmitt]
ENDCASE => TRUSTED {
type: AMTypes.Type _ AMTypes.TVType[AMBridge.TVForReferent[key]];
FOR list: LIST OF REF PaintRegRec _ paintList, list.rest WHILE list#NIL DO
IF list.first.type=type THEN {
list.first.proc[me, transmitt];
EXIT
}
ENDLOOP;
}
EXITS oops => NULL
};


NotifyRegRec: TYPE = RECORD [mode: REF, doit: CDViewerBackdoor.FurtherNotifyProc];
NotifyList: TYPE = LIST OF NotifyRegRec;
notifyList: NotifyList _ NIL;

InstallFurtherNotify: PUBLIC ENTRY PROC[mode: REF, proc: CDViewerBackdoor.FurtherNotifyProc] = {
ENABLE UNWIND => NULL;
IF proc=NIL THEN RETURN WITH ERROR CD.Error[];
IF notifyList=NIL THEN notifyList _ LIST[NotifyRegRec[mode: mode, doit: proc]]
ELSE
FOR list: NotifyList _ notifyList, list.rest DO
IF list.first.mode=mode THEN {list.first.doit _ proc; EXIT}
ELSE IF list.rest=NIL THEN {list.rest _ LIST[NotifyRegRec[mode: mode, doit: proc]]; EXIT}
ENDLOOP
};

CallFurtherNotify: PUBLIC PROC[me: CDVPrivate.VRef, mode: REF] = {
ENABLE RuntimeError.UNCAUGHT => {
IF CDVPrivate.ShallContinue[me, TRUE, "CDViewerBackdoorImpl.CFN"] THEN GOTO oops; 
};
FOR list: NotifyList _ notifyList, list.rest WHILE list#NIL DO
IF list.first.mode=mode THEN {list.first.doit[me, mode]; RETURN}
ENDLOOP;
UseDefaultOutLine[me, NIL];
EXITS oops => NULL;
};
DefaultOutLine: PROC [me: CDVPrivate.VRef] = {};

UseDefaultOutLine: CDViewerBackdoor.FurtherNotifyProc = {
me.designRec.outlineProcLC _ DefaultOutLine
};

DisplayType: TYPE = CDColors.DisplayType;
DisplayMode: TYPE = CDColors.DisplayMode;
Brick: TYPE = CDColors.Brick;
-- ARRAY [0..4) OF CARDINAL; 
ColorTable: TYPE = CDColors.ColorTable;
ColorTableSet: TYPE = CDColors.ColorTableSet;
ColorDefinition: TYPE = CDColors.ColorDefinition;

globalColors: PUBLIC REF ColorDefinition _ NEW[ColorDefinition_ALL[NIL]];  
emptyBrick: REF Brick = NEW[Brick_ALL[0]];
fullBrick: REF Brick = NEW[Brick_ALL[LAST[CARDINAL]]];

registeredColors: REF CD.ContextColors _ NEW[CD.ContextColors];
madeUpColors: REF CD.ContextColors _ NEW[CD.ContextColors];

eraseColor: Imager.Color _ NIL;

ColorNotRegistered: PUBLIC SIGNAL = CODE;

InitialColor: PUBLIC PROC [] RETURNS [col: Imager.Color] = {
IF eraseColor#NIL THEN RETURN [eraseColor];
col _ eraseColor _ ImagerColor.Find["Xerox/Research/ChipNDale/cd/InitialColor"]; 
IF col=NIL THEN {SIGNAL ColorNotRegistered; col _ Imager.white};
};

RegisteredColor: PUBLIC PROC [layer: CD.Layer] RETURNS [col: Imager.Color] = {
IF CD.LayerKey[layer]=NIL THEN ERROR CD.Error[calling]; 
col _ FindColor[layer]; 
IF col=NIL THEN {SIGNAL ColorNotRegistered; col _ MakUpColor[layer]};
};

FindColor: PROC [layer: CD.Layer] RETURNS [col: Imager.Color] = {
IF registeredColors[layer]#NIL THEN RETURN [registeredColors[layer]];
col _ registeredColors[layer] _ ImagerColor.Find[ColorName[layer]]; 
};

MakUpColor: PROC [layer: CD.Layer] RETURNS [col: Imager.Color] = {
IF madeUpColors[layer]#NIL THEN RETURN [madeUpColors[layer]];
madeUpColors[layer] _ col _ ImagerDitherContext.MakeSpecialColor[ordinaryColor: Imager.black, specialPixel: [0, or], name: ColorName[layer]];
};

ColorName: PROC [l: CD.Layer] RETURNS [Rope.ROPE] = {
tech: CD.Technology _ CD.LayerTechnology[l];
RETURN [Rope.Cat["Xerox/Research/ChipNDale/", (IF tech=NIL THEN "cd" ELSE tech.name), "/", Atom.GetPName[CD.LayerKey[l]]]]
};

NewColorTab: PROC [] RETURNS [ct: REF ColorTable] = {
ct _ NEW[ColorTable _ [
bricks: NEW[ARRAY CD.Layer OF REF Brick _ ALL[fullBrick]], 
filter: NEW[CD.ContextFilter _ ALL[TRUE]], 
cols: NEW[ARRAY CD.Layer OF Imager.Color _ ALL[Imager.black]]
]];
ct.filter[CD.backgroundLayer] _ FALSE;
};

GetCTS: PROC [table: REF ColorDefinition, display: DisplayType] RETURNS [cts: REF ColorTableSet] = {
IF table=NIL THEN table _ globalColors;
IF table[display]=NIL THEN {
IF table=globalColors THEN {
IF display=bit1 THEN display _ bw   --color 1 bit/pixel gets same stipples as bw
ELSE IF display=bit9 THEN display _ bit8;  --9 bit/pixel uses same stipples as 8 bit/pixel
};
IF table[display]=NIL THEN {
table[display] _ NEW[ColorTableSet _ ALL[NIL]];
table[display][normal] _ NewColorTab[];
table[display][pushedOut] _ NewColorTab[];
};
};
cts _ table[display];
};

DefineColor: PUBLIC PROC[
layer: CD.Layer, 
brick: REF Brick _ NIL, -- do no more change the values
display: DisplayType _ bw, 
mode: DisplayMode _ normal,
table: REF ColorDefinition _ NIL  --NIL uses the global table
] = {
cts: REF ColorTableSet _ GetCTS[table, display];
IF brick=NIL THEN brick _ fullBrick
ELSE IF brick^=fullBrick^ THEN brick _ fullBrick -- reuse fullbrick; reduce swapping
ELSE IF brick^=emptyBrick^ THEN brick _ emptyBrick;
cts[mode].bricks[layer] _ brick;
cts[mode].cols[layer] _ FindColor[layer];
IF cts[mode].cols[layer]=NIL THEN cts[mode].cols[layer] _ MakUpColor[layer];
cts[mode].filter[layer] _ cts[mode].cols[layer]#NIL;
IF mode=normal THEN { 
cts[pushedOut].bricks[layer] _ brick;
cts[pushedOut].cols[layer] _ cts[mode].cols[layer];
cts[pushedOut].filter[layer] _ cts[mode].filter[layer];
};
};

DefineIColor: PUBLIC PROC[
layer: CD.Layer, 
col: Imager.Color _ NIL, 
display: DisplayType _ bw, 
mode: DisplayMode _ normal,
table: REF ColorDefinition _ NIL  --NIL uses the global table
] = {
cts: REF ColorTableSet _ GetCTS[table, display];
abstract: Imager.Color _ registeredColors[layer];
IF abstract#NIL THEN col _ abstract;
IF abstract=NIL AND col#NIL AND display=bit8 AND ISTYPE[col, ImagerColor.OpConstantColor] THEN {
b: REF Brick _ cts[mode].bricks[layer];
IF b#NIL AND b[0]=b[1] AND b[0]=b[1] AND b[0]=b[3] THEN {
n: CARDINAL _ b[0] MOD 256;
IF n=(b[0] / 256) THEN { 
madeUpColors[layer] _ col _ ImagerDitherContext.MakeSpecialColor[
ordinaryColor: NARROW[col],
specialPixel: [n, or],
name: ColorName[layer]
];
}
}
};
cts[mode].cols[layer] _ col;
cts[mode].filter[layer] _ col#NIL;
IF mode=normal THEN {
cts[pushedOut].cols[layer] _ col;
cts[pushedOut].filter[layer] _ col#NIL;
}
};

globalColors[bw] _ globalColors[bit1] _ NEW[ColorTableSet];
globalColors[bw][normal] _ NewColorTab[];
globalColors[bw][pushedOut] _ NewColorTab[];
globalColors[bit8] _ globalColors[bit4] _ globalColors[bit2] _ globalColors[bit9] _ NEW[ColorTableSet];
globalColors[bit8][normal] _ NewColorTab[];
globalColors[bit8][pushedOut] _ NewColorTab[];
InstallFurtherNotify[NIL, UseDefaultOutLine];
END. 



pCDViewerBackdoorImpl.mesa        
Copyright c 1984, 1987 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, August 29, 1984 10:03:32 am PDT 
last edited by Christian Jacobi, June 16, 1987 5:07:08 pm PDT
CDVScale

--given the grid, offset and nscale; makes a correctly gridded and initialized CDVScale.ScaleRec
--explanation of crazy scaling procedure for ScaleViewerToDesign
--v * scale + offset         :: ideal
--v* s1/s2 + offset          :: integer arithmetic
--(v*s1 + s2/2) / s2 + offset  :: correct round of screen point
--( (v*s1 + s2/2) / s2)  + grid/2) / grid * grid + offset  :: introduce grid
--(v*s1 + s2/2 + grid/2*s2 ) / s2 / grid * grid + offset  
--(v*s1 + s2/2 + grid/2*s2 ) / (s2*grid) * grid + offset

--given the index of the (high-most) pixel in the viewer, compute an outside clipping 
--rectangle in design coordinates; (such that all outside the clipping area is invisible).


Set and Get procs
Speed is not so important

More drawing behaviours
This needs to be fast
--Catches all errors and signals!
--Called by the viewer paintproc of ChipNDale-design viewers only.
--then check if we know the type of key
More TIP notifier behaviour
This needs to be fast

--invert the order: efficiency hack: the first installed cursor is found the fastest
--error catch



CDColors
-- {bw, bit1, bit2, bit4, bit8, bit9}; 
-- {normal, pushedOut}; 
-- RECORD; 
-- 	bricks: ARRAY CD.Layer OF REF Brick; 
-- 	cols: ARRAY CD.Layer OF Imager.Color; 
-- ARRAY DisplayMode OF REF ColorTable;
-- ARRAY DisplayType OF REF ColorTableSet;
--make the abstract color win if it exists...
--check special case
--always


Κq˜
codeš
œ!™!Kšœ
Οm
œ7™BKš
œ=™=Kš
œ=™=K˜—š
Οk	˜	Kš
œ	˜	Kšœž
˜Kš
œ˜Kšžœ
˜Kš
œ
˜
Kš
œ˜Kš
œ˜Jš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ	˜	Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜—K˜šΟnœžœ
ž˜#Kšžœ†
˜
Kšžœ7˜>—Kš
ž˜K˜Jš
Πlx™J™šŸ	œžœ
žœžœ7žœžœ˜„
Kš
Οc`™`Kš
‘@™@Kš
‘%™%Kš
‘2™2Kš
‘?™?Kš
‘L™LKš
‘:™:Kš
‘8™8Kšœžœ
˜Kš
œ)˜)šœžœžœ
žœ‘˜BK˜F—šœžœžœ
žœ‘˜CK˜Y—šœžœžœ
žœ‘˜=K˜G—Kšœ‘+˜>Kšœ	žœ
˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜šžœ*žœ˜2Kš
œ
˜
Kš
œ˜K˜
—šžœ˜Kš
œ˜Kš
œ"˜"K˜—Kš
œ˜—J™šŸ
œžœ
žœ)žœžœžœ
˜bKš
‘V™VKš
‘Z™ZK˜šŸœžœžœ
žœžœžœžœ˜oKš	œžœžœžœ
žœ˜8Kšžœžœžœ	˜3Kš
œ˜—K˜šžœžœ˜Kš
œ8˜8Kš
œ8˜8Kš
œ>˜>Kš
œ>˜>Kš
œ
˜
—Kš
œ˜—J™J™Jš
 ™˜K™—K™Jš
œ;˜;Jšœž
œ˜;J˜šŸœžœ
žœžœ"˜GJšžœ
žœžœ
˜Jšœžœžœžœ
žœ
žœ
žœ
žœ˜EJšžœžœ
žœ‘-˜MJš
œ&˜&Jš
œ˜—J˜šŸœžœ
žœžœ"˜GJšžœ
žœžœ
˜Jšœžœžœžœ
žœ
žœ
žœ
žœ˜EJšžœžœ
žœ‘-˜MJš
œ&˜&Jš
œ˜—J˜šΟbœžœ˜-šžœ(žœ
ž˜7Jšœžœžœ˜7Jšžœžœžœ˜—J˜—J˜š’œžœ˜-šžœ(žœ
ž˜7Jšœžœ7˜>Jšžœžœ
˜—J˜—K˜Kš
 ™˜Kš
œ™—K˜Kšœ
žœžœ>˜YKšœžœ
žœ
žœ˜)Kš
œ-˜-K˜š
Ÿœžœ
žœ;žœ
žœ.˜
Kšžœžœ
žœ
ž˜šžœ
žœ
žœ
˜Kšœ+žœ)˜W—Kšžœ
žœžœžœ"žœ
ž˜`šžœ
˜Kšœžœ
žœ=˜Q—Kš
œ˜—K˜šŸœžœ
žœžœ˜@Kš
œ!™!K™Bšžœžœ˜ Kšžœžœžœ
žœ˜E—Kšœžœ˜šžœžœ
ž˜Kšœžœ%˜-Kšžœžœ
˜—šžœ&žœ
ž˜5Kšœžœ7˜=šžœžœ˜Kš
œ'™'Kš
œA˜Aš
žœžœ
žœ
žœ$žœžœ
ž˜Jšžœžœ˜Kš
œ˜Kš
ž˜K˜
—Kšžœ
˜—K˜
——Kšžœ	ž˜Kš
œ˜—J˜Jš
 ™˜Kš
œ™—K™Kšœžœžœžœ,˜RKšœžœžœ
žœ˜(Kšœžœ
˜K˜š
Ÿœžœ
žœ
žœžœ/˜`Kšžœ
žœžœ
˜Kšžœžœ
žœ
žœ
žœ
žœ
žœ	˜.Kšžœžœ
žœžœ&˜Nš
ž˜Kš
‘T™Tšžœ*ž˜/Kšžœžœžœ
˜;Kšžœ
žœžœ
žœžœ(žœ
˜YKš
ž˜——Kš
œ˜—K˜šŸœžœ
žœžœ˜Bšžœžœ˜!Kšžœžœžœ
žœ˜RK˜—šžœ*žœžœ
ž˜>Kšžœžœžœ
˜@Kšžœ
˜—Kš
‘
™
Kšœžœ˜Kšžœ	žœ
˜Kš
œ˜—J™KšΠbnœžœ˜0K˜š£œ(˜9Kš
œ+˜+Kš
œ˜—J™J™Jš
 ™J˜šœ
žœ˜)Jš
œ'™'—šœ
žœ˜)Jš
œ™—šœžœ˜Jš
‘˜—šœžœ˜'Jšœžœ™Jš
œ)™)Jš
œ*™*—šœžœ˜-Jš
œ'™'—šœžœ˜1Jš
œ*™*—J˜Jšœžœ
žœžœžœ
žœ˜KJšœžœ	žœžœ˜*Jšœžœ	žœžœ
žœ
žœ˜6J˜Jš	œžœ
žœžœ
žœ˜?Jš	œžœ
žœžœ
žœ˜;K˜Kšœžœ
˜J˜KšŸœžœ
žœžœ
˜)K˜šŸœžœ
žœžœ˜<Kšžœžœ
žœ
žœ˜+Kš
œQ˜QKšžœžœ
žœžœ)˜@Kš
œ˜K˜—š
Ÿœžœ
žœ	žœžœ˜NKšžœ
žœžœ
žœ
žœ
žœ˜8Kš
œ˜Kšžœžœ
žœžœ.˜EK˜—K˜šŸ	œžœ	žœžœ˜AKšžœžœ
žœ
žœ˜EKš
œD˜DK˜K˜—šŸ
œžœ	žœžœ˜BKšžœžœ
žœ
žœ˜=Kš
œ
˜
K˜—K˜š
Ÿ	œžœžœžœžœ˜5Kšœžœžœ˜,Kšžœ)žœžœ
žœžœ žœ˜zKš
œ˜K˜—šŸœžœžœžœ˜5šœžœ˜Jš
œžœ
žœ
žœžœ
žœ	žœ˜;Jš	œžœ
žœžœ
žœ˜+Jšœžœ
žœ
žœžœžœ˜=Jš
œ˜—Jšœ
žœžœ
˜&Jš
œ˜—J˜š
Ÿœžœ	žœ(žœžœ˜dKšžœžœ
žœ˜'šžœžœ
žœ˜šžœžœ˜Kšžœžœ‘,˜PKšžœ
žœžœ‘/˜ZK˜—šžœžœ
žœ˜Kšœžœžœ
žœ˜/Kš
œ'˜'Kš
œ*˜*K˜—K˜—Jš
œ˜K˜—J˜šŸœžœ
žœ	žœžœ	žœ‘œ@žœžœ‘œ˜ί
Kšœžœ(˜0Kšžœžœ
žœ˜#Kšžœ
žœžœ‘#˜TKšžœ
žœžœ˜3Kš
œ ˜ Kš
œ)˜)Kšžœžœ
žœ+˜LKšœ0žœ
˜4šžœ
žœ
˜Kš
œ%˜%Kš
œ3˜3Kš
œ7˜7K˜—Kš
œ˜—J˜šŸœžœ
žœ	žœžœBžœžœ‘œ˜Β
Kšœžœ(˜0Kš
œ1˜1Kš
‘-™-Kšžœ
žœ
žœ˜$Kš
‘™šžœ
žœ
žœžœ
žœžœ
žœ#žœ˜`Kšœžœ!˜'šžœžœ
žœžœžœžœ˜9Kšœžœžœ˜šžœžœ˜š
œA˜AKšœžœ˜Kš
œ˜Kš
œ˜K˜—K˜
—K˜
—K˜—Kš
‘™Kš
œ˜Kšœžœ
˜"šžœ
žœ˜Kš
œ!˜!Kšœ#žœ
˜'K˜
—Kš
œ˜—K˜Jšœ(žœ˜;Jš
œ)˜)Jš
œ,˜,JšœTžœ˜gJš
œ+˜+Jš
œ.˜.J™J™Kšœžœ˜-Kšžœ˜K˜K˜K˜—…—(ζ=Η