DIRECTORY
AMBridge, AMTypes, Atom, Containers, Convert, IO, Labels, MessageWindow, Rope, VFonts, ViewerOps, ViewRec;


ViewRecAux: CEDAR PROGRAM
IMPORTS AMBridge, AMTypes, Atom, Containers, Convert, IO, Labels, MessageWindow, Rope, VF:VFonts, ViewerOps, ViewRec
EXPORTS ViewRec =

BEGIN OPEN ViewRec;

EnumData: TYPE = REF EnumDataRep;
EnumDataRep: TYPE = RECORD [
wideType: Type];

enumerationHandler: SimpleHandler _ NEW [SimpleHandlerRep _ [
Parse: ParseEnumeration,
UnParse: UnParseEnumeration,
Max: MaxEnumeration,
Butt: ButtEnumeration,
blueDoc: "Shift Blue => previous member of enumeration,
Not-Shift Blue => next member of enumeration,\n"]];

ParseEnumeration: ParseProc =
BEGIN
ed: EnumData _ NARROW[handlerData];
new: TypedVariable;
index: CARDINAL;
ok _ TRUE;
index _ AMTypes.NameToIndex[type: ed.wideType, name: asRope !AMTypes.Error => {ok _ FALSE; CONTINUE}];
IF NOT ok THEN {[index, ok] _ ParseCard[asRope]; index _ index+1};
IF NOT ok THEN RETURN [FALSE];
new _ AMTypes.Value[type: ed.wideType, index: index !AMTypes.Error => {ok _ FALSE; CONTINUE}];
IF ok THEN AMTypes.Assign[lhs: tv, rhs: new];
END;

ParseCard: PROC [asRope: ROPE] RETURNS [card: CARDINAL, ok: BOOLEAN] =
BEGIN
lc: LONG CARDINAL _ 0;
ok _ TRUE;
lc _ Convert.CardFromWholeNumberLiteral[asRope !Convert.Error => {ok _ FALSE; CONTINUE}];
IF lc <= LAST[CARDINAL] THEN card _ lc ELSE ok _ FALSE;
END;

UnParseEnumeration: UnParseProc =
BEGIN
asRope _ MyTVToName[tv];
END;

MyTVToName: PROC [et: AMTypes.TypedVariable --of an enumerated type--]
RETURNS [r: ROPE] =
BEGIN
r _ AMTypes.TVToName[et !AMTypes.Error =>
TRUSTED {r _ IO.PutFR["%g", IO.card[AMBridge.TVToCardinal[et]]];
CONTINUE}];
END;

MaxEnumeration: MaxProc =
BEGIN
maxWidthNeeded _ 20;
FOR tv _ AMTypes.First[targType], AMTypes.Next[tv] WHILE tv # NIL DO
maxWidthNeeded _ MAX[maxWidthNeeded, VF.StringWidth[AMTypes.TVToName[tv !AMTypes.Error => EXIT]]];
ENDLOOP;
END;

ButtEnumeration: ButtProc =
BEGIN
IF shift
THEN {IF (new _ PrevEnum[tv]) = NIL THEN new _ AMTypes.Last[targType]}
ELSE {IF (new _ AMTypes.Next[tv]) = NIL THEN new _ AMTypes.First[targType]};
END;

PrevEnum: PROC[tv: TypedVariable--enumerated, subrange, basic--]
RETURNS[TypedVariable] = TRUSTED {
val: LONG INTEGER = AMBridge.TVToLI[tv];
type: Type = AMTypes.TVType[tv];
newTV: TypedVariable;
IF val = AMBridge.TVToLI[AMTypes.First[type]] THEN RETURN[NIL];
newTV _ AMTypes.New[type];
AMBridge.SetTVFromLC[newTV, LOOPHOLE[val - 1, LONG CARDINAL]];  -- NOTE mach dep enum?
RETURN[newTV]};
--modified RTTypedVariablesImpl.Next last modified on May 23, 1983 10:52 am by Paul Rovner--

EnumPrev: PROC [of: TypedVariable, type: Type] RETURNS [is: TypedVariable] =
BEGIN
is _ AMTypes.First[type];
WHILE is # NIL DO
next: TypedVariable _ AMTypes.Next[is];
IF AMTypes.TVEqual[next, of] THEN RETURN;
is _ next;
ENDLOOP;
is _ AMTypes.Last[type];
END;

RecognizeEnumeration: PUBLIC Recognizer =
BEGIN
IF NOT onlyRecognize THEN
BEGIN
ed: EnumData _ NEW [EnumDataRep _ [
wideType: AMTypes.GroundStar[t] ]];
handler _ enumerationHandler;
handlerData _ ed;
END;
IKnowYou _ TRUE;
END;

atomHandler: SimpleHandler _ NEW [SimpleHandlerRep _ [
Parse: ParseAtom,
UnParse: UnParseAtom,
Max: MaxAtom
]];

ParseAtom: ParseProc --PROC [asRope: ROPE, tv: TypedVariable, targType: Type, handlerData: REF ANY] RETURNS [ok: BOOLEAN]-- = TRUSTED
BEGIN
AMTypes.Assign[tv, AMBridge.TVForATOM[Atom.MakeAtom[asRope]]];
END;

UnParseAtom: UnParseProc --PROC [tv: TypedVariable, targType: Type, handlerData: REF ANY] RETURNS [asRope: ROPE]-- = TRUSTED
BEGIN
asRope _ IF AMTypes.IsNil[tv] THEN "--NIL--" ELSE Atom.GetPName[AMBridge.TVToATOM[tv]];
END;

MaxAtom: MaxProc --PROC [tv: TypedVariable, targType: Type, handlerData: REF ANY] RETURNS [maxWidthNeeded: INTEGER, lines: REAL _ 1]-- =
{maxWidthNeeded _ VF.StringWidth["This looks good"]};

RecognizeAtom: PUBLIC Recognizer =
BEGIN
handler _ atomHandler;
IKnowYou _ TRUE;
END;

NumData: TYPE = REF NumDataRep;
NumDataRep: TYPE = RECORD [
typeClass: AMTypes.Class,
cvt: ConvertProc,
tempAsTV: TypedVariable _ NIL,
tempAsRef: REF ANY];

ConvertProc: TYPE = PROC [nd: NumData, asRope: ROPE] RETURNS [ok: BOOLEAN _ TRUE];

numHandlerDatas: ARRAY AMTypes.Class OF NumData _ ALL[NIL];

numberHandler: SimpleHandler _ NEW [SimpleHandlerRep _ [
Parse: ParseNumber,
UnParse: UnParseNumber,
Max: MaxNumber,
Butt: NIL]];

ParseNumber: ParseProc =
BEGIN
nd: NumData _ NARROW[handlerData];
ok _ nd.cvt[nd, asRope !Convert.Error => {ok _ FALSE; CONTINUE}];
IF ok THEN
BEGIN
AMTypes.Assign[tv, nd.tempAsTV !AMTypes.Error =>
{ok _ FALSE; CONTINUE}];
END;
END;

ToC: ConvertProc =
BEGIN
c: REF CARDINAL _ NARROW[nd.tempAsRef];
lc: LONG CARDINAL _ 0;
lc _ Convert.CardFromWholeNumberLiteral[asRope];
IF lc <= LAST[CARDINAL] THEN c^ _ lc ELSE ok _ FALSE;
END;

ToI: ConvertProc =
BEGIN
i: REF INTEGER _ NARROW[nd.tempAsRef];
li: INT;
li _ Convert.IntFromRope[asRope];
IF li IN [FIRST[INTEGER] .. LAST[INTEGER]] THEN i^ _ li ELSE ok _ FALSE;
END;

ToLC: ConvertProc =
BEGIN
c: REF LONG CARDINAL _ NARROW[nd.tempAsRef];
c^ _ Convert.CardFromWholeNumberLiteral[asRope];
END;

ToLI: ConvertProc =
BEGIN
i: REF LONG INTEGER _ NARROW[nd.tempAsRef];
i^ _ Convert.IntFromRope[asRope];
END;

ToR: ConvertProc =
BEGIN
r: REF REAL _ NARROW[nd.tempAsRef];
r^ _ Convert.RealFromRope[asRope !Convert.Error =>
{r^ _ Convert.CardFromWholeNumberLiteral[asRope !Convert.Error =>
{r^ _ Convert.IntFromRope[asRope !Convert.Error =>
{ok _ FALSE; CONTINUE}];
CONTINUE}];
CONTINUE}];
END;

UnParseNumber: UnParseProc =
BEGIN
nd: NumData _ NARROW[handlerData];
AMTypes.Assign[nd.tempAsTV, tv];
asRope _ SELECT nd.typeClass FROM
cardinal => Convert.RopeFromCard[NARROW[nd.tempAsRef, REF CARDINAL]^],
integer => Convert.RopeFromInt[NARROW[nd.tempAsRef, REF INTEGER]^],
longCardinal => Convert.RopeFromCard[NARROW[nd.tempAsRef, REF LONG CARDINAL]^],
longInteger => Convert.RopeFromInt[NARROW[nd.tempAsRef, REF INT]^],
real => Convert.RopeFromReal[NARROW[nd.tempAsRef, REF REAL]^],
ENDCASE => ERROR;
END;

MaxNumber: MaxProc =
BEGIN
nd: NumData _ NARROW[handlerData];
maxWidthNeeded _ VF.StringWidth[SELECT nd.typeClass FROM
cardinal => "65,536",
integer => "-29,860",
longCardinal => "0,123,456,789",
longInteger => "-0,123,456,789",
real => "-3.456789E-29",
ENDCASE => ERROR];
END;

RecognizeNumber: PUBLIC Recognizer =
BEGIN
IF NOT onlyRecognize THEN
BEGIN
wt: Type _ AMTypes.GroundStar[t];
tc: AMTypes.Class _ AMTypes.TypeClass[wt];
handler _ numberHandler;
handlerData _ numHandlerDatas[tc];
END;
IKnowYou _ TRUE;
END;

ropeHandler: SimpleHandler _ NEW [SimpleHandlerRep _ [
Parse: ParseRope,
UnParse: UnParseRope,
Max: MaxRope,
Butt: NIL]];

ParseRope: ParseProc = TRUSTED
BEGIN
asTV: TypedVariable _ AMBridge.TVForROPE[asRope];
ok _ TRUE;
AMTypes.Assign[tv, asTV !AMTypes.Error => {ok _ FALSE; CONTINUE}];
END;

UnParseRope: UnParseProc =
BEGIN
asRope _ AMTypes.TVToName[tv];
END;

MaxRope: MaxProc = {RETURN [1024, 2]};

RecognizeRope: PUBLIC Recognizer =
BEGIN
IF NOT onlyRecognize THEN {handler _ ropeHandler; handlerData _ NIL};
IKnowYou _ TRUE;
END;

sequenceHandler: ComplexHandler _ NEW [ComplexHandlerRep _ [
producer: SequenceProduce,
updater: SequenceUpdate]];

SequenceProduce: ComplexProducer =
BEGIN
rv: RecordViewer _ ViewTV[agg: tv, specs: context.bindings, label: context.name.Concat[":"], parent: context.for, sample: TRUE, createOptions: context.createOptions, viewerInit: [parent: context.main, scrollable: FALSE, iconic: FALSE], paint: FALSE];
clientData _ rv;
v _ rv.RVQuaViewer[];
sampleable _ FALSE;
END;

SequenceUpdate: Updater = {};

SequenceElement: ElementGiver --PROC [agg: TypedVariable, which: Id, handlerData, clientData: REF ANY] RETURNS [eh: EltHandle]-- =
BEGIN
rv: RecordViewer _ NarrowToRV[clientData];
eh _ rv.GetEltHandle[LIST[which]];
END;

RecognizeSequence: PUBLIC Recognizer =
BEGIN
IF NOT onlyRecognize THEN {handler _ sequenceHandler; handlerData _ NIL};
IKnowYou _ TRUE;
END;

recordHandler: ComplexHandler _ NEW [ComplexHandlerRep _ [
producer: RecordProduce,
relayouter: ReLayoutRecord,
updater: RecordUpdate,
elementGiver: RecordElement]];

RecordElement: ElementGiver --PROC [agg: TypedVariable, which: Id, handlerData, clientData: REF ANY] RETURNS [eh: EltHandle]-- =
BEGIN
rv: RecordViewer _ NarrowToRV[clientData];
eh _ rv.GetEltHandle[LIST[which]];
END;

RecordUpdate: Updater --PROC [tv: TypedVariable, v: Viewer, handlerData, clientData: REF ANY]-- =
BEGIN
rv: RecordViewer _ NarrowToRV[clientData];
SampleRV[rv];
END;

RecordProduce: ComplexProducer --PROC [tv: TypedVariable, context: Context, handlerData: REF ANY] RETURNS [v: Viewer, clientData: REF ANY, sampleable: BOOLEAN _ TRUE]-- =
BEGIN
container, name, value: Viewer;
rv: RecordViewer;
mx: INTEGER;
rco: CreateOptions _ context.createOptions;
visibleCount: REF INT _ NARROW[handlerData];
IF visibleCount^ < 1 THEN RETURN [NIL, NIL, FALSE];
container _ Containers.Create[info: [parent: context.main, ww: context.maxWidth, wh: 10, border: context.createOptions.bordElts, scrollable: FALSE], paint: FALSE];
name _ Labels.Create[
info: [parent: container, name: context.name.Concat[":"], border: FALSE],
font: RightFont[context.createOptions.nameFont],
paint: FALSE];
mx _ name.wx + name.ww + context.createOptions.nvSep;
clientData _ rv _ ViewTV[agg: tv,
specs: context.bindings,
toButt: context.toButt,
parent: context.for,
sample: FALSE,
createOptions: rco,
viewerInit: [parent: container,
border: context.createOptions.bordRecs,
wx: mx, wh: 10,
ww: MAX[container.cw - mx, context.createOptions.minRecordWidth],
scrollable: FALSE],
paint: FALSE];
value _ rv.RVQuaViewer[];
ViewerOps.MoveViewer[
viewer: container,
x: container.wx,
y: container.wy,
w: MAX[name.wx + name.ww, value.wx + value.ww],
h: MAX[name.wy + name.wh, value.wy + value.wh],
paint: FALSE];
v _ container;
END;

ReLayoutRecord: PROC [v: Viewer, maxWidth: INTEGER, handlerData, clientData: REF ANY] =
BEGIN
rv: RecordViewer _ NarrowToRV[clientData];
rvv: Viewer _ rv.RVQuaViewer[];
outerDiff: INTEGER _ v.ww - v.cw;
rv.ReLayout[maxWidth - outerDiff - rvv.wx, FALSE];
ViewerOps.MoveViewer[viewer: v, x: v.wx, y: v.wy,
w: outerDiff + rvv.wx + rvv.ww,
h: MAX[10, (v.wh - v.ch) + rvv.wy + rvv.wh],
paint: FALSE];
END;

RecognizeRecord: PUBLIC Recognizer =
BEGIN
simpleEnough: BOOLEAN;
visibleCount: INT;
[simpleEnough, visibleCount] _ SimpleEnough[rt: AMTypes.UnderType[t], specs: specs, createOptions: createOptions];
IF IKnowYou _ simpleEnough THEN
BEGIN
handler _ recordHandler;
handlerData _ NEW [INT _ visibleCount];
END;
END;

Setup: PROC =
BEGIN
countAsAny: REF ANY;
Foo: TYPE = RECORD [elts: SEQUENCE length: CARDINAL OF CARDINAL];
foo: TypedVariable;
seqType: Type;

TRUSTED {foo _ AMBridge.TVForReferent[NEW[Foo[1]]]};
seqType _ AMTypes.TVType[AMTypes.IndexToTV[foo, 1]];

numHandlerDatas[cardinal] _ NEW [NumDataRep _ [typeClass: cardinal, cvt: ToC, tempAsRef: NEW [CARDINAL] ]];
numHandlerDatas[integer] _ NEW [NumDataRep _ [typeClass: integer, cvt: ToI, tempAsRef: NEW [INTEGER] ]];
numHandlerDatas[longCardinal] _ NEW [NumDataRep _ [typeClass: longCardinal, cvt: ToLC, tempAsRef: NEW [LONG CARDINAL] ]];
numHandlerDatas[longInteger] _ NEW [NumDataRep _ [typeClass: longInteger, cvt: ToLI, tempAsRef: NEW [LONG INTEGER] ]];
numHandlerDatas[real] _ NEW [NumDataRep _ [typeClass: real, cvt: ToR, tempAsRef: NEW [REAL] ]];

FOR c: AMTypes.Class IN AMTypes.Class DO
TRUSTED {
IF numHandlerDatas[c] # NIL THEN numHandlerDatas[c].tempAsTV _ AMBridge.TVForReferent[numHandlerDatas[c].tempAsRef]};
ENDLOOP;

RegisterRecognizerByType[r: RecognizeEnumeration, end: Back, type: CODE[AddPlace], reductions: TypeClass];
RegisterRecognizerByType[r: RecognizeAtom, end: Back, type: CODE[ATOM], reductions: TypeClass];

RegisterRecognizerByType[r: RecognizeNumber, end: Back, type: CODE[INTEGER], reductions: TypeClass];
RegisterRecognizerByType[r: RecognizeNumber, end: Back, type: CODE[CARDINAL], reductions: TypeClass];
RegisterRecognizerByType[r: RecognizeNumber, end: Back, type: CODE[LONG INTEGER], reductions: TypeClass];
RegisterRecognizerByType[r: RecognizeNumber, end: Back, type: CODE[LONG CARDINAL], reductions: TypeClass];
RegisterRecognizerByType[r: RecognizeNumber, end: Back, type: CODE[REAL], reductions: TypeClass];

RegisterRecognizerByType[r: RecognizeRope, end: Back, type: CODE[ROPE], reductions: TypeClass];

RegisterRecognizerByType[r: RecognizeRecord, end: Back, type: CODE[Context], reductions: TypeClass];
RegisterRecognizerByType[r: RecognizeRecord, end: Back, type: AMTypes.Domain[CODE[Recognizer]], reductions: TypeClass];

RegisterRecognizerByType[r: RecognizeSequence, end: Back, type: seqType, reductions: TypeClass];
RegisterRecognizerByType[r: RecognizeSequence, end: Back, type: CODE[ARRAY BOOLEAN OF REAL], reductions: TypeClass];

countAsAny _ Atom.GetProp[atom: $ViewRecCount, prop: $ViewRecCount];
IF countAsAny = NIL THEN
Atom.PutProp[atom: $ViewRecCount, prop: $ViewRecCount, val: NEW [INT _ 1]]
ELSE BEGIN
ri: REF INT _ NARROW[countAsAny];
ri^ _ ri^ + 1;
MessageWindow.Append[
message: IO.PutFR["ViewRec has been loaded %g times!
Confusion is likely to result.
I recommend you rollback and do things right.", IO.int[ri^]],
clearFirst: TRUE];
ERROR;
END;
END;

Setup[];

END.
|ViewRecAux.Mesa
Last Edited by: Spreitzer, October 30, 1983 6:47 pm
Last Edited by: Maxwell, March 11, 1983 10:56 am
Κ|˜J™J™3J™0Icode˜š
Οk	˜	Kšœ.œ:˜j—K˜K˜šΠbx
œ
˜Kšœ/œœ˜tKšœ
˜—K˜Kšœ
œ	˜K˜Kšœ
œœ
˜!šœ
œœ˜Kš
œ˜—K˜šœ$œ˜=K˜K˜K˜K˜˜7K˜3——K˜šΟnœ
˜Kš
˜Kšœœ˜#K˜Kšœœ
˜Kšœœ
˜
KšœTœœ˜fKšœ
œœ4˜BKš
œ
œœ
œœ˜KšœLœœ˜^Kšœœ#˜-Kšœ
˜—K˜šŸ	œœ
œœœœ˜FKš
˜Kšœœ
œ˜Kšœœ
˜
KšœGœœ˜YKšœœ
œœœœ
˜7Kšœ
˜—K˜šŸœ˜!Kš
˜Kš
œ˜Kšœ
˜—K˜šŸ
œœΟcœ
˜FKšœœ˜Kš
˜˜)Kšœœ
œ"˜@Kšœ˜—Kšœ
˜—K˜šŸœ˜Kš
˜K˜šœ0œœ
˜DKšœœœ3œ˜bKšœ
˜—Kšœ
˜—K˜šŸœ˜Kš
˜šœ˜Kšœœœ
œ˜FKšœœœ
œ ˜L—Kšœ
˜—K˜šŸœœ œ
˜@Jšœœ˜"Jšœœ
œ˜(J˜ J˜Jšœ,œ
œ
œ˜?J˜Jšœœ
œ
œ ˜VJšœ	˜Jš
 \˜\J˜—šŸœœ!œ˜LKš
˜K˜šœœ
˜K˜'Kšœœ
œ
˜)K˜
Kšœ
˜—K˜Kšœ
˜K˜—šŸœœ
˜)Kš
˜šœ
œ˜Kš
˜šœœ˜#Kš
œ#˜#—K˜K˜Kšœ
˜—Kšœœ
˜Kšœ
˜—K˜šœœ˜6Kš
œ˜Kš
œ˜K˜K˜—K˜šŸ	œ fœ˜…
Kš
˜Kš
œ>˜>Kšœ
˜—K˜šŸœ Yœ˜|Kš
˜Kšœ	œœœ&˜WKšœ
˜—K˜šŸœ
 uœ˜ˆ
Kšœœ!˜5—K˜šŸ
œœ
˜"Kš
˜K˜Kšœœ
˜Kšœ
˜—K˜Kšœ	œœ˜šœœœ˜K˜K˜Kšœœ
˜Kšœœ
œ˜—K˜KšŸœœœœœœœ˜RK˜Kš	œœœœ
œ˜;K˜šœœ˜8K˜K˜K˜Kšœœ˜—K˜šŸœ
˜Kš
˜Kšœœ˜"Kšœ/œœ˜Ašœ˜
Kš
˜š
œ0˜0Kšœœœ˜—Kšœ
˜—Kšœ
˜—K˜šŸœ˜Kš
˜Kšœœ
œœ˜'Kšœœ
œ˜Kš
œ0˜0Kšœœ
œœ	œœ
˜5Kšœ
˜K˜—šŸœ˜Kš
˜Kšœœ
œœ˜&Kšœœ
˜K˜!Kšœœœ
œœ
œœ	œœ
˜HKšœ
˜K˜—šŸœ˜Kš
˜Kš	œœ
œ
œœ˜,Kš
œ0˜0Kšœ
˜K˜—šŸœ˜Kš
˜Kš	œœ
œ
œœ˜+K˜!Kšœ
˜K˜—šŸœ˜Kš
˜Kšœœ
œœ˜#š
œ2˜2š
œA˜Aš
œ2˜2Kšœœœ˜—Kšœ˜—Kšœ˜—Kšœ
˜—K˜šŸ
œ˜Kš
˜Kšœœ˜"K˜ šœ	œ˜!Kšœ!œœ
œ˜FKšœœœ
œ˜CKš	œ%œœ
œ
œ˜OKšœ#œœ
œ˜CKšœœœ
œ˜>Kšœœ
˜—Kšœ
˜—K˜šŸ	œ˜Kš
˜Kšœœ˜"šœœ
œ˜8K˜K˜K˜ K˜ K˜Kšœœ˜—Kšœ
˜—K˜šŸœœ
˜$Kš
˜šœ
œ˜Kš
˜K˜!K˜*K˜K˜"Kšœ
˜—Kšœœ
˜Kšœ
˜—K˜šœœ˜6K˜K˜K˜
Kšœœ˜—K˜šŸ	œ˜Kš
˜K˜1Kšœœ
˜
Kšœ0œœ˜BKšœ
˜—K˜šŸœ˜Kš
˜K˜Kšœ
˜—K˜KšŸœ
œ˜&K˜šŸ
œœ
˜"Kš
˜Kšœ
œœ'œ˜EKšœœ
˜Kšœ
˜—K˜šœ"œ˜<K˜K˜—K˜šŸœ˜"Kš
˜Kš	œzœWœ
œ
œ˜ϊ
K˜K˜Kšœ
œ
˜Kšœ
˜—K˜KšŸœ˜K˜šŸœ bœ˜‚
Kš
˜K˜*Kšœœ	˜"Kšœ
˜—K˜šŸœœ
˜&Kš
˜Kšœ
œœ+œ˜IKšœœ
˜Kšœ
˜—K˜šœ œ˜:Kš
œ˜K˜Kš
œ˜Kš
œ˜—K˜šŸ
œ bœ˜€
Kš
˜K˜*Kšœœ	˜"Kšœ
˜—K˜šŸœ
 Iœ˜aKš
˜K˜*K˜
Kšœ
˜—K˜šŸ
œ ‰
œ˜ͺ
Kš
˜K˜K˜Kšœœ
˜K˜+Kšœœ
œœ˜,Kšœœ
œœœœ˜3Kšœ
œ
œ˜£
š
œ˜KšœBœ˜IKš
œ0˜0Kšœœ˜—Kš
œ5˜5˜!K˜K˜K˜Kšœœ
˜K˜˜K˜'K˜Kšœœ:˜AKšœœ˜—Kšœœ˜—K˜š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœœ)˜/Kšœœ)˜/Kšœœ˜—K˜Kšœ
˜—K˜š
Ÿœœœœ
œ˜WKš
˜Kš
œ*˜*K˜Kšœœ˜!Kšœ+œ˜2š
œ1˜1Kš
œ˜Kšœœ&˜,Kšœœ˜—Kšœ
˜—K˜šŸœœ
˜$Kš
˜Kšœœ
˜Kšœœ
˜K˜ršœ˜Kš
˜K˜Kšœœœ˜'Kšœ
˜—Kšœ
˜—K˜šŸœœ˜
Kš
˜Kšœœ
œ
˜Kš
œœœœ	œ
œ
œ˜AK˜K˜K˜Kšœœ˜4K˜4K˜Kšœœ:œœ˜kKšœœ9œœ˜hKš	œ œ?œœ
œ˜yKš	œœ>œœ
œ˜vKšœœ6œœ˜_K˜šœœ˜(š
	˜	Kšœœ
œU˜u—Kšœ
˜—K˜KšœCœ#˜jKšœ<œ
œ˜_K˜Kšœ>œ
œ˜dKšœ>œ
œ˜eKšœ>œ
œ
œ˜iKšœ>œ
œ
œ˜jKšœ>œ
œ˜aK˜Kšœ<œ
œ˜_K˜Kšœ>œ"˜dKšœMœ&˜wK˜Kš
œ`˜`Kšœ@œ
œ
œ
œ
œ˜tK˜K˜Dšœœ
˜Kšœ<œœ˜J—šœ
˜
Kšœœ
œœ
˜!K˜˜˜4K˜Kšœ0œ˜=—Kšœœ˜—Kšœ
˜Kšœ
˜—Kšœ
˜—K˜K˜K˜Kšœ
˜—…—3‚Cz