DIRECTORY Basics, BasicTime, CedarProcess, FS, IdleBackdoor, Imager, ImagerBackdoor, ImagerBox, ImagerFont, ImagerPixelArray, ImagerPixelMap, ImagerPrivate, ImagerTerminal, ImagerTransformation, IO, Menus, PrincOps, Process, Random, Real, RealFns, Rope, Terminal, ThisMachine, TIPUser, Vector2, ViewerClasses, ViewerOps;

Kal: CEDAR PROGRAM
IMPORTS Basics, BasicTime, CedarProcess, FS, IdleBackdoor, Imager, ImagerBackdoor, ImagerBox, ImagerFont, ImagerPixelMap, ImagerTerminal, ImagerTransformation, IO, Process, Random, Real, RealFns, Rope, Terminal, ThisMachine, TIPUser, ViewerOps
=

{

ROPE: TYPE = Rope.ROPE;
Viewer: TYPE = ViewerClasses.Viewer;
PixelMap: TYPE = ImagerPixelMap.PixelMap;
PixelArray: TYPE = ImagerPixelArray.PixelArray;
Font: TYPE = ImagerFont.Font;
Transformation: TYPE = ImagerTransformation.Transformation;

Generator: TYPE = REF GeneratorRep;
GeneratorRep: TYPE = RECORD [a, b, c, countLow, countHigh: CARDINAL];

TextData: TYPE = RECORD [
texts: TextList,
numTexts: NAT,
totalProbability: REAL];

TextList: TYPE = LIST OF Text;
Text: TYPE = RECORD [
text: ROPE,
bounds: Imager.Box,
cumProb: REAL
];

Request: TYPE = REF RequestRep;
RequestRep: TYPE = RECORD [
proc: PROC [data: REF ANY, context: Imager.Context],
data: REF ANY];

td: TextData;
font: Font _ NIL;
rs: Random.RandomStream _ Random.Create[seed: -1];

Milliseconds: TYPE = INT;
OneSecond: Milliseconds = 1000;

Root3Quarters: REAL _ RealFns.SqRt[0.75];
symmetry: CARDINAL _ 8;
periodLow: CARDINAL _ 10000;
periodHigh: CARDINAL _ 10000;
persistence: CARDINAL _ 5000;
halfBMin: INTEGER _ (LAST[CARDINAL]-2000)/2;
halfBMax: INTEGER _ (LAST[CARDINAL]-1500)/2;
halfCMin: INTEGER _ 0;
halfCMax: INTEGER _ (LAST[CARDINAL]-1)/2;
AtATime: NAT _ 64;
upTextMin: Milliseconds _ 10*OneSecond;
upTextMax: Milliseconds _ 60*OneSecond;
downTextMin: Milliseconds _ 1*OneSecond;
downTextMax: Milliseconds _ 6*OneSecond;
pmBoundsCheck: BOOL _ TRUE;
runningPriority: CedarProcess.Priority _ background;

xStateB: Generator _ NEW [GeneratorRep _ [1, 65536-1849, 3, , ]];
xStateE: Generator _ NEW [GeneratorRep];
yStateB: Generator _ NEW [GeneratorRep _ [1, 65536-1809, 3, , ]];
yStateE: Generator _ NEW [GeneratorRep];

pausePeriod: Process.Ticks _ 0;
retraces: NAT _ 1;
machineName: ROPE _ ThisMachine.Name[];

sfvcFlavor: ATOM _ $KaleidoscopeViewerClass;

sfvc: ViewerClasses.ViewerClass _ NEW [ViewerClasses.ViewerClassRec _ [
flavor: sfvcFlavor,
notify: NotifySFV,
paint: PaintSFV,
tipTable: TIPUser.InstantiateNewTIPTable["StarFielder.TIP"]
]];

sfv: Viewer;

okToGo: BOOL _ FALSE;
going: BOOL _ FALSE;

NotifySFV: PROC [self: Viewer, input: LIST OF REF ANY] = {
a: ATOM _ NARROW[input.first];
SELECT a FROM
$Start => {okToGo _ TRUE; IF NOT going THEN TRUSTED {Process.Detach[FORK Viewit[]]}};
$Stop => okToGo _ FALSE;
ENDCASE => ERROR;
};

PaintSFV: PROC [self: Viewer, context: Imager.Context, whatChanged: REF ANY, clear: BOOL] RETURNS [quit: BOOL _ FALSE] --ViewerClasses.PaintProc-- = {
IF whatChanged = NIL
THEN sfvPM _ PixelMapFromViewer[self]
ELSE WITH whatChanged SELECT FROM
r: Request => r.proc[r.data, context];
ENDCASE => ERROR;
};

sfvPM: PixelMap;
icConsumer: PROC [context: Imager.Context, pm: PixelMap];

Satisfy: PROC [data: REF ANY, context: Imager.Context] = {
icConsumer[context, sfvPM];
};

Viewit: PROC = {
r: Request;
GiveContext: PROC [to: PROC [context: Imager.Context, pm: PixelMap]] = {
TRUSTED {icConsumer _ to};
ViewerOps.PaintViewer[viewer: sfv, hint: client, clearClient: FALSE, whatChanged: r];
};
TRUSTED {
CedarProcess.SetPriority[runningPriority];
r _ NEW [RequestRep _ [Satisfy, NIL]]};
going _ TRUE;
Dewit[giveContext: GiveContext, xp0: 0, yp0: 0, xp1: sfv.cw, yp1: sfv.ch, Stop: StopViewing, inverse: FALSE, vt: Terminal.Current[]];
going _ FALSE;
};

StopViewing: PROC RETURNS [BOOL] =
{RETURN [NOT okToGo]};

Kalidle: PROC [parent: REF ANY, clientData: REF ANY _ NIL, 
mouseButton: Menus.MouseButton _ red, shift, control: BOOL _ FALSE] --Buttons.ButtonProc-- = {
symmetry _ SELECT shift FROM
FALSE => 8,
TRUE => 12,
ENDCASE => ERROR;
Sleepit[NOT control]};

Sleepit: PROC [logout: BOOL] = {
[] _ IdleBackdoor.UseAlternateVT[vtProc: DoForVT, logout: logout];
};

vtContext: Imager.Context;
vtPM: PixelMap;
GiveVTContext: PROC [to: PROC [context: Imager.Context, pm: PixelMap]] =
{to[vtContext, vtPM]};

DoForVT: PROC [vt: Terminal.Virtual] = {
Doit: PROC = {
Dewit[giveContext: GiveVTContext, xp0: 0, yp0: 0, xp1: vt.bwWidth, yp1: vt.bwHeight, Stop: KeyTyped, inverse: TRUE, vt: vt];
};
vt.Select[];
[] _ vt.SetBWBitmapState[allocated];
[vtContext, vtPM] _ ContextAndPMFromVT[vt];
[] _ vt.SetBWBitmapState[displayed];
CedarProcess.DoWithPriority[runningPriority, Doit];
[] _ vt.SetBWBitmapState[none];
};

KeyTyped: PROC RETURNS [stop: BOOL] = {
stop _ IdleBackdoor.KeyTyped[IdleBackdoor.defaultKeyFilter]};

upText, downText, T: Milliseconds _ 0;
curText: Text;
cto: Vector2.VEC;
cts: REAL;

FloorLog2: PROC [n: CARDINAL] RETURNS [log: INTEGER] = {
log _ SELECT n FROM
<      2B =>  0,
<      4B =>  1,
<     10B =>  2,
<     20B =>  3,
<     40B =>  4,
<    100B =>  5,
<    200B =>  6,
<    400B =>  7,
<   1000B =>  8,
<   2000B =>  9,
<   4000B => 10,
<  10000B => 11,
<  20000B => 12,
<  40000B => 13,
< 100000B => 14,
ENDCASE =>  15};

TwoToThe: ARRAY [0 .. 15] OF CARDINAL = [
00001H, 00002H, 00004H, 00008H,
00010H, 00020H, 00040H, 00080H,
00100H, 00200H, 00400H, 00800H,
01000H, 02000H, 04000H, 08000H];

Advance: PROC [gen: Generator] = TRUSTED {
gen.a _ Basics.BITXOR[gen.a + gen.b, gen.b];
IF (gen.countLow _ gen.countLow - 1) = 0 THEN {
gen.b _ Basics.BITXOR[gen.b + gen.c, gen.c];
gen.countLow _ periodLow;
IF (gen.countHigh _ gen.countHigh - 1) = 0 THEN {
rs _ Random.Create[seed: gen.c];
[] _ rs.NextInt[];
gen.c _ rs.ChooseInt[0, halfCMax]*2+1;
gen.countHigh _ periodHigh;
};
};
};

Dewit: PROC [giveContext: PROC [to: PROC [context: Imager.Context, pm: PixelMap]], xp0, yp0, xp1, yp1: INTEGER, Stop: PROC RETURNS [BOOL], inverse: BOOL, vt: Terminal.Virtual] = {
sMin, fMin: INTEGER;	--bounds of used area
sMid, fMid: INTEGER;	--center of used area
radius: LONG CARDINAL;	--of used area
radiusTimesRootThreeQuarters: LONG CARDINAL;
max: INTEGER;	--maximum z - zmin
PickText: PROC [T: Milliseconds] = {
p: REAL _ Choose[0, td.totalProbability*0.999];
tl: TextList;
FOR tl _ td.texts, tl.rest WHILE p > tl.first.cumProb DO NULL ENDLOOP;
curText _ tl.first;
upText _ T + rs.ChooseInt[upTextMin, upTextMax];
downText _ upText + rs.ChooseInt[downTextMin, downTextMax];
cts _ (xp1 - xp0)/(curText.bounds.xmax - curText.bounds.xmin)/2;
cto _ [
x: Choose[
xp0 - cts*curText.bounds.xmin,
xp1 - cts*curText.bounds.xmax],
y: Choose[
yp0 - cts*curText.bounds.ymin,
yp1 - cts*curText.bounds.ymax]];
};
DrawText: PROC [context: Imager.Context, pm: PixelMap] = {
InnerDoit: PROC = {
context.SetXY[cto];
context.TranslateT[cto];
context.ScaleT[cts];
context.SetFont[font];
context.ShowRope[curText.text];
};
Imager.DoSave[context, InnerDoit];
};
pmBounds: DeviceBounds;
DeviceBounds: TYPE = RECORD [sMin, fMin, sMax, fMax: INTEGER];
Spots: PROC [pm: PixelMap, u, v: CARDINAL, val: BOOL] _ SELECT symmetry FROM 8 => Spots8, 12 => Spots12, ENDCASE => ERROR;
Spots8: PROC [pm: PixelMap, u, v: CARDINAL, val: BOOL] = TRUSTED {
BitArrayPtr: TYPE = LONG POINTER TO PACKED ARRAY [0..0) OF BOOL;
SetBit: PROC [f, s: NAT, val: BOOL] = TRUSTED INLINE {
s _ sMin + s;
f _ fMin + f;
LOOPHOLE[pm.refRep.pointer + Basics.LongMult[(s - pm.sOrigin), pm.refRep.rast], BitArrayPtr][f - pm.fOrigin] _ val;
};
ur: NAT _ Basics.HighHalf[radius*u];
vr: NAT _ Basics.HighHalf[radius*v];
IF ur < vr THEN {
cur: NAT _ max - ur;
cvr: NAT _ max - vr;
SetBit[ ur,  vr, val];
SetBit[ ur, cvr, val];
SetBit[cur,  vr, val];
SetBit[cur, cvr, val];
SetBit[ vr,  ur, val];
SetBit[ vr, cur, val];
SetBit[cvr,  ur, val];
SetBit[cvr, cur, val];
};
};
Spots12: PROC [pm: PixelMap, u, v: CARDINAL, val: BOOL] = TRUSTED {
BitArrayPtr: TYPE = LONG POINTER TO PACKED ARRAY [0..0) OF BOOL;
SetBit: PROC [f, s: INTEGER, val: BOOL] = TRUSTED INLINE {
s _ sMid + s;
f _ fMid + f;
LOOPHOLE[pm.refRep.pointer + Basics.LongMult[(s - pm.sOrigin), pm.refRep.rast], BitArrayPtr][f - pm.fOrigin] _ val;
};
vh: CARDINAL _ Basics.BITSHIFT[v, -1];
ur: NAT _ Basics.HighHalf[radius*u];
vr: NAT _ Basics.HighHalf[radius*vh];
urH: NAT _ Basics.BITSHIFT[ur, -1];
vrH: NAT _ Basics.BITSHIFT[vr, -1];
urRTQ: NAT _ Basics.HighHalf[radiusTimesRootThreeQuarters*u];
vrRTQ: NAT _ Basics.HighHalf[radiusTimesRootThreeQuarters*vh];
IF v < u THEN {
SetBit[ ur    - vrH,	 vrRTQ,		val];
SetBit[-ur    + vrH,	 vrRTQ,		val];
SetBit[ ur    - vrH,	-vrRTQ,		val];
SetBit[-ur    + vrH,	-vrRTQ,		val];
SetBit[ urH   + vrH,	 urRTQ - vrRTQ,	val];
SetBit[-urH   - vrH,	 urRTQ - vrRTQ,	val];
SetBit[ urH   + vrH,	-urRTQ + vrRTQ,	val];
SetBit[-urH   - vrH,	-urRTQ + vrRTQ,	val];
SetBit[ urH   - vr,	 urRTQ,		val];
SetBit[-urH   + vr,	 urRTQ,		val];
SetBit[ urH   - vr,	-urRTQ,		val];
SetBit[-urH   + vr,	-urRTQ,		val];
};
};
SetBounds: PROC [pm: PixelMap] = {
dr: ImagerPixelMap.DeviceRectangle _ pm.BoundedWindow[];
pmBounds _ [sMin: dr.sMin, fMin: dr.fMin, sMax: dr.sMin + dr.sSize - 1, fMax: dr.fMin + dr.fSize - 1];
};
whiteBit: BOOL _ inverse;
blackBit: BOOL _ NOT whiteBit;
foregroundColor: Imager.Color _ IF inverse THEN Imager.black ELSE Imager.white;
backgroundColor: Imager.Color _ IF inverse THEN Imager.white ELSE Imager.black;
DrawInit: PROC [context: Imager.Context, pm: PixelMap] = {
Imager.SetColor[context, backgroundColor];
Imager.MaskRectangle[context, [xp0, yp0, xp1 - xp0, yp1 - yp0]];
SetBounds[pm];
FOR i: CARDINAL IN [1 .. persistence] DO
Advance[xStateB];
Advance[yStateB];
Spots[pm, xStateB.a, yStateB.a, whiteBit];
ENDLOOP;
};
DrawFinal: PROC [context: Imager.Context, pm: PixelMap] = {
SetBounds[pm];
FOR i: CARDINAL IN [1 .. persistence] DO
Advance[xStateE];
Advance[yStateE];
Spots[pm, xStateE.a, yStateE.a, blackBit];
ENDLOOP;
};
prevUp: BOOL _ FALSE;
DrawDelta: PROC [context: Imager.Context, pm: PixelMap] = {
shouldUp: BOOL _ (T >= upText) AND (T < downText);
SetBounds[pm];
THROUGH [0 .. AtATime) DO
Advance[xStateE]; Advance[yStateE];
Spots[pm, xStateE.a, yStateE.a, blackBit];
Advance[xStateB]; Advance[yStateB];
Spots[pm, xStateB.a, yStateB.a, whiteBit];
ENDLOOP;
IF shouldUp # prevUp THEN {
Imager.SetColor[context, IF shouldUp THEN foregroundColor ELSE backgroundColor];
DrawText[context, pm]};
prevUp _ shouldUp;
IF T >= downText THEN PickText[T];
};
oldP: BasicTime.Pulses;
SELECT symmetry FROM
8 => radius _ MIN[xp1 - xp0, yp1 - yp0]/2;
12 => radius _ MIN[xp1 - xp0, Real.FixC[(yp1 - yp0)/Root3Quarters]]/2;
ENDCASE => ERROR;
max _ radius*2 - 1;
sMin _ yp0 + (yp1 - yp0 - (max+1))/2;
fMin _ xp0 + (xp1 - xp0 - (max+1))/2;
sMid _ (yp0 + yp1)/2;
fMid _ (xp0 + xp1)/2;
radiusTimesRootThreeQuarters _ Real.RoundC[Root3Quarters*radius];
PickText[T _ 0];
RandomizeB[];
xStateB.countLow _ periodLow;
yStateB.countLow _ periodLow;
xStateB.countHigh _ periodHigh;
yStateB.countHigh _ periodHigh;
xStateE^ _ xStateB^;
yStateE^ _ yStateB^;
giveContext[DrawInit];
oldP _ BasicTime.GetClockPulses[];
FOR i: INT _ 0, i+1 WHILE NOT Stop[] DO
newP: BasicTime.Pulses;
giveContext[DrawDelta];
IF pausePeriod # 0 THEN Process.Pause[pausePeriod];
FOR i: NAT IN [0 .. retraces) DO
Terminal.WaitForBWVerticalRetrace[vt];
ENDLOOP;
newP _ BasicTime.GetClockPulses[];
IF newP > oldP THEN {
Dt: Milliseconds _ BasicTime.PulsesToMicroseconds[newP - oldP]/1000;
T _ T + Dt};
oldP _ newP;
ENDLOOP;
giveContext[DrawFinal];
};

PMContext: PROC [pm: PixelMap] RETURNS [context: Imager.Context] = {
bm: ImagerBackdoor.Bitmap _ NEW [ImagerBackdoor.BitmapRep _ [
ref: pm.refRep.ref,
base: pm.refRep.pointer,
wordsPerLine: pm.refRep.rast,
width: pm.refRep.rast*Basics.bitsPerWord,
height: pm.refRep.lines]];
IF pm.refRep.lgBitsPerPixel # 0 OR pm.sMin # 0 OR pm.fMin # 0 THEN ERROR;
context _ ImagerBackdoor.BitmapContext[bm];
Imager.ConcatT[context, ImagerTransformation.Invert[ImagerBackdoor.GetT[context]]];
};

ContextAndPMFromVT: PROC [vt: Terminal.Virtual] RETURNS [context: Imager.Context, pm: PixelMap] = {
pm _ PixelMapFromVT[vt];
context _ ImagerTerminal.BWContext[vt, TRUE];
};

PixelMapFromVT: PROC [vt: Terminal.Virtual] RETURNS [pm: PixelMap] = {
fb: Terminal.FrameBuffer _ vt.GetBWFrameBuffer[];
IF fb.bitsPerPixel # 1 THEN ERROR;
pm _ [
sOrigin: 0, fOrigin: 0,
sMin: 0, fMin: 0,
sSize: fb.height, fSize: fb.width,
refRep: NEW [ImagerPixelMap.PixelMapRep _ [
ref: fb.vm,
pointer: fb.base,
words: fb.vm.words,
lgBitsPerPixel: 0,
rast: fb.wordsPerLine,
lines: fb.height]]
];
};

PixelMapFromViewer: PROC [v: Viewer] RETURNS [pm: PixelMap] = {
vx1, vx2, vy1, vy2: INTEGER;
height: NAT;
pm _ PixelMapFromVT[Terminal.Current[]];
height _ pm.sSize;
[vx1, vy1] _ ViewerOps.UserToScreenCoords[v, 0, 0];
[vx2, vy2] _ ViewerOps.UserToScreenCoords[v, v.cw, v.ch];
vy1 _ height - vy1;
vy2 _ height - vy2;
IF vy1 > vy2 THEN {y: INTEGER _ vy1; vy1 _ vy2; vy2 _ y};
pm _ pm.Clip[[sMin: vy1, fMin: vx1, sSize: vy2-vy1, fSize: vx2 - vx1]];
pm _ pm.ShiftMap[s: -vy1, f: -vx1];
};

Floor: PROC [r: REAL] RETURNS [i: INT] = {
d: INT _ 1 - Real.Fix[r];
i _ Real.Fix[r+d]-d};

Ceiling: PROC [r: REAL] RETURNS [i: INT] = {
d: INT _ 1 + Real.Fix[r];
i _ Real.Fix[r-d]+d};

ReadTextData: PROC [fileName: ROPE] RETURNS [td: TextData] = {
from: IO.STREAM _ FS.StreamOpen[fileName];
last: TextList _ NIL;
td _ [
texts: NIL,
numTexts: 0,
totalProbability: 0];
DO
prob: REAL;
text: ROPE;
this: TextList;
[] _ from.SkipWhitespace[];
IF from.EndOf[] THEN EXIT;
prob _ from.GetReal[];
text _ from.GetRopeLiteral[];
text _ Replace[text, "<machine name>", machineName];
td.numTexts _ td.numTexts + 1;
this _ LIST[ [
text: text,
bounds: ImagerBox.BoxFromExtents[font.RopeBoundingBox[text]],
cumProb: td.totalProbability _ td.totalProbability + prob] ];
IF last = NIL THEN td.texts _ this ELSE last.rest _ this;
last _ this;
ENDLOOP;
from.Close[];
};

Choose: PROC [min, max: REAL] RETURNS [r: REAL] =
{r _ min + (rs.ChooseInt[0, 10000]/1.0E4) * (max-min)};

Replace: PROC [in, what, with: ROPE] RETURNS [new: ROPE] = {
start, len: INT;
ousLen: INT _ what.Length[];
new _ in;
WHILE (start _ new.Index[s2: what]) < (len _ new.Length[]) DO
new _ new.Substr[len: start].Cat[with, new.Substr[start: start+ousLen, len: len - (start+ousLen)]];
ENDLOOP;
};

CreateViewer: PROC = {
sfv _ ViewerOps.CreateViewer[flavor: sfvcFlavor, info: [name: "Kaleidoscope"]]};

RandomizeB: PROC = {
DO
xStateB.b _ rs.ChooseInt[halfBMin, halfBMax]*2 + 1;
yStateB.b _ rs.ChooseInt[halfBMin, halfBMax]*2 + 1;
IF xStateB.b # yStateB.b THEN EXIT;
ENDLOOP;
};

RandomizeC: PROC = {
xStateB.c _ rs.ChooseInt[halfCMin, halfCMax]*2 + 1;
yStateB.c _ rs.ChooseInt[halfCMin, halfCMax]*2 + 1;
};

Start: PROC = {
ViewerOps.RegisterViewerClass[flavor: sfvcFlavor, class: sfvc];
font _ ImagerFont.Find["Xerox/PressFonts/TimesRoman-MRR"];
td _ ReadTextData["Kal.texts"];
};

Start[];

}.
abcdefghijklmnopqrstuvwxyz1234567890-=\[]_;',./
ABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%~&*()+|{}^:"<>?
abcdefghijklmnopqrstuvwxyz1234567890-=\[]_;',./
ABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%~&*()+|{}^:"<>?

˜Kal.Mesa
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Last Edited by: Spreitzer, May 13, 1986 1:42:40 pm PDT
Mike Spreitzer October 22, 1986 12:33:02 pm PDT
IF pmBoundsCheck AND
s < pmBounds.sMin OR
f < pmBounds.fMin OR
s > pmBounds.sMax OR
f > pmBounds.fMax THEN ERROR;
IF pmBoundsCheck AND
s < pmBounds.sMin OR
f < pmBounds.fMin OR
s > pmBounds.sMax OR
f > pmBounds.fMax THEN ERROR;
ΚΩ–

"cedar" style˜
code™Jšœ
Οm
œ1™<K™6K™/—K˜KšΟk	œ"žœ–
žœ{˜ΐK˜šΠbxœžœ
ž˜Kšžœ"žœužœQ˜σ
Kš
œ
˜
K˜K˜
K˜Kšžœžœžœ
˜Kšœžœ˜$Kšœ
žœ˜)Kšœžœ˜/Kšœžœ˜Kšœžœ'˜;K˜Kšœžœžœ˜#Kšœžœžœ žœ˜EK˜šœ
žœžœ˜K˜Kšœ
žœ
˜Kšœžœ˜—K˜Kšœ
žœžœ
žœ˜šœžœžœ˜Kšœžœ
˜Kš
œ˜Kšœ	ž˜
K˜—K˜Kšœ	žœžœ˜šœžœžœ˜Kšœžœžœ
žœ˜4Kšœžœ
žœ˜—K˜K˜
Kšœ
žœ
˜K˜2K˜Kšœžœžœ
˜Kš
œ˜K˜Kšœžœ˜)Kšœ
žœ˜Kšœžœ	˜Kšœžœ	˜Kšœ
žœ˜Kšœ
žœžœ
žœ
˜,Kšœ
žœžœ
žœ
˜,Kšœ
žœ˜Kšœ
žœžœ
žœ˜)Kšœ	žœ˜Kš
œ'˜'Kš
œ'˜'Kš
œ(˜(Kš
œ(˜(Kšœžœžœ
˜K˜4K˜Kšœžœ)˜AKšœžœ˜(Kšœžœ)˜AKšœžœ˜(K˜Kš
œ˜Kšœ
žœ˜Kšœ
žœ˜'K˜Kšœžœ˜,K˜šœ"žœ"˜GK˜Kš
œ˜Kš
œ˜Kš
œ;˜;K˜—K˜Kš
œ˜K˜Kšœžœžœ
˜Kšœžœžœ
˜K˜šΟn	œžœžœ
žœ
žœ
žœ˜:Kšœžœžœ˜šžœž˜
Kš
œžœžœ
žœžœ
žœžœ
˜UKšœžœ
˜Kšžœžœ
˜—K˜—K˜š œžœ6žœ
žœ	žœžœžœžœΟcœ˜–
šžœž˜Kšžœ!˜%šžœ
žœ
žœ
ž˜!K˜&Kšžœžœ
˜——K˜—K˜K˜Kšœžœ)˜9K˜š œžœžœ
žœ˜:Kš
œ˜K˜—K˜š œžœ˜Kš
œ˜š œžœžœ-˜HKšžœ˜Kšœ>žœ˜UK˜—šžœ˜	Kš
œ*˜*Kšœžœžœ˜'—Kšœžœ
˜
Kšœ!Οdœ’œ’œ’œ&žœ˜…
Kšœžœ
˜K˜—K˜š œžœ
žœžœ˜"Kšœ
žœžœ
˜—K˜š œžœ
žœ
žœžœ
žœžœ9žœžœ‘œ˜š
šœžœž˜Kšžœ˜Kšžœ˜Kšžœžœ
˜—Kšœžœ˜—K˜š œžœ
žœ˜ Kš
œB˜BK˜—K˜K˜K˜š 
œžœžœ+˜HK˜—K˜š œžœ˜(š œžœ˜Kšœ#’œ’œ’œ’œ(žœ
˜|K˜—K˜Kš
œ$˜$K˜+Kš
œ$˜$Kš
œ3˜3Kš
œ˜K˜—K˜š œžœ
žœžœ˜'Kš
œ=˜=—K˜Kš
œ&˜&K˜K˜Kšœžœ
˜
K˜š
 	œžœžœžœžœ˜8šœžœž˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜K˜Kšžœ	˜——K˜šœ
žœžœ
žœ˜)K˜K˜K˜K˜ —K˜š œžœžœ˜*Kšœžœ˜,šžœ'žœ˜/Kšœžœ˜,K˜šžœ)žœ˜1K˜ K˜K˜&K˜K˜—K˜—K˜—K˜š œžœžœžœ,’œ’œ’œ’œžœ œžœ
žœžœžœ˜³
Kšœžœ‘˜*Kšœžœ‘˜*Kšœžœ
žœ‘˜%Kšœžœ
žœ
˜,Kšœžœ‘˜ š œžœ˜$Kšœžœ(˜/K˜
Kš
žœžœžœ
žœ
žœ
˜FK˜Kš
œ0˜0Kš
œ;˜;Kšœ’œ’œ0˜@˜˜
Kšœ
’œ˜Kšœ
’œ˜—˜
Kšœ
’œ˜Kšœ
’œ˜ ——K˜—š œžœ,˜:š 	œžœ˜Kš
œ˜Kš
œ˜K˜K˜K˜K˜—K˜"K˜—K˜Kšœžœžœžœ˜>Kš œžœžœžœžœ
žœžœžœ
˜zš
 œžœžœžœžœ˜BKšœ
žœžœ
žœ
žœ
žœ
žœžœ
žœ
˜@š œžœžœžœžœ
žœ˜6K˜
K˜
šžœž™Kšœž™Kšœž™Kšœž™Kšœžœ
žœ
™—Kšžœk˜sK˜—Kšœžœ˜$Kšœžœ˜$šžœ	žœ˜Kšœžœ˜Kšœžœ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜Kš
œ˜Kš
œ˜Kš
œ˜K˜K˜—K˜—š
 œžœžœžœžœ˜CKšœ
žœžœ
žœ
žœ
žœ
žœžœ
žœ
˜@š œžœžœžœžœ
žœ˜:K˜
K˜
šžœž™Kšœž™Kšœž™Kšœž™Kšœžœ
žœ
™—Kšžœk˜sK˜—Kšœžœ
žœ˜&Kšœžœ˜$Kšœžœ˜%Kšœžœ
žœ	˜#Kšœžœ
žœ	˜#Kšœžœ3˜=Kšœžœ4˜>šžœžœ˜K˜#K˜#K˜#K˜#K˜*K˜*K˜*K˜*K˜"K˜"K˜"K˜"K˜—K˜—š 	œžœ˜"K˜8K˜fK˜—Kšœ
žœ˜Kšœ
žœžœ
˜Kšœ žœ	žœžœ˜OKšœ žœ	žœžœ˜Oš œžœ,˜:Kš
œ*˜*Kš
œ ’œ’œ’œ’œ’œ’œ˜@Kš
œ˜šžœžœ
žœž˜(K˜K˜Kš
œ*˜*Kšžœ
˜—K˜—š 	œžœ,˜;Kš
œ˜šžœžœ
žœž˜(K˜K˜Kš
œ*˜*Kšžœ
˜—K˜—Kšœžœžœ
˜š 	œžœ,˜;Kšœ
žœžœ˜2Kš
œ˜šžœž˜K˜#Kš
œ*˜*K˜#Kš
œ*˜*Kšžœ
˜—šžœžœ˜Kšœžœ
žœžœ˜PKš
œ˜—Kš
œ˜Kšžœžœ
˜"K˜—K˜šžœ
ž˜Kšœžœ’œ’œ’œ’œ˜*Kšœžœ’œ’œ’œ’œ˜FKšžœžœ
˜—K˜Kšœ’œ’œ’œ˜%Kšœ’œ’œ’œ˜%Kšœ	’œ’œ˜Kšœ	’œ’œ˜K˜AKš
œ˜K˜
K˜K˜K˜K˜Kš
œ˜Kš
œ˜Kš
œ˜K˜"š	žœžœ
žœ
žœž˜'K˜K˜Kšžœžœ˜3šžœžœ
žœž˜ Kš
œ&˜&Kšžœ
˜—K˜"šžœ
žœ˜KšΟg
œC˜DKšœ£
œ˜—Kš
œ˜Kšžœ
˜—K˜K˜—K˜š 	œžœžœ˜Dšœžœ˜=K˜Kš
œ˜Kš
œ˜K˜)Kš
œ˜—Kš
žœžœ
žœ
žœ
žœ
˜IKš
œ+˜+Kš
œS˜SK˜—K˜š œžœžœ,˜cKš
œ˜Kšœ'žœ˜-K˜—K˜š œžœžœ˜FKš
œ1˜1Kšžœžœ
žœ
˜"š
œ˜K˜K˜K˜"šœžœ ˜+Kš
œ˜Kš
œ˜Kš
œ˜K˜K˜K˜—K˜—K˜—K˜š œžœ
žœ˜?Kšœžœ
˜Kšœžœ
˜Kš
œ(˜(K˜K˜3K˜9K˜K˜Kšžœžœžœ˜9K˜GKš
œ#˜#K˜—K˜š
 œžœžœžœžœ˜*Kšœžœ˜K˜—K˜š
 œžœžœžœžœ˜,Kšœžœ˜K˜—K˜š œžœžœžœ˜>Kšœžœ
žœžœ˜*Kšœžœ
˜˜Kšœžœ
˜K˜K˜—š
ž˜Kšœžœ
˜Kšœžœ
˜K˜K˜Kšžœžœ
žœ
˜K˜K˜K˜4Kš
œ˜šœžœ˜K˜Kš
œ=˜=Kš
œ=˜=—Kšžœžœ
žœžœ˜9K˜Kšžœ
˜—K˜
K˜—K˜š
 œžœžœžœžœ˜1K˜7—K˜š
 œžœžœžœžœ˜<Kšœžœ
˜Kšœžœ˜K˜	šžœ6ž˜=K˜cKšžœ
˜—K˜—K˜š œžœ˜Kš
œP˜P—K˜š 
œžœ˜š
ž˜Kš
œ3˜3K˜3Kšžœžœ
žœ
˜#Kšžœ
˜—K˜—K˜š 
œžœ˜Kš
œ3˜3Kš
œ3˜3K˜—K˜š œžœ˜K˜?Kš
œ:˜:K˜K˜—K˜K˜K˜K˜Kš
£/˜/KšΠgk£˜/Kš
/˜/KšΠkm˜/——…—:ΦNG