DIRECTORY
Dunn, ChoiceButtons, Commander, CommandTool, Containers, Convert, IO, Menus,
MessageWindow, Rope, ViewerClasses, ViewerEvents, ViewerOps, ViewerTools;

DunnToolImpl: CEDAR PROGRAM
IMPORTS	Dunn, ChoiceButtons, Commander, CommandTool, Containers, Convert, IO, Menus, MessageWindow, Rope, ViewerEvents, ViewerOps, ViewerTools

~ BEGIN

viewerOpened:		BOOL _ FALSE;									-- viewer takes precedence
cmdData:				Data;												-- inter-command continuity

Data: TYPE ~ RECORD[
handle:			Dunn.Handle _ NIL,							-- hardware handle
dubNum:			INT _ 1, 											-- exposure dub number
work:				REF Toggler,										-- enable/disable toggle
mode:				REF Toggler,										-- sep/cmp toggle
type:				REF Toggler,										-- bw/color toggle
dub:				REF ChoiceButtons.PromptDataRec,			-- dub text prompt
cmd:				REF ChoiceButtons.PromptDataRec,			-- cmd text prompt
printStream:		IO.STREAM _ NIL,								-- error messages
destroyEvent:	ViewerEvents.EventRegistration _ NIL		-- release Dunn upon Destroy
];

Toggler: TYPE ~ RECORD[							-- used by MakeToggle, ResetToggle & Toggle
viewer:	ViewerClasses.Viewer,							-- viewer for menu
entry1:	Menus.MenuEntry,								-- first menu entry
entry2:	Menus.MenuEntry,								-- second menu entry
name1:	Rope.ROPE,										-- first menu entry name
name2:	Rope.ROPE,										-- second menu entry name
data:		REF ANY											-- client data
];
	
Err: PROC [rope: Rope.ROPE] ~ {
IF viewerOpened
THEN {
MessageWindow.Append[Rope.Concat["\t", rope], TRUE];
MessageWindow.Blink[];
}
ELSE IF cmdData.printStream # NIL THEN cmdData.printStream.PutF[rope];
};

MakeEntry: PUBLIC PROC [menu: Menus.Menu,
name: Rope.ROPE,
proc: Menus.ClickProc,
data: REF ANY] ~ {

Menus.AppendMenuEntry[
menu,
Menus.CreateEntry[name: name, proc: proc, clientData: data, fork: FALSE]];
};

MakeToggle: PUBLIC PROC [
viewer:	ViewerClasses.Viewer,
rope1:		Rope.ROPE,
rope2:		Rope.ROPE,
proc1:		Menus.ClickProc,
proc2:		Menus.ClickProc,
data:		REF ANY _ NIL]
RETURNS [tog: REF Toggler _ NEW[Toggler]] ~ {

tog.viewer _ viewer;
tog.entry1 _ Menus.CreateEntry[name: tog.name1 _ rope1, proc: proc2, clientData: data];
tog.entry2 _ Menus.CreateEntry[name: tog.name2 _ rope2, proc: proc1, clientData: data];
tog.data _ data;
Menus.AppendMenuEntry[viewer.menu, tog.entry1];
};

ExchangeMenuEntries: PUBLIC PROC [
v: ViewerClasses.Viewer,
ent1, ent2: Menus.MenuEntry] ~ {
OPEN Menus;
ok: BOOL _ TRUE;
ReplaceMenuEntry[v.menu, ent1, ent2 ! targetNotFound => {ok _ FALSE; CONTINUE}];
IF ~ok THEN ReplaceMenuEntry[v.menu, ent2, ent1 ! targetNotFound => CONTINUE];
ViewerOps.PaintViewer[v, menu];
};

Toggle: PUBLIC PROC [t: REF Toggler] ~ {
ExchangeMenuEntries[t.viewer, t.entry1, t.entry2];
};

ResetToggle: PUBLIC PROC [tog: REF Toggler] ~ {
IF Menus.FindEntry[tog.viewer.menu, tog.name1] = NIL THEN Toggle[tog];
};

DunnViewer: PROC [handle: Dunn.Handle] RETURNS [BOOL] ~ {
viewer: ViewerClasses.Viewer;										-- main viewer
menu: Menus.Menu _ Menus.CreateMenu[];					-- main menu
data: REF Data _ NEW[Data];										-- client data for main menu

IF ~Dunn.HandleOK[handle] AND ~Dunn.HandleDisabled[handle] THEN RETURN[FALSE];

viewer _ Containers.Create[										-- first establish viewer
info: [
name: "Dunn",
openHeight: 63,
menu: menu,
iconic: TRUE,
column: right,
scrollable: FALSE],
paint: FALSE];

MakeEntry[viewer.menu, "Expose ", ExposeProc, data];
MakeEntry[viewer.menu, " Reset  ", ResetProc, data];
data.work _ MakeToggle[viewer, "Enabled ", "Disabled", EnblProc, DsblProc, data];
data.type _ MakeToggle[viewer, "Color", " BW ", ColorProc, BWProc, data];
data.mode _ MakeToggle[viewer, "Composite", "Separate", CompProc, SepProc, data];
MakeEntry[viewer.menu, "Send-cmd", CmdProc, data];
data.dub _ ChoiceButtons.BuildTextPrompt[viewer: viewer, y: 0, title: "Dub: ", default: "1"];
data.cmd _ ChoiceButtons.BuildTextPrompt[viewer: viewer, y: 17, title: "Command: "];
data.destroyEvent _ ViewerEvents.RegisterEventProc[proc: Destroy, event: destroy];

data.handle _ handle;
IF ~handle.enable THEN Toggle[data.work];

ViewerOps.AddProp[viewer, $DunnToolViewer, data];
ViewerOps.OpenIcon[viewer];
RETURN[TRUE];
};

Destroy: ViewerEvents.EventProc ~ {
data: REF Data _ NARROW[ViewerOps.FetchProp[viewer, $DunnToolViewer]];
IF data = NIL THEN RETURN;
ViewerEvents.UnRegisterEventProc[proc: data.destroyEvent, event: destroy];
viewerOpened _ FALSE;
Dunn.Close[data.handle];
};

SetScannerSelection: PROC [viewer: ViewerClasses.Viewer, nullify: BOOL] ~ {
MessageWindow.Clear[];
IF nullify THEN ViewerTools.SetContents[viewer, ""];
ViewerTools.SetSelection[viewer];
};

GetData: PROC [clientData: REF ANY] RETURNS [REF Data] ~ {
MessageWindow.Clear[];
RETURN[NARROW[clientData]];
};

GetHandle: PROC [clientData: REF ANY] RETURNS [Dunn.Handle] ~ {
RETURN[GetData[clientData].handle];
};

ColorProc: Menus.ClickProc ~ {
IF ~Dunn.Color[GetHandle[clientData]] THEN Err["Color failed"]
ELSE Toggle[GetData[clientData].type];
};

BWProc: Menus.ClickProc ~ {
IF ~Dunn.BW[GetHandle[clientData]] THEN Err["BW failed"]
ELSE Toggle[GetData[clientData].type];
};

CompProc: Menus.ClickProc ~ {
IF ~Dunn.Composite[GetHandle[clientData]] THEN Err["Composite failed"]
ELSE Toggle[GetData[clientData].mode];
};

SepProc: Menus.ClickProc ~ {
IF ~Dunn.Separate[GetHandle[clientData]] THEN Err["Separate failed"]
ELSE Toggle[GetData[clientData].mode];
};

QuitProc: Menus.ClickProc ~ {
ViewerOps.DestroyViewer[NARROW[parent, ViewerClasses.Viewer]];
};

DsblProc: Menus.ClickProc ~ {
data: REF Data _ NARROW[clientData];
IF Dunn.HandleDisabled[data.handle] THEN RETURN;
data.handle.enable _ FALSE;
Toggle[data.work];
};

EnblProc: Menus.ClickProc ~ {
temp: Dunn.Handle;
data: REF Data _ NARROW[clientData];
IF ~Dunn.HandleOK[data.handle] THEN {
temp _ MsgReserve[];
IF Dunn.HandleOK[temp] THEN data.handle _ temp;
};
IF Dunn.HandleOK[data.handle] THEN {
data.handle.enable _ TRUE;
Toggle[data.work];
};
};

Enable: PROC RETURNS [handle: Dunn.Handle] ~ {
handle _ IF Dunn.HandleOK[cmdData.handle]
THEN cmdData.handle
ELSE MsgReserve[];
IF handle # NIL THEN handle.enable _ TRUE;
};

Disable: PROC RETURNS [handle: Dunn.Handle] ~ {
handle _ IF cmdData.handle # NIL
THEN cmdData.handle
ELSE NEW[Dunn.HandleRep]; 
handle.enable _ FALSE;
};

MsgReserve: PROC RETURNS [handle: Dunn.Handle] ~ {
msg: Rope.ROPE;
[handle, msg] _ Dunn.Reserve[];
IF msg # NIL THEN Err[Rope.Concat[msg, "Dunn not reserved.\n"]];
};

UpdateDubNum: PROC [data: REF Data] RETURNS [ok: BOOL _ TRUE] ~ {
num: INT;
selection: Rope.ROPE _ ViewerTools.GetContents[data.dub.textViewer];
IF selection.IsEmpty[] THEN {Err["Enter dub number"]; RETURN[FALSE]};
num _ Convert.IntFromRope[selection ! Convert.Error => {ok _ FALSE; CONTINUE }];
IF ~ok THEN Err[Rope.Concat["Bad dub number: ", selection]]
ELSE data.dubNum _ num;
};

ExposeProc: Menus.ClickProc ~ {
data: REF Data _ GetData[clientData];
IF UpdateDubNum[data] THEN FOR i: INT IN [0..data.dubNum) DO
MessageWindow.Append[IO.PutFR["\tExposing frame %g/%g",
IO.int[i+1], IO.int[data.dubNum]], TRUE];
IF ~Dunn.Expose[data.handle] THEN {
Err[Rope.Concat["Expose failed at frame ", Convert.RopeFromInt[i]]];
EXIT;
};
REPEAT FINISHED => MessageWindow.Append["\tExposure done", TRUE];
ENDLOOP;
};

ResetProc: Menus.ClickProc ~ {
data: REF Data _ GetData[clientData];
IF ~Dunn.Reset[data.handle] THEN Err["Reset failed"];
ResetToggle[data.mode];
ResetToggle[data.type];
ViewerTools.SetContents[data.dub.textViewer, "1"];
[] _ UpdateDubNum[data];
};

CmdProc: Menus.ClickProc ~ {
data: REF Data _ GetData[clientData];
selection: Rope.ROPE _ ViewerTools.GetContents[data.cmd.textViewer];
IF selection.IsEmpty[] THEN Err["Enter a command"] 
ELSE DunnRopeCommand[data.handle, selection];
};

DunnRopeCommand: PROC [h: Dunn.Handle, rope: Rope.ROPE] ~ {
OPEN Dunn;
ok: BOOL _ TRUE;

Test: PROC [x: Rope.ROPE] RETURNS [BOOL] ~ {RETURN[rope.Equal[x, FALSE]]};

SELECT TRUE FROM
Test["videoInvertHigh"] =>			ok _ Cmd[h, cmdCode.videoInvertHigh];
Test["videoInvertLow"] =>			ok _ Cmd[h, cmdCode.videoInvertLow];
Test["readyTest"] =>					ok _ Cmd[h, cmdCode.readyTest];
Test["statusRequest"] =>				ok _ Cmd[h, cmdCode.statusRequest];
Test["expose8x5TimeReq"] =>		ok _ Cmd[h, cmdCode.expose8x5TimeReq];
Test["exposeAuxTimeReq"] =>		ok _ Cmd[h, cmdCode.exposeAuxTimeReq];
Test["exposeAdjFactorReq"] =>		ok _ Cmd[h, cmdCode.exposeAdjFactorReq];
Test["advAuxFrameCnt"] => 		ok _ Cmd[h, cmdCode.advAuxFrameCnt];
Test["reset8x10ExposeStat"] =>		ok _ Cmd[h, cmdCode.reset8x10ExposeStat];
Test["restoreFilterWheel"] => 		ok _ Cmd[h, cmdCode.restoreFilterWheel];
Test["recovDefaultVals"] => 		ok _ Cmd[h, cmdCode.recovDefaultVals];
Test["select8x10Mode"] => 			ok _ Cmd[h, cmdCode.select8x10Mode];
Test["selectAuxMode"] => 			ok _ Cmd[h, cmdCode.selectAuxMode];
Test["selectBW"] => 				ok _ Cmd[h, cmdCode.selectBW];
Test["selectColor"] => 				ok _ Cmd[h, cmdCode.selectColor];
Test["selectNrmSeqMode"] => 		ok _ Cmd[h, cmdCode.selectNrmSeqMode];
Test["selectSepSeqMode"] => 		ok _ Cmd[h, cmdCode.selectSepSeqMode];
Test["exposeSeq"] => 				ok _ Cmd[h, cmdCode.exposeSeq];
Test["selectVidAndExpose"] =>		ok _ Cmd[h, cmdCode.selectVidAndExpose];
Test["set8x10ExposeTimes"] => 		ok _ Cmd[h, cmdCode.set8x10ExposeTimes];
Test["setAuxExposeTimes"] => 		ok _ Cmd[h, cmdCode.setAuxExposeTimes];
Test["setExposeAdjFactors"] => 	ok _ Cmd[h, cmdCode.setExposeAdjFactors];
Test["openAuxShutter"] => 		ok _ Cmd[h, cmdCode.openAuxShutter];
Test["closeAuxShutter"] => 		ok _ Cmd[h, cmdCode.closeAuxShutter];
Test["unblankMonitor"] => 		ok _ Cmd[h, cmdCode.unblankMonitor];
Test["blankMonitor"] => 			ok _ Cmd[h, cmdCode.blankMonitor];
Test["selectVideoChannel"] =>		ok _ Cmd[h, cmdCode.selectVideoChannel];
Test["positionFilterWheel"] =>		ok _ Cmd[h, cmdCode.positionFilterWheel];
Test["immExposeNoVidSw"] =>		ok _ Cmd[h, cmdCode.immExposeNoVidSw];
Test["yAxisRasterCompOn"] =>		ok _ Cmd[h, cmdCode.yAxisRasterCompOn];
Test["yAxisRasterCompOff"] =>	ok _ Cmd[h, cmdCode.yAxisRasterCompOff];
Test["clearYAxisOffset"] =>			ok _ Cmd[h, cmdCode.clearYAxisOffset];
Test["stepYAxisOffset"] => 			ok _ Cmd[h, cmdCode.stepYAxisOffset];
Test["clearXAxisOffset"] => 		ok _ Cmd[h, cmdCode.clearXAxisOffset];
Test["stepXAxisOffset"] => 			ok _ Cmd[h, cmdCode.stepXAxisOffset];
Test["select35mmAuxCam"] =>		ok _ Cmd[h, cmdCode.select35mmAuxCam];
Test["select16mmAuxCam"] =>		ok _ Cmd[h, cmdCode.select16mmAuxCam];
Test["select4x5AuxCam"] => 		ok _ Cmd[h, cmdCode.select4x5AuxCam];
Test["selectSX70AuxCam"] => 		ok _ Cmd[h, cmdCode.selectSX70AuxCam];
Test["setNumPadChars"] =>			ok _ Cmd[h, cmdCode.setNumPadChars];
Test["resetAuxNoFilmStats"] =>	ok _ Cmd[h, cmdCode.resetAuxNoFilmStats];
Test["fastOn"] => 					ok _ Cmd[h, cmdCode.fastOn];
Test["fastOff"] => 					ok _ Cmd[h, cmdCode.fastOff];
ENDCASE => Err[Rope.Concat[rope, " is not a Dunn command"]];
IF ~ok THEN Err["Command failed"];
};

ParseCommand: PROC [argv: CommandTool.ArgumentVector] ~ {
Test: PROC [x: Rope.ROPE] RETURNS [BOOL] ~ {RETURN[argv[1].Equal[x, FALSE]]};

SELECT TRUE FROM
Test["quit"] => {Dunn.Close[cmdData.handle]; cmdData.handle _ NIL};
Test["reserve"] => cmdData.handle _ MsgReserve[];
Test["disable"] => cmdData.handle _ Disable[];
Test["enable"] => cmdData.handle _ Enable[];
cmdData.handle = NIL => Err["Please disable or reserve the Dunn.\n"];
Test["dub"] =>
IF argv.argc < 3
THEN Err["Dub requires an argument.\n"]
ELSE {
n: INT;
error: BOOL _ FALSE;
n _ Convert.IntFromRope[argv[2] ! Convert.Error => {error _ TRUE; CONTINUE}];
IF error THEN Err[IO.PutFR["Bad dub value: '%g'.\n", IO.rope[argv[2]]]]
ELSE Err[IO.PutFR["Dub set to %g.\n", IO.int[cmdData.dubNum _ n]]];
};
Test["command"] =>
IF argv.argc < 3
THEN Err["Command needs an argument.\n"]
ELSE DunnRopeCommand[cmdData.handle, argv[2]]; 
Test["reset"] =>
IF Dunn.Reset[cmdData.handle]
THEN cmdData.dubNum _ 1
ELSE Err["Reset failed"];
Test["composite"] =>
IF ~Dunn.Composite[cmdData.handle] THEN Err["Composite failed"];
Test["separate"] =>
IF ~Dunn.Separate[cmdData.handle] THEN Err["Normal failed"];
Test["color"] =>
IF ~Dunn.Color[cmdData.handle] THEN Err["Color failed"];
Test["bw"] =>
IF ~Dunn.BW[cmdData.handle] THEN Err["BW failed"];
Test["expose"] => {
FOR i: INT IN [0..cmdData.dubNum) DO
IF ~Dunn.Expose[cmdData.handle] THEN {
Err[IO.PutFR["Expose failed at number %g.\n", IO.int[i]]];
EXIT;
};
ENDLOOP;
};
Test["debugon"] => Dunn.DebugOn[cmdData.handle, cmdData.printStream];
Test["debugoff"] => Dunn.DebugOff[cmdData.handle];
ENDCASE => Err[IO.PutFR["'%g' is not a Dunn command.\n", IO.rope[argv[1]]]];
};

CommandProc: Commander.CommandProc ~ {
ok: BOOL;
argv: CommandTool.ArgumentVector _ CommandTool.Parse[cmd];

cmdData.printStream _ cmd.out;

IF viewerOpened THEN RETURN[$Failure, "Dunn viewer already opened."];

IF argv.argc > 1
THEN ParseCommand[argv]
ELSE {
IF Dunn.HandleOK[cmdData.handle] OR Dunn.HandleDisabled[cmdData.handle]
THEN ok _ DunnViewer[cmdData.handle]
ELSE ok _ DunnViewer[MsgReserve[]];
IF ok THEN {
viewerOpened _ TRUE;
cmdData.handle _ NIL;
};
};
};

dunnUsage: Rope.ROPE ~ "\nA program for operating the Dunn camera";

Commander.Register["///Commands/DunnTool", CommandProc, dunnUsage];

END.
„DunnToolImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Bloomenthal, January 30, 1987 8:52:08 pm PST

Κ˜
cedarš
œ™Kšœ
Οm
œ1™<K™,—K™š
Οk	˜	KšœAžœ˜LKš
œI˜I—K˜šΟbœžœ
ž˜KšžœCžœB˜Ž
K˜—Kšœž˜˜Kšœžœžœ
Οc˜?Kšœ ˜8K˜šœžœžœ
˜Kšœžœ ˜5Kšœžœ ˜4Kšœžœ ˜7Kšœžœ ˜0Kšœžœ ˜1Kšœžœ ˜=Kšœžœ ˜=Kšœžœ
žœ	 ˜7Kšœ/žœ ˜PK˜—K˜šœ	žœžœ +˜IKšœ$ ˜6Kšœ  ˜3Kšœ  ˜4Kšœžœ ˜3Kšœžœ ˜4Kšœžœ
žœ ˜'Kš
œ˜—Kš
œ
˜
šΟnœžœ
žœ˜šžœ
˜šžœ˜Kšœ.žœ˜4K˜K˜
—Kšžœ
žœžœ
žœ ˜F—Kš
œ˜—K˜
codešΠbn	œžœ˜)Kšœžœ
˜Kš
œ˜Kšœžœ
žœ˜K˜š
œ˜Kš
œ˜KšœBžœ˜J—K˜—K˜š’
œžœ˜Kš
œ˜Kšœ
žœ
˜Kšœ
žœ
˜Kš
œ˜Kš
œ˜Kšœžœ
žœžœ
˜Kšžœžœžœ˜-K˜Kš
œ˜Kš
œW˜WKš
œW˜WKš
œ˜Kš
œ/˜/K˜—K˜š‘œžœ˜"Kš
œ˜Kš
œ ˜ Kšžœ˜Kšœžœžœ
˜Kšœ>žœžœ˜PKšžœžœ9žœ˜NKš
œ˜K˜—L˜š‘œžœžœ
˜(Lš
œ2˜2Lš
œ˜—K˜š‘œžœžœ
˜/K•StartOfExpansion'[menu: 
Menus.Menu, entryName: 
ROPE]šžœ/žœ
žœ
˜FK˜—K˜š’
Ÿžœžœžœ˜9Kšœ' ˜5Kšœ+ ˜7Kšœžœžœ ˜AK˜Lš
žœžœžœ
žœ
žœ˜NK˜šœ% ˜>˜K˜
K˜K˜Kšœžœ
˜
K˜Kšœžœ˜—Kšœžœ˜—K˜Kš
œ4˜4Kš
œ4˜4Kš
œQ˜QKš
œI˜IKš
œQ˜QKš
œ2˜2Kš
œ]˜]Kš
œT˜TK˜RK˜Kš
œ˜Kšžœžœ˜)K˜Jš
œ1˜1K˜Kšžœ
žœ˜
Kš
œ˜—K˜š‘œ˜#Jšœžœžœ/˜FJšžœžœ
žœ
žœ
˜J˜JLšœžœ
˜Lš
œ˜Kš
œ˜—K˜š‘œžœ)žœ˜KKš
œ˜Kšžœ	žœ%˜4Kš
œ!˜!Kš
œ˜—K˜š’œžœžœ
žœžœžœ
˜:Kš
œ˜Kšžœ
žœ˜K˜—K˜š
‘	œžœžœ
žœžœ˜?Kšžœ˜#K˜—K˜šŸ	œ˜Kšžœ$žœ˜>Kšžœ"˜&Kš
œ˜—K˜šŸœ˜Kšžœžœžœ˜8Kšžœ"˜&Kš
œ˜—K˜šŸœ˜Kšžœ(žœ˜FKšžœ"˜&Kš
œ˜—K˜šŸœ˜Kšžœ'žœ˜DKšžœ"˜&Kš
œ˜—K˜šŸœ˜Kšœžœ ˜>Kš
œ˜—K˜šŸœ˜Kšœžœžœ
˜$Kšžœ"žœ
žœ
˜0Kšœžœ
˜Kš
œ˜Kš
œ˜—K˜šŸœ˜Kš
œ˜Kšœžœžœ
˜$šžœžœ˜%Lš
œ˜Lšžœžœ˜/L˜—šžœžœ
ž
˜$Kšœžœ
˜Kš
œ˜K˜—Kš
œ˜—K˜š‘œžœ
žœ˜.šœ	žœ˜)Kšžœ˜Kšžœ˜—Kšžœ
žœ
žœžœ
˜*K˜—K˜š‘œžœ
žœ˜/šœ	žœž˜ Kšžœ˜Kšžœ
žœž
œ
˜—Kšœžœ
˜K˜—K˜š‘
œžœ
žœ˜2Kšœ
žœ
˜K˜Kšžœžœ
žœ/˜@Kš
œ˜—K˜š’œžœžœžœžœžœ˜AKšœžœ
˜	Kšœžœ0˜DKšžœžœžœ
žœ˜EKšœ=žœž	œ˜PKšžœžœ0˜;Kšžœ˜Kš
œ˜—K˜šŸ
œ˜Kšœžœ˜%šžœžœ
žœžœ
žœž˜<šœžœ ˜7Kšžœžœžœ˜)—šžœžœ˜#Kš
œD˜DKšžœ
˜K˜—Kšžœ
žœ,žœ˜AKšžœ
˜—Kš
œ˜—K˜šŸ	œ˜Kšœžœ˜%Kšžœžœ˜5Kš
œ˜Kš
œ˜Kš
œ2˜2K˜Kš
œ˜—K˜šŸœ˜Kšœžœ˜%Kšœžœ0˜DKšžœžœ˜3Kšžœ)˜-Kš
œ˜—K˜š‘œžœžœ˜;Kšžœ˜
Kšœžœžœ
˜K˜Kš‘œžœ
žœžœžœžœžœ˜JK˜šžœ
žœ
ž˜Kš
œB˜BKš
œ@˜@Kš
œ8˜8Kš
œ?˜?Kš
œC˜CKš
œC˜CKš
œG˜GKš
œ@˜@Kš
œI˜IKš
œH˜HKš
œD˜DKš
œA˜AKš
œ?˜?Kš
œ6˜6Kš
œ<˜<Kš
œD˜DKš
œD˜DKš
œ8˜8Kš
œG˜GKš
œH˜HKš
œF˜FKš
œI˜IKš
œ@˜@Kš
œB˜BKš
œ@˜@Kš
œ=˜=Kš
œG˜GKš
œI˜IKš
œC˜CKš
œE˜EKš
œF˜FKš
œD˜DKš
œC˜CKš
œD˜DKš
œC˜CKš
œC˜CKš
œC˜CKš
œB˜BKš
œD˜DKš
œ@˜@Kš
œH˜HKš
œ3˜3Kš
œ5˜5Kšžœ5˜<—Kšžœžœ˜"Kš
œ˜—K˜š‘œžœ'˜9Kš‘œžœ
žœžœžœžœžœ˜MK˜šžœ
žœ
ž˜Kšœ>žœ˜CKš
œ1˜1Kš
œ.˜.Kš
œ,˜,Kšœžœ1˜Eš
œ˜šžœ˜Kšžœ#˜'šžœ˜Kšœžœ
˜Kšœžœžœ
˜Kšœ<žœžœ˜MKšžœžœžœ!žœ˜GKšžœžœžœ˜CKš
œ˜———š
œ˜šžœ˜Kšžœ$˜(Kšžœ+˜/——š
œ˜šžœ˜Kšžœ˜Kšžœ˜——š
œ˜Kšžœ!žœ˜@—š
œ˜Kšžœ žœ˜<—š
œ˜Kšžœžœ˜8—š
œ
˜
Kšžœžœžœ˜2—š
œ˜šžœžœ
žœž˜$šžœžœ˜&Kšœžœ(žœ
˜:Kšžœ
˜K˜—Kšžœ
˜—Kš
œ˜—Kš
œE˜EKš
œ2˜2Kšžœžœ(žœ˜L—Kš
œ˜—K˜šŸœ˜&Kšœžœ
˜	Kš
œ:˜:K˜Kš
œ˜K˜Kšžœžœ
žœ*˜EK˜šžœ˜Kšžœ˜šžœ˜šžœžœ$˜GLšžœ ˜$Lšžœ˜#—šžœžœ˜Kšœžœ
˜Lšœžœ
˜L˜—L˜——K˜—K˜Kšœžœ/˜CK˜Kš
œC˜CK˜Kšžœ
˜——…—3\Aξ