DIRECTORY
BasicTime USING [Now],
CommandTool USING [Run],
FileNames USING [CurrentWorkingDirectory],
FS USING [Error],
IO USING [PutF, rope],
MessageWindow USING [Append],
PrincOps USING [NoTimeout], 
Process USING [Abort, Detach, GetPriority, Priority, priorityBackground, SecondsToTicks, SetPriority, SetTimeout],
Real USING [FixC],
RefText USING [New],
Rope USING [Equal, Find, FromRefText, IsEmpty, ROPE, Substr],
spGlobals USING [Aborted, bomb, CircuitRec, CleanUp, defineCircuit, dumpAll, error, ErrWarnSummary, fileNameStackSeq, fileStackSeq, function, functionTable, FuncTableBlk, Handle, keys, makePlotList, makePrintList, maxInclude, maxLog, maxPlots, maxPrints, model, modFuncPtr, modelTable, ModelTableBlk, nameBlk, namePtr, next, openInputFile, output, PlotSeq, printHole, PrintSeq, PutMsgLine, runIt, searchKey, SetCursor, setICs, topoAnalysis, Variables, WorstNodeLog],
ViewerClasses USING [Viewer],
ViewerTools USING [SetContents];

spMain: CEDAR MONITOR
IMPORTS BasicTime, CommandTool, FileNames, FS, IO, MessageWindow, Process, Real, --RecursivelyNIL, --RefText, Rope, spGlobals, ViewerTools 
EXPORTS spGlobals=

{ OPEN spGlobals;

NormalRun: PUBLIC PROC[handle: Handle, background, fork: BOOL _ TRUE]= {
IF handle = NIL THEN RETURN;
IF handle.stage=idle AND handle.simulation=NIL THEN {
curPriority: Process.Priority = Process.GetPriority[];
IF background THEN Process.SetPriority[Process.priorityBackground];
handle.stage _ input;
SetCursor[handle];
handle.outer.inhibitDestroy _ TRUE;
IF fork THEN {
handle.simulation _ FORK Simulate[handle];
TRUSTED {Process.Detach[handle.simulation]};
}
ELSE {
handle.simulation _ NIL;
Simulate[handle];
};
Process.SetPriority[curPriority];
}
ELSE MessageWindow.Append[message: "Previous simulation has not finished yet.", clearFirst: TRUE];
}; -- NormalRun

BatchRun: PUBLIC PROC[handle: Handle, wDir, inputFile: Rope.ROPE _ NIL, background, fork: BOOL _ TRUE]= {
IF handle = NIL OR inputFile = NIL THEN RETURN;
IF wDir = NIL THEN wDir _ FileNames.CurrentWorkingDirectory[];
ViewerTools.SetContents[handle.wDir, wDir];
ViewerTools.SetContents[handle.input, inputFile];
NormalRun[handle, background, fork];
}; -- BatchRun

Simulate: PUBLIC PROC[handle: Handle]= {
ENABLE {
Aborted => GOTO stop;
ABORTED => {handle.vars.canned _ TRUE; GOTO dumpStop};
FS.Error => {
handle.msgStream.PutF["%g\nProgram stopped.\n", IO.rope[error.explanation]];
GOTO stop;
};
};
Process.SetPriority[Process.priorityBackground];
InitVars[handle];
openInputFile[handle];
next[handle];

WHILE handle.vars.item=name DO
IF Canned[handle] THEN GOTO stop;
IF searchKey[handle]=libraryKey THEN AddLibrary[handle] ELSE EXIT;
ENDLOOP;  

IF handle.vars.item=name AND searchKey[handle]=circuitKey THEN {
theRoot: namePtr_ NEW[nameBlk_
[name: "Main Circuit", details: NEW[CircuitRec_ []]] ];
defineCircuit[handle: handle, ckt: theRoot, root: TRUE]; -- may signal Aborted
}
ELSE error[handle, 820, TRUE];
IF handle.vars.item=slash AND handle.vars.errCount <= 0 THEN {
next[handle];
output[handle, handle.vars.cktRoot, 0];
};

IF handle.vars.item#semi THEN error[handle, 800,, FALSE]
ELSE IF handle.vars.errCount <= 0 THEN {
NextStage[handle];
bomb[handle]; -- may signal Aborted
next[handle];
IF handle.vars.item=plus THEN {next[handle]; printHole[handle]};
};
IF handle.vars.errCount <= 0 THEN {
NextStage[handle];
topoAnalysis[handle];
IF Canned[handle] THEN GOTO stop;
};
IF handle.vars.errCount <= 0 THEN {
NextStage[handle];
WHILE handle.vars.item=name DO
OPEN handle.vars;
key: keys_ searchKey[handle];
next[handle];
SELECT key FROM
runKey=> {
TRUSTED {
Process.SetTimeout[@handle.checkPointCV,
Process.SecondsToTicks[Real.FixC[60.0*checkPointInterval]]];
Process.Detach[handle.checkProcess_ FORK PeriodicSetCheckPoint[handle]];
};
lastTime_ runIt[handle];
IF NOT Canned[handle] THEN PutMsgLine[handle, "Done."];
};
printKey=> makePrintList[handle];
plotKey => makePlotList[handle];
icKey   => setICs[handle];
dumpKey => IF ~ForcedDump[handle] THEN dumpAll[handle, lastTime];
checkPointKey=> {
IF item=leftB THEN next[handle] ELSE error[handle, 801];
IF item=number THEN {
checkPointInterval_ value;
next[handle]
}
ELSE error[handle, 809, FALSE];
IF item=rightB THEN next[handle] ELSE error[handle, 802];
}
ENDCASE=> GOTO err1;
IF item=eof THEN EXIT;
IF item=semi THEN next[handle] ELSE error[handle, 800,, FALSE];
REPEAT
err1=> error[handle, 821, TRUE];
ENDLOOP;
}; -- run

IF ForcedDump[handle] THEN dumpAll[handle, handle.vars.lastTime];
ErrWarnSummary[handle]; 
GOTO stop;
EXITS
dumpStop=> {
dumpAll[handle, handle.vars.lastTime];
handle.msgStream.PutF["Last state is dumped in the dump file."];
CleanIt[handle];
};
stop=> CleanIt[handle];
}; -- Simulate
EnterModels: PUBLIC ENTRY PROC[entry: ModelTableBlk]= {
ENABLE UNWIND => NULL;
FOR m: LIST OF REF ModelTableBlk _ modelTable, m.rest UNTIL m=NIL DO
IF Rope.Equal[m.first.name, entry.name] THEN {
m.first^ _ entry;
RETURN;
};
ENDLOOP;
modelTable _ CONS[NEW[ModelTableBlk_ entry], modelTable];
}; -- EnterModels

EnterFunctions: PUBLIC ENTRY PROC[entry: FuncTableBlk]= {
ENABLE UNWIND => NULL;
FOR f: LIST OF REF FuncTableBlk _ functionTable, f.rest UNTIL f=NIL DO
IF Rope.Equal[f.first.name, entry.name] THEN {
f.first^ _ entry;
RETURN;
};
ENDLOOP;
functionTable _ CONS[NEW[FuncTableBlk_ entry], functionTable];
}; -- EnterFunctions


findModel: PUBLIC ENTRY PROC[name: Rope.ROPE] RETURNS[REF ModelTableBlk]= {
ENABLE UNWIND => NULL;
FOR m: LIST OF REF ModelTableBlk _ modelTable, m.rest UNTIL m=NIL DO
IF Rope.Equal[m.first.name, name] THEN RETURN[m.first];
ENDLOOP;
RETURN[NIL];
}; -- findModel

findFunction: PUBLIC ENTRY PROC[name: Rope.ROPE]
RETURNS[REF FuncTableBlk]= {
ENABLE UNWIND => NULL;
FOR f: LIST OF REF FuncTableBlk_ functionTable, f.rest UNTIL f=NIL DO
IF Rope.Equal[f.first.name, name] THEN RETURN[f.first];
ENDLOOP;
RETURN[NIL];
}; -- findFunction

ResetCheckPoint: PUBLIC ENTRY PROC[handle: Handle]= {
ENABLE UNWIND => NULL;
handle.vars.checkPoint_ FALSE };

Canned: PUBLIC ENTRY PROC[handle: Handle] RETURNS[BOOL]= {
ENABLE UNWIND => NULL;
RETURN[handle.vars.canned]};

ForcedDump: PUBLIC ENTRY PROC[handle: Handle] RETURNS[BOOL]= {
ENABLE UNWIND => NULL;
RETURN[handle.vars.forcedDump]};

CheckPoint: PUBLIC ENTRY PROC[handle: Handle] RETURNS[BOOL]= {
ENABLE UNWIND => NULL;
RETURN[handle.vars.checkPoint]};

ShowDetails: PUBLIC ENTRY PROC[handle: Handle] RETURNS[BOOL]= {
ENABLE UNWIND => NULL;
RETURN[handle.showTimeStep]};

EchoInput: PUBLIC ENTRY PROC[handle: Handle] RETURNS[BOOL]= {
ENABLE UNWIND => NULL;
RETURN[handle.echoInput]};

SaveAll: PUBLIC ENTRY PROC[handle: Handle] RETURNS[BOOL]= {
ENABLE UNWIND => NULL;
RETURN[handle.saveAllData]};

StopIt: PUBLIC ENTRY PROC[handle: Handle]= {
ENABLE UNWIND => NULL;
IF handle # NIL THEN {
IF handle.vars # NIL THEN {
handle.vars.forcedDump_ FALSE; 
handle.vars.canned_ TRUE;
};
AbortCheckPoint[handle];
};
}; -- StopIt

DumpIt: PUBLIC ENTRY PROC[handle: Handle]= {
ENABLE UNWIND => NULL;
IF handle # NIL THEN {
IF handle.vars # NIL THEN {
handle.vars.forcedDump_ TRUE;
handle.vars.canned_ TRUE;
};
AbortCheckPoint[handle];
};
}; -- DumpIt

ToggleShowDetails: PUBLIC ENTRY PROC[handle: Handle]= {
ENABLE UNWIND => NULL;
handle.showTimeStep_ ~handle.showTimeStep;
}; -- ToggleShowDetails

ToggleEchoInput: PUBLIC ENTRY PROC[handle: Handle]= {
ENABLE UNWIND => NULL;
handle.echoInput_ ~handle.echoInput;
}; -- ToggleEchoInput

ToggleSaveAll: PUBLIC ENTRY PROC[handle: Handle]= {
ENABLE UNWIND => NULL;
handle.saveAllData _ ~handle.saveAllData;
}; -- ToggleSaveAll

NextStage: PUBLIC ENTRY PROC[handle: Handle]= {
ENABLE UNWIND => NULL;
SELECT handle.stage FROM
input, bomb, topo => {
handle.stage_ SUCC[handle.stage];
SetCursor[handle];
};
run => {
handle.vars.runState _ (handle.vars.runState + 1) MOD 4;
SetCursor[handle];
};
ENDCASE => MessageWindow.Append[ -- should not get here
message: "* Weird situation detected in 'NextStage', please inform Thyme implementors.",
clearFirst: TRUE];
}; -- NextStage

PeriodicSetCheckPoint: ENTRY PROC[handle: Handle]= {
ENABLE UNWIND => NULL;
WHILE handle # NIL DO
ENABLE ABORTED => EXIT;
WAIT handle.checkPointCV;
IF handle # NIL THEN
IF handle.vars # NIL THEN handle.vars.checkPoint_ TRUE
ELSE EXIT;
ENDLOOP;
IF handle # NIL THEN
TRUSTED {Process.SetTimeout[@handle.checkPointCV, PrincOps.NoTimeout]};
}; -- PeriodicSetCheckPoint

CleanIt: ENTRY PROC[handle: Handle]= {
ENABLE UNWIND => NULL;
CleanUp[handle];
}; -- CleanIt

AbortCheckPoint: INTERNAL PROC[handle: Handle]= {
IF handle = NIL THEN RETURN;
IF handle.stage=run AND handle.checkProcess # NIL THEN {
TRUSTED {Process.Abort[LOOPHOLE[handle.checkProcess, UNSPECIFIED]]};
handle.checkProcess_ NIL;
};
}; -- AbortCheckPoint

AddLibrary: PROC[handle: Handle]= {
next[handle];
IF handle.vars.item=leftB THEN next[handle] ELSE error[handle, 801, TRUE];
IF handle.vars.item=name THEN {
originalName, nameRoot, errMsg: Rope.ROPE;
dotPosition: INT;
originalName_ Rope.FromRefText[handle.vars.newString];
dotPosition_ Rope.Find[originalName, "."];
nameRoot_ IF dotPosition=-1 THEN originalName
ELSE Rope.Substr[originalName, 0, dotPosition-1];
IF NOT (Rope.Equal[nameRoot, "MosModels",    FALSE] OR
Rope.Equal[nameRoot, "StdFunctions", FALSE] OR
Rope.Equal[nameRoot, "Level2Model",  FALSE]) THEN {
[errMsg, ]_ CommandTool.Run[originalName];
IF NOT errMsg.IsEmpty[] THEN PutMsgLine[handle, errMsg];
};
next[handle];
}
ELSE error[handle, 804, TRUE];
IF handle.vars.item=rightB THEN next[handle] ELSE error[handle, 802, FALSE];
IF handle.vars.item=semi THEN next[handle] ELSE error[handle, 800, FALSE];
}; -- AddLibrary

InitVars: PROC[handle: Handle]= {
handle.vars_ NEW[Variables_ [ ]];
{OPEN handle.vars;
simTime _ BasicTime.Now[];
line_ RefText.New[256];
newString_ RefText.New[256];
line.length_ 0;
newString.length_ 0;
fileStack_ NEW[fileStackSeq[maxInclude]];
FOR i: NAT IN [0..maxInclude) DO fileStack[i] _ NIL ENDLOOP;
fileNameStack_ NEW[fileNameStackSeq[maxInclude]];
FOR i: NAT IN [0..maxInclude) DO fileNameStack[i] _ NIL ENDLOOP;
prints_ NEW[PrintSeq[maxPrints]];
FOR i: NAT IN [0..maxPrints) DO prints[i] _ [] ENDLOOP;
plots_ NEW[PlotSeq[maxPlots]];
FOR i: NAT IN [0..maxPlots) DO plots[i] _ [] ENDLOOP;
worstNodeLog_ NEW[WorstNodeLog[maxLog]];
FOR i: NAT IN [0..maxLog) DO worstNodeLog[i] _ []; ENDLOOP;
};
}; -- InitVars
}.
CHANGE LOG
Wilhelm, April 27, 1982  4:07 PM
Barth,  7-May-82 14:41:52 PDT
Chen, April 19, 1983  6:45 PM, changed the version name for openSysWindow.
Barth, July 11, 1983  12:46 PM
Chen, June 12, 1984 11:37:19 am PDT, cedarized.
Chen, May 15, 1985 5:23:49 pm PDT, Thyme viewer is inhibited from being destroyed by user when simulation is running.
Chen, July 22, 1985 8:09:51 pm PDT, => Cedar6.0.
Chen, November 24, 1985 2:57:05 pm PST, as suggested by Pradeep, changed NormalRun, BatchRun, and Simulate to allow client to choose whether to fork and whether to run in background.
Christian Jacobi, June 10, 1986 6:35:28 pm PDT, Changed Simulate to always run in background; (ignoring the interface's option not run in background).


ไFile: spMain.mesa
Copyright c 1985, 1986 by Xerox Corporation.  All rights reserved.
Last Edited by:
Last Edited by: Jacobi June 10, 1986 6:37:00 pm PDT
Pradeep Sindhu March 19, 1986 11:26:37 pm PST
Sweetsun Chen, April 26, 1986 4:59:00 pm PST
Christian Jacobi, June 10, 1986 6:35:10 pm PDT

RecursivelyNIL USING [CheckProc, NILRef],
IF handle.simulation # NIL THEN TRUSTED {JOIN handle.simulation};
libraries
circuit definition
explode

analyze

run
killPlot[]

entry procs


ส‹˜Jš
ะct™Jšœ
ฯm
œ7™Bš
œ™Icode™3K™-K™,K™.—J™š
ฯk	˜	Jšœ
Ÿœ˜JšœŸœ˜Jšœ
Ÿœ˜*JšŸœ
Ÿœ	˜JšŸœ
Ÿœ˜JšœŸœ
˜Jšœ	Ÿœ˜JšœŸœe˜rJšœŸœ™)JšœŸœ˜JšœŸœ˜JšœŸœ%Ÿœ
˜=Jšœ
Ÿœร˜าJšœŸœ
˜JšœŸœ˜ —J˜šœŸœ
Ÿ˜JšŸœ$ŸœŸœ ฯcœ&˜‹
JšŸœ˜—J˜JšœŸœ˜J˜š
ฯn	œŸœ
Ÿœ#ŸœŸœ˜HJšŸœ
Ÿœ
Ÿœ
Ÿœ
˜šŸœŸœŸœ
Ÿœ˜5J˜6JšŸœŸœ1˜CJš
œ˜Jš
œ˜JšœŸœ
˜#šŸœŸœ˜JšœŸœ˜*JšŸœ%˜,J˜
—šŸœ˜JšœŸœ
˜Jš
œ˜J˜—Jš
œ!˜!Jš
œ
˜
—JšŸœXŸœ˜bJšœ 	˜—J˜šกœŸœ
Ÿœ'ŸœŸœŸœŸœ˜iJšŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ
˜/JšŸœŸœ
Ÿœ,˜>Jš
œ+˜+Jš
œ1˜1Jš
œ$˜$Jš
ŸœŸœ
Ÿœ
ŸœŸœ™AJšœ ˜—J˜šกœŸœ
Ÿœ˜(šŸœ˜JšœŸœ˜JšŸœŸœŸœ˜6šŸœ˜
Jšœ0Ÿœ˜LJšŸœ˜
J˜—J˜—Jš
œ0˜0Jš
œ˜Jš
œ˜Jš
œ
˜
J˜Jš
	™	šŸœŸ˜JšŸœŸœ
Ÿœ˜!JšŸœŸœŸœ
Ÿœ
˜BJšŸœ˜
—J˜Jš
™šŸœŸœŸœ˜@JšœŸœ	˜Jšœ Ÿœ˜7Jšœ2Ÿœ ˜NJš
œ
˜
—JšŸœŸœ˜šŸœŸœŸœ˜>Jš
œ
˜
Jš
œ'˜'Jš
œ˜—Jš
œ™JšŸœŸœŸœ
˜8šŸœ
ŸœŸœ˜(Jš
œ˜Jšœ ˜#Jš
œ
˜
JšŸœŸœ#˜@Jš
œ˜—J™Jš
œ™šŸœŸœ˜#Jš
œ˜Jš
œ˜JšŸœŸœ
Ÿœ˜!Jš
œ˜——™Jš
œ™šŸœŸœ˜#Jš
œ˜šŸœŸ˜JšŸœ
˜Jš
œ˜Jš
œ
˜
šŸœŸ˜š
œ
˜
šŸœ˜	Jš
œ(˜(Jš
œ<˜<Jšœ$Ÿœ ˜HJš
œ˜—Jš
œ˜JšŸœ
ŸœŸœ˜7Jš
œ˜—Jš
œ!˜!Jš
œ ˜ Jš
œ˜JšœŸœŸœ˜Aš
œ˜JšŸœŸœŸœ˜8šŸœ
Ÿœ˜Jš
œ˜Jš
œ˜Jš
œ
˜
—JšŸœŸœ˜JšŸœ
ŸœŸœ˜9Jš
œ
˜
—JšŸœŸœ˜—JšŸœ
Ÿœ
Ÿœ
˜JšŸœŸœŸœŸœ˜?š
Ÿ˜JšœŸœ˜ —JšŸœ
˜—Jšœ˜	—J˜JšŸœŸœ'˜AJš
œ˜Jš
œ
™
JšŸœ˜
š
Ÿ˜š
œ˜Jš
œ&˜&Jš
œ@˜@Jš
œ˜Jš
œ˜—Jš
œ˜—Jšœ˜J™—šกœŸœ
Ÿœ
Ÿœ˜7JšŸœ
ŸœŸœ
˜š
ŸœŸœ
Ÿœ
Ÿœ$ŸœŸœ
Ÿ˜DšŸœ&Ÿœ˜.Jš
œ˜JšŸœ
˜Jš
œ˜—JšŸœ
˜—Jšœ
Ÿœ
Ÿœ$˜9Jšœ˜—J˜šกœŸœ
Ÿœ
Ÿœ˜9JšŸœ
ŸœŸœ
˜š
ŸœŸœ
Ÿœ
Ÿœ&ŸœŸœ
Ÿ˜FšŸœ&Ÿœ˜.Jš
œ˜JšŸœ
˜Jš
œ˜—JšŸœ
˜—JšœŸœ
Ÿœ&˜>Jšœ˜—J˜Jš
ฯt™J˜š
œŸœ
Ÿœ
ŸœŸœŸœ
Ÿœ˜KJšŸœ
ŸœŸœ
˜š
ŸœŸœ
Ÿœ
Ÿœ$ŸœŸœ
Ÿ˜DJšŸœ Ÿœ
Ÿœ
˜7JšŸœ
˜—JšŸœ
Ÿœ˜Jšœ˜—J˜š	œŸœ
Ÿœ
ŸœŸœ
˜0JšŸœ
Ÿœ˜JšŸœ
ŸœŸœ
˜š
ŸœŸœ
Ÿœ
Ÿœ%ŸœŸœ
Ÿ˜EJšŸœ Ÿœ
Ÿœ
˜7JšŸœ
˜—JšŸœ
Ÿœ˜Jšœ˜—J˜šกœŸœ
Ÿœ
Ÿœ˜5JšŸœ
ŸœŸœ
˜JšœŸœ˜ —J˜šกœŸœ
Ÿœ
ŸœŸœ
Ÿœ˜:JšŸœ
ŸœŸœ
˜JšŸœ˜—J˜šก
œŸœ
Ÿœ
ŸœŸœ
Ÿœ˜>JšŸœ
ŸœŸœ
˜JšŸœ˜ —J˜šก
œŸœ
Ÿœ
ŸœŸœ
Ÿœ˜>JšŸœ
ŸœŸœ
˜JšŸœ˜ —J˜šกœŸœ
Ÿœ
ŸœŸœ
Ÿœ˜?JšŸœ
ŸœŸœ
˜JšŸœ˜—J˜šก	œŸœ
Ÿœ
ŸœŸœ
Ÿœ˜=JšŸœ
ŸœŸœ
˜JšŸœ˜—J˜šกœŸœ
Ÿœ
ŸœŸœ
Ÿœ˜;JšŸœ
ŸœŸœ
˜JšŸœ˜—J˜šกœŸœ
Ÿœ
Ÿœ˜,JšŸœ
ŸœŸœ
˜šŸœ
Ÿœ
Ÿœ˜šŸœŸœ
Ÿœ˜JšœŸœ˜JšœŸœ
˜J˜—Jš
œ˜J˜—Jšœ	˜—J˜šกœŸœ
Ÿœ
Ÿœ˜,JšŸœ
ŸœŸœ
˜šŸœ
Ÿœ
Ÿœ˜šŸœŸœ
Ÿœ˜JšœŸœ
˜JšœŸœ
˜J˜—Jš
œ˜J˜—Jšœ	˜—J˜šกœŸœ
Ÿœ
Ÿœ˜7JšŸœ
ŸœŸœ
˜Jš
œ*˜*Jšœ˜—J˜šกœŸœ
Ÿœ
Ÿœ˜5JšŸœ
ŸœŸœ
˜Jš
œ$˜$Jšœ˜—J˜šก
œŸœ
Ÿœ
Ÿœ˜3JšŸœ
ŸœŸœ
˜Jš
œ)˜)Jšœ 
˜—J˜šก	œŸœ
Ÿœ
Ÿœ˜/JšŸœ
ŸœŸœ
˜šŸœŸ˜š
œ˜JšœŸœ˜!Jš
œ˜Jš
œ˜—š
œ˜Jšœ2Ÿœ˜8Jš
œ˜Jš
œ˜—šŸœ˜7Jš
œX˜XJšœŸœ˜——Jšœ˜—J˜šกœŸœ
Ÿœ˜4JšŸœ
ŸœŸœ
˜šŸœ
Ÿœ
Ÿ˜JšŸœ
ŸœŸœ
˜JšŸœ˜šŸœ
Ÿœ
Ÿ˜JšŸœŸœ
ŸœŸ˜6JšŸœ
Ÿœ
˜
—JšŸœ
˜—šŸœ
Ÿœ
Ÿ˜JšŸœ@˜G—Jšœ˜—J˜šกœŸœ
Ÿœ˜&JšŸœ
ŸœŸœ
˜J˜Jšœ
˜
—J˜šกœŸœ
Ÿœ˜1JšŸœ
Ÿœ
Ÿœ
Ÿœ
˜šŸœŸœŸœ
Ÿœ˜8JšŸœŸœŸœ˜DJšœŸœ
˜Jš
œ˜—Jšœ˜—J˜šก
œŸœ˜#Jš
œ
˜
JšŸœŸœŸœŸœ˜JšŸœŸœ˜Jšœ%Ÿœ
˜*Jšœ
Ÿœ
˜Jš
œ6˜6Jš
œ*˜*šœ
ŸœŸœ
˜-JšŸœ-˜1—šŸœ
Ÿœ'ŸœŸ˜6Jšœ%ŸœŸ˜.šœ%ŸœŸœ˜3Jš
œ*˜*JšŸœ
ŸœŸœ˜8Jš
œ˜——Jš
œ
˜
Jš
œ
˜
—JšŸœŸœ˜JšŸœŸœŸœŸœ˜LJšŸœŸœŸœŸœ˜JJšœ
˜—J˜šกœŸœ˜!Jšœ
Ÿœ˜!šœ
Ÿœ
˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜JšœŸœ˜)JšŸœŸœ
ŸœŸœŸœ
Ÿœ
˜<JšœŸœ˜1JšŸœŸœ
ŸœŸœŸœ
Ÿœ
˜@JšœŸœ˜!Jš
ŸœŸœ
ŸœŸœŸœ
˜7JšœŸœ˜Jš
ŸœŸœ
ŸœŸœŸœ
˜5JšœŸœ˜(Jš
ŸœŸœ
Ÿœ
ŸœŸœ
˜;Jš
œ˜—Jšœ˜—J™Jš
œ˜J™šŸœ
Ÿ˜
JšœŸ˜ JšœŸ˜JšœŸœ-˜JJšœŸ˜Jšœ Ÿœ˜/JšœŸœT˜uJ–
"mycedar" stylešœŸœ˜0J–
"mycedar" stylešœ#Ÿœ
˜ถ
J–
"mycedar" styleš
œ–
˜–
J˜——…—+=}