DIRECTORY
CD, CDBasics, CDCommandOps, CDDirectory, CDIO, CDPlot, CDOps, CDOrient, CDProperties, CDSequencer, CDViewer, CMos, CommandTool, Commander, Convert, FileNames, FS, IO, PDFileWriter, PeachPrint, Rope, SymTab, TerminalIO, ThisMachine, TokenIO, ViewerOps;

CDPlotImpl: CEDAR PROGRAM
IMPORTS CDBasics, CDCommandOps, CDDirectory, CDIO, CDOps, CDOrient, CDPlot, CDProperties, CDSequencer, CDViewer, CommandTool, Commander, Convert, FileNames, FS, IO, PeachPrint, Rope, SymTab, TerminalIO, ThisMachine, TokenIO, ViewerOps
EXPORTS CDPlot =
BEGIN

NEW4: PUBLIC PROC[stipple: CDPlot.Stipple4] RETURNS[REF] = 
{RETURN[IF stipple = ALL[0] THEN NIL ELSE NEW[CDPlot.Stipple4 _ stipple]]};

NEW8: PUBLIC PROC[stipple: CDPlot.Stipple8] RETURNS[REF] =
{RETURN[IF stipple = ALL[0] THEN NIL ELSE NEW[CDPlot.Stipple8 _ stipple]]};

NEWLayerTonerSipples: PUBLIC PROC[size: CD.Layer]
RETURNS[lts: REF CDPlot.LayerTonerSipples] = {
lts _ NEW[CDPlot.LayerTonerSipples[size]];
FOR layer: CD.Layer IN [0..size) DO
FOR toner: CDPlot.Toner IN CDPlot.Toner DO
lts[layer][toner] _ NIL ENDLOOP ENDLOOP };

thisMachine: REF CDPlot.PrinterDesc = NEW[ CDPlot.PrinterDesc _
[name: ThisMachine.Name[], iFace: peach ] ];

CDPlotProc: Commander.CommandProc = {
ENABLE {
ABORTED		=> GOTO Abort;
PeachPrint.PupAborted	=> GOTO Abort };
design:			CD.Design;
printer:			REF CDPlot.PrinterDesc;
dName:			Rope.ROPE;
pName:			Rope.ROPE;
nn, nofNums:	INT _ 0;
xn, yn:			INT _ 1;
clip:				CD.Rect _ [0, 0, 0, 0];
argv:				CommandTool.ArgumentVector _ CommandTool.Parse[cmd];
load, exp, killC, noSend:	BOOL _ FALSE;
color:							BOOL _ TRUE;
FOR ii: INT DECREASING IN [1..argv.argc) DO
rope: Rope.ROPE _ CommandTool.ArgN[cmd, ii];
SELECT rope.Fetch[0] FROM
'- => SELECT rope.Fetch[1] FROM
'l, 'L	=> load		_ TRUE;	-- just load for interactive use
'k, 'K	=> killC		_ TRUE;	-- kill CMosB comments
'b, 'B	=> color		_ FALSE;
'c, 'C	=> color		_ TRUE;
'e, 'E	=> exp		_ TRUE;
'n, 'N	=> noSend	_ TRUE;
ENDCASE;
IN ['0..'9]	=> {
temp: INT _ MAX[0, Convert.IntFromRope[rope]];
SELECT nofNums FROM
0	=> {xn			_ MIN[20,		MAX[1, Convert.IntFromRope[rope]]]};
1	=> {yn _ xn; xn	_ MIN[20,		MAX[1, Convert.IntFromRope[rope]]]};
2	=> {nn			_ MIN[xn*yn-1,	MAX[0, Convert.IntFromRope[rope]]]};
ENDCASE	=> ERROR;
nofNums _ nofNums +1};
ENDCASE	=> {pName	_ dName;	dName _ rope} ENDLOOP;
IF NOT IsPrinterName[pName] AND IsPrinterName[dName] THEN
{temp: Rope.ROPE _ dName; dName _ pName; pName _ temp};
printer _ GetPrinter[pName: pName, color: color];
IF printer=NIL THEN {cmd.out.PutRope["Printer not found\n"]; RETURN};
color _ printer.color;
IF exp	THEN [] _ CommandTool.DoCommand["PeachExpand",	cmd];
IF dName # NIL THEN [design, clip]	_ GetDesignClip[dName, cmd];
IF design#NIL AND nofNums=3 THEN {clip _ GetNthOfXYSections[nn, xn, yn, clip]; xn_yn_1};
IF load OR design=NIL THEN {cmd.out.PutRope["CDPlot loaded\n"]; RETURN};
IF color
THEN {
ENABLE Error => {cmd.out.PutRope[msg]; ERROR ABORTED};
rect: CD.Rect _ CDCommandOps.BoundingBox[design];
pdc: REF CDPlot.PDControlRec _ NEW[CDPlot.PDControlRec _ [
ipType:		printer.ipType,
stripes:		xn,
clip:			clip  ]];
[] _ CommandTool.DoCommand["STPServer start", cmd];
InitTechnologyStipples[design.technology.key, cmd, killC];
IF killC THEN KillCmosBComments[];
CDPDPlot[design, pdc];
IF ~noSend THEN FOR xx: INT IN [1..xn] DO
IF exp
THEN {
PrintPD[thisMachine,	primary,		xx, cmd];
PrintPD[printer,			secondary,	xx, cmd]}
ELSE {
PrintPD[printer, primary, xx, cmd]}
ENDLOOP;
IF killC THEN RestoreCmosBComments[]}
ELSE {
firstNm:		Rope.ROPE _ PeachPrint.FileName[long,	primary, 1, ".ip"];
secondNm:	Rope.ROPE _ PeachPrint.FileName[long, secondary, 1, ".pd"];
line:			Rope.ROPE _ Rope.Cat["InterpressToPD ",  secondNm, " _ ", firstNm];
ipc: REF CDPlot.IPControlRec _ NEW[CDPlot.IPControlRec _ [
pageNumX:	xn,
pageNumY:	yn,
type:			IF printer.pgType=stripe THEN stripe ELSE variable,
borders:		yes,
clip:			clip,
altFonts:		FALSE,
altFontsFile:	NIL  ]];
CDIPPlot[design, ipc];
[]_CommandTool.DoCommand[Rope.Cat[line, " ", printerNames[printer.ipType] ],  cmd];
IF ~noSend THEN PrintPD[printer, secondary, 1, cmd]};
EXITS Abort => {cmd.out.PutF["aborted\n"]; RETURN[$Failure]; } };

ParseName: PROC[name: Rope.ROPE] RETURNS[root, ext: Rope.ROPE] = {
index: INT _ Rope.Find[name, "."];
SELECT index FROM
-1						=> RETURN[name,	NIL];
0						=> RETURN[NIL,		NIL];
name.Length[]-1	=> RETURN[Rope.Substr[name, 0, index],	NIL]
ENDCASE				=> RETURN[Rope.Substr[name, 0, index],	Rope.Substr[name, index+1]]};

GetDesignClip: PROC [name: Rope.ROPE, cmd: Commander.Handle]
RETURNS [design: CD.Design, clip: CD.Rect] = {
inst:		CD.Instance;
root, ext: Rope.ROPE;
[root, ext]	_ ParseName[name];
design		_ GetDesign[root, cmd];
IF design=NIL THEN RETURN[NIL, [0,0,0,0]];
clip _ CDCommandOps.BoundingBox[design];
IF Rope.Length[ext]=0 OR Rope.Equal[ext, "dale", FALSE] THEN RETURN[design, clip];
inst _ GetTopDesignObjInst[design, ext];
IF inst=NIL THEN RETURN[NIL, [0,0,0,0]];
clip _ CDOrient.RectAt[inst.location, inst.ob.size, inst.orientation];
RETURN[design, clip]};

GetTopDesignObjInst: PROC [design: CD.Design, name: Rope.ROPE] RETURNS[inst: CD.Instance]={
object: CD.Object _ CDDirectory.Fetch[design, name].object;
IF object=NIL THEN RETURN[NIL];
FOR l: CD.InstanceList _ CDOps.InstList[design], l.rest WHILE l#NIL DO
IF l.first.ob=object THEN RETURN[l.first]; ENDLOOP;
RETURN[NIL]};

GetDesign: PROC [name: Rope.ROPE, cmd: Commander.Handle]
RETURNS [design: CD.Design] = {
runFile: Rope.ROPE;
design _ FindDesignViewer[name];
IF design#NIL THEN RETURN[design];
IF Rope.Length[name]=0 THEN RETURN[NIL];
design _ CDIO.ReadDesign[name];
IF design#NIL THEN RETURN[design];
runFile _ SELECT PeekAtTechnology[name].techKey FROM
$chipnsil		=>	"CDSil",
$nmos		=>	"CDNMos",
$cmos			=>	"CDCMosA",
$cmosB		=>	"CDCMosB",
ENDCASE		=> ERROR ABORTED;
[ ] _ CommandTool.DoCommand[runFile, cmd];
design _ CDIO.ReadDesign[name] };

InitTechnologyStipples: PROC [techKey: ATOM, cmd: Commander.Handle, killC: BOOL] = {
SELECT techKey FROM
$chipnsil		=>	CDPlot.InitSil[];
$nmos		=>	CDPlot.InitNMos[];
$cmos			=>	CDPlot.InitCMosA[];
$cmosB		=> CDPlot.InitCMosB[];
ENDCASE		=> ERROR ABORTED };

CommentStipples: ARRAY CDPlot.PrinterType OF ARRAY CDPlot.Toner OF REF _ ALL[ALL[NIL]];

KillCmosBComments: PROC = {
cmosBPtrLTS: REF CDPlot.PrinterLTS _ NARROW[CDProperties.GetProp[$cmosB,	$stipples]];
IF cmosBPtrLTS=NIL THEN RETURN;
FOR printer: CDPlot.PrinterType IN CDPlot.PrinterType DO
IF cmosBPtrLTS[printer]=NIL THEN LOOP;
CommentStipples[printer] _ cmosBPtrLTS[printer][CD.commentLayer];
cmosBPtrLTS[printer][CD.commentLayer] _ ALL[NIL] ENDLOOP};
RestoreCmosBComments: PROC = {
cmosBPtrLTS: REF CDPlot.PrinterLTS _ NARROW[CDProperties.GetProp[$cmosB,	$stipples]];
IF cmosBPtrLTS=NIL THEN RETURN;
FOR printer: CDPlot.PrinterType IN CDPlot.PrinterType DO
IF cmosBPtrLTS[printer]=NIL THEN LOOP;
cmosBPtrLTS[printer][CD.commentLayer] _ CommentStipples[printer] ENDLOOP};

FindDesignViewer: PROC[name: Rope.ROPE] RETURNS[design: CD.Design_NIL] = {
Checker: ViewerOps.EnumProc ~ {design _ CDViewer.DesignOf[v]; RETURN[design=NIL]};
IF name.Length[]#0 THEN RETURN[CDViewer.FindDesign[name]];
ViewerOps.EnumerateViewers[Checker] };

PeekAtTechnology: PROC[name: Rope.ROPE] RETURNS[techKey:ATOM, techName: Rope.ROPE] ={
wDir:	Rope.ROPE	_ FileNames.CurrentWorkingDirectory[];
fileName:	Rope.ROPE	_ CDIO.MakeName[name, "dale", wDir];
ok:	BOOL	_ TRUE;
versionKey:	INT	_ 0;
binfile: FS.STREAM;
binfile _ FS.StreamOpen[fileName ! FS.Error => 
IF error.group = user THEN {
TerminalIO.WriteRope[Rope.Cat[fileName, " not opened: ", error.explanation, "\n"]];
ok _ FALSE; CONTINUE }];
IF NOT ok THEN RETURN[NIL, NIL];
IF binfile=NIL THEN ERROR;
TokenIO.AttachReader[binfile ! 
TokenIO.Error => {
r: Rope.ROPE _ "bad explanation";
IF ISTYPE[explanation, Rope.ROPE] THEN r_NARROW[explanation];
TerminalIO.WriteRopes[r, "...  not attached\n"]; 
ok _ FALSE; CONTINUE }];
IF NOT ok THEN RETURN[NIL, NIL];
IF TokenIO.ReadInt[]#12121983
THEN {TerminalIO.WriteRope["Not a ChipNDale file\n"]; RETURN[NIL, NIL]};
versionKey _ TokenIO.ReadInt[];
IF TokenIO.ReadInt[]#-1
THEN {TerminalIO.WriteRope["File does not have a seal\n"]; RETURN[NIL, NIL]};
techKey	_ TokenIO.ReadAtom[];
techName	_ TokenIO.ReadRope[];
TokenIO.ReleaseReader[] };

IsPrinterName: PROC [pName: Rope.ROPE] RETURNS[BOOL] =
{RETURN[
SymTab.Fetch[printerTable, PrinterKey[pName, TRUE]].found
OR
SymTab.Fetch[printerTable, PrinterKey[pName, FALSE]].found ]};

PrinterKey: PROC [pName: Rope.ROPE, color: BOOL] RETURNS[Rope.ROPE] =
{RETURN[Rope.Cat[(IF color THEN "+" ELSE "-"), pName]]};

GetPrinter: PROC [pName: Rope.ROPE, color: BOOL]
RETURNS [printer: REF CDPlot.PrinterDesc] = {
found:	BOOL;
val:		REF;
IF pName#NIL THEN {
[found, val] _ SymTab.Fetch[printerTable, PrinterKey[pName, color]];
IF ~found THEN color _ ~color;
[found, val] _ SymTab.Fetch[printerTable, PrinterKey[pName, color]];
IF ~found THEN RETURN[NIL];
RETURN[NARROW[val]] };
RETURN[IF color THEN defaultColorPrinter ELSE defaultBandWPrinter] };

GetNthOfXYSections: PROC [n, x, y: INT, clip: CD.Rect] RETURNS[CD.Rect] = {
size:	CD.Position _ CDBasics.SizeOfRect		[clip];
pos:	CD.Position _ CDBasics.BaseOfRect	[clip];
size.y	_ (size.y + (y-1))/y;
size.x	_ (size.x + (x-1))/x;
pos	_ [size.x * (n MOD x), size.y * (n / x)];
RETURN[CDBasics.RectAt[pos, size]]};

PrintPD: PROC [printer: REF CDPlot.PrinterDesc, order: PeachPrint.FileNameOrder, index: INT,
cmd: Commander.Handle] = {
file: Rope.ROPE _ PeachPrint.FileName[long, order, index, ".pd"];
IF printer.iFace=tsetter
THEN	[]_CommandTool.DoCommand[Rope.Cat["Tsetter ",		printer.name, " ", file], cmd]
ELSE	[]_CommandTool.DoCommand[Rope.Cat["PeachPrint ",	printer.name, " ", file], cmd]};

CDIPPlot:	PUBLIC PROC[design: CD.Design,	ipc: REF CDPlot.IPControlRec] = {
command: CDSequencer.Command _ NEW[CDSequencer.CommandRec _
[design: design, data: ipc, key: $IPAutoPlot]];
CDSequencer.ExecuteCommand[comm: command]};

CDPDPlot:	PUBLIC PROC[design: CD.Design,	pdc: REF CDPlot.PDControlRec] = {
command: CDSequencer.Command _ NEW[CDSequencer.CommandRec _
[design: design, data: pdc, key: $PDAutoPlot]];
CDSequencer.ExecuteCommand[comm: command]};

printerNames: ARRAY CDPlot.PrinterType OF Rope.ROPE _ [
nil:				NIL,
raven300:			"Raven300",
raven384:			"Raven384",
o3:					NIL,
plateMaker:		"PlateMaker",
o5:					NIL,
puffin:			"Puffin",
colorVersatec:	"ColorVersatec",
versatec:			"Versatec",
color400:			"Color400",
c150:				"C150",
d4020:				"d4020",
bw400:			"bw400",
o13:				NIL,
o14:				NIL,
o15:				NIL ];

Error: ERROR [msg: Rope.ROPE] = CODE;

GetStipples: PUBLIC PROC [design: CD.Design, printerType: CDPlot.PrinterType]
RETURNS [stipples: REF CDPlot.LayerTonerSipples] = {
printerStipples:	REF CDPlot.PrinterLTS;
color:				BOOL;
stippleSource:	ATOM;
val:				REF _ CDProperties.GetProp[from: design,	prop: $stipples];
IF val#NIL THEN RETURN[NARROW[val]];
color _ SELECT printerType FROM
colorVersatec, color400, c150 => TRUE,
ENDCASE	=> FALSE;
stippleSource _ SELECT design.technology.key FROM
$chipnsil		=>	IF color THEN $chipnsil	ELSE $silBW,
$nmos		=>	IF color THEN $nmos		ELSE NIL,
$cmos			=>	IF color THEN $cmos		ELSE NIL,
$cmosB		=>	IF color THEN $cmosB		ELSE NIL,
ENDCASE		=>	NIL;
val _ CDProperties.GetProp[from: stippleSource,	prop: $stipples];
IF val=NIL THEN ERROR Error["I can't find stipples for this technology\n"]; 
printerStipples _ NARROW[val];
stipples _ printerStipples[printerType];
IF stipples=NIL THEN ERROR Error["I can't find stipples for this device\n"];
RETURN[stipples] };

SwapSipples: PUBLIC PROC[stipples: REF CDPlot.LayerTonerSipples] = {
FOR layer: CD.Layer IN [0..stipples.size) DO
SwapRefRec: TYPE = RECORD[r0, r1: REF];
[stipples[layer][black], stipples[layer][yellow]] _
SwapRefRec[		stipples[layer][yellow], stipples[layer][black]];
[stipples[layer][cyan], stipples[layer][magenta]] _
SwapRefRec[		stipples[layer][magenta], stipples[layer][cyan]]; ENDLOOP};

Init: PROC = {
Store: PROC[printerRec: CDPlot.PrinterDesc] = {
printer: REF CDPlot.PrinterDesc _ NEW[CDPlot.PrinterDesc _ printerRec];
[] _ SymTab.Store[printerTable, PrinterKey[printer.name, printer.color], printer]};
colorKey:	Rope.ROPE = PrinterKey["Sleepy", col];
bwKey:	Rope.ROPE = PrinterKey["Sleepy", bw];
col: BOOL = TRUE;
bw: BOOL = FALSE;
Store[["Sleepy",		col,	stripe, peach,	colorVersatec	]];
Store[["Sleepy",		bw,	stripe, peach,	versatec		]];
Store[["MtFuji",		col,	page,  peach,	color400		]];
Store[["ColorPatch",	col,	page,  peach,	color400		]];
Store[["MtDiablo",	col,	page,  peach,	d4020			]];
Store[["Stinger",		bw,	page,  tsetter,	raven384		]];
Store[["Quoth",		bw,	page,  tsetter,	raven384		]];
defaultColorPrinter		_ NARROW[SymTab.Fetch[printerTable, colorKey	].val];
defaultBandWPrinter	_ NARROW[SymTab.Fetch[printerTable, bwKey		].val];
[ ] _ CDProperties.RegisterProperty[	prop: $stipples,	registrationKey: $CDPlot] };

printerTable:				SymTab.Ref _ SymTab.Create[case: FALSE]; 
defaultColorPrinter:		REF CDPlot.PrinterDesc; 
defaultBandWPrinter:	REF CDPlot.PrinterDesc; 
doc:						Rope.ROPE = " Design Nx_1 Ny_1 Server";


Init[];

Commander.Register[key:"CDPlot", proc: CDPlotProc, doc: doc];
END.
4CDPlotImpl.mesa
Curry, July 21, 1986 1:59:43 pm PDT
color _ col OR NOT (design.technology.key=$chipnsil OR bw);
IF CDSequencer.FetchCommand[$PDAutoPlot, design.technology]=NIL
THEN [] _ CommandTool.DoCommand["CDPlotPD",	cmd];
[] _ CommandTool.DoCommand["CDPlotPD",	cmd];
IF CDSequencer.FetchCommand[$IPAutoPlot, design.technology]=NIL
THEN [] _ CommandTool.DoCommand["CDPlotIP",	cmd];
[] _ CommandTool.DoCommand["CDPlotIP",	cmd];

Want to do the commnad line version (above) in order to not load the IP stuff unless needed.
See: [Cedar]<CedarChest6.0>InterpressTools>PrintFileConvertImpl.InterpressToPDAction
InterpressToPD: PROC
[iName: ROPE, oName: ROPE, printerType: ImagerPD.PrinterType, cmd: Commander.Handle] ~ {
printerTypePPD: ARRAY ImagerPD.PrinterType OF REAL _ [
nil:			5,	raven300:		6,	raven384:		6,	o3:					5,
plateMaker:	9,	o5:				5,	puffin:		6,	colorVersatec:	5,
versatec:		5,	color400:		7,	c150:			4,	o11:				5,
o12:			5,	o13:			5,	o14:			5,	o15:				5 ];
realPPD:		REAL ~ printerTypePPD[printerType];
interpress:	Interpress.OpenMaster ~ Interpress.Open[iName, Log, cmd];
pd:			ImagerPD.PD ~
ImagerPD.CreateFromPrinterType[oName, printerType, NIL, NIL, realPPD];
FOR i: INT IN [0..interpress.pages) DO
action: PROC [context: Imager.Context] ~ 
{Interpress.DoPage[master: interpress, context: context, page: i+1]};
cmd.out.PutF[" [%g", IO.int[i+1]];
ImagerPD.DoPage[pd: pd, action: action, pixelUnits: FALSE];
cmd.out.PutChar[']];
ENDLOOP;
cmd.out.PutChar[' ];
ImagerPD.Close[pd] };

Interpretations:		TYPE = {sil, silBW, sticks, nmos, cmosA, cmosB, other};
$chipnsil, $silBW and $sticks		initialized by CDPlotPDSil
$nmos								initialized by CDPlotPDNMos
$cmos									initialized by CDPlotPDCMosA
$cmosB								initialized by CDPlotPDCMosB
Sticks.Sticks	=>	IF color THEN $sticks		ELSE NIL,	-- how should this be done?


ΚΝ˜š
œ™Icodeš
œ#™#—J˜š
Οk	˜	Jšœ&œqœ
œV˜ϋ
—J˜šœœ
˜Jšœ&œlœœG˜κ
Jšœ	˜—Jš
˜J˜š
Οnœœ
œœ
œ˜;Jšœ
œ
œœœ
œ
œ
œ˜K—J˜š
žœœ
œœ
œ˜:Jšœ
œ
œœœ
œ
œ
œ˜K—J˜šžœœ
œœ˜1Jšœœ˜.Jšœœ!˜*šœœœ˜#šœœ˜*Jšœœ
œ
œ˜*———J˜šœ
œœ˜?Jšœžœ˜,—J˜š
œ%˜%šœ˜Jšœœ˜Jšœœ	˜&—Jšœ
œ˜Jšœœ˜"Jšœœ
˜Jšœœ
˜Jšœ
œ˜Jšœ
œ˜Jšœ	œ˜ Jš
œ=˜=Jšœœœ
˜'Jšœ
œœ
˜š	œœ

œ
œ˜+Jšœœ˜,šœ˜šœœ˜JšœœΟc ˜8JšœœŸ˜/Jšœœ
˜Jšœœ
˜Jšœœ
˜Jšœœ
˜Jšœ
˜—šœ˜Jšœœœ˜.šœ	˜Jšœ
œœ!˜:Jšœœœ!˜AJšœ
œ
œ!˜>Jšœœ
˜Jš
œ˜——Jšœ"œ
˜1——šœ
œœ˜9Jšœœ'˜7—Jšœœ
œ"œ™;Jš
œ1˜1Jšœ	œ
œ*œ˜EJš
œ˜Jšœœ0˜;Jšœ	œ
œ,˜?Jšœœ
œœ8˜XJš
œœœ
œ&œ˜Hšœ˜šœ˜Jšœ!œ
œ˜6Jšœœ)˜1šœœœ˜:Jš
œ˜Jš
œ
˜
Jš
œ˜—šœ:™?Jšœ-™1—Jš
œ,™,Jš
œ3˜3Jš
œ:˜:Jšœœ
˜"Jš
œ˜šœ	œ
œœ
œ	˜)šœ˜šœ˜Jš
œ(˜(Jš
œ'˜'—šœ˜Jš
œ#˜#——Jšœ
˜—Jšœœ˜%—šœ˜Jšœœ0˜CJšœœ2˜EJšœ
œ:˜Kšœœœ˜:Jš
œ
˜
Jš
œ
˜
Jšœœœœ
˜;Jš
œ˜Jš
œ
˜
Jšœœ
˜Jšœœ˜—šœ:™?Jšœ-™1—Jš
œ,™,Jš
œ˜Jš
œS˜SJšœ3˜5——Jšœ&œ˜A—J˜š
ž	œœœœœ˜BJšœœ˜"šœ˜Jšœœœ˜Jšœ
œ
œœ˜Jšœœœ
˜;Jšœœ;˜OJ˜——šž
œœ
œ˜<Jšœ
œœ
˜.Jšœœ
˜Jšœœ
˜Jš
œ˜Jš
œ˜Jš
œœ
œ
œ
œ
˜*Jš
œ(˜(Jš
œœœœ
œ˜RKš
œ(˜(Jš
œœ
œ
œ
œ
˜(Jš
œF˜FJšœ˜—J˜šžœœ
œœœœ˜[Kšœœ1˜;Jš
œœ
œ
œ
œ˜š	œœ/œœ
˜FKšœœ
œœ
˜3—Jšœ
œ˜
—J˜šž	œœ
œ˜8Jšœ
œ˜Jšœœ
˜Jš
œ ˜ Jšœœ
œ
œ	˜"Jšœœ
œ
œ˜(Jšœ	œ˜Jšœœ
œ
œ	˜"šœ
œ ˜4Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœœ
œ
˜—Jš
œ*˜*Jšœ	œ˜!—J˜šžœœœ)˜Tšœ	˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœœ
œ˜——J˜Jšœœœ
œœ
œœ
œ
œ˜WJ˜šžœœ˜Jšœ
œœ*˜UJšœ
œ
œ
œ
˜šœœ˜8Jšœœ
œ
œ
˜&Jš
œA˜AJšœ(œ
œœ˜:——šžœœ˜Jšœ
œœ*˜UJšœ
œ
œ
œ
˜šœœ˜8Jšœœ
œ
œ
˜&JšœAœ˜J——J˜šžœœœœ	œœ˜JJšœ>œœ˜RJšœœ
œ˜:Jš
œ&˜&—K˜šžœœœœ	œœ˜UKšœœ'˜6Kšœœœ˜8Kšœœœ
˜Kšœœ˜Kšœ	œ
œ
˜šœ
œœ
˜/šœœ˜Kš
œS˜SKšœœœ˜——Kšœ
œœ
œ
œœ˜ Kšœ	œ
œ
œ
˜š
œ˜š
œ˜Kšœœ˜!Kš
œ
œœœœ˜=Kš
œ1˜1Kšœœœ˜——Kšœ
œœ
œ
œœ˜ šœ˜Kšœ2œ
œœ˜H—Kš
œ˜šœ˜Kšœ7œ
œœ˜M—Kš
œ˜Kš
œ˜Kš
œ˜—J˜š
ž
œœœœ
œ˜6šœ
œ
˜Jšœ-œ˜9Jš
˜Jšœ-œ˜>——J˜šž
œœœ	œœœ˜EJš	œ
œœœœ˜8—J˜šž
œœœ	œ
˜0Jšœœ˜-Jšœœ
˜Jšœœ
˜
šœœ
œ˜Jš
œD˜DJšœœ˜Jš
œD˜DJšœœ
œ
œ˜Jšœ
œ	˜—Jšœ
œœœ˜E—J˜šžœœœœœ
œ
˜KJšœœ(˜0Jšœœ'˜.Jš
œ˜Jš
œ˜Jšœœ˜-Jšœ˜$—J˜šžœœœ=œ
˜\Jš
œ˜Jšœœ2˜Ašœ˜JšœN˜RJšœR˜V——J˜J™š
žœœ
œ	œœ˜Jšœœ˜;Jš
œ/˜/—Jš
œ+˜+—J˜š
žœœ
œ	œœ˜Jšœœ˜;Jš
œ/˜/—Jš
œ+˜+—J˜Jš
œ\™\Jšœ@žœ™Tšžœ™Jšœœ	œ?™Xšœœœ
œ™6Jš
œ0™0Jš
œ6™6Jš
œ1™1Jš
œ*™*—Jšœ
œ™-Jš
œE™Ešœœ™Jšœ3œœ™F—šœœ
œ™&šœœ™)Jš
œE™E—Jšœœ™"Jšœ4œ™;J™Jšœ
™—J™Jš
œ™J™—šœœœœ˜7Jšœœ
˜Jš
œ˜Jš
œ˜Jšœœ
˜Jš
œ˜Jšœœ
˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœœ
˜Jšœœ
˜Jšœœ˜—J˜Jšœœœœ
˜%J˜šžœœ
œ
œ)˜Mšœœ˜4Jšœœ˜'Jšœ
œ
˜Jšœœ
˜Jšœœ7˜BJš
œœ
œ
œ
œ˜$šœœ
˜Jšœ!œ
˜&Jšœœ
˜—šœœ3™IJš
œ9™9Jš
œ(™(Jš
œ*™*Jš
œ*™*—šœœ˜1Jšœœœœ˜2Jš	œ
œœœ
œ
˜(Jš	œœœœ
œ
˜)Jš	œœœ	œ
œ
˜*Jš
œM™MJšœœ
˜—Jš
œA˜AJšœœ
œ
œ7˜LJšœœ˜Jš
œ(˜(Jšœ
œ
œ
œ2˜LJšœ
˜——J˜šžœœ
œœ˜DJšœœœ˜,Jšœœœ	œ˜'š
œ3˜3JšΟb
œ4˜>—š
œ3˜3Jš 
œ5œ˜H——J˜šžœœ˜šžœœ$˜/Jšœ	œœ"˜GJš
œS˜S—Jšœœ˜0Jšœœ˜,Jšœœœ
˜Jšœœœ
˜Jš
œ7˜7Jš
œ2˜2Jš
œ2˜2Jš
œ5˜5Jš
œ1˜1Jš
œ4˜4Jš
œ2˜2Jšœœ,˜IJšœœ*˜FJ™—Jš
œR˜RJ˜Jšœ2œ˜:Jšœœ˜.Jšœœ˜-Jšœœ˜1J˜J˜Jš
œ˜J˜Jš
œ=˜=J™Jšœ
˜—…—3bLc