DIRECTORY
Ascii,
Atom,
CD,
CDBasics,
CDCells,
CDCommandOps,
CDErrors,
CDExtras,
CDInstances,
CDMenus,
CDProperties,
CDSequencer,
CDSymbolicObjects,
CDTexts,
CDOps,
IO,
Rope,
TerminalIO;

CDPCommands: CEDAR PROGRAM
IMPORTS Ascii, Atom, CDBasics, CDCells, CDCommandOps, CDErrors, CDExtras, CDInstances, CDMenus, CDProperties, CDSequencer, CDSymbolicObjects, CDTexts, CDOps, IO, Rope, TerminalIO =
BEGIN 

PropertyRec: TYPE = RECORD [key: ATOM_NIL, value: REF_NIL, onOb: BOOL_FALSE];

PutPropFromPropertyRec: PROC [inst: CD.Instance, prop: PropertyRec] =
BEGIN
IF prop.onOb THEN { 
IF inst.ob.class.inDirectory THEN 
CDProperties.PutProp[onto: inst.ob, prop: prop.key, val: prop.value]
}
ELSE CDProperties.PutProp[onto: inst, prop: prop.key, val: prop.value]
END;

SetPropsFromTextsComm: PROC [comm: CDSequencer.Command] =
BEGIN
n, m: INT;
TerminalIO.WriteRope["propertize all texts"];
n _ SetPropsFromTexts[comm.design];
TerminalIO.WriteRope[";  now check\n"];
m _ CheckProps[comm.design, NIL];
TerminalIO.WriteF["  %g texts propertized; %g mismatch(es) found\n", IO.int[n], IO.int[m]];
END;

PutPropOnSelectedComm: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["propertize selected\n"];
PutPropOnSelected[comm.design];
TerminalIO.WriteRope["  end\n"];
END;

CheckPropsFromTextsComm: PROC [comm: CDSequencer.Command] =
BEGIN
n: INT;
TerminalIO.WriteRope["check properties\n"];
n _ CheckProps[comm.design, NIL];
TerminalIO.WriteF["  %g unmatched text(s) found\n", IO.int[n]];
END;

CellCheckPropsComm: PROC [comm: CDSequencer.Command] =
BEGIN
inst: CD.Instance _ CDCommandOps.TheInstance[comm: comm, text: "check properties"];
IF inst#NIL THEN {
no: INT _ 0;
IF ~CDCells.IsCell[inst.ob] THEN {
TerminalIO.WriteRope["  not done: selected object is not cell\n"];
RETURN;
};
no _ CheckProps[comm.design, inst.ob];
TerminalIO.WriteF["  %g unmatched text(s) found\n", IO.int[no]];
};
END;

SimilarRopes: PROC [x, y: REF] RETURNS [BOOL_FALSE] = {
IF x=y THEN RETURN [TRUE];
IF ISTYPE[x, Rope.ROPE] AND ISTYPE[y, Rope.ROPE] THEN {
RETURN [ Rope.Equal[ NARROW[x, Rope.ROPE], NARROW[y, Rope.ROPE] ] ]
};
};

SelectFromPropertyComm: PROC [comm: CDSequencer.Command] =
BEGIN
pRec: PropertyRec _ [$SignalName, NIL, FALSE];
inst: CD.Instance _ CDCommandOps.TheInstance[comm: comm, text: "select from property"];
IF inst#NIL THEN {
design: CD.Design _ comm.design;
no: INT _ 0;
IF MyKindOfText[inst.ob] THEN pRec _ TextToPropRec[inst.ob]
ELSE IF inst.ob.class.wireTyped OR CDSymbolicObjects.IsSymbolicOb[inst.ob] THEN {
pRec.key _ $SignalName;
pRec.value _ CDProperties.GetProp[from: inst, prop: pRec.key];
}
ELSE {
TerminalIO.WriteRope["  not done: selected object is not text (Helvetica*I) or rectangle\n"];
RETURN;
};
IF pRec.key=NIL THEN {
TerminalIO.WriteRope["  not done: property key is NIL\n"];
RETURN;
};
TerminalIO.WriteF["  select using property: %g, value: %g\n", IO.atom[pRec.key], IO.rope[(IF pRec.value=NIL THEN "NIL" ELSE CDExtras.ToRope[pRec.value])]];
FOR l: CD.InstanceList _ CDOps.InstList[design], l.rest WHILE l#NIL DO
x: REF _ CDProperties.GetProp[l.first, pRec.key];
IF SimilarRopes[x, pRec.value] THEN {
l.first.selected _ TRUE;
CDCommandOps.RedrawInstance[design, l.first, FALSE];
no _ no+1
};
ENDLOOP;
IF no>0 AND CDTexts.IsText[inst.ob] THEN {
inst.selected _ FALSE;
CDCommandOps.RedrawInstance[design, inst];
};
TerminalIO.WriteF["  %g instance(s) selected\n", IO.int[no]];
};
END;

PropagateSignalNameComm: PROC [comm: CDSequencer.Command] =
BEGIN
inst: CD.Instance _ CDCommandOps.TheInstance[comm: comm, text: "propagate signal name"];
IF inst#NIL THEN {
design: CD.Design _ comm.design;
il: CD.InstanceList _ CDOps.InstList[design];
foundL: CD.InstanceList _ LIST[inst];
no: INT _ 1;
value: REF _ CDProperties.GetProp[from: inst, prop: $SignalName];
IF value=NIL THEN {
TerminalIO.WriteRope["  not done: no signal name\n"];
RETURN;
};
WHILE foundL#NIL DO
curr: CD.Instance _ foundL.first;
currR: CD.Rect _ CDInstances.InstRectI[curr];
foundL _ foundL.rest;
FOR l: CD.InstanceList _ il, l.rest WHILE l#NIL DO
IF ~l.first.selected AND l.first.ob.class.wireTyped AND l.first.ob.layer=curr.ob.layer THEN {
IF CDBasics.Intersect[currR, CDInstances.InstRectI[l.first]] THEN {
foundL _ CONS[l.first, foundL];
l.first.selected _ TRUE;
no _ no+1;
CDProperties.PutProp[l.first, $SignalName, value];
CDCommandOps.RedrawInstance[design, l.first, FALSE];
};
}
ENDLOOP;
ENDLOOP;
TerminalIO.WriteF["  %g instance(s) selected\n", IO.int[no]];
};
END;

SetPropsFromTexts: PROC [design: CD.Design] RETURNS [n: INT_0] =
BEGIN

HandleOneText: PROC [inst: CD.Instance, design: CD.Design] RETURNS [someFound: BOOL_FALSE] =
BEGIN
IF MyKindOfText[inst.ob] THEN {
pRec: PropertyRec _ TextToPropRec[inst.ob];
r: CD.Rect _ CDInstances.InstRectI[inst];
IF pRec.key=NIL OR ~PublicProperty[pRec.key] THEN RETURN;
FOR l: CD.InstanceList _ CDOps.InstList[design], l.rest WHILE l#NIL DO
IF ~CDTexts.IsText[l.first.ob] AND CDBasics.Intersect[r, CDInstances.InstRectI[l.first]] THEN {
someFound _ TRUE;
PutPropFromPropertyRec[l.first, pRec]
}
ENDLOOP;
}
END;

FOR l: CD.InstanceList _ CDOps.InstList[design], l.rest WHILE l#NIL DO
IF MyKindOfText[l.first.ob] THEN 
IF HandleOneText[l.first, design].someFound THEN n _ n+1;
ENDLOOP;
END;


TextToPropRec: PROC [ob: CD.Object] RETURNS [pRec: PropertyRec _ [NIL, NIL, FALSE]] =
BEGIN

RopeToPropRec: PROC [text: Rope.ROPE] RETURNS [pRec: PropertyRec _ [$SignalName, NIL, FALSE]] =
BEGIN
keyPart: Rope.ROPE;
val: Rope.ROPE;
n: INT _ Rope.SkipTo[s: text, skip: ":"];
IF n<Rope.Length[text] THEN { 
keyPart _ RemoveBlanksFromBothEnds[Rope.Substr[base: text, start: 0, len: n]];
text _ Rope.Substr[base: text, start: n+1];
IF Rope.Length[keyPart]=0 THEN pRec.key _ NIL 
ELSE pRec.key _ Atom.MakeAtom[keyPart];
};
val _ RemoveBlanksFromBothEnds[text];
IF ~Rope.IsEmpty[val] THEN pRec.value _ val
END;

TextRope: PROC [ob: CD.Object] RETURNS [r: Rope.ROPE_NIL] = 
BEGIN
WITH ob.specificRef SELECT FROM
tp: CDTexts.TextPtr => RETURN [tp.text] 
ENDCASE => NULL;
END;
RETURN [RopeToPropRec[TextRope[ob]]] 
END;


MyKindOfText: PROC [ob: CD.Object] RETURNS [BOOL_FALSE] =
BEGIN

ThatIsMyFont: PROC [name: Rope.ROPE] RETURNS [BOOL] = 
BEGIN
RETURN [ 
Rope.Match[object: name, pattern: "Xerox/TiogaFonts/Helvetica*", case: FALSE] AND
Ascii.Upper[Rope.Fetch[name, Rope.Length[name]-1]]='I
] 
END;
WITH ob.specificRef SELECT FROM
tp: CDTexts.TextPtr => RETURN [ThatIsMyFont[tp.cdFont.supposedName]] 
ENDCASE => NULL;
END;


PutPropOnSelected: PROC [design: CD.Design] =
BEGIN

Occurs: PROC [list: LIST OF PropertyRec, key: ATOM] RETURNS [BOOL_FALSE] =
BEGIN
FOR pl: LIST OF PropertyRec _ list, pl.rest WHILE pl#NIL DO
IF pl.first.key=key THEN RETURN [TRUE]
ENDLOOP;
END;
doList: LIST OF PropertyRec_NIL;
FOR l: CD.InstanceList _ CDOps.InstList[design], l.rest WHILE l#NIL DO
IF l.first.selected AND MyKindOfText[l.first.ob] THEN {
pr: PropertyRec _ TextToPropRec[l.first.ob];
IF pr.key=NIL THEN {
TerminalIO.WriteRope["unknown property\n"];
[] _ CDErrors.IncludeMessage[design: design, ob: NIL, rect: CDInstances.InstRectI[l.first], message: "bad property key", owner: $PropertyChecker]
}
ELSE IF Occurs[doList, pr.key] THEN {
TerminalIO.WriteF["  ** property: %g, value: %g twice or contradicting! ignored\n", IO.atom[pr.key], IO.rope[(IF pr.value=NIL THEN "NIL" ELSE CDExtras.ToRope[pr.value])]]
} 
ELSE {
doList _ CONS[pr, doList];
TerminalIO.WriteF["  property: %g, value: %g\n", IO.atom[pr.key], IO.rope[(IF pr.value=NIL THEN "NIL" ELSE CDExtras.ToRope[pr.value])]];
}
}
ENDLOOP;
IF doList=NIL THEN TerminalIO.WriteRope["no text (in Helvetica*I) selected"]
ELSE {
FOR il: CD.InstanceList _ CDOps.InstList[design], il.rest WHILE il#NIL DO
IF il.first.selected AND ~CDTexts.IsText[il.first.ob] THEN {
FOR pl: LIST OF PropertyRec _ doList, pl.rest WHILE pl#NIL DO
PutPropFromPropertyRec[il.first, pl.first]
ENDLOOP;
}
ENDLOOP;
}
END;


CheckProps: PROC [design: CD.Design, cell: CD.Object] RETURNS [cnt: INT_0] =
BEGIN

BlownIntersection: PROC [r1, r2: CD.Rect, blow: CD.Number]  RETURNS [CD.Rect] = {
RETURN [ CDBasics.Intersection[CDBasics.Extend[r1, blow], CDBasics.Extend[r2, blow]] ];
};

CheckPropsOfOneText: PROC [inst: CD.Instance, design: CD.Design, cell: CD.Object] RETURNS [ok: BOOL_TRUE] =
BEGIN
IF MyKindOfText[inst.ob] THEN {
r: CD.Rect _ CDInstances.InstRectI[inst];
pRec: PropertyRec _ TextToPropRec[inst.ob];
cellPtr: CD.CellPtr _ IF cell=NIL THEN design.actual.first.specific ELSE NARROW[cell.specificRef];
val: REF;
IF pRec.key=NIL THEN RETURN;
FOR l: CD.InstanceList _ cellPtr.contents, l.rest WHILE l#NIL DO
IF ~CDTexts.IsText[l.first.ob] AND CDBasics.Intersect[r, CDInstances.InstRectI[l.first]] THEN {
IF pRec.onOb THEN  val _ CDProperties.GetProp[from: l.first.ob, prop: pRec.key]
ELSE val _ CDProperties.GetProp[from: l.first, prop: pRec.key];
IF ~SimilarRopes[val, pRec.value] THEN {
errR: CD.Rect _ BlownIntersection[r, CDInstances.InstRectI[l.first], design.technology.lambda];
[] _ CDErrors.IncludeMessage[design: design, ob: cell, rect: r, message: "property missmatch", owner: $PropertyChecker];
RETURN [ok_FALSE]
}
};
ENDLOOP;
}
END;
cellPtr: CD.CellPtr _ IF cell=NIL THEN design.actual.first.specific ELSE NARROW[cell.specificRef];
CDErrors.RemoveMessages[design: design, ob: cell, owner: $PropertyChecker];
FOR l: CD.InstanceList _ cellPtr.contents, l.rest WHILE l#NIL DO
IF CDTexts.IsText[l.first.ob] THEN 
IF ~CheckPropsOfOneText[inst: l.first, design: design, cell: cell] THEN cnt _ cnt+1
ENDLOOP;
END;

PublicProperty: PROC [key: ATOM] RETURNS [BOOL_TRUE] = {
pType: CDProperties.PropertyProcs _ CDProperties.FetchProcs[key];
RETURN [ pType=NIL OR ~pType.exclusive ];
};

RemoveTrailingBlanks: PROC [r: Rope.ROPE] RETURNS [Rope.ROPE] = {
n: INT _ Rope.Length[r];
WHILE n>0 AND Rope.Fetch[r, n-1]='  DO n _ n-1 ENDLOOP;
RETURN [Rope.Substr[base: r, start: 0, len: n]];
};

RemoveLeadingBlanks: PROC [r: Rope.ROPE] RETURNS [Rope.ROPE] = {
RETURN [Rope.Substr[base: r, start: Rope.SkipOver[s: r, skip: " "]]]
};

RemoveBlanksFromBothEnds: PROC [r: Rope.ROPE] RETURNS [Rope.ROPE] = {
RETURN [RemoveLeadingBlanks[RemoveTrailingBlanks[r]]]
};

CDSequencer.ImplementCommand[a: $AllPropertize, p: SetPropsFromTextsComm, queue: doQueue];
CDSequencer.ImplementCommand[a: $SelPropertize, p: PutPropOnSelectedComm, queue: doQueue];
CDSequencer.ImplementCommand[a: $PropSel, p: SelectFromPropertyComm, queue: doQueue];
CDSequencer.ImplementCommand[a: $PropTextCheckCell, p: CellCheckPropsComm, queue: doQueue];
CDSequencer.ImplementCommand[a: $PropTextCheck, p: CheckPropsFromTextsComm, queue: doQueue];
CDSequencer.ImplementCommand[a: $PropSig, p: PropagateSignalNameComm, queue: doQueue];

[] _ CDMenus.CreateMenu["Names & Properties", $NameMenu];
CDMenus.ImplementMenuCommand[$NameMenu, $NameMenu];

CDMenus.CreateEntry[menu: $NameMenu, entry: "properties from intersecting Texts", key: $AllPropertize];
CDMenus.CreateEntry[menu: $NameMenu, entry: "propertize selected from Text(s)", key: $SelPropertize];
CDMenus.CreateEntry[menu: $NameMenu, entry: "select all having property (Text)", key: $PropSel];
CDMenus.CreateEntry[menu: $NameMenu, entry: "check properties (top level)", key: $PropTextCheck];
CDMenus.CreateEntry[menu: $NameMenu, entry: "check properties (selected CELL)", key: $PropTextCheckCell];
CDMenus.CreateEntry[menu: $NameMenu, entry: "propagate SignalName of selected", key: $PropSig];
CDMenus.CreateEntry[menu: $NameMenu, entry: "other entries", key: $NameMenu2];
END.

lCDPCommands.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
by Ch. Jacobi, November 20, 1985 7:59:40 pm PST
Last Edited by: Jacobi, November 26, 1985 11:07:31 am PST
--SetPropsFromTexts
--key nil means bad syntax

--TextToPropRec

--MyKindOfText

--PutPropOnSelected
--build list of properties
-- put properties on instances

--CheckProps
Κ€
code˜š
œ™Jšœ
Οm
œ1™<Kš
œ/™/Kš
œ9™9—š
Ο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š
œ
žœžœžœ	žœžœ
žœ˜MK˜šΟnœžœžœ˜EKš
ž˜šžœžœ˜šžœžœ
˜"Kš
œD˜D—K˜
—KšžœB˜FKšžœ
˜—K˜š œžœ˜9Kš
ž˜Kšœžœ
˜
Kš
œ-˜-Kš
œ#˜#Kš
œ'˜'Kš
œ!˜!KšœEžœ	žœ	˜[Kšžœ
˜—K˜š œžœ˜9Kš
ž˜Kš
œ.˜.Kš
œ˜Kš
œ ˜ Kšžœ
˜—K˜š œžœ˜;Kš
ž˜Kšœžœ
˜Kš
œ+˜+Kšœžœ˜!Kšœ4žœ	˜?Kšžœ
˜—K˜š œžœ˜6Kš
ž˜KšœžœK˜Sšžœžœ
žœ˜Kšœžœ˜šžœžœ˜"Kš
œB˜BKšžœ
˜K˜—Kš
œ&˜&Kšœ4žœ
˜@Kš
œ˜—Kšžœ
˜—K˜š œžœžœžœžœ
žœ˜7Kšžœžœ
žœžœ˜šžœ
žœ	žœžœ
žœ	žœžœ˜7Kš
žœžœ	žœžœ	žœ˜CK˜—Kš
œ˜—K˜š œžœ˜:Kš
ž˜Kšœ"žœžœ˜.KšœžœO˜Wšžœžœ
žœ˜Kšœžœ˜ Kšœžœ˜Kšžœžœ˜;šžœ
žœžœ)žœ˜QKš
œ˜Kš
œ>˜>K˜
—šžœ˜Kš
œ]˜]Kšžœ
˜K˜—šžœ
žœ
žœ˜Kš
œ:˜:Kšžœ
˜K˜—Kš
œ>žœžœžœžœ
žœžœ ˜›
š	žœžœ/žœžœ
ž˜FKšœžœ+˜1šžœžœ˜%Kšœžœ
˜Kšœ-žœ˜4Kš
œ	˜	Kš
œ˜—Kšžœ
˜—šžœžœžœ˜*Kšœžœ
˜Kš
œ*˜*K˜—Kšœ1žœ
˜=Kš
œ˜—Kšžœ
˜—K˜š œžœ˜;Kš
ž˜KšœžœP˜Xšžœžœ
žœ˜Kšœžœ˜ Kšœžœ'˜-Kšœžœžœ˜%Kšœžœ˜Kšœžœ7˜Ašžœžœ
žœ˜Kš
œ5˜5Kšžœ
˜K˜—šžœžœ
ž˜Kšœžœ˜!Kš
œ-˜-Kš
œ˜š	žœžœžœžœ
ž˜2šžœžœžœ žœ˜]šžœ;žœ˜CKšœ	žœ˜Kšœžœ
˜Kš
œ
˜
Kš
œ2˜2Kšœ-žœ˜4K˜—K˜
—Kšžœ
˜—Kšžœ
˜—Kšœ1žœ
˜=Kš
œ˜—Kšžœ
˜—K˜š
 œžœ
žœ	žœžœ˜@Kš
ž˜K˜š 
œžœžœžœ	žœ
žœ
žœ˜\Kš
ž˜šžœžœ˜Kš
œ+˜+Kšœžœ$˜)Kš
žœ
žœ
žœžœ
žœ
˜9š	žœžœ/žœžœ
ž˜Fšžœžœ7žœ˜_Kšœžœ
˜Kš
œ%˜%K˜
—Kšžœ
˜—Kš
œ
˜
—Kšžœ˜—Kš
œ™š	žœžœ/žœžœ
ž˜Fšžœžœ
˜!Kšžœ*žœ	˜9—Kšžœ
˜—Kšžœ
˜—K˜K˜š 
œžœžœ	žœžœžœžœ˜UKš
ž˜K˜š 
œžœ
žœžœ$žœžœ˜_Kš
œ™Kš
ž˜Kšœžœ
˜Kšœ
žœ
˜Kšœžœ#˜)šžœžœ˜Kš
œN˜NKš
œ+˜+Kšžœžœžœ
˜.Kšžœ#˜'K˜—Kš
œ%˜%Kšžœžœ˜+Kšžœ
˜—K˜š œžœžœ	žœ
žœ
žœ˜<Kš
ž˜šžœžœ
ž˜Kšœžœ˜(Kšžœžœ
˜—Kšžœ
˜—K™Kš
œ™Kšžœ˜%Kšžœ
˜—K˜K˜š œžœžœ	žœžœ
žœ˜9Kš
ž˜K˜š
 œžœ
žœžœžœ˜6Kš
ž˜šžœ˜	KšœGžœž˜QKš
œ5˜5Kš
œ˜—Kšžœ
˜—K™Kš
œ™šžœžœ
ž˜Kšœžœ(˜EKšžœžœ
˜—Kšžœ
˜—K˜K˜š œžœ
žœ
˜-Kš
ž˜K˜š œžœžœ
žœžœžœžœ
žœ˜JKš
ž˜šžœžœ
žœžœžœ
ž˜;Kšžœžœ
žœžœ
˜&Kšžœ
˜—Kšžœ
˜—K™Kš
œ™Kšœžœ
žœ
ž˜ Kš
œ™š	žœžœ/žœžœ
ž˜Fšžœžœžœ˜7Kš
œ,˜,šžœžœ
žœ˜Kš
œ+˜+Kšœ1žœ]˜‘
K˜
—šžœ
žœžœ˜%Kš
œTžœžœžœ
žœ
žœžœ˜ͺ
Kš
œ˜—šžœ˜Kšœ	žœ
˜Kš
œ1žœžœžœ
žœ
žœžœ˜ˆ
K˜
—K˜
—Kšžœ
˜—Kš
œ™Kšžœžœ
žœ:˜Lšžœ˜š	žœžœ0žœžœ
ž˜Išžœžœžœ˜<šžœžœ
žœžœžœ
ž˜=Kš
œ*˜*Kšžœ
˜—K˜
—Kšžœ
˜—K˜
—Kšžœ
˜—K˜K˜šΠbn
œžœ
žœžœ	žœžœ˜LKš
ž˜K˜š œžœ
žœ
žœ
žœžœ
˜QJšžœQ˜WK˜—K˜š œžœžœžœžœ	žœžœ
žœ˜kKš
ž˜šžœžœ˜Kšœžœ$˜)Kš
œ+˜+Kš
œ	žœžœžœ
žœžœ
žœ˜bKšœžœ
˜	Kšžœ
žœ
žœ
žœ
˜š	žœžœ)žœžœ
ž˜@šžœžœ7žœ˜_Kšžœžœ>˜OKšžœ;˜?šžœ žœ˜(KšœžœW˜_Jš
œx˜xKšžœžœ
˜K˜
—Kš
œ˜—Kšžœ
˜—Kš
œ
˜
—Kšžœ
˜—K™Kš
œ™Kš
œ	žœ	žœžœ
žœžœ
žœ˜bKš
œK˜Kš	žœžœ)žœžœ
ž˜@šžœžœ
˜#KšžœAžœ˜S—Kšžœ
˜—Kšžœ
˜—K˜š œžœžœžœžœ
žœ˜8Kš
œA˜AKšžœ	žœ
žœ˜)Kš
œ˜—K˜š
 œžœ
žœžœžœ˜AKšœžœ˜Kšžœžœžœ	žœ
˜7Kšžœ*˜0K˜—K˜š
 œžœ
žœžœžœ˜@Kšžœ>˜DK˜—K˜š
 œžœ
žœžœžœ˜EKšžœ/˜5K˜—K˜Kš
œZ˜ZKš
œZ˜ZKš
œU˜UKš
œ[˜[Kš
œ\˜\Kš
œV˜VK˜Kš
œ9˜9Kš
œ3˜3K˜Kš
œg˜gKš
œe˜eKš
œ`˜`Kš
œa˜aKš
œi˜iKš
œ_˜_Kš
œN˜NKšžœ
˜—…—,Έ<Θ