DIRECTORY Args, ColorTrixBasics, ColorTrixFile, ColorTrixMap, ColorTrixMod, ColorTrixPalette, ColorTrixPix, ColorTrixPrivate, Commander, FileNames, ImagerPixelMap, IO, Rope, Terminal, ViewerClasses;

ColorTrixCommandsImplA: CEDAR PROGRAM
IMPORTS Args, ColorTrixBasics, ColorTrixFile, ColorTrixMap, ColorTrixMod, ColorTrixPalette, ColorTrixPix, ColorTrixPrivate, FileNames, ImagerPixelMap, IO, Rope
EXPORTS ColorTrixPrivate

~ BEGIN

ROPE:					TYPE ~ Rope.ROPE;
PixelMap:				TYPE ~ ColorTrixBasics.PixelMap;
PixelMapMisc:		TYPE ~ ColorTrixBasics.PixelMapMisc;
DeviceRectangle:	TYPE ~ ImagerPixelMap.DeviceRectangle;
Cmap:			 		TYPE ~ ColorTrixMap.Cmap;

palOn:				BOOL _ FALSE;
CtView: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
name, center, clear, cmap, aisX, aisY, aisW, aisH, dum: Args.Arg;

[ok, name, center, clear, cmap, aisX, aisY, aisW, aisH, dum, dum, dum, dum]
_ Args.ArgsGet[cmd, "%s-center%b-clear%b-cmap%s-a%iiii-w%iiii"];
IF NOT ok
THEN RETURN[$Failure, NIL]
ELSE {
pmMisc: PixelMapMisc _ ColorTrixPrivate.GetWindowedPmMisc[cmd];
x: CARDINAL _ IF aisX.ok THEN aisX.int ELSE 0;
y: CARDINAL _ IF aisY.ok THEN aisY.int ELSE 0;
w: CARDINAL _ IF aisW.ok THEN aisW.int ELSE LAST[CARDINAL];
h: CARDINAL _ IF aisH.ok THEN aisH.int ELSE LAST[CARDINAL];

IF cmap.ok AND NOT ColorTrixMap.Load[cmap.rope]
THEN RETURN[$Failure, Rope.Concat["Can't load ", cmap.rope]];

IF clear.ok AND clear.bool THEN {
IF pmMisc.bpp = 8
THEN ColorTrixBasics.FillPm[pmMisc.bw, 0]
ELSE ColorTrixBasics.FillRGBPm[pmMisc, 0, 0, 0];
};

msg _ColorTrixFile.ViewFile[pmMisc, name.rope, center.ok AND center.bool, x, y, w, h];
IF msg # NIL THEN RETURN[$Failure, "Error in viewing file."];
};
};

CtSave: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
name, dum: Args.Arg;
pmMisc: PixelMapMisc _ ColorTrixPrivate.GetWindowedPmMisc[cmd];
[ok, name, dum, dum, dum, dum] _ Args.ArgsGet[cmd, "%s-w%iiii"];
IF NOT ok THEN RETURN[$Failure, NIL];
ColorTrixFile.WritePmMiscToAIS[pmMisc, FileNames.ResolveRelativePath[name.rope]];
};
CtSetWindow: PUBLIC Commander.CommandProc ~ {
IF Args.NArgs[cmd] > 0
THEN {
ok: BOOL;
x, y, w, h: Args.Arg;
[ok, x, y, w, h] _ Args.ArgsGet[cmd, "%iiii"];
IF NOT ok THEN RETURN[$Failure, NIL];
ColorTrixPrivate.SetGlobalWindow[[y.int, x.int, h.int, w.int]];
};
};

CtResetWindow: PUBLIC Commander.CommandProc ~ {
ColorTrixPrivate.SetGlobalWindow[ColorTrixPrivate.GetInitialWindow[]];
};

CtPrintWindow: PUBLIC Commander.CommandProc ~ {
w: DeviceRectangle ~ ColorTrixPrivate.GetGlobalWindow[];
cmd.out.PutF["global window is (x, y, w, h): [%g, %g, %g, %g].\n",
IO.int[w.fMin], IO.int[w.sMin], IO.int[w.fSize], IO.int[w.sSize]];
};
CtClear: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
rVal, gVal, bVal: CARDINAL;
rArg, gArg, bArg, dum: Args.Arg;
pmMisc: PixelMapMisc _ ColorTrixPrivate.GetWindowedPmMisc[cmd];

[ok, dum, dum, dum, dum, rArg, gArg, bArg] _ Args.ArgsGet[cmd, "-w%iiii[iii"];
IF NOT ok THEN RETURN[$Failure, NIL];
rVal _ MIN[255, IF rArg.ok THEN INTEGER[rArg.int] ELSE 0];
gVal _ MIN[255, IF gArg.ok THEN INTEGER[gArg.int] ELSE rVal];
bVal _ MIN[255, IF bArg.ok THEN INTEGER[bArg.int] ELSE gVal];

SELECT pmMisc.bpp FROM
8 => ColorTrixBasics.FillPm[pmMisc.bw, rVal];
24 => ColorTrixBasics.FillRGBPm[pmMisc, rVal, gVal, bVal]
ENDCASE => NULL;
};

CtLine: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
x0, y0, x1, y1, r, g, b, dum: Args.Arg;
pmMisc: PixelMapMisc _ ColorTrixPrivate.GetWindowedPmMisc[cmd];

[ok, x0, y0, x1, y1, r, g, b, dum, dum, dum, dum] _ Args.ArgsGet[cmd, "[iiiiiii-w%iiii"];
IF NOT (ok AND x0.ok AND y0.ok AND x1.ok AND y1.ok AND r.ok)
THEN RETURN[$Failure, "Bad argument(s)."];

SELECT pmMisc.bpp FROM
8 => ColorTrixBasics.PutLine[pmMisc.bw, x0.int, y0.int, x1.int, y1.int, r.int];
24 => {
IF NOT (g.ok AND b.ok) THEN RETURN[$Failure, NIL];
ColorTrixBasics.PutRGBLine[pmMisc, x0.int, y0.int, x1.int, y1.int, r.int, g.int, b.int];
};
ENDCASE => NULL;
};

CtRamp: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
v, h, dum: Args.Arg;
pmMisc: PixelMapMisc _ ColorTrixPrivate.GetWindowedPmMisc[cmd];

[ok, v, h, dum, dum, dum, dum] _ Args.ArgsGet[cmd, "-v%b-h%b-w%iiii"];
IF NOT ok THEN RETURN[$Failure, NIL];
SELECT pmMisc.bpp FROM
8 => IF h.bool
THEN ColorTrixPix.RampH[pmMisc.bw]
ELSE ColorTrixPix.RampV[pmMisc.bw];
24 => {
IF h.bool THEN ColorTrixPix.RampH[pmMisc.rg] ELSE ColorTrixPix.RampV[pmMisc.rg];
IF h.bool THEN ColorTrixPix.RampH[pmMisc.b] ELSE ColorTrixPix.RampV[pmMisc.b];
};
ENDCASE => NULL;
};

CtPie: PUBLIC Commander.CommandProc ~ {
pmMisc: PixelMapMisc _ ColorTrixPrivate.GetWindowedPmMisc[cmd];
SELECT pmMisc.bpp FROM
8 => ColorTrixPix.Pie[pmMisc.bw];
24 => {
ColorTrixPix.Pie[pmMisc.rg];
ColorTrixPix.Pie[pmMisc.b];
};
ENDCASE => NULL;
};

CtDither: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
dum, arg: Args.Arg;
[ok, arg, dum, dum, dum, dum] _ Args.ArgsGet[cmd, "%i-w%iiii"];
IF NOT ok OR NOT arg.ok
THEN RETURN[$Failure, NIL]
ELSE {
pmMisc: PixelMapMisc _ ColorTrixPrivate.GetWindowedPmMisc[cmd];

SELECT pmMisc.bpp FROM
8 => ColorTrixPix.Dither[pmMisc.bw, arg.int];
24 => {
ColorTrixPix.Dither[pmMisc.rg, arg.int];
ColorTrixPix.Dither[pmMisc.b, arg.int];
};
ENDCASE => NULL;
};
};

CtGrid: PUBLIC Commander.CommandProc ~ {
InnerGrid: PROC [pm: PixelMap] ~ {
FOR i: NAT _ 0, i+spacing WHILE i < pm.fSize DO
FOR j: NAT _ 0, j+1 WHILE j < pm.sSize DO
ImagerPixelMap.Fill[pm, [j, i, lineWidth, lineWidth], pVal];
ENDLOOP;
ENDLOOP;

FOR j: NAT _ 0, j+spacing WHILE j < pm.sSize DO
FOR i: NAT _ 0, i+1 WHILE i < pm.fSize DO
ImagerPixelMap.Fill[pm, [j, i, lineWidth, lineWidth], pVal];
ENDLOOP;
ENDLOOP;
};
ok: BOOL;
pVal, spacing, lineWidth: CARDINAL;
pValArg, spacingArg, lineWidthArg, dum: Args.Arg;
pmMisc: PixelMapMisc _ ColorTrixPrivate.GetWindowedPmMisc[cmd];

[ok, pValArg, spacingArg, lineWidthArg, dum, dum, dum, dum]
_ Args.ArgsGet[cmd, "-pVal%i-spacing%i-lineWidth%i-w%iiii"];
IF NOT ok THEN RETURN[$Failure, NIL];

pVal _ IF pValArg.ok THEN pValArg.int ELSE 255;
pVal _ 256*pVal+pVal;
spacing _ IF spacingArg.ok THEN spacingArg.int ELSE 40;
lineWidth _ IF lineWidthArg.ok THEN lineWidthArg.int ELSE 1;

SELECT pmMisc.bpp FROM
8 => InnerGrid[pmMisc.bw];
24 => {
InnerGrid[pmMisc.rg];
InnerGrid[pmMisc.b];
};
ENDCASE => NULL;
};
CtPal: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
n, smooth: Args.Arg;
pm: PixelMap _ ColorTrixBasics.GetColorDisplayPm[];
[ok, n, smooth] _ Args.ArgsGet[cmd, "[i-smooth%b"];
IF NOT ok THEN RETURN[$Failure, NIL];
ColorTrixPalette.Pal[pm, IF n.ok THEN n.int ELSE 5, smooth.ok AND smooth.bool];
palOn _ TRUE;
};

CtUnPal: PUBLIC Commander.CommandProc ~ {
IF palOn THEN ColorTrixPalette.UnPal[ColorTrixBasics.GetColorDisplayPm[]];
palOn _ FALSE;
};
CtLum: PUBLIC Commander.CommandProc ~ {
pmMisc: PixelMapMisc _ ColorTrixPrivate.GetWindowedPmMisc[cmd];
SELECT pmMisc.bpp FROM
8 => ColorTrixMod.Lum[pmMisc.bw];
24 => {
ColorTrixMod.Lum[pmMisc.rg];
ColorTrixMod.Lum[pmMisc.b];
};
ENDCASE => NULL;
};

CtPVal: PUBLIC Commander.CommandProc ~ {
n: NAT _ 0;
new, old: Args.Arg;
list: REF List _ NIL;
nArgs: NAT _ Args.NArgs[cmd];
List: TYPE ~ RECORD[first: NAT, rest: REF List];
pmMisc: PixelMapMisc _ ColorTrixPrivate.GetWindowedPmMisc[cmd];

WHILE n < nArgs DO
IF Args.GetRope[cmd, n].Equal["-w"] THEN {n _ n+5; LOOP};
IF new.ok THEN {
IF NOT (old _ Args.ArgInt[cmd, n]).ok THEN RETURN[$Failure, "Bad old value."];
list _ NEW[List _ [old.int, list]];
}
ELSE IF NOT (new _ Args.ArgInt[cmd, n]).ok THEN RETURN[$Failure, "Bad new value."];
n _ n+1;
ENDLOOP;

IF list # NIL THEN SELECT pmMisc.bpp FROM
8 => ColorTrixMod.PVal[pmMisc.bw, new.int, list];
24 => {
ColorTrixMod.PVal[pmMisc.rg, new.int, list];
ColorTrixMod.PVal[pmMisc.b, new.int, list];
};
ENDCASE => NULL;
};
CtCopy: PUBLIC Commander.CommandProc ~ {
InnerCopy: PROC [pm: PixelMap] ~ {
src: PixelMap ~ ImagerPixelMap.Clip[pm, [y0.int, x0.int, h0.int, w0.int]];
dst: PixelMap ~ ImagerPixelMap.Clip[pm, [y1.int, x1.int, h1.int, w1.int]];
ImagerPixelMap.Transfer[dst, ImagerPixelMap.ShiftMap[src, y1.int-y0.int, x1.int-x0.int]];
};
ok: BOOL;
x0, y0, w0, h0, x1, y1, w1, h1: Args.Arg;
[ok, x0, y0, w0, h0, x1, y1, w1, h1] _ Args.ArgsGet[cmd, "%iiiiii[ii"];
IF NOT ok
THEN RETURN[$Failure, NIL]
ELSE {
pmMisc: PixelMapMisc _ ColorTrixBasics.GetColorDisplayPmMisc[];
IF NOT w1.ok THEN w1.int _ w0.int;
IF NOT h1.ok THEN h1.int _ h0.int;
SELECT pmMisc.bpp FROM
8 => InnerCopy[pmMisc.bw];
24 => {
InnerCopy[pmMisc.rg];
InnerCopy[pmMisc.b];
};
ENDCASE => NULL;
};
};

CtLeft: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
dum, arg: Args.Arg;
[ok, arg, dum, dum, dum, dum] _ Args.ArgsGet[cmd, "%i-w%iiii"];
IF NOT ok OR NOT arg.ok
THEN RETURN[$Failure, NIL]
ELSE {
pmMisc: PixelMapMisc _ ColorTrixPrivate.GetWindowedPmMisc[cmd];
SELECT pmMisc.bpp FROM
8 => ColorTrixMod.Left[pmMisc.bw, arg.int];
24 => {
ColorTrixMod.Left[pmMisc.rg, arg.int];
ColorTrixMod.Left[pmMisc.b, arg.int];
};
ENDCASE => NULL;
};
};

CtUp: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
dum, arg: Args.Arg;
[ok, arg, dum, dum, dum, dum] _ Args.ArgsGet[cmd, "%i-w%iiii"];
IF NOT ok OR NOT arg.ok
THEN RETURN[$Failure, NIL]
ELSE {
pmMisc: PixelMapMisc _ ColorTrixPrivate.GetWindowedPmMisc[cmd];
SELECT pmMisc.bpp FROM
8 => ColorTrixMod.Up[pmMisc.bw, arg.int];
24 => {
ColorTrixMod.Up[pmMisc.rg, arg.int];
ColorTrixMod.Up[pmMisc.b, arg.int];
};
ENDCASE => NULL;
};
};

CtNegate: PUBLIC Commander.CommandProc ~ {
pmMisc: PixelMapMisc _ ColorTrixPrivate.GetWindowedPmMisc[cmd];
SELECT pmMisc.bpp FROM
8 => ColorTrixMod.Negate[pmMisc.bw];
24 => {
ColorTrixMod.Negate[pmMisc.rg];
ColorTrixMod.Negate[pmMisc.b];
};
ENDCASE => NULL;
};

CtReflect: PUBLIC Commander.CommandProc ~ {
ok: BOOL;
v, h, dum: Args.Arg;
pmMisc: PixelMapMisc _ ColorTrixPrivate.GetWindowedPmMisc[cmd];

[ok, v, h, dum, dum, dum, dum] _ Args.ArgsGet[cmd, "-v%b-h%b-w%iiii"];
IF NOT ok THEN RETURN[$Failure, NIL];
IF h.bool
THEN SELECT pmMisc.bpp FROM
8 => ColorTrixMod.ReflectH[pmMisc.bw];
24 => {
ColorTrixMod.ReflectH[pmMisc.rg];
ColorTrixMod.ReflectH[pmMisc.b];
};
ENDCASE => NULL
ELSE SELECT pmMisc.bpp FROM
8 => ColorTrixMod.ReflectV[pmMisc.bw];
24 => {
ColorTrixMod.ReflectV[pmMisc.rg];
ColorTrixMod.ReflectV[pmMisc.b];
};
ENDCASE => NULL;
};

CtMirror: PUBLIC Commander.CommandProc ~ {
MirrorH: PROC [pmMisc: PixelMapMisc, leftToRight: BOOL] ~ {
SELECT pmMisc.bpp FROM
8 => ColorTrixMod.MirrorH[pmMisc.bw];
24 => {
ColorTrixMod.MirrorH[pmMisc.rg];
ColorTrixMod.MirrorH[pmMisc.b];
};
ENDCASE => NULL;
};
MirrorV: PROC [pmMisc: PixelMapMisc, leftToRight: BOOL] ~ {
SELECT pmMisc.bpp FROM
8 => ColorTrixMod.MirrorV[pmMisc.bw];
24 => {
ColorTrixMod.MirrorV[pmMisc.rg];
ColorTrixMod.MirrorV[pmMisc.b];
};
ENDCASE => NULL;
};
ok: BOOL;
l, r, t, b, dum: Args.Arg;
pmMisc: PixelMapMisc _ ColorTrixPrivate.GetWindowedPmMisc[cmd];

[ok, l, r, t, b, dum, dum, dum, dum] _ Args.ArgsGet[cmd, "-l%b-r%b-t%b-b%b-w%iiii"];
IF NOT ok THEN RETURN[$Failure, NIL];
SELECT TRUE FROM
l.bool => MirrorV[pmMisc, TRUE];
r.bool => MirrorV[pmMisc, FALSE];
t.bool => MirrorH[pmMisc, TRUE];
b.bool => MirrorH[pmMisc, FALSE];
ENDCASE => MirrorH[pmMisc, FALSE];
};

END.


ColorTrixCommandsImplA.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Bloomenthal, December 4, 1986 12:38:31 pm PST
File IO Commands
Window Commands
Clearing/Drawing Commands
Palette Commands
Processing Commands
Manipulations Commands

Κš˜š
œ™Jšœ
Οm
œ1™<J™-—J˜JšΟk	œ›
žœ ˜Ζ
J˜šΠblœžœ
ž˜%Jšžœ
žœ˜Ÿ
Jšžœ˜—J˜šœž˜J˜Jšžœ
ž	œžœ
˜Jšœžœ˜-Jšœžœ ˜3Jšœžœ"˜7Jšœ
žœ˜$J˜Jšœžœžœ
˜—
headš
Οl™šΠbnœžœ˜(Jšœžœ
˜	Jš
œA˜AJ˜š
œK˜KJš
œ@˜@—šžœ
žœ˜	Jšžœ
žœžœ
˜šžœ˜J˜?Jš	œžœžœ	žœ
žœ˜.Jš	œžœžœ	žœ
žœ˜.Jš
œžœžœ	žœ
žœ
žœ
žœ˜;Jš
œžœžœ	žœ
žœ
žœ
žœ˜;—˜šžœ	žœ
žœ˜/Jšžœ
žœ2˜=—J˜šžœ
žœžœ˜!šžœ˜Jšžœ%˜)Jšžœ,˜0—J˜J˜—Jšœ9žœ˜VJšžœžœ
žœ
žœ%˜=J˜——J˜J˜—š‘œžœ˜(Icedaršœžœ
˜	Lš
œ˜Lš
œ?˜?Lš
œ@˜@Jš
žœ
žœžœ
žœžœ˜%Lš
œQ˜QJ˜——š
 ™š‘œžœ˜-šžœ˜šžœ˜Lšœžœ
˜	L˜Lšœ-ž
˜.Lš
žœ
žœžœ
žœžœ˜%Lš
œ?˜?L˜——Jš
œ˜J˜—š‘
œžœ˜/J˜FJš
œ˜J˜—š‘
œžœ˜/J˜8š
œB˜BJšžœžœžœžœ˜B—Jš
œ˜——š
œ™š‘œžœ˜)Lšœžœ
˜	Lšœžœ
˜Lš
œ ˜ Lš
œ?˜?L˜Lš
œN˜NLš
žœ
žœžœ
žœžœ˜%Lšœžœžœ	žœ
žœžœ˜:Lšœžœžœ	žœ
žœžœ˜=Lšœžœžœ	žœ
žœžœ˜=L˜šžœž˜L˜-L˜9Lšžœžœ
˜—Jš
œ˜J˜—š‘œžœ˜(Lšœžœ
˜	Lš
œ'˜'Lš
œ?˜?L˜Lš
œY˜Yšžœ
žœžœžœžœžœžœ˜<Lšžœ
žœ˜*—L˜šžœž˜L˜O˜Lšžœ
žœžœžœ
žœžœ˜2Lš
œX˜XL˜—Lšžœžœ
˜—Jš
œ˜—J˜š‘œžœ˜(Icodešœžœ
˜	Mš
œ˜J˜?J˜Jš
œF˜FJš
žœ
žœžœ
žœžœ˜%šžœž˜šœžœ˜Mšžœ˜"Mšžœ˜#—š
œ˜Mšžœžœžœ˜PMšžœžœžœ˜NMš
œ˜—Mšžœžœ
˜—Jš
œ˜J˜—š‘œžœ˜'Jš
œ?˜?šžœž˜Mš
œ!˜!š
œ˜Mš
œ˜Mš
œ˜Mš
œ˜—Mšžœžœ
˜—Jš
œ˜J˜—š‘œžœ˜*Mšœžœ
˜	Mš
œ˜Mš
œ?˜?šžœ
žœžœ
žœ˜Jšžœ
žœžœ
˜šžœ˜Jš
œ?˜?J˜šžœž˜Jš
œ-˜-˜Jš
œ(˜(Jš
œ'˜'J˜—Jšžœžœ
˜—J˜——Jš
œ˜—J˜š‘œžœ˜(šΟn	œžœ˜"šžœžœžœž˜/šžœžœ
žœž˜)Mš
œ<˜<Mšžœ
˜—Mšžœ
˜—M˜šžœžœžœž˜/šžœžœ
žœž˜)Mš
œ<˜<Mšžœ
˜—Mšžœ
˜—M˜—Jšœžœ
˜	Jšœžœ
˜#Jš
œ1˜1Jš
œ?˜?J˜š
œ;˜;Mš
œ<˜<—Mš
žœ
žœžœ
žœžœ˜%M˜Jšœžœžœ
žœ˜/Jš
œ˜Jšœ
žœžœžœ˜7Jšœžœžœžœ˜<J˜šžœž˜Jš
œ˜˜Jš
œ˜Jš
œ˜J˜—Jšžœžœ
˜—Jš
œ˜——š
 ™š‘œžœ˜'Jšœžœ
˜	Jš
œ˜Jš
œ3˜3Jš
œ3˜3Jš
žœ
žœžœ
žœžœ˜%Jš	œžœžœžœžœ˜OJšœžœ
˜
J˜J˜—š‘œžœ˜)Jšžœžœ=˜JJšœžœ
˜J˜——š
 ™š‘œžœ˜'J˜?šžœž˜Lš
œ!˜!˜Lš
œ˜Lš
œ˜L˜—Lšžœžœ
˜—Jš
œ˜J˜—š‘œžœ˜(Mšœžœ˜Mš
œ˜Mšœžœžœ
˜Mšœžœ˜Jš	œžœžœžœžœ˜0Jš
œ?˜?M˜šžœž˜Mšžœ"žœžœ˜9šžœžœ˜Mšžœ
žœ žœ
žœ˜NMšœžœ˜#M˜
—Mšžœ
žœ žœ
žœ˜SMš
œ˜Mšžœ
˜—J˜š	žœžœ
žœ
žœž˜)Jš
œ1˜1˜Jš
œ,˜,Jš
œ+˜+J˜—Jšžœžœ
˜—Jš
œ˜——š
 ™š‘œžœ˜(š’	œžœ˜"J˜JJ˜JJš
œY˜YM˜—Mšœžœ
˜	Mš
œ)˜)Mš
œG˜Gšžœ
žœ˜	Jšžœ
žœžœ
˜šžœ˜Jš
œ?˜?Jšžœ
žœžœ˜"Jšžœ
žœžœ˜"šžœž˜Mš
œ˜š
œ˜Mš
œ˜Mš
œ˜Mš
œ˜—Mšžœžœ
˜—M˜——Jš
œ˜J˜—š‘œžœ˜(Mšœžœ
˜	Mš
œ˜Mš
œ?˜?šžœ
žœžœ
žœ˜Jšžœ
žœžœ
˜šžœ˜Jš
œ?˜?šžœž˜Mš
œ+˜+š
œ˜Mš
œ&˜&Mš
œ%˜%Mš
œ˜—Mšžœžœ
˜—M˜——Jš
œ˜J˜—š‘œžœ˜&Mšœžœ
˜	Mš
œ˜Mš
œ?˜?šžœ
žœžœ
žœ˜Jšžœ
žœžœ
˜šžœ˜Jš
œ?˜?šžœž˜Mš
œ)˜)š
œ˜Mš
œ$˜$Mš
œ#˜#Mš
œ˜—Mšžœžœ
˜—M˜——Jš
œ˜J˜—š‘œžœ˜*Jš
œ?˜?šžœž˜Mš
œ$˜$š
œ˜Mš
œ˜Mš
œ˜Mš
œ˜—Mšžœžœ
˜—Jš
œ˜J˜—š‘	œžœ˜+Mšœžœ
˜	Mš
œ˜J˜?J˜Jš
œF˜FJš
žœ
žœžœ
žœžœ˜%šžœ˜	šžœ
žœž˜J˜&˜J˜!J˜ J˜—Jšžœž˜—šžœ
žœž˜J˜&˜J˜!J˜ J˜—Jšžœžœ
˜——Jš
œ˜J˜—š‘œžœ˜*š’œžœ%žœ˜;šžœž˜Jš
œ%˜%˜Jš
œ ˜ Jš
œ˜J˜—Jšžœžœ
˜—J˜—š’œžœ%žœ˜;šžœž˜Jš
œ%˜%˜Jš
œ ˜ Jš
œ˜J˜—Jšžœžœ
˜—J˜—Mšœžœ
˜	Mš
œ˜Jš
œ?˜?M˜Jš
œT˜TJš
žœ
žœžœ
žœžœ˜%šžœ
žœ
ž˜Mšœžœ˜ Mšœžœ˜!Mšœžœ˜ Mšœžœ˜!Mšžœžœ˜"—Jš
œ˜J˜——Jš
ž˜J™J˜—…—*ς:’