DIRECTORY Ascii, Commander, CommanderOps, Convert, Rope, IO, PFS;

MetaCedarImpl: CEDAR PROGRAM
IMPORTS Commander, CommanderOps, Convert, Rope, IO, PFS
= BEGIN

ROPE: TYPE ~ Rope.ROPE;
RopePair: TYPE ~ RECORD [name, value: ROPE];
Scanner: TYPE ~ REF ScannerRep;
ScannerRep: TYPE ~ RECORD [
stream: IO.STREAM,
tokenKind: Kind,
inputBuffer: REF TEXT,
locationOfBufferStart: INT,
identifierScratch: REF TEXT,
tokenStart: NAT,
tokenLength: NAT
];

inputBufferSize: NAT ¬ 1024;
identifierScratchSize: NAT ¬ 120;
CreateScanner: PROC [stream: IO.STREAM] RETURNS [scanner: Scanner] ~ {
scanner ¬ NEW[ScannerRep ¬ [
stream: stream,
tokenKind: whitespace,
inputBuffer: NEW[TEXT[inputBufferSize]],
locationOfBufferStart: IO.GetIndex[stream],
identifierScratch: NEW[TEXT[identifierScratchSize]],
tokenStart: 0,
tokenLength: 0
]];
};

Kind: TYPE ~ {identifier, special, whitespace, newline, eof};
KindOf: PROC [c: CHAR] RETURNS [Kind] ~ {
SELECT c FROM
IN ['a..'z], IN ['A..'Z], IN ['0..'9], '$ => RETURN [identifier];
Ascii.SP, Ascii.TAB, Ascii.LF => RETURN [whitespace];
Ascii.CR => RETURN [newline];
ENDCASE => RETURN [special];
};

breakLoc: INT ¬ LAST[INT];
breakCount: INT ¬ 0;

GetToken: PROC [scanner: Scanner] ~ {
scanner.tokenStart ¬ scanner.tokenStart+scanner.tokenLength;
scanner.tokenLength ¬ 0;
IF scanner.tokenStart>=scanner.inputBuffer.length THEN RefillBuffer[scanner];
IF scanner.inputBuffer.length = 0 THEN {scanner.tokenKind ¬ eof; RETURN};
scanner.tokenKind ¬ KindOf[scanner.inputBuffer[scanner.tokenStart]];
IF scanner.tokenKind = special THEN {
scanner.tokenLength ¬ 1;
RETURN;
};
WHILE scanner.tokenStart+scanner.tokenLength<scanner.inputBuffer.length
AND KindOf[scanner.inputBuffer[scanner.tokenStart+scanner.tokenLength]]
      = scanner.tokenKind DO
IF scanner.locationOfBufferStart+scanner.tokenStart+scanner.tokenLength = breakLoc THEN
breakCount ¬ breakCount + 1;
scanner.tokenLength ¬ scanner.tokenLength + 1;
IF scanner.tokenStart + scanner.tokenLength = scanner.inputBuffer.length THEN {
IF IO.EndOf[scanner.stream] THEN RETURN;
RefillBuffer[scanner];
};
ENDLOOP;
};

RefillBuffer: PROC [scanner: Scanner] = {
FOR i: NAT IN [0..scanner.tokenLength) DO
scanner.inputBuffer[i] ¬ scanner.inputBuffer[i+scanner.tokenStart];
ENDLOOP;
scanner.inputBuffer.length ¬ scanner.tokenLength;
scanner.locationOfBufferStart ¬ scanner.locationOfBufferStart+scanner.tokenStart;
scanner.tokenStart ¬ 0;
[] ¬ scanner.stream.GetBlock[block: scanner.inputBuffer, startIndex: scanner.tokenLength, count: scanner.inputBuffer.maxLength-scanner.tokenLength];
};

Match: PROC [scanner: Scanner, key: REF READONLY TEXT] RETURNS [equal: BOOL] = {
i: NAT ¬ scanner.tokenStart;
IF key.length # scanner.tokenLength THEN RETURN [FALSE];
FOR j: NAT IN [0..key.length) DO
IF key[j]#scanner.inputBuffer[i] THEN RETURN [FALSE];
i¬i+1;
ENDLOOP;
RETURN [TRUE]
};

MetaError: ERROR [sourceLoc: INT] = CODE;

Run: PROC [fileNameStem: ROPE, outputNameStem: ROPE, binding: LIST OF RopePair] = {
in: IO.STREAM ¬ PFS.StreamOpen[PFS.PathFromRope[fileNameStem.Concat[".meta"]]];
out: IO.STREAM ¬ PFS.StreamOpen[PFS.PathFromRope["MetaProgram.mesa"], $create];
scanner: Scanner ¬ CreateScanner[in];
mode: {meta, quoteargs, text} ¬ text;
lineStart: BOOL ¬ TRUE;
copiedTextStart: INT ¬ -1;
copiedTextLength: INT ¬ 0;
WriteBindings: PROC [bindings: LIST OF RopePair] ~ {
IF bindings # NIL THEN {
WriteBindings[bindings.rest];
out.PutF["\t%g: INT ~ %g;\n", [rope[bindings.first.name]], [rope[bindings.first.value]]];
};
};
Flush: PROC ~ {
IF copiedTextLength > 0 THEN {
IO.PutF[out, "Ptxt[%g, %g];\n", [integer[copiedTextStart]], [integer[copiedTextLength]]];
};
copiedTextStart ¬ -1;
copiedTextLength ¬ 0;
};
CopyOut: PROC ~ {
IF mode#text THEN ERROR;
IF copiedTextStart+copiedTextLength = scanner.locationOfBufferStart+scanner.tokenStart THEN copiedTextLength ¬ copiedTextLength + scanner.tokenLength
ELSE IF scanner.tokenLength > 0 THEN {
Flush[];
copiedTextStart ¬ scanner.locationOfBufferStart+scanner.tokenStart;
copiedTextLength ¬ scanner.tokenLength;
};
lineStart ¬ FALSE;
};
CopyMetaOut: PROC ~ {
IF scanner.tokenLength > 0 THEN {
Flush[];
IO.PutBlock[out, scanner.inputBuffer, scanner.tokenStart, scanner.tokenLength];
};
lineStart ¬ FALSE;
};
arg: ROPE ¬ NIL;
unquoted: ROPE ¬ NIL;
CopyQuotedOut: PROC ~ {
arg ¬ Rope.Concat[arg, Rope.FromRefText[s: scanner.inputBuffer, start: scanner.tokenStart, len: scanner.tokenLength]];
};
CopyUnquotedOut: PROC [type: ROPE] ~ {
id: ROPE ~ Rope.FromRefText[s: scanner.inputBuffer, start: scanner.tokenStart, len: scanner.tokenLength];
arg ¬ Rope.Concat[arg, "%g"];
IF unquoted # NIL THEN unquoted ¬ Rope.Concat[unquoted, ", "];
unquoted ¬ Rope.Concat[unquoted, IO.PutFR["[%g[%g]]", [rope[type]], [rope[id]]]];
};
QFlush: PROC ~ {
Flush[];
IF unquoted # NIL THEN IO.PutRope[out, "IO.PutFLR["];
IF arg#NIL THEN IO.PutRope[out, Convert.RopeFromRope[arg]];
IF unquoted # NIL THEN {
IO.PutRope[out, ", LIST["];
IO.PutRope[out, unquoted];
IO.PutRope[out, "]]"];
};
unquoted ¬ arg ¬ NIL;
};
StartPlain: PROC = {
mode ¬ text;
};
startMetaCount: INT ¬ 0;
StartMeta: PROC [eof: BOOL ¬ FALSE] = {
Flush[];
mode ¬ meta;
};
MetaText: PROC [rope: ROPE] = {
IF mode#text THEN ERROR;
Flush[];
IO.PutRope[out, rope];
};
inxx: BOOL ¬ FALSE;
nestCount: NAT ¬ 0;
qnest: INT ¬ 0;
beginStackTop: NAT ¬ 0;
beginStack: ARRAY [0..50) OF NAT;
GetToken[scanner];
IO.PutF[out, boilerPlateBegin, [rope[outputNameStem]], [rope[outputNameStem]], [rope[fileNameStem]]];
WriteBindings[binding];
StartPlain[];
WHILE scanner.tokenKind # eof DO
SELECT mode FROM
meta => {
SELECT scanner.tokenKind FROM
special => SELECT scanner.inputBuffer[scanner.tokenStart] FROM
' => StartPlain[];
'
 => MetaError[scanner.locationOfBufferStart+scanner.tokenStart];
ENDCASE => CopyMetaOut[];
ENDCASE => CopyMetaOut[];
};
quoteargs => {
SELECT scanner.tokenKind FROM
special => SELECT scanner.inputBuffer[scanner.tokenStart] FROM
', => {
IF qnest = 0
THEN {QFlush[]; IO.PutRope[out, ", "]}
ELSE CopyQuotedOut[]
};
'(, '{, '[ => {qnest ¬ qnest + 1; CopyQuotedOut[]};
'), '} => {
qnest ¬ qnest - 1;
IF qnest < 0
THEN MetaError[scanner.locationOfBufferStart+scanner.tokenStart]
ELSE CopyQuotedOut[]
};
'] => {
qnest ¬ qnest - 1;
IF qnest < 0
THEN {mode ¬ text; QFlush[]; IO.PutRope[out, "]; "]}
ELSE CopyQuotedOut[]
};
'& => {
GetToken[scanner];
CopyUnquotedOut["integer"];
};
'% => {
GetToken[scanner];
CopyUnquotedOut["rope"];
};
'?, '
, ' => {
MetaError[scanner.locationOfBufferStart+scanner.tokenStart];
};
ENDCASE => CopyQuotedOut[];
ENDCASE => CopyQuotedOut[];
};
text => {
SELECT scanner.tokenKind FROM
special => SELECT scanner.inputBuffer[scanner.tokenStart] FROM
'
 => StartMeta[];
' => MetaError[scanner.locationOfBufferStart+scanner.tokenStart];
'(, '{, '[ => {nestCount ¬ nestCount + 1; CopyOut[]};
'), '}, '] => {nestCount ¬ nestCount - 1; CopyOut[]};
'& => {
Flush[];
GetToken[scanner];
IO.PutRope[out, "PutInt["];
CopyMetaOut[];
IO.PutRope[out, "]; "];
};
'% => {
Flush[];
GetToken[scanner];
IO.PutRope[out, "stream.PutRope["];
CopyMetaOut[];
IO.PutRope[out, "]; "];
};
'? => {
Flush[];
GetToken[scanner];
CopyMetaOut[];
GetToken[scanner];
IF scanner.inputBuffer[scanner.tokenStart] # '[ THEN MetaError[scanner.locationOfBufferStart+scanner.tokenStart];
IO.PutRope[out, "["];
qnest ¬ 0;
mode ¬ quoteargs;
};
ENDCASE => CopyOut[];
newline => {CopyOut[]; lineStart ¬ TRUE};
whitespace => IF lineStart THEN NULL ELSE CopyOut[];
identifier => {
CopyOut[];
SELECT TRUE FROM
Match[scanner, "DO"],
Match[scanner, "FROM"],
Match[scanner, "BEGIN"] => {
MetaText["Begin[];"];
beginStack[beginStackTop] ¬ nestCount;
beginStackTop ¬ beginStackTop + 1;
};
Match[scanner, "ENDLOOP"],
Match[scanner, "ENDCASE"],
Match[scanner, "END"] => {
MetaText["End[];"];
beginStackTop ¬ beginStackTop - 1;
IF beginStack[beginStackTop] # nestCount THEN MetaError[scanner.locationOfBufferStart+scanner.tokenStart];
};
ENDCASE => NULL;
};
ENDCASE => CopyOut[];
};
ENDCASE => ERROR;
GetToken[scanner];
ENDLOOP;
IF mode=meta THEN StartPlain[];
StartMeta[eof: TRUE];
IO.PutRope[out, boilerPlateEnd];
IO.Close[in];
IO.Close[out];
};

boilerPlateBegin: ROPE = "
DIRECTORY Rope, IO, PFS;
MetaProgram: CEDAR PROGRAM IMPORTS Rope, IO, PFS = {
  ROPE: TYPE ~ Rope.ROPE;
  TwoToThe: PROC [a: INT] RETURNS [b: INT] ~ {
    IF a < 0 THEN RETURN [0];
    b _ 1;
    THROUGH [0..a) DO b _ b+b ENDLOOP;
    };
  ModuleName: PROC ~ {IO.PutRope[stream, \"%g\"]};
  stream: IO.STREAM ~ PFS.StreamOpen[PFS.PathFromRope[\"%g.mesa\"], $create];
  nest: NAT _ 0;
  Begin: PROC ~ {nest _ nest + 1};
  End: PROC ~ {nest _ nest - 1};
  PutInt: PROC [i: INT] ~ {
    IO.PutF1[stream, IF i < 0 THEN \"(%%g)\" ELSE \"%%g\", [integer[i]]]};
  metaSource: ROPE ~ PFS.RopeOpen[PFS.PathFromRope[\"%g.meta\"]].rope;
  Ptxt: PROC [start, length: CARDINAL] ~ {
    s: INT _ start;
    FOR i: INT IN [start..start+length) DO
      SELECT metaSource.Fetch[i] FROM
        '{, '[, '( => Begin[];
        '}, '], ') => End[];
        '\r => {
          stream.PutRope[metaSource.Substr[s, i-s+1]];
          FOR i: NAT IN [0..nest) DO stream.PutChar['\t] ENDLOOP;
          s _ i+1;
          };
        ENDCASE => NULL;
      ENDLOOP;
    stream.PutRope[metaSource.Substr[s, start+length-s]];
    };
  ";
boilerPlateEnd: ROPE = "IO.Close[stream]}.";

GetCmdToken: PROC [stream: IO.STREAM] RETURNS [rope: ROPE ¬ NIL] ~ {
rope ¬ IO.GetTokenRope[stream ! IO.EndOfStream => CONTINUE].token;
};

MetaCedarRunCommand: Commander.CommandProc ~ {
ENABLE PFS.Error => CommanderOps.Failed[error.explanation];
c: IO.STREAM ¬ IO.RIS[cmd.commandLine];
stem: ROPE ¬ GetCmdToken[c];
outputStem: ROPE ¬ GetCmdToken[c];
binding: LIST OF RopePair ¬ NIL;
out: IO.STREAM ¬ cmd.out;
tmpDir: ROPE ~ Rope.Cat["/tmp/meta-", stem, "/"];
IF outputStem = NIL THEN outputStem ¬ stem;
out.PutF["Creating %g.mesa from %g.meta:\n", [rope[outputStem]], [rope[stem]]];
UNTIL c.EndOf DO
ropePair: RopePair ¬ [name: GetCmdToken[c], value: GetCmdToken[c]];
IF ropePair.name = NIL OR ropePair.value = NIL THEN EXIT;
cmd.out.PutF["  %g: INT ~ %g;\n", [rope[ropePair.name]], [rope[ropePair.value]]];
binding ¬ CONS[ropePair, binding];
ENDLOOP;
result ¬ CommanderOps.DoCommand[Rope.Concat["mkdir /tmp/meta-", stem], cmd];
result ¬ CommanderOps.DoCommand[
Rope.Cat["Copy ", tmpDir, "MetaCedarTemp.meta _ ", stem, ".meta"],
cmd];
IF result = $Failure THEN RETURN;
BEGIN
InTmp: PROC ~ {
result ¬ CommanderOps.DoCommand["WriteMesaPlain MetaCedarTemp.meta", cmd];
IF result = $Failure THEN RETURN;
IO.PutRope[out, "Writing MetaProgram.mesa . . . "];
Run["MetaCedarTemp", outputStem, binding !
MetaError => {
result ¬ $Failure;
msg ¬ IO.PutFR1["Something fishy at position &g of MetaCedarTemp.meta\n", [integer[sourceLoc]]]
}
];
IF result = $Failure THEN RETURN;
out.PutRope["Done.\n"];
result ¬ CommanderOps.DoCommand["bringover -o BasicTime.mob Rope.mob IO.mob PFS.mob /Cedar/Top/PFS.df", cmd];
result ¬ CommanderOps.DoCommand["mkdir sun4", cmd];
result ¬ CommanderOps.DoCommand["Mako -~o MetaProgram.mesa", cmd];
IF result = $Failure THEN RETURN;
result ¬ CommanderOps.DoCommand["Run -a MetaProgram", cmd];
IF result = $Failure THEN RETURN;
result ¬ CommanderOps.DoCommand[Rope.Cat["TiogaMesa ", outputStem, ".mesa"], cmd];
};
PFS.DoInWDir[PFS.PathFromRope[tmpDir], InTmp];
END;
IF result = $Failure THEN RETURN;
result ¬ CommanderOps.DoCommand[Rope.Cat["Copy ", tmpDir, outputStem, ".mesa"], cmd];
IF result = $Failure THEN RETURN;
};

Commander.Register["MetaCedar", MetaCedarRunCommand, "Simpleton macro expander"];

END.

ž
MetaCedarImpl.mesa
Copyright Σ 1984, 1985, 1987, 1990, 1991, 1992 Xerox Corporation.  All rights reserved.
Michael Plass, November 23, 1992 7:30:56 pm PST
Russ Atkinson (RRA) May 11, 1987 6:19:05 pm PDT
Gets the next token into inputBuffer[tokenStart] .. inputBuffer[tokenLength-1]
Something funny about the way things match up.
result ¬ CommanderOps.DoCommand[Rope.Cat["Mako ", outputStem, ".mesa"], cmd];
Κ›•NewlineDelimiter

–
(cedarcode) style™
codeš
œ™Kšœ
Οe
œL™WK™/K™/K˜—KšΟk	œ0žœžœ
˜AK˜KšΟn
œžœ
ž˜Kšžœ)žœž˜7šœž˜K˜Kšžœžœžœ
˜Kšœ
žœžœžœ˜,Kšœ	žœžœ˜šœžœžœ˜Kšœžœ
žœ
˜Kš
œ˜Kšœ
žœ
žœ
˜Kšœžœ
˜Kšœžœ
žœ
˜Kšœžœ
˜Kšœ
ž˜Kš
œ˜K˜—Kšœžœ˜Kšœžœ˜!š
Ÿ
œžœ
žœ
žœžœ˜Fšœ
žœ˜Kš
œ˜Kš
œ˜Kšœ
žœ
žœ˜(Kšœžœ˜+Kšœžœ
žœ˜4Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜K˜—Kšœžœ3˜=šŸœžœžœžœ˜)šžœž˜
Kšžœžœžœžœ˜AKš	œžœžœžœžœ˜5Kšœžœžœ˜Kšžœžœ˜—Kš
œ˜K˜—Kšœ
žœžœ
žœ˜šœžœ˜K˜—šŸœžœ˜%Kš
œN™NKš
œ<˜<Kš
œ˜Kšžœ0žœ˜MKšžœ žœžœ˜IKš
œD˜Dšžœžœ˜%Kš
œ˜Kšžœ
˜Kš
œ˜—šžœCžœ_ž˜¬
šžœQž˜WKš
œ˜—Kš
œ.˜.šžœGžœ˜OKšžœ
žœžœ
žœ
˜(Kš
œ˜Kš
œ˜—Kšžœ
˜—Kš
œ˜K˜—šŸœžœ˜)šžœžœ
žœž˜)Kš
œC˜CKšžœ
˜—Kš
œ1˜1Kš
œQ˜QKš
œ˜Kš
œ”
˜”
K˜K˜—šŸœžœžœ
žœ
žœžœ	žœ˜PKšœžœ˜Kšžœ"žœ
žœžœ˜8šžœžœ
žœž˜ Kšžœžœ
žœžœ˜5K˜Kšžœ
˜—Kšžœžœ
˜
K˜K˜—šŸ	œžœ
žœžœ
˜)K˜—šŸœžœžœžœžœ
žœ˜SKš	œžœ
žœžœžœ-˜OKš	œžœ
žœžœžœ,˜OKš
œ%˜%Kšœž
œ˜%Kšœžœžœ
˜Kšœžœ˜Kšœžœ˜šŸ
œžœžœ
žœ˜4šžœžœ
žœ˜Kš
œ˜KšœžœF˜YKš
œ˜—Kš
œ˜—šŸœžœ˜šžœžœ˜KšžœW˜YKš
œ˜—Kš
œ˜Kš
œ˜Kš
œ˜—šŸœžœ˜Kšžœžœ
žœ
˜KšžœUžœ:˜•
šžœ
žœžœ˜&Kš
œ˜Kš
œC˜CKš
œ'˜'Kš
œ˜—Kšœžœ
˜Kš
œ˜—šŸœžœ˜šžœžœ˜!Kš
œ˜KšžœM˜OKš
œ˜—Kšœžœ
˜Kš
œ˜—Kšœžœžœ
˜Kšœ
žœžœ
˜šŸ
œžœ˜K•StartOfExpansion>[s: 
REF READONLY TEXT, start: 
NAT _ 0, len: 
NAT _ 32767]š
œv˜vKš
œ˜—šŸœžœžœ˜&K–>[s: 
REF READONLY TEXT, start: 
NAT _ 0, len: 
NAT _ 32767]šœžœa˜iKš
œ˜K–>[s: 
REF READONLY TEXT, start: 
NAT _ 0, len: 
NAT _ 32767]šžœžœ
žœ(˜>Kšœ!žœ.˜QKš
œ˜—šŸœžœ˜Kš
œ˜Kšžœžœ
žœ
žœ˜5Kšžœžœ
žœ
žœ)˜;šžœžœ
žœ˜Kšžœ˜Kšžœ˜Kšžœ˜K˜—Kšœžœ
˜Kš
œ˜—šŸ
œžœ˜Kš
œ˜Kš
œ˜—Kšœžœ˜šŸ	œžœžœžœ˜'K˜Kš
œ˜Kš
œ˜—šŸœžœžœ˜Kšžœžœ
žœ
˜K˜Kšžœ˜Kš
œ˜—Kšœžœžœ
˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ	žœ
žœ
˜!Kš
œ˜Kšžœc˜eKš
œ˜Kš
œ
˜
šžœž˜ šžœž˜š
œ	˜	šžœž˜šœžœ)ž˜>Kš
œ˜Kš
œB˜BKšžœ˜—Kšžœ˜—Kš
œ˜—˜šžœž˜šœžœ)ž˜>š
œ˜šžœ
˜Kšžœžœ˜&Kšžœ˜—Kš
œ˜—Kš
œ3˜3š
œ˜Kš
œ˜šžœ
˜Kšžœ<˜@Kšžœ˜—Kš
œ˜—š
œ˜Kš
œ˜šžœ
˜Kšžœžœ˜4Kšžœ˜—Kš
œ˜—š
œ˜Kš
œ˜K˜Kš
œ˜—š
œ˜Kš
œ˜K˜Kš
œ˜—š
œ˜Kš
œ<˜<Kš
œ˜—Kšžœ˜—Kšžœ˜—K˜—˜	šžœž˜šœžœ)ž˜>Kš
œ˜Kš
œB˜BKš
œ5˜5Kš
œ5˜5š
œ˜K˜Kš
œ˜Kšžœ˜Kš
œ˜Kšžœ˜Kš
œ˜—š
œ˜K˜Kš
œ˜Kšžœ!˜#Kš
œ˜Kšžœ˜Kš
œ˜—š
œ˜K˜Kš
œ˜Kš
œ˜Kš
œ˜Kšžœ.žœ=˜qKšžœ˜K˜
K˜Kš
œ˜—Kšžœ˜—Kšœ#žœ˜)Kš	œžœžœ
žœ
žœ˜4š
œ˜Kš
œ
˜
šžœ
žœ
ž˜Kš
œ˜Kš
œ˜š
œ˜Kš
œ˜Kš
œ&˜&Kš
œ"˜"K˜—Kš
œ˜Kš
œ˜š
œ˜Kš
œ˜Kš
œ"˜"šžœ'žœ=˜jK™.—K˜—Kšžœžœ
˜—Kš
œ˜—Kšžœ˜—K˜—Kšžœžœ
˜—Kš
œ˜Kšžœ
˜—Kšžœžœ˜Kšœžœ˜Kšžœ˜ Kšžœ˜
Kšžœ˜K˜K˜—Kš
œžœž	œžœžœŸœžœ
žœ
žœžœžœžœžœžœŸœžœžœžœžœ
žœžœ
žœžœžœ	žœŸ
œžœžœ%žœ
žœžœžœ.žœŸœžœŸœžœŸœžœžœ
žœžœžœžœ(žœžœ
žœ$Ÿœžœžœ
žœžœžœ
žœžœžœžœ
žœžœ
žœžœžœ*žœžœžœG˜πKšœžœžœ˜-šŸœžœ
žœ
žœžœžœžœ˜DKšœžœžœžœ˜BKš
œ˜K˜—šŸœ˜.Kšžœ
žœ1˜;Kš	œžœ
žœžœ
žœ˜'Kšœžœ˜Kšœžœ˜"Kšœ	žœ
žœžœ
˜ Kšœžœ
žœ˜Kšœžœ%˜1Kšžœžœ
žœ˜+Kš
œO˜Ošžœ	ž˜Kš
œC˜CKšžœžœ
žœžœ
žœ
žœ
˜9Kšœžœ:˜QKšœ
žœ˜"Kšžœ
˜—K˜LK˜iKšžœžœ
žœ
˜!š
ž˜šŸœžœ˜K˜JKšžœžœ
žœ
˜!Kšžœ1˜3š
œ*˜*š
œ˜Kš
œ˜KšœžœW˜_Kš
œ
˜
—Kš
œ˜—Kšžœžœ
žœ
˜!Kš
œ˜K˜mK˜3K˜BKšžœžœ
žœ
˜!Kš
œ;˜;Kšžœžœ
žœ
˜!Kš
œR˜RK˜—Kšžœ
žœ˜.Kšžœ
˜—Kšžœžœ
žœ
˜!K˜UKšžœžœ
žœ
˜!K™MKš
œ˜K˜—˜QK˜——Kšžœ
˜—…—,θ>!