DIRECTORY
CoordSys,
CSGGraphics,
DisplayList3d,
GraphicsColor,
IO,
Matrix3d,
MessageWindow,
Rope,
SVArtwork,
SVPolygon3d,
SVVector3d,
SVMappings,
SVMatrix2d,
TFI3d;

TFI3dImpl: PROGRAM
IMPORTS CSGGraphics, DisplayList3d, GraphicsColor, IO, Matrix3d, MessageWindow, SVArtwork, SVMappings, SVMatrix2d, SVPolygon3d, Rope
EXPORTS TFI3d =

BEGIN

Assembly: TYPE = DisplayList3d.Assembly;
Color: TYPE = GraphicsColor.Color;
CoordSystem: TYPE = CoordSys.CoordSystem;
DrawStyle: TYPE = CSGGraphics.DrawStyle;
FileCamera: TYPE = DisplayList3d.FileCamera;
FrameBox: TYPE = REF FrameBoxObj;
FrameBoxObj: TYPE = CSGGraphics.FrameBoxObj;
Matrix3by3: TYPE = SVMatrix2d.Matrix3by3;
Matrix4by4: TYPE = Matrix3d.Matrix4by4;
OMap: TYPE = SVArtwork.OMap;
Plane: TYPE = SVPolygon3d.Plane;
Point3d: TYPE = Matrix3d.Point3d;
Point2d: TYPE = Matrix3d.Point2d;
Scene: TYPE = DisplayList3d.Scene;
Vector: TYPE = SVVector3d.Vector;
Material: TYPE = SVArtwork.Material;
SMap: TYPE = SVArtwork.SMap;
CharClass: TYPE = IO.CharClass;

FileinMatrix: PUBLIC PROC [f: IO.STREAM] RETURNS [mat: Matrix4by4] = {
mat _ Matrix3d.Identity[];
ReadRope[f, "["];
ReadBlankAndRope[f, "["];
mat[1][1] _ ReadBlankAndReal[f];
FOR j: NAT IN[2..4] DO
ReadBlankAndRope[f,","];
mat[1][j] _ ReadBlankAndReal[f];
ENDLOOP;
ReadBlank[f];
ReadBlankAndRope[f, "]"];
FOR i: NAT IN[2..3] DO
ReadBlankAndRope[f, ","];
ReadBlankAndRope[f, "["];
mat[i][1] _ ReadBlankAndReal[f];
FOR j: NAT IN[2..4] DO
ReadBlankAndRope[f, ","];
mat[i][j] _ ReadBlankAndReal[f];
ENDLOOP;
ReadBlankAndRope[f, "]"];
ENDLOOP;
ReadBlankAndRope[f, "]"];
}; -- end of FileinMatrix

FileinMatrix3by3: PUBLIC PROC [f: IO.STREAM] RETURNS [mat: Matrix3by3] = {
mat _ SVMatrix2d.Identity[];
ReadRope[f, "["];
ReadBlankAndRope[f, "["];
mat[1][1] _ ReadBlankAndReal[f];
FOR j: NAT IN[2..3] DO
ReadBlankAndRope[f,","];
mat[1][j] _ ReadBlankAndReal[f];
ENDLOOP;
ReadBlank[f];
ReadBlankAndRope[f, "]"];
ReadBlankAndRope[f, ","];
ReadBlankAndRope[f, "["];
mat[2][1] _ ReadBlankAndReal[f];
FOR j: NAT IN[2..3] DO
ReadBlankAndRope[f, ","];
mat[2][j] _ ReadBlankAndReal[f];
ENDLOOP;
ReadBlankAndRope[f, "]"];
ReadBlankAndRope[f, "]"];
}; -- end of FileinMatrix3by3

ReadRope: PUBLIC PROC [f: IO.STREAM, rope: Rope.ROPE] = {
c: CHAR;
FOR i: NAT IN[1..Rope.Length[rope]] DO
c _ IO.GetChar[f];
IF NOT c = Rope.Fetch[rope,i-1] THEN 
SIGNAL RopeNotOnTop [IO.GetIndex[f], Rope.FromChar[c], rope];
ENDLOOP;
};
RopeNotOnTop: PUBLIC SIGNAL [position: NAT, wasThere: Rope.ROPE, notThere: Rope.ROPE] = CODE;

ReadChar: PUBLIC PROC [f: IO.STREAM, c: CHAR] = {
streamC: CHAR _ IO.GetChar[f];
IF NOT c = streamC THEN SIGNAL RopeNotOnTop[IO.GetIndex[f], Rope.FromChar[streamC], Rope.FromChar[c]];
};

ReadReturn: PUBLIC PROC [f: IO.STREAM] = {
ReadChar[f, IO.CR];
};

WordBreakProc: SAFE PROC [char: CHAR] RETURNS [IO.CharClass] = CHECKED {
SELECT char FROM
IO.TAB => RETURN [break];
IO.CR =>RETURN [break];
IO.SP => RETURN [break];
', => RETURN [break];
'] => RETURN [break];
') => RETURN [break];
ENDCASE => RETURN [other];
};

KeyWordBreakProc: SAFE PROC [char: CHAR] RETURNS [IO.CharClass] = CHECKED {
SELECT char FROM
IO.CR =>RETURN [break];
': => RETURN [break];
ENDCASE => RETURN [other];
};

ReadWord: PUBLIC PROC [f: IO.STREAM] RETURNS [word: Rope.ROPE] = {
word _ IO.GetToken[f, WordBreakProc];
};

ReadKeyWord: PUBLIC PROC [f: IO.STREAM] RETURNS [keyWord: Rope.ROPE, good: BOOL] = {
nextChar: Rope.ROPE;
keyWord _ IO.GetToken[f, KeyWordBreakProc];
nextChar _ IO.GetToken[f, KeyWordBreakProc];
good _ Rope.Equal[nextChar, ":", TRUE];
};

LineBreakProc: SAFE PROC [char: CHAR] RETURNS [IO.CharClass] = CHECKED {
SELECT char FROM
IO.CR =>RETURN [break];
ENDCASE => RETURN [other];
};

ReadLine: PUBLIC PROC [f: IO.STREAM] RETURNS [line: Rope.ROPE] = {
line _ IO.GetToken[f, LineBreakProc];
[] _ IO.GetToken[f, LineBreakProc]; -- remove <CR>
};

WhiteSpaceProc: SAFE PROC [char: CHAR] RETURNS [IO.CharClass] = TRUSTED {
SELECT char FROM
IO.TAB => RETURN [other];
IO.CR =>RETURN [other];
IO.SP => RETURN [other];
ENDCASE => RETURN [break];
};

ReadWhiteSpace: PUBLIC PROC [f: IO.STREAM] = {
whiteSpace: Rope.ROPE _ IO.GetToken[f, WhiteSpaceProc];
IF Rope.Size[whiteSpace] = 0 THEN SIGNAL RopeNotOnTop[IO.GetIndex[f], "null", "<whitespace>"];
};

ReadBlank: PUBLIC PROC [f: IO.STREAM] = {
whiteSpace: Rope.ROPE;
len: NAT;
c: CHAR;
whiteSpace _ IO.GetSequence[f, BlankProc];
len _ Rope.Size[whiteSpace];
IF len # 0 THEN {
c _ Rope.Fetch[whiteSpace, len-1];
IO.Backup[f, c];
RETURN;
};
};

BlankProc: SAFE PROC [char: CHAR] RETURNS [quit: BOOL _ FALSE, include: BOOL _ TRUE] = TRUSTED {
SELECT char FROM
IO.CR, IO.TAB, IO.SP => RETURN [FALSE, TRUE];
ENDCASE => RETURN [TRUE, TRUE];
};

ReadHorizontalBlank: PUBLIC PROC [f: IO.STREAM] RETURNS [good: BOOL] = {
whiteSpace: Rope.ROPE;
len: NAT;
c: CHAR;
good _ TRUE;
whiteSpace _ IO.GetSequence[f, HorizontalBlankProc];
IF whiteSpace = NIL THEN {good _ FALSE; RETURN};
len _ Rope.Size[whiteSpace];
IF len # 0 THEN {
c _ Rope.Fetch[whiteSpace, len-1];
IF c = IO.CR THEN good _ FALSE;
IO.Backup[f, c];
RETURN;
};
};

HorizontalBlankProc: SAFE PROC [char: CHAR] RETURNS [quit: BOOL _ FALSE, include: BOOL _ TRUE] = TRUSTED {
SELECT char FROM
IO.TAB, IO.SP => RETURN [FALSE, TRUE];
ENDCASE => RETURN [TRUE, TRUE];
};

ReadBlankAndRope: PUBLIC PROC [f: IO.STREAM, rope: Rope.ROPE] = {
ReadBlank[f];
ReadRope[f, rope];
};

ReadBlankAndReal: PUBLIC PROC [f: IO.STREAM] RETURNS [r: REAL] = {
ReadBlank[f];
r _ ReadReal[f];
};

ReadBlankAndWord: PUBLIC PROC [f: IO.STREAM] RETURNS [word: Rope.ROPE] = {
ReadBlank[f];
word _ ReadWord[f];
};

ReadBlankAndNAT: PUBLIC PROC [f: IO.STREAM] RETURNS [n: NAT] = {
ReadBlank[f];
n _ ReadNAT[f];
};

ReadPoint3d: PUBLIC PROC [f: IO.STREAM] RETURNS [point3d: Point3d] = {
ReadRope[f, "["];
point3d[1] _ ReadBlankAndReal[f];
ReadRope[f, ","];
point3d[2] _ ReadBlankAndReal[f];
ReadRope[f, ","];
point3d[3] _ ReadBlankAndReal[f];
ReadRope[f, "]"];
};

ReadPoint2d: PUBLIC PROC [f: IO.STREAM] RETURNS [point2d: Point2d] = {
ReadRope[f, "["];
point2d[1] _ ReadBlankAndReal[f];
ReadRope[f, ","];
point2d[2] _ ReadBlankAndReal[f];
ReadRope[f, "]"];
};

ReadPoint2dAsPoint3d: PUBLIC PROC [f: IO.STREAM] RETURNS [point3d: Point3d] = {
ReadRope[f, "["];
point3d[1] _ ReadBlankAndReal[f];
ReadRope[f, ","];
point3d[2] _ ReadBlankAndReal[f];
point3d[3] _ 0;
ReadRope[f, "]"];
};

RealBreakProc: SAFE PROC [char: CHAR] RETURNS [IO.CharClass] = TRUSTED {
SELECT char FROM
'], ', => RETURN [break];
IO.CR =>RETURN [break];
IO.SP => RETURN [break];
ENDCASE => RETURN [other];
};

ReadReal: PUBLIC PROC [f: IO.STREAM] RETURNS [r: REAL] = {
realRope: Rope.ROPE _ IO.GetToken[f, RealBreakProc];
IF Rope.Find[realRope, ".", 0, FALSE] = -1 THEN realRope _ Rope.Concat[realRope, ".0"];
r _ IO.GetReal[IO.RIS[realRope]];
};

NATBreakProc: SAFE PROC [char: CHAR] RETURNS [IO.CharClass] = TRUSTED {
SELECT char FROM
'], IO.CR, IO.SP, '., ', => RETURN [break];
ENDCASE => RETURN [other];
};

ReadNAT: PUBLIC PROC [f: IO.STREAM] RETURNS [n: NAT] = {
intRope: Rope.ROPE _ IO.GetToken[f, NATBreakProc];
n _ IO.GetInt[IO.RIS[intRope]];
};

BoolBreakProc: SAFE PROC [char: CHAR] RETURNS [IO.CharClass] = TRUSTED {
SELECT char FROM
'], IO.CR, IO.SP, '., ', => RETURN [break];
ENDCASE => RETURN [other];
};

ReadBool: PUBLIC PROC [f: IO.STREAM] RETURNS [truth: BOOL, good: BOOL] = {
boolRope: Rope.ROPE _ IO.GetToken[f, BoolBreakProc];
good _ TRUE;
IF Rope.Equal[boolRope, "TRUE", TRUE] THEN truth _ TRUE
ELSE IF Rope.Equal[boolRope, "FALSE", TRUE] THEN truth _ FALSE
ELSE {truth _ FALSE; good _ FALSE};
};

ReadColor: PUBLIC PROC [f: IO.STREAM] RETURNS [color: Color] = {
r, g, b: REAL;
ReadChar[f, '[];
r _ ReadBlankAndReal[f];
ReadChar[f, ',];
g _ ReadBlankAndReal[f];
ReadChar[f, ',];
b _ ReadBlankAndReal[f];
ReadChar[f, ']];
color _ GraphicsColor.RGBToColor[r, g, b];
}; -- end of ReadColor

ReadSurface: PUBLIC PROC [f: IO.STREAM] RETURNS [surface: REF ANY] = {
surfType: Rope.ROPE _ ReadBlankAndWord[f];
SELECT TRUE FROM
Rope.Equal[surfType, "tube", FALSE] => {
radius, height: REAL;
ReadBlankAndRope[f, "[radius:"];
radius _ ReadBlankAndReal[f];
ReadBlankAndRope[f, ","];
ReadBlankAndRope[f, "height:"];
height _ ReadBlankAndReal[f];
ReadBlankAndRope[f, "]"];
surface _ SVMappings.CreateTube[radius, height];
};
Rope.Equal[surfType, "box", FALSE] => {
boxSide: Vector;
ReadBlank[f];
boxSide _ ReadPoint3d[f];
surface _ SVMappings.CreateBox[boxSide[1], boxSide[2], boxSide[3]];
};
Rope.Equal[surfType, "NIL"] => {};
ENDCASE => ERROR;
}; -- end of ReadSurface

ReadMaterial: PUBLIC PROC [f: IO.STREAM] RETURNS [material: Material] = {
matRope: Rope.ROPE _ ReadWord[f];
success: BOOL;
[material, success] _ SVArtwork.RopeToMaterial[matRope];
IF NOT success THEN ERROR;
};

ReadSMap: PUBLIC PROC [f: IO.STREAM] RETURNS [sMap: SMap] = {
mapRope: Rope.ROPE _ ReadWord[f];
success: BOOL;
[sMap, success] _ SVArtwork.RopeToSMap[mapRope];
IF NOT success THEN ERROR;
};

ReadOMap: PUBLIC PROC [f: IO.STREAM] RETURNS [oMap: OMap] = {
mapRope: Rope.ROPE _ ReadWord[f];
success: BOOL;
[oMap, success] _ SVArtwork.RopeToOMap[mapRope];
IF NOT success THEN ERROR;
};

ReadCamera: PUBLIC PROC [f: IO.STREAM, worldCS: CoordSystem, scene: Scene] RETURNS [fileCamera: FileCamera] = {
name: Rope.ROPE;
origin, focusPoint: Point3d;
slant, focalLength, resolution: REAL;
clippingPlanes: LIST OF Plane;
visibleAssemblies: LIST OF Rope.ROPE;
frame: FrameBox;
ReadBlankAndRope[f, "Camera:"];
name _ ReadBlankAndWord[f];
ReadBlankAndRope[f, "origin:"];
ReadBlank[f];
origin _ ReadPoint3d[f];
ReadBlankAndRope[f, "focusPoint:"];
ReadBlank[f];
focusPoint _ ReadPoint3d[f];
ReadBlankAndRope[f, "slant:"];
slant _ ReadBlankAndReal[f];

ReadBlankAndRope[f, "resolution:"];
resolution _ ReadBlankAndReal[f];
ReadBlankAndRope[f, "focalLength:"];
focalLength _ ReadBlankAndReal[f];

ReadBlankAndRope[f, "frame:"];
ReadBlank[f];
frame _ ReadFrame[f];

ReadBlankAndRope[f, "clippingPlanes:"];
clippingPlanes _ ReadClippingPlanes[f];

ReadBlankAndRope[f, "visibleAssemblies:"];
visibleAssemblies _ ReadListOfRope[f];
ReadBlank[f];

fileCamera _ DisplayList3d.CreateFileCamera[name, origin, focusPoint, slant, resolution, focalLength, clippingPlanes, visibleAssemblies];
};

ReadClippingPlanes: PUBLIC PROC [f: IO.STREAM] RETURNS [clippingPlanes: LIST OF Plane] = {
plane: Plane;
continue: BOOL;
clippingPlanes _ NIL;
continue _ ReadHorizontalBlank[f];
IF NOT continue THEN RETURN;
plane _ ReadPlane[f];
clippingPlanes _ AppendPlaneToList[plane, clippingPlanes];
WHILE TRUE DO
continue _ ReadHorizontalBlank[f];
IF NOT continue THEN RETURN;
ReadRope[f, ","];
ReadBlank[f];
plane _ ReadPlane[f];
clippingPlanes _ AppendPlaneToList[plane, clippingPlanes];
ENDLOOP;
};

AppendPlaneToList: PROC [plane: Plane, list: LIST OF Plane] RETURNS [LIST OF Plane] = {
z: LIST OF Plane _ list;
IF z = NIL THEN RETURN[CONS[plane,NIL]];
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ CONS[plane,NIL];
RETURN[list];
};

ReadPlane: PUBLIC PROC [f: IO.STREAM] RETURNS [plane: Plane] = {
A, B, C, D: REAL;
ReadBlankAndRope[f, "["];
A _ ReadBlankAndReal[f];
ReadBlankAndRope[f, ","];
B _ ReadBlankAndReal[f];
ReadBlankAndRope[f, ","];
C _ ReadBlankAndReal[f];
ReadBlankAndRope[f, ","];
D _ ReadBlankAndReal[f];
ReadBlankAndRope[f, "]"];
plane _ SVPolygon3d.PlaneFromCoefficients[A, B, C, D];
};

ReadStyle: PUBLIC PROC [f: IO.STREAM] RETURNS [style: DrawStyle] = {
styleName: Rope.ROPE _ ReadBlankAndWord[f];
success: BOOL;
[style, success] _ CSGGraphics.RopeToDrawStyle[styleName];
IF NOT success THEN style _ wire;
}; -- end of ReadStyle

ReadFrame: PUBLIC PROC [f: IO.STREAM] RETURNS [frame: FrameBox] = {
success: BOOL;
point: Point2d;
frame _ NEW[FrameBoxObj];
ReadBlankAndRope[f, "["];
ReadBlank[f];
point _ ReadPoint2d[f];
frame.downLeft[1] _ point[1];
frame.upRight[2] _ point[2];
ReadBlankAndRope[f, ","];
ReadBlank[f];
point _ ReadPoint2d[f];
frame.upRight[1] _ point[1];
frame.downLeft[2] _ point[2];
ReadBlankAndRope[f, "fullScreen:"];
ReadBlank[f];
[frame.fullScreen, success] _ ReadBool[f];
IF NOT success THEN frame.fullScreen _ TRUE;
ReadBlankAndRope[f, "]"];
}; -- end of ReadFrame

RopesOnOneLineProc: SAFE PROC [char: CHAR] RETURNS [IO.CharClass] = CHECKED {
SELECT char FROM
IO.CR =>RETURN [break];
IO.SP, IO.TAB, ', , '; => RETURN [sepr];
ENDCASE => RETURN [other];
};

ReadListOfRope: PUBLIC PROC [f: IO.STREAM] RETURNS [ropeList: LIST OF Rope.ROPE] = {
rope: Rope.ROPE;
ropeList _ NIL;
WHILE TRUE DO
rope _ IO.GetToken[f, RopesOnOneLineProc];
IF rope = NIL THEN RETURN;
IF Rope.Equal[rope, Rope.FromChar[IO.CR]] THEN RETURN
ELSE ropeList _ AppendRopeToRopeList[rope, ropeList];
ENDLOOP;
};

AppendRopeToRopeList: PROC [rope: Rope.ROPE, list: LIST OF Rope.ROPE] RETURNS [LIST OF Rope.ROPE] = {
z: LIST OF Rope.ROPE _ list;
IF z = NIL THEN RETURN[CONS[rope,NIL]];
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ CONS[rope,NIL];
RETURN[list];
};

ReadVisibleAssemblies: PUBLIC PROC [f: IO.STREAM, scene: Scene] RETURNS [assemblyList: LIST OF Assembly] = {
assembly: Assembly;
assemblyName: Rope.ROPE;
continue, found: BOOL;
assemblyList _ NIL;
found _ TRUE;
WHILE continue DO
assemblyName _ IO.GetToken[f, RopesOnOneLineProc];
IF assemblyName = NIL OR Rope.Equal[assemblyName, Rope.FromChar[IO.CR]] THEN continue _ FALSE
ELSE {
[assembly, ----] _ DisplayList3d.FindAssemblyFromName[assemblyName, scene
!DisplayList3d.AssemblyNotFound => {found _ FALSE; CONTINUE}];
IF NOT found THEN {
index: NAT;
outStream: IO.STREAM;
errorRope: Rope.ROPE;
index _ IO.GetIndex[f];
outStream _ IO.ROS[];
outStream.PutF["Assembly %g not found at: %g.", [rope[assemblyName]], [integer[index]]];
errorRope _ IO.GetOutputStreamRope[outStream];
MessageWindow.Append[errorRope, TRUE];
MessageWindow.Blink[];
}
ELSE assemblyList _ AppendAssemblyToList[assembly, assemblyList];
};
ENDLOOP;
};

AppendAssemblyToList: PROC [assembly: Assembly, list: LIST OF Assembly] RETURNS [LIST OF Assembly] = {
z: LIST OF Assembly _ list;
IF z = NIL THEN RETURN[CONS[assembly,NIL]];
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ CONS[assembly,NIL];
RETURN[list];
};

END.
ΠFile: TFI3dImpl.mesa (text file in for 3d)
Last edited by Bier on August 12, 1983 1:40 pm
Contents: convenience functions for parsing low-level parts of a 3d fileout produced by fileout3d.mesa
{break, sepr, other}
Removes the given rope from the top of the stream. Used to remove formatting words and phrases from 3d files.  We are not interested in these strings but only in the data in between them.
Signals RopeNotOnTop if some other rope is on top.
Convenience function.  Equivalent to ReadChar[f, IO.CR];
Reads a rope until <SPACE>, <CR>, <COMMA> or <TAB> are encountered.  Used to read in a rope which is data.  ie the name of a coordinate system from a 3d file.
Reads a rope until a ':' or <CR> are encountered.  If CR is encountered first, then good is FALSE since ":" is expected after a keyword.
Reads a rope UNTIL <CR> is encountered.  Used to read Solidviews version rope
Reads, <SPACE>'s, <CR>'s, and <TAB>'s until something else is encountered.  Signals RopeNotOnTop if no white space characters are found.
Reads, <SPACE>'s, <CR>'s, and <TAB>'s until something else is encountered.  Doesn't mind if no white space characters are found.
Reads <SPACE>'s, and <TABS>'s until something else is encountered.  Returns good = FALSE if a CR is encountered before anything else
A convenience function.  Equivalent to ReadBlank[f]; r _ ReadReal[f];
A convenience function.  Equivalent to ReadBlank[f]; word _ ReadWord[f];
A convenience function.  Equivalent to ReadBlank[f]; n _ ReadNAT[f];
Assumes the next rope on the stream will be of the form "[<real1>,<real2>,<real3>]".
Assumes the next rope on the stream will be of the form "[<real1>,<real2>]".
Assumes the next rope on the stream will be of the form "[<real1>,<real2>]".  Fills in point3d[3] with zero.
Reads digits up to the next ], <CR>, <SPACE> or <COMMA>.  Leaves these terminators on the stream.
Reads digits up to the next ], <CR>, <SPACE>.  Leaves these terminators on the stream.
Tries to read TRUE or FALSE from the stream.  If it encounters another word, good = FALSE;
A copy of List.Nconc1 for LIST OF Plane instead of LIST OF REF ANY
A copy of List.Nconc1 for LIST OF Rope.ROPE instead of LIST OF REF ANY
A copy of List.Nconc1 for LIST OF Assembly instead of LIST OF REF ANY
Κ)–

"cedar" style˜Iheadš
œ*™*Iprocš
œ.™.Lš
œf™fL˜š
Οk	˜	Lš
œ	˜	Lš
œ˜Lš
œ˜Lš
œ˜Lšœ
˜Lš
œ	˜	L˜Lš
œ˜Lš
œ
˜
Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜—L˜šœ˜Lšœ,œO˜„
Lšœ˜—L˜Lš
˜˜Lšœ
œ˜(Lšœœ˜"Lšœ
œ˜)Lšœœ˜(Lšœœ˜,Lšœ
œœ
˜!Lšœ
œ˜,Lšœœ˜)Lšœœ˜'Lšœœ˜Lšœœ˜ Lšœ	œ˜!Lšœ	œ˜!Lšœœ˜"Lšœœ˜!Lšœ
œ˜$Lšœœ˜Lšœœœ˜Lš
œ™L˜šΟnœœ
œœ
œœ˜FLš
œ˜Lš
œ˜Lš
œ˜Lš
œ ˜ šœœ
œ˜Lš
œ˜Lš
œ ˜ —Lšœ
˜Lš
œ
˜
Lš
œ˜šœœ
œ˜Lš
œ˜Lš
œ˜Lš
œ ˜ šœœ
œ˜Lš
œ˜Lš
œ ˜ —Lšœ
˜Lš
œ˜—Lšœ
˜Lš
œ˜LšœΟc˜—L˜šžœœ
œœ
œœ˜JLš
œ˜Lš
œ˜Lš
œ˜Lš
œ ˜ šœœ
œ˜Lš
œ˜Lš
œ ˜ —Lšœ
˜Lš
œ
˜
Lš
œ˜Lš
œ˜Lš
œ˜š
œ ˜ Lšœœ
œ˜Lš
œ˜Lš
œ ˜ —Lšœ
˜Lš
œ˜Lš
œ˜LšœŸ˜—L˜šžœœ
œœ
œ
œ˜9Lš
œ»
™»
Lš
œ2™2Lšœœ
˜šœœ
œ˜&Lšœœ˜Lšœ
œœ
˜%Lšœœ&˜=—Lšœ
˜Lš
œ˜—Lš
œœ
œœœœœ
˜]L˜šžœœ
œœ
œœ˜1Lšœ	œœ˜Lš
œ
œ
œ
œœ8˜fLš
œ˜—L˜š
ž
œœ
œœ
œ˜*Lš
œ8™8Lšœœ
œ˜Lš
œ˜—L˜šž
œœ
œœœœœ˜Hšœ˜Lšœ
œœ	˜Lšœ
œœ	˜Lšœ
œœ	˜Lšœœ	˜Lšœœ	˜Lšœœ	˜Lšœœ	˜—Lš
œ˜—L˜šžœœ
œœœœœ˜Kšœ˜Lšœ
œœ	˜Lšœœ	˜Lšœœ	˜—Lš
œ˜—L˜šžœœ
œœ
œœ
œ˜BLš
œž
™ž
Lšœœ˜%Lš
œ˜—L˜šžœœ
œœ
œœœœ˜TLš
œˆ
™ˆ
Lšœœ
˜Lšœ
œ˜+Lšœœ˜,Lšœ!œ˜'Lš
œ˜—L˜šž
œœ
œœœœœ˜Hšœ˜Lšœ
œœ	˜Lšœœ	˜—Lš
œ˜—L˜šžœœ
œœ
œœ
œ˜BLš
œM™MLšœœ˜%LšœœŸ˜2Lš
œ˜—L˜šžœœ
œœœœœ˜Išœ˜Lšœ
œœ	˜Lšœ
œœ	˜Lšœ
œœ	˜Lšœœ	˜—Lš
œ˜—L˜š
žœœ
œœ
œ˜.Lš
œˆ
™ˆ
Lšœœœ˜7Lšœœ
œœ&˜^Lš
œ˜—L˜š
ž	œœ
œœ
œ˜)Lš
œ€
™€
Lšœœ
˜Lšœœ
˜	Lšœœ
˜Lšœ
œ˜*Lš
œ˜šœ	œ˜Lš
œ"˜"Lšœ˜Lšœ
˜Lš
œ˜—Lš
œ˜—L˜šž	œœ
œœœœœœœœ˜`šœ˜Lšœ
œœ
œœ
œœœœ˜-Lšœœœœ˜—Lš
œ˜—L˜šžœœ
œœ
œœœ˜HLš
œ„
™„
Lšœœ
˜Lšœœ
˜	Lšœœ
˜Lšœœ
˜Lšœ
œ%˜4Lš
œœ
œ	œœ˜0Lš
œ˜šœ	œ˜Lš
œ"˜"Lš
œœ
œ
œœ
˜Lšœ˜Lšœ
˜Lš
œ˜—Lš
œ˜—L˜šžœœ
œœœœœœœœ˜jšœ˜Lšœ
œœ
œœœœ˜&Lšœœœœ˜—Lš
œ˜—L˜šžœœ
œœ
œ
œ˜ALš
œ
˜
Lš
œ˜Lš
œ˜—L˜šžœœ
œœ
œœœ˜BLš
œE™ELš
œ
˜
Lš
œ˜Lš
œ˜—L˜šžœœ
œœ
œœ
œ˜JLš
œH™HLš
œ
˜
Lš
œ˜Lš
œ˜—L˜šžœœ
œœ
œœœ˜@Lš
œD™DLš
œ
˜
Lš
œ˜Lš
œ˜—L˜šžœœ
œœ
œœ˜FLš
œT™TLš
œ˜Lš
œ!˜!Lš
œ˜Lš
œ!˜!Lš
œ˜Lš
œ!˜!Lš
œ˜Lš
œ˜—L˜šžœœ
œœ
œœ˜FLš
œL™LLš
œ˜Lš
œ!˜!Lš
œ˜Lš
œ!˜!Lš
œ˜Lš
œ˜—L˜šžœœ
œœ
œœ˜OLš
œl™lLš
œ˜Lš
œ!˜!Lš
œ˜Lš
œ!˜!Lš
œ˜Lš
œ˜Lš
œ˜—L˜šž
œœ
œœœœœ˜Hšœ˜Lšœ
œ	˜Lšœ
œœ	˜Lšœ
œœ	˜Lšœœ	˜—Lš
œ˜—L˜šžœœ
œœ
œœœ˜:Lš
œa™aLšœœœ˜4Lšœœœ(˜WLšœœ	œ
œ˜!Lš
œ˜—L˜šžœœ
œœœœœ˜Gšœ˜Lšœœ
œœ
œœ	˜+Lšœœ	˜—Lš
œ˜—L˜šžœœ
œœ
œœœ˜8Lš
œV™VLšœœœ˜2Lšœœœ
œ˜Lš
œ˜—L˜šž
œœ
œœœœœ˜Hšœ˜Lšœœ
œœ
œœ	˜+Lšœœ	˜—Lš
œ˜—L˜šžœœ
œœ
œœ	œœ˜JLš
œZ™ZLšœœœ˜4Lšœœ
˜Lšœœœ	˜7š	œ
œœœ	˜>Lšœ
œ	œ˜#—Lš
œ˜—L˜šž	œœ
œœ
œœ˜@Lšœ	œ
˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ*˜*LšœŸ˜—L˜šžœœ
œœ
œœœ
œ˜FLšœœ˜*šœ
œ
˜šœœ˜(Lšœœ
˜Lš
œ ˜ Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ0˜0Lš
œ˜—šœœ˜'Lš
œ˜Lš
œ
˜
Lš
œ˜Lš
œC˜CLš
œ˜—Lš
œ"˜"Lšœœ
˜—LšœŸ˜—L˜šžœœ
œœ
œœ˜ILšœœ˜!Lšœ	œ
˜Lš
œ8˜8Lšœ
œ	œ
œ
˜Lš
œ˜—L˜šžœœ
œœ
œœ˜=Lšœœ˜!Lšœ	œ
˜Lš
œ0˜0Lšœ
œ	œ
œ
˜Lš
œ˜—L˜šžœœ
œœ
œœ˜=Lšœœ˜!Lšœ	œ
˜Lš
œ0˜0Lšœ
œ	œ
œ
˜Lš
œ˜—šž
œœ
œœ
œ&œ˜oLšœœ
˜L˜Lšœ œ
˜%Lšœœ
œ˜Lšœœ
œœ
˜%L˜Lš
œ˜Lš
œ˜Lš
œ˜L˜
Lš
œ˜Lš
œ#˜#L˜
Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ#˜#Lš
œ!˜!Lš
œ$˜$Lš
œ#˜#Lš
œ˜L˜
Lš
œ˜Lš
œ'˜'L˜(Lš
œ*˜*Lš
œ&˜&L˜
L˜Lš
œ‰
˜‰
L˜L˜—šžœœ
œœ
œœœ
œ˜ZL˜
Lšœ
œ
˜Lšœœ
˜L˜"Lšœ
œ
œ
œ
˜Lš
œ˜Lš
œ:˜:šœ
œ
˜
L˜"Lšœ
œ
œ
œ
˜Lš
œ˜Lš
œ
˜
Lš
œ˜Lš
œ:˜:—Lšœ
˜Lš
œ˜—šžœœœ
œœœ
œ˜WJš
œB™BJšœœ
œ˜Jšœœ
œ
œ
œœ˜(Jšœ
œ
œ
œ
˜*Jšœ	œœ˜Jšœ˜
Jš
œ˜—šž	œœ
œœ
œœ˜@Lš

œ
œ
œ
œœ
˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš	œ*
œ
œ
œ
œ˜6L˜L˜—šž	œœ
œœ
œœ˜DLšœœ˜+Lšœ	œ
˜Lš
œ:˜:Lšœ
œ	œ˜!LšœŸ˜—šž	œœ
œœ
œœ˜CLšœ	œ
˜L˜Lšœœ˜Lš
œ˜L˜
Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜L˜
Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ#˜#L˜
Lš
œ*˜*Lšœ
œ	œœ
˜,Lš
œ˜LšœŸ˜—šžœœ
œœœœœ˜Mšœ˜Lšœ
œœ	˜Lš
œ
œœ
œ
œ˜(Lšœœ	˜—Lš
œ˜—šžœœ
œœ
œœœ
œœ˜TLšœœ
˜Lšœœ
˜šœ
œ
˜
Lšœœ!˜*Lšœœ
œ
œ
˜Lš	œ œ
œœ
˜5Lšœ1˜5—Lšœ
˜L˜—šžœœ
œœ
œœœœ
œœ˜eJš
œF™FJšœœ
œœ˜Jšœœ
œ
œ
œœ˜'Jšœ
œ
œ
œ
˜*Jšœ	œœ˜Jšœ˜
Jš
œ˜L˜—šžœœ
œœ
œœœ
œ˜lLš
œ˜Lšœœ
˜Lšœœ
˜Lšœœ
˜Lšœœ
˜
šœ
˜Lšœœ!˜2Lš
œœ
œ(œ
œœ˜]šœ˜šœŸœ:˜ILšœ,œœ˜>—šœ
œœ˜Lšœœ
˜Lšœœ
œ
˜Lšœœ
˜Lšœœ
˜Lšœœ
œ˜Lšœeœ ˜‡
Lšœ œ˜&Lš
œ˜L˜
—Lšœ=˜AL˜——Lšœ
˜L˜—šžœœœ
œœœ
œ˜fJš
œE™EJšœœ
œ˜Jšœœ
œ
œ
œ
œ˜+Jšœ
œ
œ
œ
˜*Jšœ	œ
œ˜Jšœ˜
Jš
œ˜——Lšœ
˜—…—6ζWί