DIRECTORY FS, IO, List, OrderedSymbolTableRef, Rope, SchemeRep, SchemeEditing, ViewerOps, ViewerTools, ViewRec;

SchemeFiles: CEDAR PROGRAM
IMPORTS FS, IO, List, OrderedSymbolTableRef, Rope, SchemeEditing, ViewerOps, ViewerTools, ViewRec
EXPORTS SchemeEditing =

BEGIN OPEN SchemeRep, SchemeEditing;

writeCount: INT _ 0;

Clear: PUBLIC PROC [session: Session] =
BEGIN
ViewerTools.SetContents[viewer: session.typesMenu, contents: NIL];
FOR le: LIST OF Editor _ session.editors, le.rest WHILE le # NIL DO
ViewerOps.DestroyViewer[le.first.v];
ENDLOOP;
session.editors _ NIL;
session.mostRecentEditor _ NIL;
session.typesTable.DeleteAllItems[];
session.picsTable.DeleteAllItems[];
END;

ReadFile: PUBLIC PROC [session: Session, file: ROPE, additively: BOOLEAN _ TRUE] =
BEGIN ENABLE Collision => {session.ctlRV.DisplayMessage[IO.PutFR["Collision on CellType %g --- you lose", IO.rope[ct.name]]]; Clear[session]; CONTINUE};
in: IO.STREAM _ FS.StreamOpen[fileName: file];
IF NOT additively THEN Clear[session];
DO
[] _ in.SkipWhitespace[];
IF in.EndOf[] THEN EXIT;
ReadCellType[in, session];
ENDLOOP;
END;

Collision: ERROR [ct: CellType] = CODE;

ReadCellType: PROC [from: IO.STREAM, session: Session] =
BEGIN
cellTypeName: ROPE _ from.GetRopeLiteral[];
cellType: CellType _ NARROW[session.typesTable.Lookup[cellTypeName]];
IF cellType # NIL THEN ERROR Collision[cellType];
cellType _ NewCellType[session, cellTypeName, TRUE];
cellType.otherProps _ ReadPropList[from];
cellType.expansion _ ReadPictureDef[from, session];
WHILE NotDot[from] DO ReadIcon[from, session, cellType] ENDLOOP;
EatDot[from];
WHILE NotDot[from] DO ReadPort[from, session, cellType] ENDLOOP;
EatDot[from];
WHILE NotDot[from] DO ReadNet[from, session, cellType] ENDLOOP;
EatDot[from];
WHILE NotDot[from] DO ReadComponent[from, session, cellType] ENDLOOP;
EatDot[from];
END;

ReadIcon: PROC [from: IO.STREAM, session: Session, cellType: CellType] =
BEGIN
pic: PictureDef _ ReadPictureDef[from, session];
cellType.icons.Insert[pic];
END;

ReadPort: PROC [from: IO.STREAM, session: Session, cellType: CellType] =
BEGIN
portName: ROPE _ from.GetRopeLiteral[];
props: PropList _ ReadPropList[from];
pointName: ROPE _ from.GetRopeLiteral[];
labelFlag: ROPE _ from.GetRopeLiteral[];
port: Port _ CreatePort[cellType, portName, NARROW[cellType.expansion.points.Lookup[pointName]]];
port.otherProps _ props;
IF labelFlag.Equal["noLabel"] THEN NULL
ELSE IF labelFlag.Equal["label"] THEN
BEGIN
labelName: ROPE _ from.GetRopeLiteral[];
port.label _ NARROW[cellType.expansion.objects.Lookup[labelName]];
port.label.labelOf _ port;
END
ELSE ERROR;
END;

ReadNet: PROC [from: IO.STREAM, session: Session, cellType: CellType] =
BEGIN
name: ROPE _ from.GetRopeLiteral[];
props: PropList _ ReadPropList[from];
net: Net _ NEW [NetRep _ [name: name, otherProps: props]];
cellType.nets.Insert[net];
WHILE NotDot[from] DO
class: ROPE _ from.GetTokenRope[].token;
IF class.Equal["point"] THEN {name: ROPE _ from.GetRopeLiteral[];
point: Point _ NARROW[cellType.expansion.points.Lookup[name]];
net.stuff _ CONS[point, net.stuff]; point.net _ net}
ELSE IF class.Equal["line"] THEN {name: ROPE _ from.GetRopeLiteral[];
line: Line _ NARROW[cellType.expansion.objects.Lookup[name]];
net.stuff _ CONS[line, net.stuff]; line.net _ net}
ELSE IF class.Equal["text"] THEN {name: ROPE _ from.GetRopeLiteral[];
text: Text _ NARROW[cellType.expansion.objects.Lookup[name]];
net.stuff _ CONS[text, net.stuff]; text.labelOf _ net}
ELSE ERROR;
ENDLOOP;
END;

ReadComponent: PROC [from: IO.STREAM, session: Session, cellType: CellType] =
BEGIN
name: ROPE _ from.GetRopeLiteral[];
typeName: ROPE _ from.GetRopeLiteral[];
of: CellType _ NARROW[session.typesTable.Lookup[typeName]];
instName: ROPE _ from.GetRopeLiteral[];
inst: PictureInstance _ NARROW[cellType.expansion.objects.Lookup[instName]];
props: PropList _ ReadPropList[from];
comp: Component _ CreateComponent[in: cellType, of: of, name: name, inst: inst];
labelFlag: ROPE _ from.GetTokenRope[].token;
comp.otherProps _ props;
IF labelFlag.Equal["noLabel"] THEN NULL
ELSE IF labelFlag.Equal["label"] THEN comp.label _ NARROW[cellType.expansion.objects.Lookup[from.GetRopeLiteral[]]]
ELSE ERROR;
END;

ReadPictureDef: PROC [from: IO.STREAM, session: Session] RETURNS [pic: PictureDef] =
BEGIN
name: ROPE _ from.GetRopeLiteral[];
pic _ NewPicture[session, name];
WHILE NotDot[from] DO ReadCoord[from, pic] ENDLOOP; EatDot[from];
WHILE NotDot[from] DO ReadPoint[from, pic] ENDLOOP; EatDot[from];
WHILE NotDot[from] DO ReadObject[from, pic, session] ENDLOOP; EatDot[from];
END;

ReadCoord: PROC [from: IO.STREAM, pic: PictureDef] =
BEGIN
name, axisName, parentCode, parentName: ROPE;
axis: Axis;
z, dz: REAL;
parent: REF ANY;
exported: BOOLEAN;
name _ from.GetRopeLiteral[];
axisName _ from.GetTokenRope[].token;
IF axisName.Equal["X"] THEN axis _ X ELSE IF axisName.Equal["Y"] THEN axis _ Y ELSE ERROR;
exported _ from.GetBool[];
z _ from.GetReal[];
dz _ from.GetReal[];
parentCode _ from.GetTokenRope[].token;
parentName _ from.GetRopeLiteral[];
IF parentCode.Equal["n"] THEN parent _ NIL
ELSE IF parentCode.Equal["c"] THEN parent _ EnsureCoord[pic, parentName]
ELSE IF parentCode.Equal["p"] THEN parent _ EnsurePictureInstance[pic, parentName]
ELSE ERROR;
NewCoord[axis: axis, at: z, pic: pic, parent: parent, name: name].exported _ exported;
END;

EnsureCoord: PUBLIC PROC [pic: PictureDef, name: ROPE] RETURNS [coord: Coord] =
BEGIN
coord _ NARROW[pic.coordsByName.Lookup[name]];
IF coord = NIL THEN pic.coordsByName.Insert[coord _ NEW [CoordRep _ [name: name]]];
END;

EnsurePictureInstance: PUBLIC PROC [pic: PictureDef, name: ROPE] RETURNS [pi: PictureInstance] =
BEGIN
pi _ NARROW[pic.objects.Lookup[name]];
IF pi = NIL THEN pic.objects.Insert[pi _ NEW [PictureInstanceRep _ [name: name]]];
END;

ReadPoint: PROC [from: IO.STREAM, pic: PictureDef] =
BEGIN
name: ROPE _ from.GetRopeLiteral[];
xName: ROPE _ from.GetRopeLiteral[];
yName: ROPE _ from.GetRopeLiteral[];
exported: BOOLEAN _ from.GetBool[];
fromPort: ROPE _ from.GetRopeLiteral[];
piName: ROPE _ from.GetRopeLiteral[];
point: Point _ NewPoint[pic, name, [NARROW[pic.coordsByName.Lookup[xName]], NARROW[pic.coordsByName.Lookup[yName]]]];
point.exported _ exported;
point.fromPort _ fromPort;
IF piName.Length[] > 0 THEN point.fromPI _ EnsurePictureInstance[pic, piName];
END;

ReadObject: PROC [from: IO.STREAM, pic: PictureDef, session: Session] =
BEGIN
class: ROPE _ from.GetTokenRope[].token;
IF class.Equal["line"] THEN ReadLine[from, pic]
ELSE IF class.Equal["text"] THEN ReadText[from, pic]
ELSE IF class.Equal["pi"] THEN ReadPictureInstance[from, pic, session]
ELSE ERROR;
END;

ReadLine: PROC [from: IO.STREAM, pic: PictureDef] =
BEGIN
name: ROPE _ from.GetRopeLiteral[];
aName: ROPE _ from.GetRopeLiteral[];
bName: ROPE _ from.GetRopeLiteral[];
[] _ NewLine[pic, NARROW[pic.points.Lookup[aName]], NARROW[pic.points.Lookup[bName]]];
END;

ReadText: PROC [from: IO.STREAM, pic: PictureDef] =
BEGIN
name: ROPE _ from.GetRopeLiteral[];
orgName: ROPE _ from.GetRopeLiteral[];
rope: ROPE _ from.GetRopeLiteral[];
NewText[pic, NARROW[pic.points.Lookup[orgName]], rope];
END;

ReadPictureInstance: PROC [from: IO.STREAM, pic: PictureDef, session: Session] =
BEGIN
name: ROPE _ from.GetRopeLiteral[];
orgName: ROPE _ from.GetRopeLiteral[];
defName: ROPE _ from.GetRopeLiteral[];
def: PictureDef _ NARROW[session.picsTable.Lookup[defName]];
pi: PictureInstance _ CreateInstance[in: pic, of: def, org: NARROW[pic.points.Lookup[orgName]]];
WHILE NotDot[from] DO
cName: ROPE _ from.GetRopeLiteral[];
x: REF ANY _ pic.coordsByName.Lookup[cName];
pi.coords.Insert[x];
ENDLOOP;
EatDot[from];
WHILE NotDot[from] DO
pName: ROPE _ from.GetRopeLiteral[];
x: REF ANY _ pic.points.Lookup[pName];
pi.points.Insert[x];
ENDLOOP;
EatDot[from];
END;

ReadPropList: PROC [from: IO.STREAM] RETURNS [propList: PropList] =
BEGIN
propList _ NIL;
WHILE NotDot[from] DO
key, value: REF ANY;
key _ from.GetRefAny[];
value _ from.GetRefAny[];
propList _ List.PutAssoc[key: propList, val: value, aList: propList];
ENDLOOP;
EatDot[from];
END;

NotDot: PROC [from: IO.STREAM] RETURNS [not: BOOLEAN] =
{[] _ from.SkipWhitespace[];
not _ from.PeekChar[] # '.};

EatDot: PROC [from: IO.STREAM] = {
char: CHAR _ from.GetChar[];
IF char # '. THEN ERROR};

WriteFile: PUBLIC PROC [session: Session, file: ROPE] =
BEGIN
EnsureWritten: PROC [any: REF ANY] RETURNS [stop: BOOLEAN] =
BEGIN
stop _ FALSE;
WITH any SELECT FROM
cellType: CellType => {
IF cellType.writtenFor = thisWrite THEN RETURN;
cellType.components.EnumerateIncreasing[EnsureWritten];
WriteCellType[out, cellType]};
comp: Component => [] _ EnsureWritten[comp.type];
ENDCASE => ERROR;
END;
out: IO.STREAM _ FS.StreamOpen[fileName: file, accessOptions: create];
thisWrite: INT _ writeCount _ writeCount + 1;
session.typesTable.EnumerateIncreasing[EnsureWritten];
out.Close[];
END;

WriteCellType: PROC [to: IO.STREAM, cellType: CellType] =
BEGIN
WriteIcon: PROC [any: REF ANY] RETURNS [stop: BOOLEAN] =
BEGIN
pic: PictureDef _ NARROW[any];
stop _ FALSE;
WritePictureDef[to, pic];
END;
WritePort: PROC [any: REF ANY] RETURNS [stop: BOOLEAN] =
{port: Port _ NARROW[any];
stop _ FALSE;
to.PutF[" \"%q\"", IO.rope[port.name]];
WritePropList[to, port.otherProps];
to.PutF[" \"%q\"", IO.rope[port.pt.name]];
IF port.label # NIL THEN to.PutF[" label \"%q\"", IO.rope[port.label.name]] ELSE to.PutRope[" noLabel"]};
WriteNet: PROC [any: REF ANY] RETURNS [stop: BOOLEAN] =
{net: Net _ NARROW[any];
stop _ FALSE;
IF net.eatenBy # NIL THEN ERROR;
to.PutF[" \"%q\"", IO.rope[net.name]];
WritePropList[to, net.otherProps];
FOR l: LORA _ net.stuff, l.rest WHILE l # NIL DO
WITH l.first SELECT FROM
point: Point => to.PutF[" point \"%q\"", IO.rope[point.name]];
line: Line => to.PutF[" line \"%q\"", IO.rope[line.name]];
label: Text => to.PutF[" text \"%q\"", IO.rope[label.name]];
ENDCASE => ERROR;
ENDLOOP;
to.PutRope[" ."]};
WriteComponent: PROC [any: REF ANY] RETURNS [stop: BOOLEAN] =
{component: Component _ NARROW[any];
stop _ FALSE;
to.PutF[" %g %g %g", IO.refAny[component.name], IO.refAny[component.type.name], IO.refAny[component.inst.name]];
WritePropList[to, component.otherProps];
IF component.label # NIL THEN to.PutF[" label \"%q\"", IO.rope[component.label.name]] ELSE to.PutRope[" noLabel"]};
to.PutF[" \"%q\"", IO.rope[cellType.name]];
WritePropList[to, cellType.otherProps];
WritePictureDef[to, cellType.expansion];
cellType.icons.EnumerateIncreasing[WriteIcon];
to.PutRope[" ."];
cellType.ports.EnumerateIncreasing[WritePort];
to.PutRope[" ."];
cellType.nets.EnumerateIncreasing[WriteNet];
to.PutRope[" ."];
cellType.components.EnumerateIncreasing[WriteComponent];
to.PutRope[" ."];
END;

axisNames: PUBLIC ARRAY Axis OF ROPE _ ["X", "Y"];

WritePictureDef: PROC [to: IO.STREAM, pic: PictureDef] =
BEGIN
WriteCoord: PROC [any: REF ANY] RETURNS [stop: BOOLEAN] =
{coord: Coord _ NARROW[any]; stop _ FALSE;
to.PutF[" %g %g %g %g %g", IO.refAny[coord.name], IO.rope[axisNames[coord.axis]], IO.bool[coord.exported], IO.real[coord.z], IO.real[coord.dz]];
IF coord.parent # NIL
THEN WITH coord.parent SELECT FROM
c: Coord => to.PutF[" c %g", IO.refAny[c.name]];
pi: PictureInstance => to.PutF[" p %g", IO.refAny[pi.name]];
ENDCASE => ERROR
ELSE to.PutRope[" n \"\""]};
WritePoint: PROC [any: REF ANY] RETURNS [stop: BOOLEAN] =
{point: Point _ NARROW[any];
stop _ FALSE;
to.PutF[" \"%q\" \"%q\" \"%q\" %g", IO.rope[point.name], IO.rope[point.c[X].name], IO.rope[point.c[Y].name], IO.bool[point.exported]];
to.PutF[" \"%q\" \"%q\"", IO.rope[point.fromPort], IO.rope[IF point.fromPI # NIL THEN point.fromPI.name ELSE NIL]]};
WriteObject: PROC [any: REF ANY] RETURNS [stop: BOOLEAN] =
{stop _ FALSE;
WITH any SELECT FROM
line: Line => to.PutF[" line \"%q\" \"%q\" \"%q\"", IO.rope[line.name], IO.rope[line.a.name], IO.rope[line.b.name]];
text: Text => to.PutF[" text \"%q\" \"%q\" \"%q\"", IO.rope[text.name], IO.rope[text.org.name], IO.rope[text.rope]];
pi: PictureInstance => {
to.PutF[" pi \"%q\" \"%q\" \"%q\"",
IO.rope[pi.name], IO.rope[pi.org.name], IO.rope[pi.of.name]];
pi.coords.EnumerateIncreasing[WritePIC];
to.PutRope[" ."];
pi.points.EnumerateIncreasing[WritePIP];
to.PutRope[" ."]};
ENDCASE => ERROR};
WritePIC: PROC [any: REF ANY] RETURNS [stop: BOOLEAN] =
{c: Coord _ NARROW[any]; stop _ FALSE;
to.PutF[" \"%q\"", IO.rope[c.name]]};
WritePIP: PROC [any: REF ANY] RETURNS [stop: BOOLEAN] =
{p: Point _ NARROW[any]; stop _ FALSE;
to.PutF[" \"%q\"", IO.rope[p.name]]};
to.PutF[" \"%q\"", IO.rope[pic.name]];
pic.coordsByName.EnumerateIncreasing[WriteCoord];
to.PutRope[" ."];
pic.points.EnumerateIncreasing[WritePoint];
to.PutRope[" ."];
pic.objects.EnumerateIncreasing[WriteObject];
to.PutRope[" ."];
END;

WritePropList: PROC [to: IO.STREAM, propList: PropList] =
BEGIN
FOR propList _ propList, propList.rest WHILE propList # NIL DO
to.PutF[" %g %g", IO.refAny[propList.first.key], IO.refAny[propList.first.val]];
ENDLOOP;
to.PutRope[" ."];
END;

END.

TScheme>SchemeFiles.Mesa
Last Edited by: Spreitzer, February 12, 1984 10:22 pm
ΚΒ˜Icode™Jš
œ5™5K˜KšΟk	œ
œœ_˜oK˜šΠbxœœ
˜Kšœ
œœS˜aKšœ˜—K˜Kšœ
˜$K˜Kšœœ˜K˜šΟnœœ
œ˜'Kš
˜Kšœ=œ˜Bšœœ
œ#œœ
˜CK˜$Kšœ
˜—Kšœœ
˜Kšœœ
˜K˜$K˜#Kšœ
˜—K˜šŸœœ
œœœœ˜RKš
œ
œ,œ0œ"œ˜˜
Kšœœ
œœ˜.Kšœ
œœ˜&š
˜K˜Kšœœ
œ
˜Kš
œ˜Kšœ
˜—Kšœ
˜—K˜Kšœœœ
˜'K˜šŸœœœ
œ˜8Kš
˜Kšœœ˜+Kšœœ*˜EKšœœ
œ
œ˜1Kšœ.œ˜4K˜)K˜3Kšœœ#œ
˜@J˜
Jšœœ#œ
˜@J˜
Kšœœ"œ
˜?J˜
Jšœœ(œ
˜EJ˜
Kšœ
˜—K˜šŸœœœ
œ)˜HKš
˜K˜0K˜Kšœ
˜—K˜šŸœœœ
œ)˜HKš
˜Kšœ
œ˜'K˜%Kšœœ˜(Kšœœ˜(Kšœ,œ/˜aK˜Kšœœ
˜'šœ
œ˜%Kš
˜Kšœœ˜(Kšœ
œ/˜BK˜Kš
˜—Kšœ
œ
˜Kšœ
˜—K˜šŸœœœ
œ)˜GKš
˜Kšœœ˜#K˜%Kšœœ,˜:K˜šœ˜Kšœœ˜(šœœœ˜AKšœœ)˜>Kšœœ$˜4—šœ
œœœ˜EKšœ
œ*˜=Kšœœ"˜2—šœ
œœœ˜EKšœ
œ*˜=Kšœœ&˜6—Kšœ
œ
˜Kšœ
˜—Kšœ
˜—K˜šŸ
œœœ
œ)˜MKš
˜Kšœœ˜#Kšœ
œ˜'Kšœœ&˜;Kšœ
œ˜'Kšœœ.˜LK˜%Kš
œP˜PKšœœ˜,K˜Kšœœ
˜'Kšœ
œœœ:˜sKšœ
œ
˜Kšœ
˜—K˜š
Ÿœœœ
œœ˜TKš
˜Kšœœ˜#K˜ Kšœœœ˜AKšœœœ˜AKšœœ œ˜KKšœ
˜—K˜šŸ	œœœ
œ˜4Kš
˜Kšœ(œ
˜-K˜Kšœœ
˜Kšœœ
œ
˜Kšœ
œ
˜K˜K˜%Kšœœ
œ
œ
œœ
œ
œ
œ
˜ZK˜K˜K˜K˜'K˜#Kšœœ
˜*Kšœ
œœ&˜HKšœ
œœ0˜RKšœ
œ
˜K˜VKšœ
˜—K˜š
Ÿœœ
œœœ˜OKš
˜Kšœœ ˜.Kšœ	œ
œ!œ˜SKšœ
˜—K˜š
Ÿœœ
œœœ˜`Kš
˜Kšœœ˜&Kšœœ
œœ&˜RKšœ
˜—K˜šŸ	œœœ
œ˜4Kš
˜Kšœœ˜#Kšœœ˜$Kšœœ˜$Kšœ
œ˜#Kšœ
œ˜'Kšœœ˜%Kšœ$œ"œ#˜uKš
œ˜K˜Kšœœ3˜NKšœ
˜—K˜šŸ
œœœ
œ&˜GKš
˜Kšœœ˜(Kšœœ˜/Kšœ
œœ˜4Kšœ
œœ(˜FKšœ
œ
˜Kšœ
˜—K˜šŸœœœ
œ˜3Kš
˜Kšœœ˜#Kšœœ˜$Kšœœ˜$Kšœœœ˜VKšœ
˜—K˜šŸœœœ
œ˜3Kš
˜Kšœœ˜#Kšœ	œ˜&Kšœœ˜#Kšœ
œ$˜7Kšœ
˜—K˜šŸœœœ
œ&˜PKš
˜Kšœœ˜#Kšœ	œ˜&Kšœ	œ˜&Kšœœ$˜<Kšœ<œ˜`šœ˜Kšœœ˜$Kšœœ
œ"˜,K˜Kšœ
˜—K˜
šœ˜Kšœœ˜$Kšœœ
œ˜&Kš
œ˜Kšœ
˜—K˜
Kšœ
˜—K˜š
Ÿœœœ
œœ˜CKš
˜Kšœœ
˜šœ˜Kšœœ
œ
˜K˜K˜K˜EKšœ
˜—K˜
Kšœ
˜—K˜šŸœœœ
œœœ˜7K˜K˜—K˜šŸœœœ
œ˜"Kšœœ˜Kšœœ
œ˜—K˜šŸ	œœ
œœ˜7Kš
˜šŸ
œœœ
œœœ˜<Kš
˜Kšœœ
˜
šœœ
˜˜Kšœ!œ
œ
˜/K˜7Kš
œ˜—K˜1Kšœœ
˜—Kšœ
˜—Kšœœ
œœ3˜FKšœœ˜-K˜6K˜Kšœ
˜—K˜šŸ
œœœ
œ˜9Kš
˜šŸ	œœœ
œœœ˜8Kš
˜Kšœœ˜Kšœœ
˜
K˜Kšœ
˜—šŸ	œœœ
œœœ˜8Kšœœ˜Kšœœ
˜
Kšœœ˜'K˜#Kšœœ˜*Kš
œœ
œœœ˜i—šŸœœœ
œœœ˜7Kšœœ˜Kšœœ
˜
Kšœœ
œ
œ
˜ Kšœœ˜&K˜"š	œœœœ
˜0šœ	œ
˜Kšœ)œ˜>Kšœ&œ˜:Kšœ'œ˜<Kšœœ
˜—Kšœ
˜—K˜—šŸœœœ
œœœ˜=Kšœœ˜$Kšœœ
˜
Kšœœœœ˜pKš
œ(˜(Kš
œœ
œœœ˜s—Kšœœ˜+K˜'K˜(K˜.K˜K˜.K˜Kš
œ,˜,K˜Kš
œ8˜8K˜Kšœ
˜—K˜Kš	œœ
œœ
œ˜2K˜šŸœœœ
œ˜8Kš
˜šŸ
œœœ
œœœ˜9Kšœœœ
˜*Kšœœœœœœ˜
šœ˜šœ
œœ
˜"Kšœœ˜0Kš
œ<˜<Kšœ˜—Kšœ˜——šŸ
œœœ
œœœ˜9Kšœœ˜Kšœœ
˜
Kš
œ$œœ
œ	œ
œ	œ˜†
Kšœœœœœ
œœ
œ˜t—šŸœœœ
œœœ˜:Kšœœ
˜šœœ
˜Kšœ4œœœ˜tKšœ4œœœ˜tš
œ˜š
œ#˜#Kšœœœ˜=—K˜(K˜K˜(K˜—Kšœœ˜——šŸœœœ
œœœ˜7Kšœœœ
˜&Kšœœ˜%—šŸœœœ
œœœ˜7Kšœœœ
˜&Kšœœ˜%—Kšœœ˜&Kš
œ1˜1K˜Kš
œ+˜+K˜Kš
œ-˜-K˜Kšœ
˜—K˜šŸ
œœœ
œ˜9Kš
˜šœ$œœ
˜>Kšœœœ˜PKšœ
˜—K˜Kšœ
˜—K˜Kšœ
˜J˜—…—2B¦