DIRECTORY
CoordSys, CSG, SVScene, Filein3d, FS, Imager, ImagerColor, IO, Rope, SV2d, SV3d, SVArtwork, SVError, SVModelTypes, SVSceneTypes, SweepGeometry, TFI3d;

Filein3dImpl: CEDAR PROGRAM
IMPORTS CoordSys, CSG, SVScene, FS, ImagerColor, IO, Rope, SVArtwork, SVError, TFI3d
EXPORTS Filein3d =
BEGIN

ArtworkClass: TYPE = SVModelTypes.ArtworkClass;
Assembly: TYPE = SVSceneTypes.Assembly;
AssemblyList: TYPE = SVSceneTypes.AssemblyList;
Artwork: TYPE = SVModelTypes.Artwork;
Color: TYPE = Imager.Color;
CoordSystem: TYPE = SVModelTypes.CoordSystem;
CoordSysList: TYPE = SVModelTypes.CoordSysList;
FileCamera: TYPE = SVSceneTypes.FileCamera;
LightSource: TYPE = SVModelTypes.LightSource;
LightSourceList: TYPE = LIST OF LightSource;
MasterObject: TYPE = SVSceneTypes.MasterObject;
MasterObjectList: TYPE = SVSceneTypes.MasterObjectList;
MasterObjectClass: TYPE = SVSceneTypes.MasterObjectClass;
Material: TYPE = SVModelTypes.Material;
Matrix3by3: TYPE = SV2d.Matrix3by3;
Matrix4by4: TYPE = SV3d.Matrix4by4;
NameList: TYPE = LIST OF Rope.ROPE;
OMap: TYPE = SVModelTypes.OMap;
Point2d: TYPE = SV2d.Point2d;
Point3d: TYPE = SV3d.Point3d;
PointSetOp: TYPE = SVSceneTypes.PointSetOp; -- {union, intersection, difference}
Scene: TYPE = SVSceneTypes.Scene;
SMap: TYPE = SVModelTypes.SMap;
SpaceFunction: TYPE = REF SpaceFunctionObj;
SpaceFunctionObj: TYPE = SVModelTypes.SpaceFunctionObj;
Vector: TYPE = SV3d.Vector;

LinearMesh: TYPE = REF LinearMeshRecord;
LinearMeshRecord: TYPE = SweepGeometry.LinearMeshRecord;
RevoluteMesh: TYPE = REF RevoluteMeshRecord;
RevoluteMeshRecord: TYPE = SweepGeometry.RevoluteMeshRecord;

LinearMeshArray: TYPE = SweepGeometry.LinearMeshArray;
RevoluteMeshArray: TYPE = SweepGeometry.RevoluteMeshArray;

FileinScene: PUBLIC PROC [scene: Scene, f: IO.STREAM, wdirForAIS: Rope.ROPE] = {
csList: CoordSysList;
worldCS: CoordSystem;
sceneName: Rope.ROPE;
version: REAL;
restOfVersionRope: Rope.ROPE;
TFI3d.ReadBlankAndRope[f, "File:"];
TFI3d.ReadBlank[f];
[] _ TFI3d.ReadWord[f];
TFI3d.ReadWhiteSpace[f];
TFI3d.ReadRope[f, "3D file for scene:"];
TFI3d.ReadBlank[f];
sceneName _ TFI3d.ReadWord[f];
TFI3d.ReadWhiteSpace[f];
TFI3d.ReadRope[f, "Produced by Solidviews Version"];
TFI3d.ReadBlank[f];
version _ TFI3d.ReadReal[f];
restOfVersionRope _ TFI3d.ReadLine[f];
IF version >= 2.0 THEN ReadOptions[f, scene];
IF scene.lightSources = NIL THEN {
ambientLight: LightSource _ SVScene.CreateAmbientLightSource["Ambient", ImagerColor.ColorFromRGB[[0.2,0.2,0.2]]];
scene.lightSources _ CONS[ambientLight, NIL];
};
TFI3d.ReadBlank[f];
csList _ FileinCoordSystems[f, scene];
FileinLightSources[f, scene];
worldCS _ CoordSys.FindCoordSysInList["WORLD", csList];
FileinObjects[f, scene];
scene.assembly _ FileinAssembly[f, scene, csList, version, wdirForAIS];
IF version >= 3.0 THEN FileinCameras[f, scene, csList, version]
ELSE scene.cameras _ SVScene.InitialCameraList[];
IF version >= 3.0 THEN FileinCameraOrder[f, scene]
ELSE scene.cameraOrder _ LIST["Front"];
TFI3d.ReadBlank[f];
TFI3d.ReadRope[f, "END"];
f.Close[];
};

ReadOptions: PROCEDURE [f: IO.STREAM, scene: Scene] = {
keyWord, option: Rope.ROPE;
good: BOOL;
nextChar: CHAR;
twoCRsFound: BOOL _ FALSE;
TFI3d.ReadBlank[f];
UNTIL twoCRsFound DO
[keyWord, good] _ TFI3d.ReadKeyWord[f];
IF NOT good THEN {
nextChar _ IO.PeekChar[f];
IF nextChar = IO.CR THEN {
[] _ IO.GetChar[f];
twoCRsFound _ TRUE;
};
LOOP};
good _ TFI3d.ReadHorizontalBlank[f];
IF NOT good THEN {
nextChar _ IO.PeekChar[f];
IF nextChar = IO.CR THEN {
[] _ IO.GetChar[f];
twoCRsFound _ TRUE;
};
LOOP};
option _ TFI3d.ReadLine[f];
ProcessOption[keyWord, option, scene];
nextChar _ IO.PeekChar[f];
IF nextChar = IO.CR THEN {
[] _ IO.GetChar[f];
twoCRsFound _ TRUE;
};
ENDLOOP;
};

ProcessOption: PROC [keyWord: Rope.ROPE, option: Rope.ROPE, scene: Scene] = {
SELECT TRUE FROM
Rope.Equal[keyWord, "background color", FALSE] => {
scene.backgroundColor _ TFI3d.ReadColor[IO.RIS[option]];
};
Rope.Equal[keyWord, "shadows", FALSE] => {
good, truth: BOOL;
[truth, good] _ TFI3d.ReadBool[IO.RIS[option]];
IF NOT good THEN RETURN;
scene.shadows _ truth;
};
Rope.Equal[keyWord, "ambient", FALSE] => {
color: Color;
ls: LightSource;
color _ TFI3d.ReadColor[IO.RIS[option]];
ls _ SVScene.CreateAmbientLightSource["Ambient", color];
SVScene.AddLightSourceToScene[ls, scene];
};
ENDCASE;
}; -- end of ProcessOption

FileinCoordSystems: PROC [f: IO.STREAM, scene: Scene] RETURNS [csList: CoordSysList] = {
count: NAT;
mat: Matrix4by4;
newCS: CoordSystem;
csName, wrtName: Rope.ROPE;
csList _ NIL;
TFI3d.ReadRope[f, "CoordSystems"];
TFI3d.ReadWhiteSpace[f];
TFI3d.ReadRope[f, "["];
count _ TFI3d.ReadNAT[f];
TFI3d.ReadRope[f, "]:"]; TFI3d.ReadWhiteSpace[f];
FOR i: NAT IN[1..count] DO
TFI3d.ReadRope[f, "CoordSys:"];
csName _ TFI3d.ReadBlankAndWord[f];
TFI3d.ReadWhiteSpace[f];
TFI3d.ReadRope[f, "mat:"];
TFI3d.ReadBlank[f];
mat _ TFI3d.FileinMatrix[f];
TFI3d.ReadBlankAndRope[f, "withRespectTo:"];
wrtName _ TFI3d.ReadBlankAndWord[f];
TFI3d.ReadWhiteSpace[f];
SELECT TRUE FROM
Rope.Equal[csName,"WORLD"] => {
newCS _ CoordSys.CreateRoot["WORLD"];
scene.coordSysRoot _ newCS;
csList _ AppendToCoordSystems[newCS, csList];
};
Rope.Equal[csName,"SCREEN"] => {};
ENDCASE => {
wrtCS: CoordSystem _ CoordSys.FindCoordSysInList[wrtName, csList];
newCS _ CoordSys.CreateCoordSysInTree[csName,mat,wrtCS,scene.coordSysRoot];
csList _ AppendToCoordSystems[newCS, csList];
};
ENDLOOP;
}; -- end of FileinCoordSystems

AppendToCoordSystems: PROC [cs: CoordSystem, list: CoordSysList]  RETURNS [CoordSysList] = {
z: CoordSysList _ list;
IF z = NIL THEN RETURN[CONS[cs,NIL]];
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ CONS[cs,NIL];
RETURN[list];
};

FileinLightSources: PROC [f: IO.STREAM, scene: Scene] = {
count: NAT;
thisLS: LightSource;
lsName: Rope.ROPE;
point3d: Point3d;
color: Color;
TFI3d.ReadRope[f, "LightSources"];
TFI3d.ReadBlankAndRope[f, "["];
count _ TFI3d.ReadNAT[f];
TFI3d.ReadRope[f, "]:"];  TFI3d.ReadWhiteSpace[f];
FOR i: NAT IN[1..count] DO
TFI3d.ReadRope[f, "LightSource:"];
lsName _ TFI3d.ReadBlankAndWord[f];
TFI3d.ReadBlankAndRope[f, "position:"];
TFI3d.ReadBlank[f];
point3d _ TFI3d.ReadPoint3d[f];
TFI3d.ReadBlankAndRope[f, "color:"];
TFI3d.ReadBlank[f];
color _ TFI3d.ReadColor[f];
TFI3d.ReadWhiteSpace[f];
thisLS _ SVScene.CreateLightSource[lsName, point3d, color];
SVScene.AddLightSourceToScene[thisLS, scene];
ENDLOOP;
};
FileinCameras: PROC [f: IO.STREAM, scene: Scene, csList: CoordSysList, version: REAL] = {
worldCS: CoordSystem _ CoordSys.FindCoordSysInList["WORLD", csList];
count: NAT;
fileCamera: FileCamera;
TFI3d.ReadBlankAndRope[f, "Cameras"];
TFI3d.ReadBlankAndRope[f, "["];
count _ TFI3d.ReadNAT[f];
TFI3d.ReadRope[f, "]:"];  TFI3d.ReadWhiteSpace[f];
FOR i: NAT IN[1..count] DO
fileCamera _ TFI3d.ReadCamera[f, worldCS, scene, version];
SVScene.AddCameraToScene[fileCamera, scene];
ENDLOOP;
};

FileinCameraOrder: PROC [f: IO.STREAM, scene: Scene] = {
count: NAT;
fileCameraName: Rope.ROPE;
TFI3d.ReadBlankAndRope[f, "Initial Camera Order"];
TFI3d.ReadBlankAndRope[f, "["];
count _ TFI3d.ReadNAT[f];
TFI3d.ReadRope[f, "]:"];
IF count > 0 THEN {
TFI3d.ReadBlank[f];
fileCameraName _ TFI3d.ReadWord[f];
SVScene.AddCameraOrderNameToScene[fileCameraName, scene];
FOR i: NAT IN[2..count] DO
TFI3d.ReadBlankAndRope[f, ","];
TFI3d.ReadBlank[f];
fileCameraName _ TFI3d.ReadWord[f];
SVScene.AddCameraOrderNameToScene[fileCameraName, scene];
ENDLOOP;
};
TFI3d.ReadBlank[f];
};

ReadArtwork: PRIVATE PROC [f: IO.STREAM, csList: CoordSysList, defaultCS: CoordSystem, wdir: Rope.ROPE, version: REAL] RETURNS [artwork: Artwork] = {
source, isColorRope, nextWord, aisFileName: Rope.ROPE _ NIL;
surface: REF ANY;
material: Material;
mat: Matrix3by3;
color: Imager.Color;
isColorFile: BOOL;
sMap: SMap;
oMap: OMap;
resolution: REAL;
success: BOOL;
csName, className: Rope.ROPE;
coordSys: CoordSystem;
class: ArtworkClass;

IF version > 5.2 THEN {
TFI3d.ReadBlankAndRope[f, "coordSys: "];
csName _ TFI3d.ReadBlankAndWord[f];
IF Rope.Equal[csName, "NIL"] THEN coordSys _ NIL
ELSE coordSys _ CoordSys.FindCoordSysInList[csName, csList];
TFI3d.ReadBlankAndRope[f, "class: "];
className _ TFI3d.ReadBlankAndWord[f];
class _ RopeToArtworkClass[className];
}
ELSE {
coordSys _ defaultCS;
class _ simpleSurface;
};
TFI3d.ReadBlankAndRope[f, "material:"];
TFI3d.ReadBlank[f];
material _ TFI3d.ReadMaterial[f];
TFI3d.ReadBlankAndRope[f, "surface:"];
surface _ TFI3d.ReadSurface[f];

IF (surface # NIL) AND class # spaceFunction THEN {
nextWord _ TFI3d.ReadBlankAndWord[f];
SELECT TRUE FROM
Rope.Equal[nextWord, "source:"] => {-- oMap and sMap are defaulted
source _ TFI3d.ReadBlankAndWord[f];
SELECT TRUE FROM
ISTYPE[surface, SVModelTypes.Tube] => {oMap _  tubeO; sMap _ tubeS};
ISTYPE[surface, SVModelTypes.Box] => {oMap _  orthogonal; sMap _ unfoldedBox};
ENDCASE => ERROR;
};
Rope.Equal[nextWord, "SMap:"] => {
TFI3d.ReadBlank[f];
sMap _ TFI3d.ReadSMap[f];
TFI3d.ReadBlankAndRope[f, "OMap:"];
TFI3d.ReadBlank[f];
oMap _ TFI3d.ReadOMap[f];
TFI3d.ReadBlankAndRope[f, "source:"];
source _ TFI3d.ReadBlankAndWord[f];
};
ENDCASE => ERROR;
isColorRope _ TFI3d.ReadBlankAndWord[f];
SELECT TRUE FROM
Rope.Equal[isColorRope, "colorFile", FALSE] => isColorFile _ TRUE;
Rope.Equal[isColorRope, "bwFile", FALSE] => isColorFile _ FALSE;
ENDCASE => ERROR;
TFI3d.ReadBlankAndRope[f, "resolution:"];
TFI3d.ReadBlank[f];
resolution _ TFI3d.ReadReal[f];
TFI3d.ReadBlankAndRope[f, "mat:"];
TFI3d.ReadBlank[f];
mat _ TFI3d.FileinMatrix3by3[f];
success _ TRUE;
[aisFileName,,] _ FS.ExpandName[source, wdir
! FS.Error =>  {
IF error.group = user THEN {
success _ FALSE;
SVError.Append[error.explanation, oneLiner];
CONTINUE;
};
}];
IF NOT success THEN ERROR SVArtwork.FileNotFound;
TFI3d.ReadBlankAndRope[f, "color:"];
TFI3d.ReadBlank[f];
color _ TFI3d.ReadColor[f];
artwork _ SVArtwork.CreateFileArtwork[coordSys, material, surface, oMap, sMap, aisFileName, isColorFile, color, resolution, mat]; -- may generate ERROR SVArtwork.FileNotFound
}
ELSE {
IF surface = NIL AND class#spaceFunction THEN {
TFI3d.ReadBlankAndRope[f, "color:"];
TFI3d.ReadBlank[f];
color _ TFI3d.ReadColor[f];
artwork _ SVArtwork.CreateColorArtwork[color, material]
}
ELSE {
spaceFunction: SpaceFunction;
TFI3d.ReadBlankAndRope[f, "scalars:"];
spaceFunction _ NEW[SpaceFunctionObj];
TFI3d.ReadBlank[f];
spaceFunction.scalars _ TFI3d.ReadPoint3d[f];
TFI3d.ReadBlankAndRope[f, "func: colorcube"];
artwork _ SVArtwork.Create3DArtwork[coordSys, material, spaceFunction];
};
};
};

RopeToArtworkClass: PROC [className: Rope.ROPE] RETURNS [class: ArtworkClass] = {
SELECT TRUE FROM
Rope.Equal[className, "justColor"] => class _ justColor;
Rope.Equal[className, "simpleSurface"] => class _ simpleSurface;
Rope.Equal[className, "spaceFunction"] => class _ spaceFunction;
ENDCASE => ERROR;
};

FileinAssembly: PROC [f: IO.STREAM, scene: Scene, csList: CoordSysList, version: REAL, wdirForAIS: Rope.ROPE] RETURNS [thisA: Assembly] = {
thisCS: CoordSystem;
artwork: Artwork;
scalars: Vector;
primOrComp: Rope.ROPE;
asName, csName, opRope, chairName: Rope.ROPE;
pointSetOp: PointSetOp;
subAssemblies: LIST OF Assembly;

TFI3d.ReadBlankAndRope[f, "Assembly:"];
asName _ TFI3d.ReadBlankAndWord[f];
TFI3d.ReadBlankAndRope[f, ","];
TFI3d.ReadBlankAndRope[f, "coordSys:"];
csName _ TFI3d.ReadBlankAndWord[f];
thisCS _ CoordSys.FindCoordSysInList[csName, csList];
TFI3d.ReadBlankAndRope[f, ","];
primOrComp _ TFI3d.ReadBlankAndWord[f];
SELECT TRUE FROM
Rope.Equal[primOrComp, "Composite", FALSE] => {
TFI3d.ReadBlankAndRope[f, "artwork:"];
TFI3d.ReadBlank[f];
artwork _ ReadArtwork[f, csList, thisCS, wdirForAIS, version];
TFI3d.ReadBlankAndRope[f, "subassemblies"];
TFI3d.ReadBlankAndRope[f, "["];
IF version < 5.2 THEN TFI3d.ReadBlankAndRope[f, "point set op:"];
opRope _ TFI3d.ReadBlankAndWord[f];
pointSetOp _ CSG.RopeToPointSetOp[opRope];
TFI3d.ReadBlankAndRope[f, "]"];
TFI3d.ReadWhiteSpace[f];
[] _ FileinSubassemblyNames[f];
thisA _ SVScene.CreateClusterAssemblyAtExistingCoordSys[asName, pointSetOp, scene, thisCS, FALSE, NIL];
thisA.artwork _ artwork;
subAssemblies _ FileinAssemblies[f, scene, csList, version, wdirForAIS];
WireUpAssemblyToSubassemblies[thisA, subAssemblies, scene];
};
Rope.Equal[primOrComp, "Primitive", FALSE] => {
obName: Rope.ROPE;
masterObjectFound: BOOL;
TFI3d.ReadBlankAndRope[f, "scalars:"];
TFI3d.ReadBlank[f];
scalars _ TFI3d.ReadPoint3d[f];
TFI3d.ReadBlankAndRope[f, "artwork:"];
TFI3d.ReadBlank[f];
artwork _ ReadArtwork[f, csList, thisCS, wdirForAIS, version];
TFI3d.ReadBlankAndRope[f, "object:"];
obName _ TFI3d.ReadBlankAndWord[f];
[thisA, masterObjectFound] _
SVScene.CreatePrimitiveAtExistingCoordSys[asName, obName, scalars, scene, thisCS, artwork, FALSE, NIL];
IF NOT masterObjectFound THEN ERROR MasterObjectNotFound;
IF version >= 5.3 AND Rope.Equal[obName, "jack", FALSE] THEN {
TFI3d.ReadBlankAndRope[f, "sittingOn:"];
chairName _ TFI3d.ReadBlankAndWord[f];
IF Rope.Equal[chairName, "NIL", FALSE] THEN thisA.sittingOn _ NIL
ELSE thisA.sittingOn _ chairName;
};
};
ENDCASE => SIGNAL ErrorInAssemblyFileout;
}; -- end of FileinAssembly
MasterObjectNotFound: PUBLIC ERROR = CODE;

FileinAssemblies: PROC [f: IO.STREAM, scene: Scene, csList: CoordSysList, version: REAL, wdirForAIS: Rope.ROPE] RETURNS [asList: LIST OF Assembly] = {
count: NAT;
thisA: Assembly;
asList _ NIL;-- initially
TFI3d.ReadBlankAndRope[f, "Subassemblies"];
TFI3d.ReadBlankAndRope[f, "["];
count _ TFI3d.ReadBlankAndNAT[f];
TFI3d.ReadBlankAndRope[f, "]:"];  TFI3d.ReadWhiteSpace[f];
FOR i: NAT IN[1..count] DO
thisA _ FileinAssembly[f, scene, csList, version, wdirForAIS];
asList _ AppendToAssemblyList[thisA, asList];
ENDLOOP;
};

ErrorInAssemblyFileout: PUBLIC SIGNAL = CODE;
WireUpAssemblyToSubassemblies: PROC [assem: Assembly, subA: LIST OF Assembly, scene: Scene] = {
thisSub: Assembly;
FOR al: LIST OF Assembly _ subA, al.rest UNTIL al = NIL DO
thisSub _ al.first;
SVScene.ConnectAssemblyToParent[thisSub, assem];
ENDLOOP;
};
AppendToAssemblyList: PROC [as: Assembly, list: LIST OF Assembly] RETURNS [LIST OF Assembly] = {
z: LIST OF Assembly _ list;
IF z = NIL THEN RETURN[CONS[as,NIL]];
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ CONS[as,NIL];
RETURN[list];
};
AppendToNameList: PROC [name: Rope.ROPE, list: NameList] RETURNS [NameList] = {
z: NameList _ list;
IF z = NIL THEN RETURN[CONS[name,NIL]];
UNTIL z.rest = NIL DO z _ z.rest; ENDLOOP;
z.rest _ CONS[name,NIL];
RETURN[list];
};
FileinSubassemblyNames: PROC [f: IO.STREAM] RETURNS [nameList: NameList] = {
count: NAT;
thisName: Rope.ROPE;
nameList _ NIL;
TFI3d.ReadBlankAndRope[f, "["];
count _ TFI3d.ReadBlankAndNAT[f];
TFI3d.ReadBlankAndRope[f, "]:"];
TFI3d.ReadBlankAndRope[f, "("];
IF count = 0 THEN {TFI3d.ReadBlankAndRope[f, ")"]; RETURN;};
thisName _ TFI3d.ReadBlankAndWord[f];
nameList _ AppendToNameList[thisName, nameList];
FOR i: NAT IN[2..count] DO
TFI3d.ReadRope[f, ", "];
thisName _ TFI3d.ReadBlankAndWord[f];
nameList _ AppendToNameList[thisName, nameList];
ENDLOOP;
TFI3d.ReadBlankAndRope[f, ")"];
TFI3d.ReadWhiteSpace[f];
};
FileinObjects: PROC [f: IO.STREAM, scene: Scene] = {
count: NAT;
obName, obClass: Rope.ROPE;
moClass: MasterObjectClass;
moClassFound: BOOL;
mo: MasterObject;

TFI3d.ReadRope[f, "Objects"];
TFI3d.ReadBlankAndRope[f, "["];
count _ TFI3d.ReadNAT[f];
TFI3d.ReadRope[f, "]:"];
TFI3d.ReadWhiteSpace[f];
FOR i: NAT IN[1..count] DO
TFI3d.ReadBlankAndRope[f, "Master Object:"];
obName _ TFI3d.ReadBlankAndWord[f];
TFI3d.ReadWhiteSpace[f];
TFI3d.ReadRope[f, "class:"];
obClass _ TFI3d.ReadBlankAndWord[f];
TFI3d.ReadBlank[f];
[moClass, moClassFound] _ SVScene.FindClassFromName[obClass];
IF NOT moClassFound THEN ERROR MasterObjectClassNotFound;
mo _ moClass.filein[f, obName];
SVScene.AddMasterObjectToScene[mo, scene];
ENDLOOP;-- next master object
TFI3d.ReadBlank[f];
}; -- end of FileinObjects
MasterObjectClassNotFound: PUBLIC ERROR = CODE;

END.
File: Filein3dImpl.mesa
Last edited by Bier on January 28, 1987 12:47:04 pm PST
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Contents: Recreates a 3d database from a 3d text file of the sort produced by Fileout3d.mesa.
Note: When you change this file, you may wish to update versionRope in SVSceneImplA.
Known Options
WORLD must be defined with respect to NIL, and must be the identity matrix.
SCREEN must be in terms of NIL.
The matrix between them must be a translation
SCREEN is ignored since it depends on viewer size and shouldn't be in these files anyway.
Other coord systems are unrestricted.  Create them with the new data.
All coordinate systems other than screen and world will be added to the scene's coord sys list (not the same as csList!) when assemblies (see FileinAssemblies) are added.
A copy of List.Nconc1 for CoordSysList instead of LIST OF REF ANY
A copy of List.Nconc1 for AssemblyListObj instead of LIST OF REF ANY
A copy of List.Nconc1 for NameList instead of LIST OF REF ANY.
ส[–

"cedar" style˜Iheadš
œ™Iprocš
œ7™7Jšœ
ฯm
œ1™<Lš
œ]™]Lš
œT™TL˜š
ฯk	˜	Lšœ	žœžœžœY˜–
—L˜šœž
˜Lšžœžœžœ
žœ!˜TLšžœ˜—Lš
ž˜˜Lšœžœ˜/Lšœ
žœ˜'Lšœžœ˜/Lšœ	žœ˜%Lšœžœ˜Lšœ
žœ˜-Lšœžœ˜/Lšœžœ˜+Lšœ
žœ˜-Lšœžœžœ
žœ
˜,Lšœžœ˜/Lšœžœ!˜7Lšœžœ"˜9Lšœ
žœ˜'Lšœžœ˜#Lšœžœ˜#Lš	œ
žœžœ
žœžœ
˜#Lšœžœ˜Lšœ	žœ˜Lšœ	žœ˜Lšœžœฯc%˜PLšœžœ˜!Lšœžœ˜Lšœžœžœ˜+Lšœžœ!˜7Lšœžœ˜L˜Lšœžœžœ˜(Lšœžœ"˜8Lšœžœžœ˜,Lšœžœ$˜<L˜Lšœžœ!˜6Lšœžœ#˜:L˜—šฯnœžœ
žœžœ
žœžœ˜PLš
œ˜L˜Lšœžœ
˜Lšœ	žœ
˜Lšœžœ
˜Lš
œ#˜#Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ(˜(Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ4˜4Lš
œ˜Lš
œ˜Lš
œ&˜&Lšžœžœ
ฯbœ˜-šžœžœ
žœ˜"Jš
œq˜qJšœžœžœ˜-J˜—Lš
œ˜Lšœ	กœ˜&Lšกœ˜Lš
œ7˜7Lšก
œ˜Lšœกœ(˜GLšžœžœ*žœ-˜qLšžœžœžœžœ
˜ZLš
œ˜Lš
œ˜Lš
œ
˜
Lš
œ˜—š œž	œžœ
žœ˜7Jšœžœ
˜Jšœžœ
˜Jšœ
žœ
˜Jšœ
žœžœ
˜Jš
œ˜šžœ
ž˜J˜'šžœ
žœžœ˜Jšœžœ
˜šžœžœ
žœ
žœ˜Jšœžœ˜Jšœžœ
˜J˜—Jšžœ˜—Jš
œ$˜$šžœ
žœžœ˜Jšœžœ
˜šžœžœ
žœ
žœ˜Jšœžœ˜Jšœžœ
˜J˜—Jšžœ˜—J˜J˜&Jšœžœ
˜šžœžœ
žœ
žœ˜Jšœžœ˜Jšœžœ
˜J˜——Jšžœ
˜J˜—š 
œžœžœžœ˜MJšžœ
žœ
ž˜™
šœ(žœ˜3Jšœ(žœ
žœ
˜8J˜—šœžœ˜*Jšœ
žœ
˜Jšœžœ
žœ
˜/Jšžœ
žœžœ
žœ
˜J˜J˜—šœžœ˜*Jš
œ
˜
J˜Jš
œ(˜(Jš
œ8˜8Jš
œ)˜)J˜—Jšžœ
˜—JšœŸ˜—L˜š
 œžœžœ
žœžœ˜XLšœžœ
˜Lš
œ˜Lš
œ˜Lšœžœ
˜Lšœ	žœ
˜
Lš
œ"˜"Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ1˜1šžœžœ
žœž˜Lš
œ˜Lš
œ#˜#Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ,˜,Lš
œ$˜$Lš
œ˜šžœ
žœ
ž˜š
œ˜Lš
œ%˜%Lš
œK™KLšกœ
˜Lš
œ-˜-Lš
œ˜—Lš
œ"˜"Lš
œ™Lš
œ-™-Lš
œY™Yšžœ˜Lš
œE™ELš
œB˜BLš
œK˜KLš
œ-˜-Lš
œ˜——Lš
œช
™ช
—Lšžœ
˜LšœŸ˜L˜—š œžœ(žœ˜\Lš
œA™ALš
œ˜Lšžœžœ
žœ
žœ
žœžœ˜%šžœ
žœ
žœ
žœ
˜*Lšœ	žœžœ˜—Lšžœ˜
Lš
œ˜—L˜š œžœžœ
žœ˜9Lšœžœ
˜Lš
œ˜Lšœ
žœ
˜Lš
œ˜Lš
œ
˜
Lš
œ"˜"Lš
œ˜Lš
œ˜Lš
œ2˜2šžœžœ
žœž˜Lš
œ"˜"Lš
œ#˜#Lš
œ'˜'Lš
œ˜Lš
œ˜Lš
œ$˜$Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ;˜;Lš
œ-˜-—Lšžœ
˜Lš
œ˜—š
 
œžœžœ
žœ/žœ˜YLš
œD˜DLšœžœ
˜L˜L˜%Lš
œ˜Lš
œ˜Lš
œ2˜2šžœžœ
žœž˜Lš
œ:˜:Lš
œ,˜,—Lšžœ
˜Lš
œ˜—š œžœžœ
žœ˜8Lšœžœ
˜Lšœžœ
˜L˜2Lš
œ˜Lš
œ˜Lš
œ˜šžœžœ˜Lš
œ˜Lš
œ#˜#Lš
œ9˜9šžœžœ
žœž˜L˜Lš
œ˜Lš
œ#˜#Lš
œ9˜9—Lšžœ
˜L˜Lš
œ˜—Lš
œ˜—š œžœ
žœžœ
žœ;žœžœžœ˜•
Lšœ1žœžœ
˜<Lšœ	žœ
žœ
˜Lš
œ˜Lš
œ˜Lš
œ˜Lšœ
žœ
˜Lš
œ˜Lš
œ˜Lšœžœ
˜Lšœ	žœ
˜L˜Lš
œ˜L˜L˜šžœ˜Lš
œ(˜(Lš
œ#˜#Lšžœžœ
กœž˜0Lšžก	œ/˜<Lš
œ%˜%Lš
œ&˜&Lšกœ!˜&L˜
—š
œ˜Lšกœ
˜Lšกœ˜L˜—Lš
œ'˜'Lš
œ˜Lšกœ˜!Lš
œ&˜&Lšกœ˜L˜šžœžœžœžœ˜3Lš
œ%˜%šžœ
žœ
ž˜šœ$Ÿ˜BLš
œ#˜#šžœ
žœ
ž˜Lšžœ>˜DLšžœH˜NLšžœžœ
˜—Lš
œ˜—š
œ"˜"Lš
œ˜Lš
œ˜Lš
œ#˜#Lš
œ˜Lš
œ˜Lš
œ%˜%Lš
œ#˜#Lš
œ˜—Lšžœžœ
˜—Lš
œ(˜(šžœ
žœ
ž˜Lšœ%žœžœ
˜BLšœ"žœžœ
˜@Lšžœžœ
˜—Lš
œ)˜)Lš
œ˜Lš
œ˜Lš
œ"˜"Lš
œ˜Lš
œ ˜ Lšœ
žœ
˜šœžœ˜,šœžœ˜šžœžœ˜Lšœ
žœ
˜Lš
œ,˜,Lšžœ
˜	L˜—L˜——Lšžœ
žœ	žœ
žœ˜1Lš
œ$˜$Lš
œ˜Lšกœ˜Lšœกœ]Ÿ,˜ฎ
Lš
œ
˜
—šžœ˜šžœžœ
žœžœ˜/Lš
œ$˜$Lš
œ˜Lšกœ˜Lšœกœ˜7L˜
—šžœ˜Lš
œ˜Lš
œ&˜&Lšœžœ˜&L˜Lšœ œ˜-Lš
œ-˜-Lš
œG˜GL˜—L˜—Lš
œ˜L˜—š œžœžœžœ˜QLšžœ
žœ
ž˜Lš
œ8˜8Lš
œ@˜@Lš
œ@˜@Lšžœžœ
˜L˜L˜—š œžœžœ
žœ/žœžœžœ˜‹
Lš
œ˜Lš
œ˜Lš
œ˜Lšœžœ
˜Lšœ(žœ
˜-Lš
œ˜Lšœžœ
žœ
˜ L˜Lš
œ'˜'Lš
œ#˜#Lš
œ˜Lš
œ'˜'Lš
œ#˜#Lš
œ5˜5Lš
œ˜Lš
œ'˜'Lšžœ
žœ
ž˜šœ$žœ˜/Lš
œ&˜&Lš
œ˜Lšœ
กœ)˜>Lš
œ+˜+Lš
œ˜Lšžœžœ,˜ALš
œ#˜#Lšœ
žœ˜*Lš
œ˜Lš
œ˜Lš
œ˜Lšœ[žœžœ˜gLš
œ˜Lš
œH˜HLš
œ;˜;Lš
œ˜—šœ$žœ˜/Lšœ
žœ
˜Lšœžœ
˜Lš
œ&˜&Lš
œ˜Lš
œ˜Lš
œ&˜&Lš
œ˜Lšœ
กœ)˜>Lš
œ%˜%Lš
œ#˜#š
œ˜Lšœ[žœžœ˜g—Lšžœ
žœžœ
žœ˜9šžœžœžœž˜>Lš
œ(˜(Lš
œ&˜&Lšžœžœžœž˜ALšžœ˜!L˜—Lš
œ˜—Lšžœžœ˜)LšœŸ˜—Lšœžœ
žœžœ
˜*L˜š œžœžœ
žœ/žœžœžœ
žœ
žœ˜–
Lšœžœ
˜Lš
œ˜Lšœ	žœ
Ÿ˜Lš
œ+˜+Lš
œ˜Lš
œ!˜!Lš
œ:˜:šžœžœ
žœž˜Lš
œ>˜>Lš
œ-˜-—Lšžœ
˜Lš
œ˜—Lšœžœ
žœžœ
˜-š œžœžœ
žœ˜_Lš
œ˜šžœžœ
žœžœžœ
ž˜:Lš
œ˜Lš
œ0˜0—Lšžœ
˜Lš
œ˜—š œžœžœ
žœžœžœ
žœ˜`Lš
œD™DLšœžœ
žœ˜Lšžœžœ
žœ
žœ
žœžœ˜%šžœ
žœ
žœ
žœ
˜*Lšœ	žœžœ˜—Lšžœ˜
Lš
œ˜—š œžœ
žœžœ˜OLš
œ>™>Lš
œ˜Lšžœžœ
žœ
žœ
žœžœ˜'šžœ
žœ
žœ
žœ
˜*Lšœ	žœžœ˜—Lšžœ˜
Lš
œ˜—š
 œžœžœ
žœžœ˜LLšœžœ
˜Lšœžœ
˜Lšœžœ
˜Lš
œ˜Lš
œ!˜!Lš
œ ˜ Lš
œ˜Lšžœžœ"žœ˜<Lš
œ%˜%Lš
œ0˜0šžœžœ
žœž˜Lš
œ˜Lš
œ%˜%Lš
œ0˜0—Lšžœ
˜Lš
œ˜Lš
œ˜Lš
œ˜—š 
œžœžœ
žœ˜4Lšœžœ
˜Lšœžœ
˜Lš
œ˜Lšœžœ
˜Lš
œ˜L˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜šžœžœ
žœž˜Lš
œ,˜,Lš
œ#˜#Lš
œ˜Lš
œ˜Lš
œ$˜$Lš
œ˜Lš
œ=˜=Lšžœ
žœžœ
žœ˜9Lš
œ˜Lš
œ*˜*—Lšžœ
Ÿ˜Lš
œ˜LšœŸ˜—Lšœžœ
žœžœ
˜/L˜Lšžœ
˜—…—=๒UM